diff --git a/Gruntfile.js b/Gruntfile.js
index 96ace8aafa..87c89e0e52 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -205,6 +205,15 @@ module.exports = function (grunt) {
             ],
             dest: paths.adminJsLib
           },
+          {
+            expand: true,
+            cwd: 'node_modules/vue-i18n/dist',
+            src: [
+              // not using runtime 'cos we need the messages compiler
+              'vue-i18n.global.js' 
+            ],
+            dest: paths.adminJsLib
+          },
         ],
       },
     },
diff --git a/modules/admin/app/assets/css/admin/_admin.scss b/modules/admin/app/assets/css/admin/_admin.scss
index d1a96563e5..be870e3543 100644
--- a/modules/admin/app/assets/css/admin/_admin.scss
+++ b/modules/admin/app/assets/css/admin/_admin.scss
@@ -127,8 +127,11 @@ body > .admin-content > .flash {
   padding-top: $margin-md;
 }
 
-.add-address {
+.add-address,
+.add-concept
+{
   float: right;
+  margin-bottom: $margin-md;
 }
 
 .admin-help-notice {
@@ -315,12 +318,18 @@ pre.code-format {
   margin-bottom: $margin-md;
 }
 
-.add-description {
-  margin-bottom: $margin-md;
-  @include clearfix();
-  a {
-    float: right;
+.control-elements {
+  .add-inline-element:not(.btn) {
+    display: block;
+    background-color: $gray-100;
+    border-bottom: 1px solid darken($gray-100, 5%);
+    padding: 0 $margin-xs;
+    color: $gray-700;
+  }
+  .add-inline-element:hover:not(.btn) {
+    background-color: darken($gray-100, 5%);
   }
+
 }
 
 .inline-element-block-controls {
@@ -436,6 +445,20 @@ pre.code-format {
    }
 }
 
+// Metadata validation
+.metadata-validation {
+  summary {
+    font-size: $font-size-lg;
+    @extend .alert, .alert-warning;
+  }
+  .validation-errors {
+    @extend .alert, .alert-danger;
+  }
+  .validation-warnings {
+    @extend .alert, .alert-warning;
+  }
+}
+
 // Vue Single-page applications
 %expanding-row {
   display: flex;
diff --git a/modules/admin/app/assets/css/dmeditor.scss b/modules/admin/app/assets/css/dmeditor.scss
index 179e9a1ada..addeafbddb 100644
--- a/modules/admin/app/assets/css/dmeditor.scss
+++ b/modules/admin/app/assets/css/dmeditor.scss
@@ -12,3 +12,30 @@ $active-table-row: #e7f1ff;
   overflow: auto;
   flex-basis: 0;
 }
+
+.section {
+  background-color: $gray-100;
+  font-weight: bold;
+}
+
+.fm-list td.fm-actions {
+  width: 5rem;
+}
+
+.fm-see-also a + a {
+  display: inline-block;
+}
+
+.fm-usage {
+  white-space: nowrap;
+
+}
+
+.fm-list td:last-child a {
+  margin-left: $margin-xs;
+}
+
+#delete-metadata {
+  margin-right: auto;
+}
+
diff --git a/modules/admin/app/assets/js/admin.js b/modules/admin/app/assets/js/admin.js
index 350c6c4d38..c8cb3b104f 100644
--- a/modules/admin/app/assets/js/admin.js
+++ b/modules/admin/app/assets/js/admin.js
@@ -188,7 +188,7 @@ jQuery(function ($) {
       event.preventDefault();
 
       var container = $(event.target).closest(".inline-formset");
-      var set = container.children(".inline-element-list");
+      var set = container.children(".control-elements").children(".inline-element-list").first();
       var prefix = container.data("prefix");
       if (!prefix) {
         throw "No prefix found for formset";
@@ -212,6 +212,10 @@ jQuery(function ($) {
 
       // And a help popover
       addPopover($elem.find("textarea,input"));
+
+      // Focus the first input
+      $elem.find("input,textarea").first().focus();
+
     }).on("click", ".remove-inline-element", function (event) {
       event.preventDefault();
       $(this)
diff --git a/modules/admin/app/assets/js/datasets/components/_manager-convert.vue b/modules/admin/app/assets/js/datasets/components/_manager-convert.vue
index 3f180bf347..062ead04e0 100644
--- a/modules/admin/app/assets/js/datasets/components/_manager-convert.vue
+++ b/modules/admin/app/assets/js/datasets/components/_manager-convert.vue
@@ -20,7 +20,6 @@ import _takeWhile from 'lodash/takeWhile';
 import _find from 'lodash/find';
 import {DataTransformation} from "../types";
 
-
 let initialConvertState = function (config) {
   return {
     ingesting: {},
diff --git a/modules/admin/app/assets/js/dmeditor/api.ts b/modules/admin/app/assets/js/dmeditor/api.ts
index e7a92aba19..9c2bfc3179 100644
--- a/modules/admin/app/assets/js/dmeditor/api.ts
+++ b/modules/admin/app/assets/js/dmeditor/api.ts
@@ -1,5 +1,6 @@
 import axios from "axios";
 import {
+  EntityType,
   EntityTypeMetadata, EntityTypeMetadataInfo,
   FieldMetadata,
   FieldMetadataInfo, FieldMetadataTemplates,
@@ -30,36 +31,36 @@ export default class EntityTypeMetadataApi {
       withCredentials: true,
     }).then(r => r.data);
   }
-  list(): Promise<Record<string, EntityTypeMetadata>> {
-    return EntityTypeMetadataApi.call<Record<string, EntityTypeMetadata>>(this.service.list(), {});
+  list(): Promise<Record<EntityType, EntityTypeMetadata>> {
+    return EntityTypeMetadataApi.call<Record<EntityType, EntityTypeMetadata>>(this.service.list(), {});
   }
 
-  get(entityType: string): Promise<Record<string, EntityTypeMetadata>> {
-    return EntityTypeMetadataApi.call<Record<string, EntityTypeMetadata>>(this.service.list(), {}, {entityType});
+  get(entityType: EntityType): Promise<Record<EntityType, EntityTypeMetadata>> {
+    return EntityTypeMetadataApi.call<Record<EntityType, EntityTypeMetadata>>(this.service.list(), {}, {entityType});
   }
 
-  save(entityType: string, data: EntityTypeMetadataInfo): Promise<EntityTypeMetadata> {
+  save(entityType: EntityType, data: EntityTypeMetadataInfo): Promise<EntityTypeMetadata> {
     return EntityTypeMetadataApi.call<EntityTypeMetadata>(this.service.save(entityType), data);
   }
 
-  delete(entityType: string): Promise<boolean> {
+  delete(entityType: EntityType): Promise<boolean> {
     return EntityTypeMetadataApi.call<boolean>(this.service.delete(entityType));
   }
 
-  listFields(entityType?: string): Promise<Record<string, FieldMetadata[]>> {
+  listFields(entityType?: EntityType): Promise<Record<EntityType, FieldMetadata[]>> {
     let params = entityType ? {entityType} : {};
-    return EntityTypeMetadataApi.call<Record<string, FieldMetadata[]>>(this.service.listFields(), {}, params)
+    return EntityTypeMetadataApi.call<Record<EntityType, FieldMetadata[]>>(this.service.listFields(), {}, params)
   }
 
-  getField(entityType: string, id: string): Promise<FieldMetadata | null> {
+  getField(entityType: EntityType, id: string): Promise<FieldMetadata | null> {
     return EntityTypeMetadataApi.call<FieldMetadata>(this.service.getField(entityType, id));
   }
 
-  saveField(entityType: string, id: string, data: FieldMetadataInfo): Promise<FieldMetadata> {
+  saveField(entityType: EntityType, id: string, data: FieldMetadataInfo): Promise<FieldMetadata> {
     return EntityTypeMetadataApi.call<FieldMetadata>(this.service.saveField(entityType, id), data);
   }
 
-  deleteField(entityType: string, id: string): Promise<boolean> {
+  deleteField(entityType: EntityType, id: string): Promise<boolean> {
     return EntityTypeMetadataApi.call<boolean>(this.service.deleteField(entityType, id));
   }
 
diff --git a/modules/admin/app/assets/js/dmeditor/app.spec.ts b/modules/admin/app/assets/js/dmeditor/app.spec.ts
index 279bfb3ada..563deec623 100644
--- a/modules/admin/app/assets/js/dmeditor/app.spec.ts
+++ b/modules/admin/app/assets/js/dmeditor/app.spec.ts
@@ -1,10 +1,14 @@
-import {mount, flushPromises} from '@vue/test-utils';
+import {mount, flushPromises,config} from '@vue/test-utils';
 import App from './app.vue';
 import ListEt from './components/_list-et.vue';
 import EntityTypeMetadataApi from "./api";
 
 jest.mock('./api');
 
+config.global.mocks = {
+  '$t': (msg) => msg, // return i18n key
+}
+
 const defaultInit = {
   props: {
     service: {},
@@ -55,7 +59,9 @@ test('deleting a field', async () => {
   expect(wrapper.find(".fm-list").exists()).toBe(true);
   expect(wrapper.find("#fm-Country-history").exists()).toBe(true);
 
-  await wrapper.find("#fm-Country-history .fm-delete").trigger("click");
+  await wrapper.find("#fm-Country-history .fm-edit").trigger("click");
+  expect(wrapper.find("#delete-metadata").exists()).toBe(true);
+  await wrapper.find("#delete-metadata").trigger("click");
   expect(wrapper.find(".confirm-delete-field-metadata").exists()).toBe(true);
   await wrapper.find(".confirm-delete-field-metadata button.accept").trigger("click");
   await flushPromises();
diff --git a/modules/admin/app/assets/js/dmeditor/app.vue b/modules/admin/app/assets/js/dmeditor/app.vue
index d1947272cd..9f90a1bd61 100644
--- a/modules/admin/app/assets/js/dmeditor/app.vue
+++ b/modules/admin/app/assets/js/dmeditor/app.vue
@@ -1,6 +1,9 @@
 <script lang="ts">
 import ListEt from "./components/_list-et";
 import EntityTypeMetadataApi from "./api";
+import {VueI18n} from "vue-i18n";
+import Vue from "vue";
+
 
 export default {
   components: {ListEt},
diff --git a/modules/admin/app/assets/js/dmeditor/components/_list-et.vue b/modules/admin/app/assets/js/dmeditor/components/_list-et.vue
index f5be35a471..dc8cd830aa 100644
--- a/modules/admin/app/assets/js/dmeditor/components/_list-et.vue
+++ b/modules/admin/app/assets/js/dmeditor/components/_list-et.vue
@@ -19,10 +19,9 @@ export default {
       fieldMetadata: Object as Record<string, FieldMetadata[]>,
       templates: null as FieldMetadataTemplates | null,
       editET: null as EntityTypeMetadata | null,
-      addNew: null as FieldMetadata | null,
+      addFieldMeta: null as FieldMetadata | null,
+      editFieldMeta: null as FieldMetadata | null,
       addNewEntityType: null as Record<string, string> | null,
-      confirmDelete: null as { entityType: EntityType, id: string } | null,
-      deleting: null as { entityType: EntityType, id: string } | null,
     }
   },
   methods: {
@@ -38,42 +37,38 @@ export default {
         console.log(fm);
         this.fieldMetadata = fm;
 
-        let td = await this.api.templates();
-        console.log("Templates", td);
-        this.templates = td;
+        this.templates = await this.api.templates();
       } catch (e) {
         this.$emit('error', "Error fetching data model info from API", e);
       } finally {
         this.loading = false;
       }
     },
-    addNewFieldMetadata: function (entityType) {
-      this.addNew = {entityType};
-    },
     updateFieldMetadata: function (entityType, id) {
       this.$emit('update-field-metadata', entityType, id);
     },
-    deleteFieldMetadata: async function (entityType: EntityType, id: string) {
-      this.deleting = {entityType, id};
-      try {
-        await this.api.deleteField(entityType, id);
-        await this.reload();
-      } catch (e) {
-        this.$emit('error', "Error deleting field metadata", e);
-      } finally {
-        this.deleting = null;
-      }
-      this.$emit('delete-field-metadata', entityType, id);
+    addNewFieldMetadata: function (entityType) {
+      this.addFieldMeta = {entityType};
     },
     editFieldMetadata: function (fm: FieldMetadata) {
-      this.addNew = fm;
+      this.editFieldMeta = fm;
+    },
+    addEntityTypeMetadata: function (entityType: EntityType) {
+      this.editET = {
+        entityType,
+        name: this.$t(`contentTypes.${entityType}`),
+        description: ''
+      };
+    },
+    editEntityTypeMetadata: function (et: EntityTypeMetadata) {
+      this.editET = et;
     },
     fieldMetadataFor: function (entityType: string, cat: string) {
       let items = []
       let fieldMetaForType = this.fieldMetadata[entityType];
       if (fieldMetaForType) {
         for (let fm of fieldMetaForType) {
-          if (!fm.category || fm.category === cat) {
+          if ((!fm.category && cat === '_') || fm.category === cat) {
             items.push(fm);
           }
         }
@@ -106,7 +101,7 @@ export default {
                 <h3>
                     {{ entityTypeMetadata[entityType].name ? entityTypeMetadata[entityType].name : entityType }}
                     <a v-if="entityTypeMetadata[entityType]"
-                       v-on:click.prevent="editET = entityTypeMetadata[entityType]" href="#">
+                       v-on:click.prevent="editEntityTypeMetadata(entityTypeMetadata[entityType])" href="#">
                         <i class="fa fa-pencil"></i>
                     </a>
                 </h3>
@@ -129,15 +124,15 @@ export default {
                         <tr v-if="cat !== '_' && fieldMetadataFor(entityType, cat).length > 0"
                             v-bind:id="fieldRowId(entityType, cat)">
                             <td colspan="5" class="section">
-                                <h4>{{ cat }}</h4>
+                                <h4>{{ $t(`dataModel.${entityType}.${cat}`) }}</h4>
                             </td>
                         </tr>
 
                         <tr v-for="fm in fieldMetadataFor(entityType, cat)" v-bind:id="fieldRowId(entityType, fm.id)">
                             <td class="fm-name">{{ fm.name }}</td>
                             <td class="fm-usage" v-bind:class="fm.usage">
-                                <div v-if="fm.usage" v-bind:class="'badge badge-'+ fm.usage">{{ fm.usage }}</div>
-                                <div v-else class="badge badge-optional">optional</div>
+                                <div v-if="fm.usage" v-bind:class="'badge badge-'+ fm.usage">{{ $t(`dataModel.field.usage.${fm.usage}`) }}</div>
+                                <div v-else class="badge badge-optional">Optional</div>
                             </td>
                             <td class="fm-description">
                                 <markdown v-bind:content="fm.description"/>
@@ -146,38 +141,45 @@ export default {
                                 <a v-for="sa in fm.seeAlso" v-bind:href="sa">{{ sa }}</a>
                             </td>
                             <td class="fm-actions">
-                                <a class="fm-edit" v-on:click="editFieldMetadata(fm)" href="#">
+                                <a class="fm-edit" v-on:click.prevent="editFieldMetadata(fm)" href="#">
                                     <i class="fa fa-pencil"></i>
                                 </a>
-                                <a class="fm-delete" v-on:click="confirmDelete = {entityType: fm.entityType, id: fm.id}"
-                                   href="#">
-                                    <i v-if="deleting && deleting.entityType === fm.entityType && deleting.id === fm.id"
-                                       class="fa fa-spinner fa-spin"></i>
-                                    <i v-else class="fa fa-trash"></i>
-                                </a>
                             </td>
                         </tr>
                     </template>
                     </tbody>
                 </table>
                 <button class="btn btn-default" v-bind:id="'fm-editor-add-field-' + entityType"
-                        v-on:click="addNewFieldMetadata(entityType)">Add new field metadata
+                        v-on:click.prevent="addNewFieldMetadata(entityType)">Add new field metadata
                 </button>
 
                 <hr/>
             </template>
         </div>
         <template v-if="missingEntityTypes.length > 0" v-for="et in missingEntityTypes">
-            <button class="btn btn-default btn-lg" v-on:click="editET = {entityType: et, name: '', description: ''}">Add metadata for {{ et }}</button>
+            <button class="btn btn-default btn-lg" v-on:click.prevent="addEntityTypeMetadata(et)">Add metadata for {{ $t(`contentTypes.${et}`) }}</button>
             <hr/>
         </template>
-        <modal-fm-editor v-if="addNew !== null"
+        <modal-fm-editor v-if="addFieldMeta !== null"
+                         v-bind:api="api"
+                         v-bind:item="addFieldMeta"
+                         v-bind:templates="templates"
+                         v-bind:field-metadata="fieldMetadata"
+                         v-bind:editing="false"
+                         v-on:saved="addFieldMeta = null; reload()"
+                         v-on:deleted="reload"
+                         v-on:close="addFieldMeta = null"
+                         v-on:error="(...args) => $emit('error', ...args)">
+        </modal-fm-editor>
+        <modal-fm-editor v-if="editFieldMeta !== null"
                          v-bind:api="api"
-                         v-bind:item="addNew"
+                         v-bind:item="editFieldMeta"
                          v-bind:templates="templates"
                          v-bind:field-metadata="fieldMetadata"
-                         v-on:saved="addNew = null; reload()"
-                         v-on:close="addNew = null"
+                         v-bind:editing="true"
+                         v-on:saved="editFieldMeta = null; reload()"
+                         v-on:deleted="reload"
+                         v-on:close="editFieldMeta = null"
                          v-on:error="(...args) => $emit('error', ...args)">
         </modal-fm-editor>
         <modal-et-editor v-if="editET !== null"
@@ -185,53 +187,9 @@ export default {
                          v-bind:item="editET"
                          v-bind:entityTypeMetadata="entityTypeMetadata"
                          v-on:saved="editET = null; reload()"
+                         v-on:deleted="reload"
                          v-on:close="editET = null"
                          v-on:error="(...args) => $emit('error', ...args)">
         </modal-et-editor>
-        <modal-alert v-if="confirmDelete !== null"
-                     v-bind:title="'Delete Field Metadata'"
-                     v-bind:cls="'danger confirm-delete-field-metadata'"
-                     v-bind:accept="'Delete'"
-                     v-bind:cancel="'Cancel'"
-                     v-on:accept="deleteFieldMetadata(confirmDelete.entityType, confirmDelete.id); confirmDelete = null"
-                     v-on:close="confirmDelete = null">
-            <p>Are you sure you want to delete this field?</p>
-        </modal-alert>
     </div>
 </template>
-
-<style scoped>
-.section {
-    background-color: #dfdfdf;
-    font-weight: bold;
-}
-
-.fm-list td.fm-actions {
-    width: 5rem;
-}
-
-.fm-see-also a + a {
-    display: inline-block;
-}
-
-.fm-usage {
-    white-space: nowrap;
-
-}
-
-.fm-list td:last-child a {
-    margin-left: .5rem;
-}
-
-.badge-mandatory {
-    background-color: #fba8a6;
-}
-
-.badge-desirable {
-    background-color: #f8dab1;
-}
-
-.badge-optional {
-    background-color: #f5f5f5;
-}
-</style>
diff --git a/modules/admin/app/assets/js/dmeditor/components/_modal-et-editor.vue b/modules/admin/app/assets/js/dmeditor/components/_modal-et-editor.vue
index 8bd2f8c22a..466330fcfe 100644
--- a/modules/admin/app/assets/js/dmeditor/components/_modal-et-editor.vue
+++ b/modules/admin/app/assets/js/dmeditor/components/_modal-et-editor.vue
@@ -3,9 +3,10 @@
 import EntityTypeMetadataApi from "../api";
 import {EntityTypeMetadata} from "../types";
 import ModalWindow from "../../datasets/components/_modal-window";
+import ModalAlert from "../../datasets/components/_modal-alert.vue";
 
 export default {
-  components: {ModalWindow},
+  components: {ModalAlert, ModalWindow},
   props: {
     api: Object as EntityTypeMetadataApi,
     item: Object as EntityTypeMetadata,
@@ -14,6 +15,8 @@ export default {
   data() {
     return {
       saving: false,
+      deleting: false,
+      confirmDelete: false,
       name: this.item.name ? this.item.name : "",
       description: this.item.description ? this.item.description : ""
     }
@@ -33,18 +36,26 @@ export default {
         this.saving = false;
       }
     },
+    deleteEt: async function() {
+      this.deleting = true;
+      try {
+        await this.api.delete(this.item.entityType);
+        this.$emit('deleted');
+      } catch (e) {
+        this.$emit('error', "Error deleting entity type metadata", e);
+      } finally {
+        this.deleting = false;
+        this.$emit('close');
+      }
+    }
   },
-  created() {
-    console.log("Entity Type Metadata Editor", this.templates);
-
-  }
 }
 
 
 </script>
 
 <template>
-    <modal-window v-bind:resizable="true" v-on:close="$emit('close')">
+    <modal-window v-bind:resizable="true" v-on:close="$emit('close')" v-on:keyup.esc="$emit('close')">
         <template v-slot:title>Entity Type Metadata Editor</template>
         <fieldset id="entity-type-metadata-editor-form" class="options-form">
             <div class="form-group">
@@ -57,11 +68,26 @@ export default {
             </div>
         </fieldset>
         <template v-slot:footer>
-            <button class="btn btn-primary" v-on:click="save">Save</button>
+            <button v-if="item.created" class="btn btn-danger" id="delete-metadata" v-on:click="confirmDelete = true">
+                <i v-if="saving" class="fa fa-fw fa-circle-o-notch fa-spin"></i>
+                <i v-else class="fa fa-fw fa-trash-o"></i>
+                Delete Metadata
+            </button>
+            <button class="btn btn-primary" v-on:click="save">
+                <i v-if="saving" class="fa fa-fw fa-circle-o-notch fa-spin"></i>
+                <i v-else class="fa fa-fw fa-save"></i>
+                Save
+            </button>
+            <modal-alert v-if="confirmDelete"
+                         v-bind:title="'Delete Entity Type Metadata'"
+                         v-bind:cls="'danger confirm-delete-metadata'"
+                         v-bind:accept="'Delete'"
+                         v-bind:cancel="'Cancel'"
+                         v-on:accept="deleteEt"
+                         v-on:close="confirmDelete = false">
+                <p>Are you sure you want to delete this entity type metadata?
+                    All associated fields will be removed.</p>
+            </modal-alert>
         </template>
     </modal-window>
 </template>
-
-<style scoped>
-
-</style>
diff --git a/modules/admin/app/assets/js/dmeditor/components/_modal-fm-editor.vue b/modules/admin/app/assets/js/dmeditor/components/_modal-fm-editor.vue
index 447b9cf9b1..3872723080 100644
--- a/modules/admin/app/assets/js/dmeditor/components/_modal-fm-editor.vue
+++ b/modules/admin/app/assets/js/dmeditor/components/_modal-fm-editor.vue
@@ -1,21 +1,25 @@
 <script lang="ts">
 
 import EntityTypeMetadataApi from "../api";
-import {FieldMetadata, FieldMetadataTemplates} from "../types";
+import {EntityType, FieldMetadata, FieldMetadataTemplates} from "../types";
 import ModalWindow from "../../datasets/components/_modal-window";
 import MultiItem from "./_multi-item";
+import ModalAlert from "../../datasets/components/_modal-alert.vue";
 
 export default {
-  components: {ModalWindow, MultiItem},
+  components: {ModalAlert, ModalWindow, MultiItem},
   props: {
     api: Object as EntityTypeMetadataApi,
     item: Object as FieldMetadata,
     fieldMetadata: Object as Record<string, FieldMetadata[]>,
     templates: Object as FieldMetadataTemplates,
+    editing: Boolean
   },
   data() {
     return {
       saving: false,
+      deleting: false,
+      confirmDelete: false,
       et: this.item.entityType ? this.item.entityType : "",
       id: this.item.id ? this.item.id : "",
       name: this.item.name ? this.item.name : "",
@@ -43,44 +47,47 @@ export default {
         this.saving = false;
       }
     },
-    categoryFor: function (entityType, id) {
+    deleteField: async function (entityType: EntityType, id: string) {
+      this.deleting = true;
+      try {
+        await this.api.deleteField(this.et, this.id);
+        this.$emit('deleted');
+      } catch (e) {
+        this.$emit('error', "Error deleting field metadata", e);
+      } finally {
+        this.deleting = false;
+        this.$emit('close');
+      }
+      this.$emit('delete-field-metadata', entityType, id);
+    },
+    categoryForId: function (entityType: EntityType, id: string): string | null {
       for (let [category, fields] of Object.entries(this.templates[entityType])) {
         if (fields.includes(id)) {
-          return category;
+          return category === "_" ? null : category
         }
       }
       return null;
     },
-    idsForCategory: function(entityType, category) {
-        return category
-            ? this.templates[entityType][category]
-            : this.templates[entityType]["_"];
+    categoryName: function(entityType: EntityType, category: string): string {
+      return category === '_' ? '' : this.$t(`dataModel.${entityType}.${category}`);
+    },
+    isUsed: function (entityType, id): boolean {
+      return entityType in this.fieldMetadata
+          ? this.fieldMetadata[entityType].some(f => f.id === id)
+          : false;
     },
-    unusedIds: function (entityType) {
-      let used = new Set();
-      let items = this.fieldMetadata[entityType] as FieldMetadata[];
-      for (let fm of items) {
-        if (fm.entityType === entityType) {
-          used.add(fm.id);
-        }
-      }
-
-      let all = new Set();
-      for (let [_, fields] of Object.entries(this.templates[entityType])) {
-        for (let id in fields) {
-          all.add(id);
-        }
-      }
-      return Array.from(all).filter(id => !used.has(id));
-    }
   },
   computed: {
     categories: function () {
       return this.templates[this.et];
     },
-    hasCategories: function () {
-      // If there's a single blank category, then there are no categories
-      return !("_" in this.categories);
+    i18nPrefix: function() {
+      // hack where we lowercase the first letter of the entityType to
+      // prefix the i18n keys
+      return this.et.charAt(0).toLowerCase() + this.et.slice(1);
+    },
+    isValid: function() {
+      return Boolean(this.et) && Boolean(this.id) && Boolean(this.name);
     }
   },
   watch: {
@@ -93,37 +100,36 @@ export default {
         this.seeAlso = [];
       }
     },
+    id: function(value) {
+      let tNameKey = `${this.i18nPrefix}.${value}`;
+      let tDescKey = `${tNameKey}.description`;
+      if (tNameKey !== this.$t(tNameKey)) {
+        this.name = this.$t(tNameKey);
+      }
+      if (tDescKey !== this.$t(tDescKey)) {
+        this.description = this.$t(tDescKey);
+      }
+      this.category = this.categoryForId(this.et, value);
+    }
   },
-  created() {
-    console.log("Field Metadata Editor", this.templates);
-
-  }
 }
 
 
 </script>
 
 <template>
-    <modal-window v-bind:resizable="true" v-on:close="$emit('close')">
+    <modal-window v-bind:resizable="true" v-on:close="$emit('close')" v-on:keyup.esc="$emit('close')">
         <template v-slot:title>Field Metadata: {{ et }}</template>
 
         <fieldset id="field-metadata-editor-form" class="options-form">
-            <div class="form-group" v-if="hasCategories">
-                <label for="fm-category">Section</label>
-                <select id="fm-category" v-model="category" class="form-control">
-                    <option v-for="(_, category) in templates[et]">{{ category }}</option>
-                </select>
-            </div>
-
             <div class="form-group">
                 <label for="fm-id">Field ID</label>
-                <select id="fm-id" v-model="id" class="form-control"
-                        v-bind:readonly="!Boolean(et) || (hasCategories && !Boolean(category))">
-                    <option v-if="hasCategories && !Boolean(category)" value="">Select a section first...</option>
-                    <option v-else-if="!id" value="">Select a field ID...</option>
-                    
-                    <template v-if="et" v-for="field in idsForCategory(et, category)">
-                        <option v-bind:value="field">{{ field }}</option>
+                <select id="fm-id" v-model="id" class="form-control" v-bind:disabled="editing">
+                    <template v-if="et" v-for="(fields, category) in templates[et]">
+                        <option v-if="category === '_'" v-for="field in fields" v-bind:value="field">{{ field }}</option>
+                        <optgroup v-else v-bind:label="categoryName(et, category)">
+                            <option v-for="field in fields" v-bind:value="field" v-bind:disabled="isUsed(et, field)">{{ field }}</option>
+                        </optgroup>
                     </template>
                 </select>
             </div>
@@ -140,18 +146,32 @@ export default {
                 <label for="fm-usage">Usage</label>
                 <select id="fm-usage" v-model="usage" class="form-control">
                     <option v-for="usage in [null, 'desirable', 'mandatory']" v-bind:value="usage">
-                        {{ usage === null ? 'optional' : usage }}
+                        {{ usage === null ? 'Optional' : $t(`dataModel.field.usage.${usage}`) }}
                     </option>
                 </select>
             </div>
             <multi-item v-bind:label="'See Also'" v-model="seeAlso" v-bind:type="'url'" />
         </fieldset>
         <template v-slot:footer>
-            <button class="btn btn-primary" v-on:click="saveField">Save Field</button>
+            <button v-if="editing" class="btn btn-danger" id="delete-metadata" v-on:click="confirmDelete = true">
+                <i v-if="saving" class="fa fa-fw fa-circle-o-notch fa-spin"></i>
+                <i v-else class="fa fa-fw fa-trash-o"></i>
+                Delete Field Metadata
+            </button>
+            <button class="btn btn-primary" v-on:click="saveField" v-bind:disabled="!isValid">
+                <i v-if="saving" class="fa fa-fw fa-circle-o-notch fa-spin"></i>
+                <i v-else class="fa fa-fw fa-save"></i>
+                Save Field Metadata
+            </button>
+            <modal-alert v-if="confirmDelete"
+                         v-bind:title="'Delete Field Metadata'"
+                         v-bind:cls="'danger confirm-delete-field-metadata'"
+                         v-bind:accept="'Delete'"
+                         v-bind:cancel="'Cancel'"
+                         v-on:accept="deleteField(et, id)"
+                         v-on:close="confirmDelete = false">
+                <p>Are you sure you want to delete this field?</p>
+            </modal-alert>
         </template>
     </modal-window>
 </template>
-
-<style scoped>
-
-</style>
diff --git a/modules/admin/app/assets/js/lib/vue-i18n.global.js b/modules/admin/app/assets/js/lib/vue-i18n.global.js
new file mode 100644
index 0000000000..add83a4a95
--- /dev/null
+++ b/modules/admin/app/assets/js/lib/vue-i18n.global.js
@@ -0,0 +1,6690 @@
+/*!
+  * vue-i18n v9.13.1
+  * (c) 2024 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+var VueI18n = (function (exports, vue) {
+  'use strict';
+
+  /**
+   * Original Utilities
+   * written by kazuya kawaguchi
+   */
+  const inBrowser = typeof window !== 'undefined';
+  let mark;
+  let measure;
+  {
+      const perf = inBrowser && window.performance;
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          // @ts-ignore browser compat
+          perf.clearMeasures) {
+          mark = (tag) => {
+              perf.mark(tag);
+          };
+          measure = (name, startTag, endTag) => {
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
+          };
+      }
+  }
+  const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+  /* eslint-disable */
+  function format$1(message, ...args) {
+      if (args.length === 1 && isObject(args[0])) {
+          args = args[0];
+      }
+      if (!args || !args.hasOwnProperty) {
+          args = {};
+      }
+      return message.replace(RE_ARGS, (match, identifier) => {
+          return args.hasOwnProperty(identifier) ? args[identifier] : '';
+      });
+  }
+  const makeSymbol = (name, shareable = false) => !shareable ? Symbol(name) : Symbol.for(name);
+  const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+  const friendlyJSONstringify = (json) => JSON.stringify(json)
+      .replace(/\u2028/g, '\\u2028')
+      .replace(/\u2029/g, '\\u2029')
+      .replace(/\u0027/g, '\\u0027');
+  const isNumber = (val) => typeof val === 'number' && isFinite(val);
+  const isDate = (val) => toTypeString(val) === '[object Date]';
+  const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+  const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+  const assign = Object.assign;
+  let _globalThis;
+  const getGlobalThis = () => {
+      // prettier-ignore
+      return (_globalThis ||
+          (_globalThis =
+              typeof globalThis !== 'undefined'
+                  ? globalThis
+                  : typeof self !== 'undefined'
+                      ? self
+                      : typeof window !== 'undefined'
+                          ? window
+                          : typeof global !== 'undefined'
+                              ? global
+                              : {}));
+  };
+  function escapeHtml(rawText) {
+      return rawText
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/'/g, '&apos;');
+  }
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
+  }
+  /* eslint-enable */
+  /**
+   * Useful Utilities By Evan you
+   * Modified by kazuya kawaguchi
+   * MIT License
+   * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+   * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+   */
+  const isArray = Array.isArray;
+  const isFunction = (val) => typeof val === 'function';
+  const isString = (val) => typeof val === 'string';
+  const isBoolean = (val) => typeof val === 'boolean';
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const isObject = (val) => val !== null && typeof val === 'object';
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const isPromise = (val) => {
+      return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+  };
+  const objectToString = Object.prototype.toString;
+  const toTypeString = (value) => objectToString.call(value);
+  const isPlainObject = (val) => {
+      if (!isObject(val))
+          return false;
+      const proto = Object.getPrototypeOf(val);
+      return proto === null || proto.constructor === Object;
+  };
+  // for converting list and named values to displayed strings.
+  const toDisplayString = (val) => {
+      return val == null
+          ? ''
+          : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
+  };
+  function join(items, separator = '') {
+      return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+  }
+  const RANGE = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+      const lines = source.split(/\r?\n/);
+      let count = 0;
+      const res = [];
+      for (let i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      continue;
+                  const line = j + 1;
+                  res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                  const lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      const pad = start - (count - lineLength) + 1;
+                      const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                      res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          const length = Math.max(Math.min(end - count, lineLength), 1);
+                          res.push(`   |  ` + '^'.repeat(length));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
+          }
+      }
+      return res.join('\n');
+  }
+  function incrementer(code) {
+      let current = code;
+      return () => ++current;
+  }
+
+  function warn(msg, err) {
+      if (typeof console !== 'undefined') {
+          console.warn(`[intlify] ` + msg);
+          /* istanbul ignore if */
+          if (err) {
+              console.warn(err.stack);
+          }
+      }
+  }
+  const hasWarned = {};
+  function warnOnce(msg) {
+      if (!hasWarned[msg]) {
+          hasWarned[msg] = true;
+          warn(msg);
+      }
+  }
+
+  /**
+   * Event emitter, forked from the below:
+   * - original repository url: https://github.com/developit/mitt
+   * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+   * - author: Jason Miller (https://github.com/developit)
+   * - license: MIT
+   */
+  /**
+   * Create a event emitter
+   *
+   * @returns An event emitter
+   */
+  function createEmitter() {
+      const events = new Map();
+      const emitter = {
+          events,
+          on(event, handler) {
+              const handlers = events.get(event);
+              const added = handlers && handlers.push(handler);
+              if (!added) {
+                  events.set(event, [handler]);
+              }
+          },
+          off(event, handler) {
+              const handlers = events.get(event);
+              if (handlers) {
+                  handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+              }
+          },
+          emit(event, payload) {
+              (events.get(event) || [])
+                  .slice()
+                  .map(handler => handler(payload));
+              (events.get('*') || [])
+                  .slice()
+                  .map(handler => handler(event, payload));
+          }
+      };
+      return emitter;
+  }
+
+  const isNotObjectOrIsArray = (val) => !isObject(val) || isArray(val);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  function deepCopy(src, des) {
+      // src and des should both be objects, and none of them can be a array
+      if (isNotObjectOrIsArray(src) || isNotObjectOrIsArray(des)) {
+          throw new Error('Invalid value');
+      }
+      const stack = [{ src, des }];
+      while (stack.length) {
+          const { src, des } = stack.pop();
+          Object.keys(src).forEach(key => {
+              if (isNotObjectOrIsArray(src[key]) || isNotObjectOrIsArray(des[key])) {
+                  // replace with src[key] when:
+                  // src[key] or des[key] is not an object, or
+                  // src[key] or des[key] is an array
+                  des[key] = src[key];
+              }
+              else {
+                  // src[key] and des[key] are both objects, merge them
+                  stack.push({ src: src[key], des: des[key] });
+              }
+          });
+      }
+  }
+
+  function createPosition(line, column, offset) {
+      return { line, column, offset };
+  }
+  function createLocation(start, end, source) {
+      const loc = { start, end };
+      if (source != null) {
+          loc.source = source;
+      }
+      return loc;
+  }
+
+  const CompileWarnCodes = {
+      USE_MODULO_SYNTAX: 1,
+      __EXTEND_POINT__: 2
+  };
+  /** @internal */
+  const warnMessages$2 = {
+      [CompileWarnCodes.USE_MODULO_SYNTAX]: `Use modulo before '{{0}}'.`
+  };
+  function createCompileWarn(code, loc, ...args) {
+      const msg = format$1(warnMessages$2[code] || '', ...(args || [])) ;
+      const message = { message: String(msg), code };
+      if (loc) {
+          message.location = loc;
+      }
+      return message;
+  }
+
+  const CompileErrorCodes = {
+      // tokenizer error codes
+      EXPECTED_TOKEN: 1,
+      INVALID_TOKEN_IN_PLACEHOLDER: 2,
+      UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+      UNKNOWN_ESCAPE_SEQUENCE: 4,
+      INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+      UNBALANCED_CLOSING_BRACE: 6,
+      UNTERMINATED_CLOSING_BRACE: 7,
+      EMPTY_PLACEHOLDER: 8,
+      NOT_ALLOW_NEST_PLACEHOLDER: 9,
+      INVALID_LINKED_FORMAT: 10,
+      // parser error codes
+      MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+      UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+      UNEXPECTED_EMPTY_LINKED_KEY: 13,
+      UNEXPECTED_LEXICAL_ANALYSIS: 14,
+      // generator error codes
+      UNHANDLED_CODEGEN_NODE_TYPE: 15,
+      // minifier error codes
+      UNHANDLED_MINIFIER_NODE_TYPE: 16,
+      // Special value for higher-order compilers to pick up the last code
+      // to avoid collision of error codes. This should always be kept as the last
+      // item.
+      __EXTEND_POINT__: 17
+  };
+  /** @internal */
+  const errorMessages$2 = {
+      // tokenizer error messages
+      [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+      [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+      [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+      [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+      [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+      [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+      [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+      [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+      [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+      [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+      // parser error messages
+      [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+      [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+      [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+      [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+      // generator error messages
+      [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+      // minimizer error messages
+      [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+  };
+  function createCompileError(code, loc, options = {}) {
+      const { domain, messages, args } = options;
+      const msg = format$1((messages || errorMessages$2)[code] || '', ...(args || []))
+          ;
+      const error = new SyntaxError(String(msg));
+      error.code = code;
+      if (loc) {
+          error.location = loc;
+      }
+      error.domain = domain;
+      return error;
+  }
+  /** @internal */
+  function defaultOnError(error) {
+      throw error;
+  }
+
+  // eslint-disable-next-line no-useless-escape
+  const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+  const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+  const CHAR_SP = ' ';
+  const CHAR_CR = '\r';
+  const CHAR_LF = '\n';
+  const CHAR_LS = String.fromCharCode(0x2028);
+  const CHAR_PS = String.fromCharCode(0x2029);
+  function createScanner(str) {
+      const _buf = str;
+      let _index = 0;
+      let _line = 1;
+      let _column = 1;
+      let _peekOffset = 0;
+      const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+      const isLF = (index) => _buf[index] === CHAR_LF;
+      const isPS = (index) => _buf[index] === CHAR_PS;
+      const isLS = (index) => _buf[index] === CHAR_LS;
+      const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+      const index = () => _index;
+      const line = () => _line;
+      const column = () => _column;
+      const peekOffset = () => _peekOffset;
+      const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+      const currentChar = () => charAt(_index);
+      const currentPeek = () => charAt(_index + _peekOffset);
+      function next() {
+          _peekOffset = 0;
+          if (isLineEnd(_index)) {
+              _line++;
+              _column = 0;
+          }
+          if (isCRLF(_index)) {
+              _index++;
+          }
+          _index++;
+          _column++;
+          return _buf[_index];
+      }
+      function peek() {
+          if (isCRLF(_index + _peekOffset)) {
+              _peekOffset++;
+          }
+          _peekOffset++;
+          return _buf[_index + _peekOffset];
+      }
+      function reset() {
+          _index = 0;
+          _line = 1;
+          _column = 1;
+          _peekOffset = 0;
+      }
+      function resetPeek(offset = 0) {
+          _peekOffset = offset;
+      }
+      function skipToPeek() {
+          const target = _index + _peekOffset;
+          // eslint-disable-next-line no-unmodified-loop-condition
+          while (target !== _index) {
+              next();
+          }
+          _peekOffset = 0;
+      }
+      return {
+          index,
+          line,
+          column,
+          peekOffset,
+          charAt,
+          currentChar,
+          currentPeek,
+          next,
+          peek,
+          reset,
+          resetPeek,
+          skipToPeek
+      };
+  }
+
+  const EOF = undefined;
+  const DOT = '.';
+  const LITERAL_DELIMITER = "'";
+  const ERROR_DOMAIN$3 = 'tokenizer';
+  function createTokenizer(source, options = {}) {
+      const location = options.location !== false;
+      const _scnr = createScanner(source);
+      const currentOffset = () => _scnr.index();
+      const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+      const _initLoc = currentPosition();
+      const _initOffset = currentOffset();
+      const _context = {
+          currentType: 14 /* TokenTypes.EOF */,
+          offset: _initOffset,
+          startLoc: _initLoc,
+          endLoc: _initLoc,
+          lastType: 14 /* TokenTypes.EOF */,
+          lastOffset: _initOffset,
+          lastStartLoc: _initLoc,
+          lastEndLoc: _initLoc,
+          braceNest: 0,
+          inLinked: false,
+          text: ''
+      };
+      const context = () => _context;
+      const { onError } = options;
+      function emitError(code, pos, offset, ...args) {
+          const ctx = context();
+          pos.column += offset;
+          pos.offset += offset;
+          if (onError) {
+              const loc = location ? createLocation(ctx.startLoc, pos) : null;
+              const err = createCompileError(code, loc, {
+                  domain: ERROR_DOMAIN$3,
+                  args
+              });
+              onError(err);
+          }
+      }
+      function getToken(context, type, value) {
+          context.endLoc = currentPosition();
+          context.currentType = type;
+          const token = { type };
+          if (location) {
+              token.loc = createLocation(context.startLoc, context.endLoc);
+          }
+          if (value != null) {
+              token.value = value;
+          }
+          return token;
+      }
+      const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+      function eat(scnr, ch) {
+          if (scnr.currentChar() === ch) {
+              scnr.next();
+              return ch;
+          }
+          else {
+              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+              return '';
+          }
+      }
+      function peekSpaces(scnr) {
+          let buf = '';
+          while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+              buf += scnr.currentPeek();
+              scnr.peek();
+          }
+          return buf;
+      }
+      function skipSpaces(scnr) {
+          const buf = peekSpaces(scnr);
+          scnr.skipToPeek();
+          return buf;
+      }
+      function isIdentifierStart(ch) {
+          if (ch === EOF) {
+              return false;
+          }
+          const cc = ch.charCodeAt(0);
+          return ((cc >= 97 && cc <= 122) || // a-z
+              (cc >= 65 && cc <= 90) || // A-Z
+              cc === 95 // _
+          );
+      }
+      function isNumberStart(ch) {
+          if (ch === EOF) {
+              return false;
+          }
+          const cc = ch.charCodeAt(0);
+          return cc >= 48 && cc <= 57; // 0-9
+      }
+      function isNamedIdentifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = isIdentifierStart(scnr.currentPeek());
+          scnr.resetPeek();
+          return ret;
+      }
+      function isListIdentifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+          const ret = isNumberStart(ch);
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLiteralStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedDotStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedModifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = isIdentifierStart(scnr.currentPeek());
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedDelimiterStart(scnr, context) {
+          const { currentType } = context;
+          if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+              currentType === 12 /* TokenTypes.LinkedModifier */)) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedReferStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+              return false;
+          }
+          const fn = () => {
+              const ch = scnr.currentPeek();
+              if (ch === "{" /* TokenChars.BraceLeft */) {
+                  return isIdentifierStart(scnr.peek());
+              }
+              else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "%" /* TokenChars.Modulo */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                  ch === "." /* TokenChars.LinkedDot */ ||
+                  ch === CHAR_SP ||
+                  !ch) {
+                  return false;
+              }
+              else if (ch === CHAR_LF) {
+                  scnr.peek();
+                  return fn();
+              }
+              else {
+                  // other characters
+                  return isTextStart(scnr, false);
+              }
+          };
+          const ret = fn();
+          scnr.resetPeek();
+          return ret;
+      }
+      function isPluralStart(scnr) {
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function detectModuloStart(scnr) {
+          const spaces = peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+              scnr.peek() === "{" /* TokenChars.BraceLeft */;
+          scnr.resetPeek();
+          return {
+              isModulo: ret,
+              hasSpace: spaces.length > 0
+          };
+      }
+      function isTextStart(scnr, reset = true) {
+          const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+              const ch = scnr.currentPeek();
+              if (ch === "{" /* TokenChars.BraceLeft */) {
+                  return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+              }
+              else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                  return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+              }
+              else if (ch === "%" /* TokenChars.Modulo */) {
+                  scnr.peek();
+                  return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+              }
+              else if (ch === "|" /* TokenChars.Pipe */) {
+                  return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                      ? true
+                      : !(prev === CHAR_SP || prev === CHAR_LF);
+              }
+              else if (ch === CHAR_SP) {
+                  scnr.peek();
+                  return fn(true, CHAR_SP, detectModulo);
+              }
+              else if (ch === CHAR_LF) {
+                  scnr.peek();
+                  return fn(true, CHAR_LF, detectModulo);
+              }
+              else {
+                  return true;
+              }
+          };
+          const ret = fn();
+          reset && scnr.resetPeek();
+          return ret;
+      }
+      function takeChar(scnr, fn) {
+          const ch = scnr.currentChar();
+          if (ch === EOF) {
+              return EOF;
+          }
+          if (fn(ch)) {
+              scnr.next();
+              return ch;
+          }
+          return null;
+      }
+      function isIdentifier(ch) {
+          const cc = ch.charCodeAt(0);
+          return ((cc >= 97 && cc <= 122) || // a-z
+              (cc >= 65 && cc <= 90) || // A-Z
+              (cc >= 48 && cc <= 57) || // 0-9
+              cc === 95 || // _
+              cc === 36 // $
+          );
+      }
+      function takeIdentifierChar(scnr) {
+          return takeChar(scnr, isIdentifier);
+      }
+      function isNamedIdentifier(ch) {
+          const cc = ch.charCodeAt(0);
+          return ((cc >= 97 && cc <= 122) || // a-z
+              (cc >= 65 && cc <= 90) || // A-Z
+              (cc >= 48 && cc <= 57) || // 0-9
+              cc === 95 || // _
+              cc === 36 || // $
+              cc === 45 // -
+          );
+      }
+      function takeNamedIdentifierChar(scnr) {
+          return takeChar(scnr, isNamedIdentifier);
+      }
+      function isDigit(ch) {
+          const cc = ch.charCodeAt(0);
+          return cc >= 48 && cc <= 57; // 0-9
+      }
+      function takeDigit(scnr) {
+          return takeChar(scnr, isDigit);
+      }
+      function isHexDigit(ch) {
+          const cc = ch.charCodeAt(0);
+          return ((cc >= 48 && cc <= 57) || // 0-9
+              (cc >= 65 && cc <= 70) || // A-F
+              (cc >= 97 && cc <= 102)); // a-f
+      }
+      function takeHexDigit(scnr) {
+          return takeChar(scnr, isHexDigit);
+      }
+      function getDigits(scnr) {
+          let ch = '';
+          let num = '';
+          while ((ch = takeDigit(scnr))) {
+              num += ch;
+          }
+          return num;
+      }
+      function readModulo(scnr) {
+          skipSpaces(scnr);
+          const ch = scnr.currentChar();
+          if (ch !== "%" /* TokenChars.Modulo */) {
+              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+          }
+          scnr.next();
+          return "%" /* TokenChars.Modulo */;
+      }
+      function readText(scnr) {
+          let buf = '';
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+              const ch = scnr.currentChar();
+              if (ch === "{" /* TokenChars.BraceLeft */ ||
+                  ch === "}" /* TokenChars.BraceRight */ ||
+                  ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  !ch) {
+                  break;
+              }
+              else if (ch === "%" /* TokenChars.Modulo */) {
+                  if (isTextStart(scnr)) {
+                      buf += ch;
+                      scnr.next();
+                  }
+                  else {
+                      break;
+                  }
+              }
+              else if (ch === CHAR_SP || ch === CHAR_LF) {
+                  if (isTextStart(scnr)) {
+                      buf += ch;
+                      scnr.next();
+                  }
+                  else if (isPluralStart(scnr)) {
+                      break;
+                  }
+                  else {
+                      buf += ch;
+                      scnr.next();
+                  }
+              }
+              else {
+                  buf += ch;
+                  scnr.next();
+              }
+          }
+          return buf;
+      }
+      function readNamedIdentifier(scnr) {
+          skipSpaces(scnr);
+          let ch = '';
+          let name = '';
+          while ((ch = takeNamedIdentifierChar(scnr))) {
+              name += ch;
+          }
+          if (scnr.currentChar() === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+          }
+          return name;
+      }
+      function readListIdentifier(scnr) {
+          skipSpaces(scnr);
+          let value = '';
+          if (scnr.currentChar() === '-') {
+              scnr.next();
+              value += `-${getDigits(scnr)}`;
+          }
+          else {
+              value += getDigits(scnr);
+          }
+          if (scnr.currentChar() === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+          }
+          return value;
+      }
+      function isLiteral(ch) {
+          return ch !== LITERAL_DELIMITER && ch !== CHAR_LF;
+      }
+      function readLiteral(scnr) {
+          skipSpaces(scnr);
+          // eslint-disable-next-line no-useless-escape
+          eat(scnr, `\'`);
+          let ch = '';
+          let literal = '';
+          while ((ch = takeChar(scnr, isLiteral))) {
+              if (ch === '\\') {
+                  literal += readEscapeSequence(scnr);
+              }
+              else {
+                  literal += ch;
+              }
+          }
+          const current = scnr.currentChar();
+          if (current === CHAR_LF || current === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+              // TODO: Is it correct really?
+              if (current === CHAR_LF) {
+                  scnr.next();
+                  // eslint-disable-next-line no-useless-escape
+                  eat(scnr, `\'`);
+              }
+              return literal;
+          }
+          // eslint-disable-next-line no-useless-escape
+          eat(scnr, `\'`);
+          return literal;
+      }
+      function readEscapeSequence(scnr) {
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case '\\':
+              case `\'`: // eslint-disable-line no-useless-escape
+                  scnr.next();
+                  return `\\${ch}`;
+              case 'u':
+                  return readUnicodeEscapeSequence(scnr, ch, 4);
+              case 'U':
+                  return readUnicodeEscapeSequence(scnr, ch, 6);
+              default:
+                  emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                  return '';
+          }
+      }
+      function readUnicodeEscapeSequence(scnr, unicode, digits) {
+          eat(scnr, unicode);
+          let sequence = '';
+          for (let i = 0; i < digits; i++) {
+              const ch = takeHexDigit(scnr);
+              if (!ch) {
+                  emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                  break;
+              }
+              sequence += ch;
+          }
+          return `\\${unicode}${sequence}`;
+      }
+      function isInvalidIdentifier(ch) {
+          return (ch !== "{" /* TokenChars.BraceLeft */ &&
+              ch !== "}" /* TokenChars.BraceRight */ &&
+              ch !== CHAR_SP &&
+              ch !== CHAR_LF);
+      }
+      function readInvalidIdentifier(scnr) {
+          skipSpaces(scnr);
+          let ch = '';
+          let identifiers = '';
+          while ((ch = takeChar(scnr, isInvalidIdentifier))) {
+              identifiers += ch;
+          }
+          return identifiers;
+      }
+      function readLinkedModifier(scnr) {
+          let ch = '';
+          let name = '';
+          while ((ch = takeIdentifierChar(scnr))) {
+              name += ch;
+          }
+          return name;
+      }
+      function readLinkedRefer(scnr) {
+          const fn = (buf) => {
+              const ch = scnr.currentChar();
+              if (ch === "{" /* TokenChars.BraceLeft */ ||
+                  ch === "%" /* TokenChars.Modulo */ ||
+                  ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  ch === "(" /* TokenChars.ParenLeft */ ||
+                  ch === ")" /* TokenChars.ParenRight */ ||
+                  !ch) {
+                  return buf;
+              }
+              else if (ch === CHAR_SP) {
+                  return buf;
+              }
+              else if (ch === CHAR_LF || ch === DOT) {
+                  buf += ch;
+                  scnr.next();
+                  return fn(buf);
+              }
+              else {
+                  buf += ch;
+                  scnr.next();
+                  return fn(buf);
+              }
+          };
+          return fn('');
+      }
+      function readPlural(scnr) {
+          skipSpaces(scnr);
+          const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+          skipSpaces(scnr);
+          return plural;
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readTokenInPlaceholder(scnr, context) {
+          let token = null;
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case "{" /* TokenChars.BraceLeft */:
+                  if (context.braceNest >= 1) {
+                      emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                  }
+                  scnr.next();
+                  token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                  skipSpaces(scnr);
+                  context.braceNest++;
+                  return token;
+              case "}" /* TokenChars.BraceRight */:
+                  if (context.braceNest > 0 &&
+                      context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                      emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                  }
+                  scnr.next();
+                  token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                  context.braceNest--;
+                  context.braceNest > 0 && skipSpaces(scnr);
+                  if (context.inLinked && context.braceNest === 0) {
+                      context.inLinked = false;
+                  }
+                  return token;
+              case "@" /* TokenChars.LinkedAlias */:
+                  if (context.braceNest > 0) {
+                      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                  }
+                  token = readTokenInLinked(scnr, context) || getEndToken(context);
+                  context.braceNest = 0;
+                  return token;
+              default: {
+                  let validNamedIdentifier = true;
+                  let validListIdentifier = true;
+                  let validLiteral = true;
+                  if (isPluralStart(scnr)) {
+                      if (context.braceNest > 0) {
+                          emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                      }
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  if (context.braceNest > 0 &&
+                      (context.currentType === 5 /* TokenTypes.Named */ ||
+                          context.currentType === 6 /* TokenTypes.List */ ||
+                          context.currentType === 7 /* TokenTypes.Literal */)) {
+                      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                      context.braceNest = 0;
+                      return readToken(scnr, context);
+                  }
+                  if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                      token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                      token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if ((validLiteral = isLiteralStart(scnr, context))) {
+                      token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                      // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                      token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                      emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  break;
+              }
+          }
+          return token;
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readTokenInLinked(scnr, context) {
+          const { currentType } = context;
+          let token = null;
+          const ch = scnr.currentChar();
+          if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+              currentType === 9 /* TokenTypes.LinkedDot */ ||
+              currentType === 12 /* TokenTypes.LinkedModifier */ ||
+              currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+              (ch === CHAR_LF || ch === CHAR_SP)) {
+              emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+          }
+          switch (ch) {
+              case "@" /* TokenChars.LinkedAlias */:
+                  scnr.next();
+                  token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                  context.inLinked = true;
+                  return token;
+              case "." /* TokenChars.LinkedDot */:
+                  skipSpaces(scnr);
+                  scnr.next();
+                  return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+              case ":" /* TokenChars.LinkedDelimiter */:
+                  skipSpaces(scnr);
+                  scnr.next();
+                  return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+              default:
+                  if (isPluralStart(scnr)) {
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  if (isLinkedDotStart(scnr, context) ||
+                      isLinkedDelimiterStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      return readTokenInLinked(scnr, context);
+                  }
+                  if (isLinkedModifierStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                  }
+                  if (isLinkedReferStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      if (ch === "{" /* TokenChars.BraceLeft */) {
+                          // scan the placeholder
+                          return readTokenInPlaceholder(scnr, context) || token;
+                      }
+                      else {
+                          return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                      }
+                  }
+                  if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                      emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                  }
+                  context.braceNest = 0;
+                  context.inLinked = false;
+                  return readToken(scnr, context);
+          }
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readToken(scnr, context) {
+          let token = { type: 14 /* TokenTypes.EOF */ };
+          if (context.braceNest > 0) {
+              return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+          }
+          if (context.inLinked) {
+              return readTokenInLinked(scnr, context) || getEndToken(context);
+          }
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case "{" /* TokenChars.BraceLeft */:
+                  return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+              case "}" /* TokenChars.BraceRight */:
+                  emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                  scnr.next();
+                  return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+              case "@" /* TokenChars.LinkedAlias */:
+                  return readTokenInLinked(scnr, context) || getEndToken(context);
+              default: {
+                  if (isPluralStart(scnr)) {
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  const { isModulo, hasSpace } = detectModuloStart(scnr);
+                  if (isModulo) {
+                      return hasSpace
+                          ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                          : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                  }
+                  if (isTextStart(scnr)) {
+                      return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                  }
+                  break;
+              }
+          }
+          return token;
+      }
+      function nextToken() {
+          const { currentType, offset, startLoc, endLoc } = _context;
+          _context.lastType = currentType;
+          _context.lastOffset = offset;
+          _context.lastStartLoc = startLoc;
+          _context.lastEndLoc = endLoc;
+          _context.offset = currentOffset();
+          _context.startLoc = currentPosition();
+          if (_scnr.currentChar() === EOF) {
+              return getToken(_context, 14 /* TokenTypes.EOF */);
+          }
+          return readToken(_scnr, _context);
+      }
+      return {
+          nextToken,
+          currentOffset,
+          currentPosition,
+          context
+      };
+  }
+
+  const ERROR_DOMAIN$2 = 'parser';
+  // Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+  const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+  function fromEscapeSequence(match, codePoint4, codePoint6) {
+      switch (match) {
+          case `\\\\`:
+              return `\\`;
+          // eslint-disable-next-line no-useless-escape
+          case `\\\'`:
+              // eslint-disable-next-line no-useless-escape
+              return `\'`;
+          default: {
+              const codePoint = parseInt(codePoint4 || codePoint6, 16);
+              if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                  return String.fromCodePoint(codePoint);
+              }
+              // invalid ...
+              // Replace them with U+FFFD REPLACEMENT CHARACTER.
+              return '�';
+          }
+      }
+  }
+  function createParser(options = {}) {
+      const location = options.location !== false;
+      const { onError, onWarn } = options;
+      function emitError(tokenzer, code, start, offset, ...args) {
+          const end = tokenzer.currentPosition();
+          end.offset += offset;
+          end.column += offset;
+          if (onError) {
+              const loc = location ? createLocation(start, end) : null;
+              const err = createCompileError(code, loc, {
+                  domain: ERROR_DOMAIN$2,
+                  args
+              });
+              onError(err);
+          }
+      }
+      function emitWarn(tokenzer, code, start, offset, ...args) {
+          const end = tokenzer.currentPosition();
+          end.offset += offset;
+          end.column += offset;
+          if (onWarn) {
+              const loc = location ? createLocation(start, end) : null;
+              onWarn(createCompileWarn(code, loc, args));
+          }
+      }
+      function startNode(type, offset, loc) {
+          const node = { type };
+          if (location) {
+              node.start = offset;
+              node.end = offset;
+              node.loc = { start: loc, end: loc };
+          }
+          return node;
+      }
+      function endNode(node, offset, pos, type) {
+          if (type) {
+              node.type = type;
+          }
+          if (location) {
+              node.end = offset;
+              if (node.loc) {
+                  node.loc.end = pos;
+              }
+          }
+      }
+      function parseText(tokenizer, value) {
+          const context = tokenizer.context();
+          const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+          node.value = value;
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseList(tokenizer, index) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(5 /* NodeTypes.List */, offset, loc);
+          node.index = parseInt(index, 10);
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseNamed(tokenizer, key, modulo) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+          node.key = key;
+          if (modulo === true) {
+              node.modulo = true;
+          }
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLiteral(tokenizer, value) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+          node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLinkedModifier(tokenizer) {
+          const token = tokenizer.nextToken();
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+          const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+          if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+              // empty modifier
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+              node.value = '';
+              endNode(node, offset, loc);
+              return {
+                  nextConsumeToken: token,
+                  node
+              };
+          }
+          // check token
+          if (token.value == null) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+          }
+          node.value = token.value || '';
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return {
+              node
+          };
+      }
+      function parseLinkedKey(tokenizer, value) {
+          const context = tokenizer.context();
+          const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+          node.value = value;
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLinked(tokenizer) {
+          const context = tokenizer.context();
+          const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+          let token = tokenizer.nextToken();
+          if (token.type === 9 /* TokenTypes.LinkedDot */) {
+              const parsed = parseLinkedModifier(tokenizer);
+              linkedNode.modifier = parsed.node;
+              token = parsed.nextConsumeToken || tokenizer.nextToken();
+          }
+          // asset check token
+          if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+          }
+          token = tokenizer.nextToken();
+          // skip brace left
+          if (token.type === 2 /* TokenTypes.BraceLeft */) {
+              token = tokenizer.nextToken();
+          }
+          switch (token.type) {
+              case 11 /* TokenTypes.LinkedKey */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                  break;
+              case 5 /* TokenTypes.Named */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseNamed(tokenizer, token.value || '');
+                  break;
+              case 6 /* TokenTypes.List */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseList(tokenizer, token.value || '');
+                  break;
+              case 7 /* TokenTypes.Literal */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                  break;
+              default: {
+                  // empty key
+                  emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                  const nextContext = tokenizer.context();
+                  const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                  emptyLinkedKeyNode.value = '';
+                  endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                  linkedNode.key = emptyLinkedKeyNode;
+                  endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                  return {
+                      nextConsumeToken: token,
+                      node: linkedNode
+                  };
+              }
+          }
+          endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return {
+              node: linkedNode
+          };
+      }
+      function parseMessage(tokenizer) {
+          const context = tokenizer.context();
+          const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+              ? tokenizer.currentOffset()
+              : context.offset;
+          const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.endLoc
+              : context.startLoc;
+          const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+          node.items = [];
+          let nextToken = null;
+          let modulo = null;
+          do {
+              const token = nextToken || tokenizer.nextToken();
+              nextToken = null;
+              switch (token.type) {
+                  case 0 /* TokenTypes.Text */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseText(tokenizer, token.value || ''));
+                      break;
+                  case 6 /* TokenTypes.List */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseList(tokenizer, token.value || ''));
+                      break;
+                  case 4 /* TokenTypes.Modulo */:
+                      modulo = true;
+                      break;
+                  case 5 /* TokenTypes.Named */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseNamed(tokenizer, token.value || '', !!modulo));
+                      if (modulo) {
+                          emitWarn(tokenizer, CompileWarnCodes.USE_MODULO_SYNTAX, context.lastStartLoc, 0, getTokenCaption(token));
+                          modulo = null;
+                      }
+                      break;
+                  case 7 /* TokenTypes.Literal */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseLiteral(tokenizer, token.value || ''));
+                      break;
+                  case 8 /* TokenTypes.LinkedAlias */: {
+                      const parsed = parseLinked(tokenizer);
+                      node.items.push(parsed.node);
+                      nextToken = parsed.nextConsumeToken || null;
+                      break;
+                  }
+              }
+          } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+              context.currentType !== 1 /* TokenTypes.Pipe */);
+          // adjust message node loc
+          const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.lastOffset
+              : tokenizer.currentOffset();
+          const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.lastEndLoc
+              : tokenizer.currentPosition();
+          endNode(node, endOffset, endLoc);
+          return node;
+      }
+      function parsePlural(tokenizer, offset, loc, msgNode) {
+          const context = tokenizer.context();
+          let hasEmptyMessage = msgNode.items.length === 0;
+          const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+          node.cases = [];
+          node.cases.push(msgNode);
+          do {
+              const msg = parseMessage(tokenizer);
+              if (!hasEmptyMessage) {
+                  hasEmptyMessage = msg.items.length === 0;
+              }
+              node.cases.push(msg);
+          } while (context.currentType !== 14 /* TokenTypes.EOF */);
+          if (hasEmptyMessage) {
+              emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+          }
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseResource(tokenizer) {
+          const context = tokenizer.context();
+          const { offset, startLoc } = context;
+          const msgNode = parseMessage(tokenizer);
+          if (context.currentType === 14 /* TokenTypes.EOF */) {
+              return msgNode;
+          }
+          else {
+              return parsePlural(tokenizer, offset, startLoc, msgNode);
+          }
+      }
+      function parse(source) {
+          const tokenizer = createTokenizer(source, assign({}, options));
+          const context = tokenizer.context();
+          const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+          if (location && node.loc) {
+              node.loc.source = source;
+          }
+          node.body = parseResource(tokenizer);
+          if (options.onCacheKey) {
+              node.cacheKey = options.onCacheKey(source);
+          }
+          // assert whether achieved to EOF
+          if (context.currentType !== 14 /* TokenTypes.EOF */) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+          }
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      return { parse };
+  }
+  function getTokenCaption(token) {
+      if (token.type === 14 /* TokenTypes.EOF */) {
+          return 'EOF';
+      }
+      const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+      return name.length > 10 ? name.slice(0, 9) + '…' : name;
+  }
+
+  function createTransformer(ast, options = {} // eslint-disable-line
+  ) {
+      const _context = {
+          ast,
+          helpers: new Set()
+      };
+      const context = () => _context;
+      const helper = (name) => {
+          _context.helpers.add(name);
+          return name;
+      };
+      return { context, helper };
+  }
+  function traverseNodes(nodes, transformer) {
+      for (let i = 0; i < nodes.length; i++) {
+          traverseNode(nodes[i], transformer);
+      }
+  }
+  function traverseNode(node, transformer) {
+      // TODO: if we need pre-hook of transform, should be implemented to here
+      switch (node.type) {
+          case 1 /* NodeTypes.Plural */:
+              traverseNodes(node.cases, transformer);
+              transformer.helper("plural" /* HelperNameMap.PLURAL */);
+              break;
+          case 2 /* NodeTypes.Message */:
+              traverseNodes(node.items, transformer);
+              break;
+          case 6 /* NodeTypes.Linked */: {
+              const linked = node;
+              traverseNode(linked.key, transformer);
+              transformer.helper("linked" /* HelperNameMap.LINKED */);
+              transformer.helper("type" /* HelperNameMap.TYPE */);
+              break;
+          }
+          case 5 /* NodeTypes.List */:
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("list" /* HelperNameMap.LIST */);
+              break;
+          case 4 /* NodeTypes.Named */:
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("named" /* HelperNameMap.NAMED */);
+              break;
+      }
+      // TODO: if we need post-hook of transform, should be implemented to here
+  }
+  // transform AST
+  function transform(ast, options = {} // eslint-disable-line
+  ) {
+      const transformer = createTransformer(ast);
+      transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+      // traverse
+      ast.body && traverseNode(ast.body, transformer);
+      // set meta information
+      const context = transformer.context();
+      ast.helpers = Array.from(context.helpers);
+  }
+
+  function optimize(ast) {
+      const body = ast.body;
+      if (body.type === 2 /* NodeTypes.Message */) {
+          optimizeMessageNode(body);
+      }
+      else {
+          body.cases.forEach(c => optimizeMessageNode(c));
+      }
+      return ast;
+  }
+  function optimizeMessageNode(message) {
+      if (message.items.length === 1) {
+          const item = message.items[0];
+          if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+              message.static = item.value;
+              delete item.value; // optimization for size
+          }
+      }
+      else {
+          const values = [];
+          for (let i = 0; i < message.items.length; i++) {
+              const item = message.items[i];
+              if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                  break;
+              }
+              if (item.value == null) {
+                  break;
+              }
+              values.push(item.value);
+          }
+          if (values.length === message.items.length) {
+              message.static = join(values);
+              for (let i = 0; i < message.items.length; i++) {
+                  const item = message.items[i];
+                  if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                      delete item.value; // optimization for size
+                  }
+              }
+          }
+      }
+  }
+
+  const ERROR_DOMAIN$1 = 'minifier';
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  function minify(node) {
+      node.t = node.type;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */: {
+              const resource = node;
+              minify(resource.body);
+              resource.b = resource.body;
+              delete resource.body;
+              break;
+          }
+          case 1 /* NodeTypes.Plural */: {
+              const plural = node;
+              const cases = plural.cases;
+              for (let i = 0; i < cases.length; i++) {
+                  minify(cases[i]);
+              }
+              plural.c = cases;
+              delete plural.cases;
+              break;
+          }
+          case 2 /* NodeTypes.Message */: {
+              const message = node;
+              const items = message.items;
+              for (let i = 0; i < items.length; i++) {
+                  minify(items[i]);
+              }
+              message.i = items;
+              delete message.items;
+              if (message.static) {
+                  message.s = message.static;
+                  delete message.static;
+              }
+              break;
+          }
+          case 3 /* NodeTypes.Text */:
+          case 9 /* NodeTypes.Literal */:
+          case 8 /* NodeTypes.LinkedModifier */:
+          case 7 /* NodeTypes.LinkedKey */: {
+              const valueNode = node;
+              if (valueNode.value) {
+                  valueNode.v = valueNode.value;
+                  delete valueNode.value;
+              }
+              break;
+          }
+          case 6 /* NodeTypes.Linked */: {
+              const linked = node;
+              minify(linked.key);
+              linked.k = linked.key;
+              delete linked.key;
+              if (linked.modifier) {
+                  minify(linked.modifier);
+                  linked.m = linked.modifier;
+                  delete linked.modifier;
+              }
+              break;
+          }
+          case 5 /* NodeTypes.List */: {
+              const list = node;
+              list.i = list.index;
+              delete list.index;
+              break;
+          }
+          case 4 /* NodeTypes.Named */: {
+              const named = node;
+              named.k = named.key;
+              delete named.key;
+              break;
+          }
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN$1,
+                      args: [node.type]
+                  });
+              }
+      }
+      delete node.type;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  // eslint-disable-next-line @typescript-eslint/triple-slash-reference
+  /// <reference types="source-map-js" />
+  const ERROR_DOMAIN = 'parser';
+  function createCodeGenerator(ast, options) {
+      const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+      const location = options.location !== false;
+      const _context = {
+          filename,
+          code: '',
+          column: 1,
+          line: 1,
+          offset: 0,
+          map: undefined,
+          breakLineCode,
+          needIndent: _needIndent,
+          indentLevel: 0
+      };
+      if (location && ast.loc) {
+          _context.source = ast.loc.source;
+      }
+      const context = () => _context;
+      function push(code, node) {
+          _context.code += code;
+      }
+      function _newline(n, withBreakLine = true) {
+          const _breakLineCode = withBreakLine ? breakLineCode : '';
+          push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+      }
+      function indent(withNewLine = true) {
+          const level = ++_context.indentLevel;
+          withNewLine && _newline(level);
+      }
+      function deindent(withNewLine = true) {
+          const level = --_context.indentLevel;
+          withNewLine && _newline(level);
+      }
+      function newline() {
+          _newline(_context.indentLevel);
+      }
+      const helper = (key) => `_${key}`;
+      const needIndent = () => _context.needIndent;
+      return {
+          context,
+          push,
+          indent,
+          deindent,
+          newline,
+          helper,
+          needIndent
+      };
+  }
+  function generateLinkedNode(generator, node) {
+      const { helper } = generator;
+      generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+      generateNode(generator, node.key);
+      if (node.modifier) {
+          generator.push(`, `);
+          generateNode(generator, node.modifier);
+          generator.push(`, _type`);
+      }
+      else {
+          generator.push(`, undefined, _type`);
+      }
+      generator.push(`)`);
+  }
+  function generateMessageNode(generator, node) {
+      const { helper, needIndent } = generator;
+      generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+      generator.indent(needIndent());
+      const length = node.items.length;
+      for (let i = 0; i < length; i++) {
+          generateNode(generator, node.items[i]);
+          if (i === length - 1) {
+              break;
+          }
+          generator.push(', ');
+      }
+      generator.deindent(needIndent());
+      generator.push('])');
+  }
+  function generatePluralNode(generator, node) {
+      const { helper, needIndent } = generator;
+      if (node.cases.length > 1) {
+          generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+          generator.indent(needIndent());
+          const length = node.cases.length;
+          for (let i = 0; i < length; i++) {
+              generateNode(generator, node.cases[i]);
+              if (i === length - 1) {
+                  break;
+              }
+              generator.push(', ');
+          }
+          generator.deindent(needIndent());
+          generator.push(`])`);
+      }
+  }
+  function generateResource(generator, node) {
+      if (node.body) {
+          generateNode(generator, node.body);
+      }
+      else {
+          generator.push('null');
+      }
+  }
+  function generateNode(generator, node) {
+      const { helper } = generator;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */:
+              generateResource(generator, node);
+              break;
+          case 1 /* NodeTypes.Plural */:
+              generatePluralNode(generator, node);
+              break;
+          case 2 /* NodeTypes.Message */:
+              generateMessageNode(generator, node);
+              break;
+          case 6 /* NodeTypes.Linked */:
+              generateLinkedNode(generator, node);
+              break;
+          case 8 /* NodeTypes.LinkedModifier */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 7 /* NodeTypes.LinkedKey */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 5 /* NodeTypes.List */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+              break;
+          case 4 /* NodeTypes.Named */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+              break;
+          case 9 /* NodeTypes.Literal */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 3 /* NodeTypes.Text */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN,
+                      args: [node.type]
+                  });
+              }
+      }
+  }
+  // generate code from AST
+  const generate = (ast, options = {} // eslint-disable-line
+  ) => {
+      const mode = isString(options.mode) ? options.mode : 'normal';
+      const filename = isString(options.filename)
+          ? options.filename
+          : 'message.intl';
+      const sourceMap = !!options.sourceMap;
+      // prettier-ignore
+      const breakLineCode = options.breakLineCode != null
+          ? options.breakLineCode
+          : mode === 'arrow'
+              ? ';'
+              : '\n';
+      const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+      const helpers = ast.helpers || [];
+      const generator = createCodeGenerator(ast, {
+          mode,
+          filename,
+          sourceMap,
+          breakLineCode,
+          needIndent
+      });
+      generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+      generator.indent(needIndent);
+      if (helpers.length > 0) {
+          generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+          generator.newline();
+      }
+      generator.push(`return `);
+      generateNode(generator, ast);
+      generator.deindent(needIndent);
+      generator.push(`}`);
+      delete ast.helpers;
+      const { code, map } = generator.context();
+      return {
+          ast,
+          code,
+          map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+      };
+  };
+
+  function baseCompile$1(source, options = {}) {
+      const assignedOptions = assign({}, options);
+      const jit = !!assignedOptions.jit;
+      const enalbeMinify = !!assignedOptions.minify;
+      const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+      // parse source codes
+      const parser = createParser(assignedOptions);
+      const ast = parser.parse(source);
+      if (!jit) {
+          // transform ASTs
+          transform(ast, assignedOptions);
+          // generate javascript codes
+          return generate(ast, assignedOptions);
+      }
+      else {
+          // optimize ASTs
+          enambeOptimize && optimize(ast);
+          // minimize ASTs
+          enalbeMinify && minify(ast);
+          // In JIT mode, no ast transform, no code generation.
+          return { ast, code: '' };
+      }
+  }
+
+  const pathStateMachine =  [];
+  pathStateMachine[0 /* States.BEFORE_PATH */] = {
+      ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+      ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+  };
+  pathStateMachine[1 /* States.IN_PATH */] = {
+      ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+      ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+  };
+  pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+      ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+      ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
+  };
+  pathStateMachine[3 /* States.IN_IDENT */] = {
+      ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+      ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
+  };
+  pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+      ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+      ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+          4 /* States.IN_SUB_PATH */,
+          2 /* Actions.INC_SUB_PATH_DEPTH */
+      ],
+      ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+      ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
+  };
+  pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+      ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+      ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
+  };
+  pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+      ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+      ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
+  };
+  /**
+   * Check if an expression is a literal value.
+   */
+  const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+  function isLiteral(exp) {
+      return literalValueRE.test(exp);
+  }
+  /**
+   * Strip quotes from a string
+   */
+  function stripQuotes(str) {
+      const a = str.charCodeAt(0);
+      const b = str.charCodeAt(str.length - 1);
+      return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+  }
+  /**
+   * Determine the type of a character in a keypath.
+   */
+  function getPathCharType(ch) {
+      if (ch === undefined || ch === null) {
+          return "o" /* PathCharTypes.END_OF_FAIL */;
+      }
+      const code = ch.charCodeAt(0);
+      switch (code) {
+          case 0x5b: // [
+          case 0x5d: // ]
+          case 0x2e: // .
+          case 0x22: // "
+          case 0x27: // '
+              return ch;
+          case 0x5f: // _
+          case 0x24: // $
+          case 0x2d: // -
+              return "i" /* PathCharTypes.IDENT */;
+          case 0x09: // Tab (HT)
+          case 0x0a: // Newline (LF)
+          case 0x0d: // Return (CR)
+          case 0xa0: // No-break space (NBSP)
+          case 0xfeff: // Byte Order Mark (BOM)
+          case 0x2028: // Line Separator (LS)
+          case 0x2029: // Paragraph Separator (PS)
+              return "w" /* PathCharTypes.WORKSPACE */;
+      }
+      return "i" /* PathCharTypes.IDENT */;
+  }
+  /**
+   * Format a subPath, return its plain form if it is
+   * a literal string or number. Otherwise prepend the
+   * dynamic indicator (*).
+   */
+  function formatSubPath(path) {
+      const trimmed = path.trim();
+      // invalid leading 0
+      if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+          return false;
+      }
+      return isLiteral(trimmed)
+          ? stripQuotes(trimmed)
+          : "*" /* PathCharTypes.ASTARISK */ + trimmed;
+  }
+  /**
+   * Parse a string path into an array of segments
+   */
+  function parse(path) {
+      const keys = [];
+      let index = -1;
+      let mode = 0 /* States.BEFORE_PATH */;
+      let subPathDepth = 0;
+      let c;
+      let key; // eslint-disable-line
+      let newChar;
+      let type;
+      let transition;
+      let action;
+      let typeMap;
+      const actions = [];
+      actions[0 /* Actions.APPEND */] = () => {
+          if (key === undefined) {
+              key = newChar;
+          }
+          else {
+              key += newChar;
+          }
+      };
+      actions[1 /* Actions.PUSH */] = () => {
+          if (key !== undefined) {
+              keys.push(key);
+              key = undefined;
+          }
+      };
+      actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+          actions[0 /* Actions.APPEND */]();
+          subPathDepth++;
+      };
+      actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
+          if (subPathDepth > 0) {
+              subPathDepth--;
+              mode = 4 /* States.IN_SUB_PATH */;
+              actions[0 /* Actions.APPEND */]();
+          }
+          else {
+              subPathDepth = 0;
+              if (key === undefined) {
+                  return false;
+              }
+              key = formatSubPath(key);
+              if (key === false) {
+                  return false;
+              }
+              else {
+                  actions[1 /* Actions.PUSH */]();
+              }
+          }
+      };
+      function maybeUnescapeQuote() {
+          const nextChar = path[index + 1];
+          if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+              nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+              (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                  nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
+              index++;
+              newChar = '\\' + nextChar;
+              actions[0 /* Actions.APPEND */]();
+              return true;
+          }
+      }
+      while (mode !== null) {
+          index++;
+          c = path[index];
+          if (c === '\\' && maybeUnescapeQuote()) {
+              continue;
+          }
+          type = getPathCharType(c);
+          typeMap = pathStateMachine[mode];
+          transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
+          // check parse error
+          if (transition === 8 /* States.ERROR */) {
+              return;
+          }
+          mode = transition[0];
+          if (transition[1] !== undefined) {
+              action = actions[transition[1]];
+              if (action) {
+                  newChar = c;
+                  if (action() === false) {
+                      return;
+                  }
+              }
+          }
+          // check parse finish
+          if (mode === 7 /* States.AFTER_PATH */) {
+              return keys;
+          }
+      }
+  }
+  // path token cache
+  const cache = new Map();
+  /**
+   * key-value message resolver
+   *
+   * @remarks
+   * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+   *
+   * @param obj - A target object to be resolved with path
+   * @param path - A {@link Path | path} to resolve the value of message
+   *
+   * @returns A resolved {@link PathValue | path value}
+   *
+   * @VueI18nGeneral
+   */
+  function resolveWithKeyValue(obj, path) {
+      return isObject(obj) ? obj[path] : null;
+  }
+  /**
+   * message resolver
+   *
+   * @remarks
+   * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+   *
+   * @param obj - A target object to be resolved with path
+   * @param path - A {@link Path | path} to resolve the value of message
+   *
+   * @returns A resolved {@link PathValue | path value}
+   *
+   * @VueI18nGeneral
+   */
+  function resolveValue(obj, path) {
+      // check object
+      if (!isObject(obj)) {
+          return null;
+      }
+      // parse path
+      let hit = cache.get(path);
+      if (!hit) {
+          hit = parse(path);
+          if (hit) {
+              cache.set(path, hit);
+          }
+      }
+      // check hit
+      if (!hit) {
+          return null;
+      }
+      // resolve path value
+      const len = hit.length;
+      let last = obj;
+      let i = 0;
+      while (i < len) {
+          const val = last[hit[i]];
+          if (val === undefined) {
+              return null;
+          }
+          if (isFunction(last)) {
+              return null;
+          }
+          last = val;
+          i++;
+      }
+      return last;
+  }
+
+  const DEFAULT_MODIFIER = (str) => str;
+  const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+  const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+  const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : join(values);
+  const DEFAULT_INTERPOLATE = toDisplayString;
+  function pluralDefault(choice, choicesLength) {
+      choice = Math.abs(choice);
+      if (choicesLength === 2) {
+          // prettier-ignore
+          return choice
+              ? choice > 1
+                  ? 1
+                  : 0
+              : 1;
+      }
+      return choice ? Math.min(choice, 2) : 0;
+  }
+  function getPluralIndex(options) {
+      // prettier-ignore
+      const index = isNumber(options.pluralIndex)
+          ? options.pluralIndex
+          : -1;
+      // prettier-ignore
+      return options.named && (isNumber(options.named.count) || isNumber(options.named.n))
+          ? isNumber(options.named.count)
+              ? options.named.count
+              : isNumber(options.named.n)
+                  ? options.named.n
+                  : index
+          : index;
+  }
+  function normalizeNamed(pluralIndex, props) {
+      if (!props.count) {
+          props.count = pluralIndex;
+      }
+      if (!props.n) {
+          props.n = pluralIndex;
+      }
+  }
+  function createMessageContext(options = {}) {
+      const locale = options.locale;
+      const pluralIndex = getPluralIndex(options);
+      const pluralRule = isObject(options.pluralRules) &&
+          isString(locale) &&
+          isFunction(options.pluralRules[locale])
+          ? options.pluralRules[locale]
+          : pluralDefault;
+      const orgPluralRule = isObject(options.pluralRules) &&
+          isString(locale) &&
+          isFunction(options.pluralRules[locale])
+          ? pluralDefault
+          : undefined;
+      const plural = (messages) => {
+          return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+      };
+      const _list = options.list || [];
+      const list = (index) => _list[index];
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const _named = options.named || {};
+      isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+      const named = (key) => _named[key];
+      function message(key) {
+          // prettier-ignore
+          const msg = isFunction(options.messages)
+              ? options.messages(key)
+              : isObject(options.messages)
+                  ? options.messages[key]
+                  : false;
+          return !msg
+              ? options.parent
+                  ? options.parent.message(key) // resolve from parent messages
+                  : DEFAULT_MESSAGE
+              : msg;
+      }
+      const _modifier = (name) => options.modifiers
+          ? options.modifiers[name]
+          : DEFAULT_MODIFIER;
+      const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize)
+          ? options.processor.normalize
+          : DEFAULT_NORMALIZE;
+      const interpolate = isPlainObject(options.processor) &&
+          isFunction(options.processor.interpolate)
+          ? options.processor.interpolate
+          : DEFAULT_INTERPOLATE;
+      const type = isPlainObject(options.processor) && isString(options.processor.type)
+          ? options.processor.type
+          : DEFAULT_MESSAGE_DATA_TYPE;
+      const linked = (key, ...args) => {
+          const [arg1, arg2] = args;
+          let type = 'text';
+          let modifier = '';
+          if (args.length === 1) {
+              if (isObject(arg1)) {
+                  modifier = arg1.modifier || modifier;
+                  type = arg1.type || type;
+              }
+              else if (isString(arg1)) {
+                  modifier = arg1 || modifier;
+              }
+          }
+          else if (args.length === 2) {
+              if (isString(arg1)) {
+                  modifier = arg1 || modifier;
+              }
+              if (isString(arg2)) {
+                  type = arg2 || type;
+              }
+          }
+          const ret = message(key)(ctx);
+          const msg = 
+          // The message in vnode resolved with linked are returned as an array by processor.nomalize
+          type === 'vnode' && isArray(ret) && modifier
+              ? ret[0]
+              : ret;
+          return modifier ? _modifier(modifier)(msg, type) : msg;
+      };
+      const ctx = {
+          ["list" /* HelperNameMap.LIST */]: list,
+          ["named" /* HelperNameMap.NAMED */]: named,
+          ["plural" /* HelperNameMap.PLURAL */]: plural,
+          ["linked" /* HelperNameMap.LINKED */]: linked,
+          ["message" /* HelperNameMap.MESSAGE */]: message,
+          ["type" /* HelperNameMap.TYPE */]: type,
+          ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+          ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
+          ["values" /* HelperNameMap.VALUES */]: assign({}, _list, _named)
+      };
+      return ctx;
+  }
+
+  let devtools = null;
+  function setDevToolsHook(hook) {
+      devtools = hook;
+  }
+  function initI18nDevTools(i18n, version, meta) {
+      // TODO: queue if devtools is undefined
+      devtools &&
+          devtools.emit("i18n:init" /* IntlifyDevToolsHooks.I18nInit */, {
+              timestamp: Date.now(),
+              i18n,
+              version,
+              meta
+          });
+  }
+  const translateDevTools = /* #__PURE__*/ createDevToolsHook("function:translate" /* IntlifyDevToolsHooks.FunctionTranslate */);
+  function createDevToolsHook(hook) {
+      return (payloads) => devtools && devtools.emit(hook, payloads);
+  }
+
+  const code$3 = CompileWarnCodes.__EXTEND_POINT__;
+  const inc$3 = incrementer(code$3);
+  const CoreWarnCodes = {
+      NOT_FOUND_KEY: code$3, // 2
+      FALLBACK_TO_TRANSLATE: inc$3(), // 3
+      CANNOT_FORMAT_NUMBER: inc$3(), // 4
+      FALLBACK_TO_NUMBER_FORMAT: inc$3(), // 5
+      CANNOT_FORMAT_DATE: inc$3(), // 6
+      FALLBACK_TO_DATE_FORMAT: inc$3(), // 7
+      EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: inc$3(), // 8
+      __EXTEND_POINT__: inc$3() // 9
+  };
+  /** @internal */
+  const warnMessages$1 = {
+      [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+      [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+      [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+      [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+      [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+      [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
+      [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`
+  };
+  function getWarnMessage$1(code, ...args) {
+      return format$1(warnMessages$1[code], ...args);
+  }
+
+  const code$2 = CompileErrorCodes.__EXTEND_POINT__;
+  const inc$2 = incrementer(code$2);
+  const CoreErrorCodes = {
+      INVALID_ARGUMENT: code$2, // 17
+      INVALID_DATE_ARGUMENT: inc$2(), // 18
+      INVALID_ISO_DATE_ARGUMENT: inc$2(), // 19
+      NOT_SUPPORT_NON_STRING_MESSAGE: inc$2(), // 20
+      NOT_SUPPORT_LOCALE_PROMISE_VALUE: inc$2(), // 21
+      NOT_SUPPORT_LOCALE_ASYNC_FUNCTION: inc$2(), // 22
+      NOT_SUPPORT_LOCALE_TYPE: inc$2(), // 23
+      __EXTEND_POINT__: inc$2() // 24
+  };
+  function createCoreError(code) {
+      return createCompileError(code, null, { messages: errorMessages$1 } );
+  }
+  /** @internal */
+  const errorMessages$1 = {
+      [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',
+      [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +
+          'Make sure your Date represents a valid date.',
+      [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string',
+      [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]: 'Not support non-string message',
+      [CoreErrorCodes.NOT_SUPPORT_LOCALE_PROMISE_VALUE]: 'cannot support promise value',
+      [CoreErrorCodes.NOT_SUPPORT_LOCALE_ASYNC_FUNCTION]: 'cannot support async function',
+      [CoreErrorCodes.NOT_SUPPORT_LOCALE_TYPE]: 'cannot support locale type'
+  };
+
+  /** @internal */
+  function getLocale(context, options) {
+      return options.locale != null
+          ? resolveLocale(options.locale)
+          : resolveLocale(context.locale);
+  }
+  let _resolveLocale;
+  /** @internal */
+  function resolveLocale(locale) {
+      if (isString(locale)) {
+          return locale;
+      }
+      else {
+          if (isFunction(locale)) {
+              if (locale.resolvedOnce && _resolveLocale != null) {
+                  return _resolveLocale;
+              }
+              else if (locale.constructor.name === 'Function') {
+                  const resolve = locale();
+                  if (isPromise(resolve)) {
+                      throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_PROMISE_VALUE);
+                  }
+                  return (_resolveLocale = resolve);
+              }
+              else {
+                  throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_ASYNC_FUNCTION);
+              }
+          }
+          else {
+              throw createCoreError(CoreErrorCodes.NOT_SUPPORT_LOCALE_TYPE);
+          }
+      }
+  }
+  /**
+   * Fallback with simple implemenation
+   *
+   * @remarks
+   * A fallback locale function implemented with a simple fallback algorithm.
+   *
+   * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+   *
+   * @param ctx - A {@link CoreContext | context}
+   * @param fallback - A {@link FallbackLocale | fallback locale}
+   * @param start - A starting {@link Locale | locale}
+   *
+   * @returns Fallback locales
+   *
+   * @VueI18nGeneral
+   */
+  function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
+  ) {
+      // prettier-ignore
+      return [...new Set([
+              start,
+              ...(isArray(fallback)
+                  ? fallback
+                  : isObject(fallback)
+                      ? Object.keys(fallback)
+                      : isString(fallback)
+                          ? [fallback]
+                          : [start])
+          ])];
+  }
+  /**
+   * Fallback with locale chain
+   *
+   * @remarks
+   * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+   *
+   * @param ctx - A {@link CoreContext | context}
+   * @param fallback - A {@link FallbackLocale | fallback locale}
+   * @param start - A starting {@link Locale | locale}
+   *
+   * @returns Fallback locales
+   *
+   * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+   *
+   * @VueI18nGeneral
+   */
+  function fallbackWithLocaleChain(ctx, fallback, start) {
+      const startLocale = isString(start) ? start : DEFAULT_LOCALE;
+      const context = ctx;
+      if (!context.__localeChainCache) {
+          context.__localeChainCache = new Map();
+      }
+      let chain = context.__localeChainCache.get(startLocale);
+      if (!chain) {
+          chain = [];
+          // first block defined by start
+          let block = [start];
+          // while any intervening block found
+          while (isArray(block)) {
+              block = appendBlockToChain(chain, block, fallback);
+          }
+          // prettier-ignore
+          // last block defined by default
+          const defaults = isArray(fallback) || !isPlainObject(fallback)
+              ? fallback
+              : fallback['default']
+                  ? fallback['default']
+                  : null;
+          // convert defaults to array
+          block = isString(defaults) ? [defaults] : defaults;
+          if (isArray(block)) {
+              appendBlockToChain(chain, block, false);
+          }
+          context.__localeChainCache.set(startLocale, chain);
+      }
+      return chain;
+  }
+  function appendBlockToChain(chain, block, blocks) {
+      let follow = true;
+      for (let i = 0; i < block.length && isBoolean(follow); i++) {
+          const locale = block[i];
+          if (isString(locale)) {
+              follow = appendLocaleToChain(chain, block[i], blocks);
+          }
+      }
+      return follow;
+  }
+  function appendLocaleToChain(chain, locale, blocks) {
+      let follow;
+      const tokens = locale.split('-');
+      do {
+          const target = tokens.join('-');
+          follow = appendItemToChain(chain, target, blocks);
+          tokens.splice(-1, 1);
+      } while (tokens.length && follow === true);
+      return follow;
+  }
+  function appendItemToChain(chain, target, blocks) {
+      let follow = false;
+      if (!chain.includes(target)) {
+          follow = true;
+          if (target) {
+              follow = target[target.length - 1] !== '!';
+              const locale = target.replace(/!/g, '');
+              chain.push(locale);
+              if ((isArray(blocks) || isPlainObject(blocks)) &&
+                  blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any
+              ) {
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  follow = blocks[locale];
+              }
+          }
+      }
+      return follow;
+  }
+
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  /**
+   * Intlify core-base version
+   * @internal
+   */
+  const VERSION$1 = '9.13.1';
+  const NOT_REOSLVED = -1;
+  const DEFAULT_LOCALE = 'en-US';
+  const MISSING_RESOLVE_VALUE = '';
+  const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+  function getDefaultLinkedModifiers() {
+      return {
+          upper: (val, type) => {
+              // prettier-ignore
+              return type === 'text' && isString(val)
+                  ? val.toUpperCase()
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? val.children.toUpperCase()
+                      : val;
+          },
+          lower: (val, type) => {
+              // prettier-ignore
+              return type === 'text' && isString(val)
+                  ? val.toLowerCase()
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? val.children.toLowerCase()
+                      : val;
+          },
+          capitalize: (val, type) => {
+              // prettier-ignore
+              return (type === 'text' && isString(val)
+                  ? capitalize(val)
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? capitalize(val.children)
+                      : val);
+          }
+      };
+  }
+  let _compiler;
+  function registerMessageCompiler(compiler) {
+      _compiler = compiler;
+  }
+  let _resolver;
+  /**
+   * Register the message resolver
+   *
+   * @param resolver - A {@link MessageResolver} function
+   *
+   * @VueI18nGeneral
+   */
+  function registerMessageResolver(resolver) {
+      _resolver = resolver;
+  }
+  let _fallbacker;
+  /**
+   * Register the locale fallbacker
+   *
+   * @param fallbacker - A {@link LocaleFallbacker} function
+   *
+   * @VueI18nGeneral
+   */
+  function registerLocaleFallbacker(fallbacker) {
+      _fallbacker = fallbacker;
+  }
+  // Additional Meta for Intlify DevTools
+  let _additionalMeta =  null;
+  /* #__NO_SIDE_EFFECTS__ */
+  const setAdditionalMeta = (meta) => {
+      _additionalMeta = meta;
+  };
+  /* #__NO_SIDE_EFFECTS__ */
+  const getAdditionalMeta = () => _additionalMeta;
+  let _fallbackContext = null;
+  const setFallbackContext = (context) => {
+      _fallbackContext = context;
+  };
+  const getFallbackContext = () => _fallbackContext;
+  // ID for CoreContext
+  let _cid = 0;
+  function createCoreContext(options = {}) {
+      // setup options
+      const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;
+      const version = isString(options.version) ? options.version : VERSION$1;
+      const locale = isString(options.locale) || isFunction(options.locale)
+          ? options.locale
+          : DEFAULT_LOCALE;
+      const _locale = isFunction(locale) ? DEFAULT_LOCALE : locale;
+      const fallbackLocale = isArray(options.fallbackLocale) ||
+          isPlainObject(options.fallbackLocale) ||
+          isString(options.fallbackLocale) ||
+          options.fallbackLocale === false
+          ? options.fallbackLocale
+          : _locale;
+      const messages = isPlainObject(options.messages)
+          ? options.messages
+          : { [_locale]: {} };
+      const datetimeFormats = isPlainObject(options.datetimeFormats)
+              ? options.datetimeFormats
+              : { [_locale]: {} }
+          ;
+      const numberFormats = isPlainObject(options.numberFormats)
+              ? options.numberFormats
+              : { [_locale]: {} }
+          ;
+      const modifiers = assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
+      const pluralRules = options.pluralRules || {};
+      const missing = isFunction(options.missing) ? options.missing : null;
+      const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+          ? options.missingWarn
+          : true;
+      const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+          ? options.fallbackWarn
+          : true;
+      const fallbackFormat = !!options.fallbackFormat;
+      const unresolving = !!options.unresolving;
+      const postTranslation = isFunction(options.postTranslation)
+          ? options.postTranslation
+          : null;
+      const processor = isPlainObject(options.processor) ? options.processor : null;
+      const warnHtmlMessage = isBoolean(options.warnHtmlMessage)
+          ? options.warnHtmlMessage
+          : true;
+      const escapeParameter = !!options.escapeParameter;
+      const messageCompiler = isFunction(options.messageCompiler)
+          ? options.messageCompiler
+          : _compiler;
+      const messageResolver = isFunction(options.messageResolver)
+          ? options.messageResolver
+          : _resolver || resolveWithKeyValue;
+      const localeFallbacker = isFunction(options.localeFallbacker)
+          ? options.localeFallbacker
+          : _fallbacker || fallbackWithSimple;
+      const fallbackContext = isObject(options.fallbackContext)
+          ? options.fallbackContext
+          : undefined;
+      // setup internal options
+      const internalOptions = options;
+      const __datetimeFormatters = isObject(internalOptions.__datetimeFormatters)
+              ? internalOptions.__datetimeFormatters
+              : new Map()
+          ;
+      const __numberFormatters = isObject(internalOptions.__numberFormatters)
+              ? internalOptions.__numberFormatters
+              : new Map()
+          ;
+      const __meta = isObject(internalOptions.__meta) ? internalOptions.__meta : {};
+      _cid++;
+      const context = {
+          version,
+          cid: _cid,
+          locale,
+          fallbackLocale,
+          messages,
+          modifiers,
+          pluralRules,
+          missing,
+          missingWarn,
+          fallbackWarn,
+          fallbackFormat,
+          unresolving,
+          postTranslation,
+          processor,
+          warnHtmlMessage,
+          escapeParameter,
+          messageCompiler,
+          messageResolver,
+          localeFallbacker,
+          fallbackContext,
+          onWarn,
+          __meta
+      };
+      {
+          context.datetimeFormats = datetimeFormats;
+          context.numberFormats = numberFormats;
+          context.__datetimeFormatters = __datetimeFormatters;
+          context.__numberFormatters = __numberFormatters;
+      }
+      // for vue-devtools timeline event
+      {
+          context.__v_emitter =
+              internalOptions.__v_emitter != null
+                  ? internalOptions.__v_emitter
+                  : undefined;
+      }
+      // NOTE: experimental !!
+      {
+          initI18nDevTools(context, version, __meta);
+      }
+      return context;
+  }
+  /** @internal */
+  function isTranslateFallbackWarn(fallback, key) {
+      return fallback instanceof RegExp ? fallback.test(key) : fallback;
+  }
+  /** @internal */
+  function isTranslateMissingWarn(missing, key) {
+      return missing instanceof RegExp ? missing.test(key) : missing;
+  }
+  /** @internal */
+  function handleMissing(context, key, locale, missingWarn, type) {
+      const { missing, onWarn } = context;
+      // for vue-devtools timeline event
+      {
+          const emitter = context.__v_emitter;
+          if (emitter) {
+              emitter.emit("missing" /* VueDevToolsTimelineEvents.MISSING */, {
+                  locale,
+                  key,
+                  type,
+                  groupId: `${type}:${key}`
+              });
+          }
+      }
+      if (missing !== null) {
+          const ret = missing(context, locale, key, type);
+          return isString(ret) ? ret : key;
+      }
+      else {
+          if (isTranslateMissingWarn(missingWarn, key)) {
+              onWarn(getWarnMessage$1(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
+          }
+          return key;
+      }
+  }
+  /** @internal */
+  function updateFallbackLocale(ctx, locale, fallback) {
+      const context = ctx;
+      context.__localeChainCache = new Map();
+      ctx.localeFallbacker(ctx, fallback, locale);
+  }
+  /** @internal */
+  function isAlmostSameLocale(locale, compareLocale) {
+      if (locale === compareLocale)
+          return false;
+      return locale.split('-')[0] === compareLocale.split('-')[0];
+  }
+  /** @internal */
+  function isImplicitFallback(targetLocale, locales) {
+      const index = locales.indexOf(targetLocale);
+      if (index === -1) {
+          return false;
+      }
+      for (let i = index + 1; i < locales.length; i++) {
+          if (isAlmostSameLocale(targetLocale, locales[i])) {
+              return true;
+          }
+      }
+      return false;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  function format(ast) {
+      const msg = (ctx) => formatParts(ctx, ast);
+      return msg;
+  }
+  function formatParts(ctx, ast) {
+      const body = ast.b || ast.body;
+      if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+          const plural = body;
+          const cases = plural.c || plural.cases;
+          return ctx.plural(cases.reduce((messages, c) => [
+              ...messages,
+              formatMessageParts(ctx, c)
+          ], []));
+      }
+      else {
+          return formatMessageParts(ctx, body);
+      }
+  }
+  function formatMessageParts(ctx, node) {
+      const _static = node.s || node.static;
+      if (_static) {
+          return ctx.type === 'text'
+              ? _static
+              : ctx.normalize([_static]);
+      }
+      else {
+          const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+          return ctx.normalize(messages);
+      }
+  }
+  function formatMessagePart(ctx, node) {
+      const type = node.t || node.type;
+      switch (type) {
+          case 3 /* NodeTypes.Text */: {
+              const text = node;
+              return (text.v || text.value);
+          }
+          case 9 /* NodeTypes.Literal */: {
+              const literal = node;
+              return (literal.v || literal.value);
+          }
+          case 4 /* NodeTypes.Named */: {
+              const named = node;
+              return ctx.interpolate(ctx.named(named.k || named.key));
+          }
+          case 5 /* NodeTypes.List */: {
+              const list = node;
+              return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
+          }
+          case 6 /* NodeTypes.Linked */: {
+              const linked = node;
+              const modifier = linked.m || linked.modifier;
+              return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
+          }
+          case 7 /* NodeTypes.LinkedKey */: {
+              const linkedKey = node;
+              return (linkedKey.v || linkedKey.value);
+          }
+          case 8 /* NodeTypes.LinkedModifier */: {
+              const linkedModifier = node;
+              return (linkedModifier.v || linkedModifier.value);
+          }
+          default:
+              throw new Error(`unhandled node type on format message part: ${type}`);
+      }
+  }
+
+  const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
+  function checkHtmlMessage(source, warnHtmlMessage) {
+      if (warnHtmlMessage && detectHtmlTag(source)) {
+          warn(format$1(WARN_MESSAGE, { source }));
+      }
+  }
+  const defaultOnCacheKey = (message) => message;
+  let compileCache = Object.create(null);
+  function onCompileWarn(_warn) {
+      if (_warn.code === CompileWarnCodes.USE_MODULO_SYNTAX) {
+          warn(`The use of named interpolation with modulo syntax is deprecated. ` +
+              `It will be removed in v10.\n` +
+              `reference: https://vue-i18n.intlify.dev/guide/essentials/syntax#rails-i18n-format \n` +
+              `(message compiler warning message: ${_warn.message})`);
+      }
+  }
+  const isMessageAST = (val) => isObject(val) &&
+      (val.t === 0 || val.type === 0) &&
+      ('b' in val || 'body' in val);
+  function baseCompile(message, options = {}) {
+      // error detecting on compile
+      let detectError = false;
+      const onError = options.onError || defaultOnError;
+      options.onError = (err) => {
+          detectError = true;
+          onError(err);
+      };
+      // compile with mesasge-compiler
+      return { ...baseCompile$1(message, options), detectError };
+  }
+  function compile(message, context) {
+      // set onWarn
+      {
+          context.onWarn = onCompileWarn;
+      }
+      if (isString(message)) {
+          // check HTML message
+          const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
+              ? context.warnHtmlMessage
+              : true;
+          checkHtmlMessage(message, warnHtmlMessage);
+          // check caches
+          const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+          const cacheKey = onCacheKey(message);
+          const cached = compileCache[cacheKey];
+          if (cached) {
+              return cached;
+          }
+          // compile with JIT mode
+          const { ast, detectError } = baseCompile(message, {
+              ...context,
+              location: true,
+              jit: true
+          });
+          // compose message function from AST
+          const msg = format(ast);
+          // if occurred compile error, don't cache
+          return !detectError
+              ? (compileCache[cacheKey] = msg)
+              : msg;
+      }
+      else {
+          if (!isMessageAST(message)) {
+              warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
+              return (() => message);
+          }
+          // AST case (passed from bundler)
+          const cacheKey = message.cacheKey;
+          if (cacheKey) {
+              const cached = compileCache[cacheKey];
+              if (cached) {
+                  return cached;
+              }
+              // compose message function from message (AST)
+              return (compileCache[cacheKey] =
+                  format(message));
+          }
+          else {
+              return format(message);
+          }
+      }
+  }
+
+  const NOOP_MESSAGE_FUNCTION = () => '';
+  const isMessageFunction = (val) => isFunction(val);
+  // implementation of `translate` function
+  function translate(context, ...args) {
+      const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+      const [key, options] = parseTranslateArgs(...args);
+      const missingWarn = isBoolean(options.missingWarn)
+          ? options.missingWarn
+          : context.missingWarn;
+      const fallbackWarn = isBoolean(options.fallbackWarn)
+          ? options.fallbackWarn
+          : context.fallbackWarn;
+      const escapeParameter = isBoolean(options.escapeParameter)
+          ? options.escapeParameter
+          : context.escapeParameter;
+      const resolvedMessage = !!options.resolvedMessage;
+      // prettier-ignore
+      const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option
+          ? !isBoolean(options.default)
+              ? options.default
+              : (!messageCompiler ? () => key : key)
+          : fallbackFormat // default by `fallbackFormat` option
+              ? (!messageCompiler ? () => key : key)
+              : '';
+      const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';
+      const locale = getLocale(context, options);
+      // escape params
+      escapeParameter && escapeParams(options);
+      // resolve message format
+      // eslint-disable-next-line prefer-const
+      let [formatScope, targetLocale, message] = !resolvedMessage
+          ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+          : [
+              key,
+              locale,
+              messages[locale] || {}
+          ];
+      // NOTE:
+      //  Fix to work around `ssrTransfrom` bug in Vite.
+      //  https://github.com/vitejs/vite/issues/4306
+      //  To get around this, use temporary variables.
+      //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+      let format = formatScope;
+      // if you use default message, set it as message format!
+      let cacheBaseKey = key;
+      if (!resolvedMessage &&
+          !(isString(format) ||
+              isMessageAST(format) ||
+              isMessageFunction(format))) {
+          if (enableDefaultMsg) {
+              format = defaultMsgOrKey;
+              cacheBaseKey = format;
+          }
+      }
+      // checking message format and target locale
+      if (!resolvedMessage &&
+          (!(isString(format) ||
+              isMessageAST(format) ||
+              isMessageFunction(format)) ||
+              !isString(targetLocale))) {
+          return unresolving ? NOT_REOSLVED : key;
+      }
+      // TODO: refactor
+      if (isString(format) && context.messageCompiler == null) {
+          warn(`The message format compilation is not supported in this build. ` +
+              `Because message compiler isn't included. ` +
+              `You need to pre-compilation all message format. ` +
+              `So translate function return '${key}'.`);
+          return key;
+      }
+      // setup compile error detecting
+      let occurred = false;
+      const onError = () => {
+          occurred = true;
+      };
+      // compile message format
+      const msg = !isMessageFunction(format)
+          ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
+          : format;
+      // if occurred compile error, return the message format
+      if (occurred) {
+          return format;
+      }
+      // evaluate message with context
+      const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+      const msgContext = createMessageContext(ctxOptions);
+      const messaged = evaluateMessage(context, msg, msgContext);
+      // if use post translation option, proceed it with handler
+      const ret = postTranslation
+          ? postTranslation(messaged, key)
+          : messaged;
+      // NOTE: experimental !!
+      {
+          // prettier-ignore
+          const payloads = {
+              timestamp: Date.now(),
+              key: isString(key)
+                  ? key
+                  : isMessageFunction(format)
+                      ? format.key
+                      : '',
+              locale: targetLocale || (isMessageFunction(format)
+                  ? format.locale
+                  : ''),
+              format: isString(format)
+                  ? format
+                  : isMessageFunction(format)
+                      ? format.source
+                      : '',
+              message: ret
+          };
+          payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
+          translateDevTools(payloads);
+      }
+      return ret;
+  }
+  function escapeParams(options) {
+      if (isArray(options.list)) {
+          options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);
+      }
+      else if (isObject(options.named)) {
+          Object.keys(options.named).forEach(key => {
+              if (isString(options.named[key])) {
+                  options.named[key] = escapeHtml(options.named[key]);
+              }
+          });
+      }
+  }
+  function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+      const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+      const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+      let message = {};
+      let targetLocale;
+      let format = null;
+      let from = locale;
+      let to = null;
+      const type = 'translate';
+      for (let i = 0; i < locales.length; i++) {
+          targetLocale = to = locales[i];
+          if (locale !== targetLocale &&
+              !isAlmostSameLocale(locale, targetLocale) &&
+              isTranslateFallbackWarn(fallbackWarn, key)) {
+              onWarn(getWarnMessage$1(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
+                  key,
+                  target: targetLocale
+              }));
+          }
+          // for vue-devtools timeline event
+          if (locale !== targetLocale) {
+              const emitter = context.__v_emitter;
+              if (emitter) {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                      type,
+                      key,
+                      from,
+                      to,
+                      groupId: `${type}:${key}`
+                  });
+              }
+          }
+          message =
+              messages[targetLocale] || {};
+          // for vue-devtools timeline event
+          let start = null;
+          let startTag;
+          let endTag;
+          if (inBrowser) {
+              start = window.performance.now();
+              startTag = 'intlify-message-resolve-start';
+              endTag = 'intlify-message-resolve-end';
+              mark && mark(startTag);
+          }
+          if ((format = resolveValue(message, key)) === null) {
+              // if null, resolve with object key path
+              format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+          }
+          // for vue-devtools timeline event
+          if (inBrowser) {
+              const end = window.performance.now();
+              const emitter = context.__v_emitter;
+              if (emitter && start && format) {
+                  emitter.emit("message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */, {
+                      type: "message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */,
+                      key,
+                      message: format,
+                      time: end - start,
+                      groupId: `${type}:${key}`
+                  });
+              }
+              if (startTag && endTag && mark && measure) {
+                  mark(endTag);
+                  measure('intlify message resolve', startTag, endTag);
+              }
+          }
+          if (isString(format) || isMessageAST(format) || isMessageFunction(format)) {
+              break;
+          }
+          if (!isImplicitFallback(targetLocale, locales)) {
+              const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+              key, targetLocale, missingWarn, type);
+              if (missingRet !== key) {
+                  format = missingRet;
+              }
+          }
+          from = to;
+      }
+      return [format, targetLocale, message];
+  }
+  function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
+      const { messageCompiler, warnHtmlMessage } = context;
+      if (isMessageFunction(format)) {
+          const msg = format;
+          msg.locale = msg.locale || targetLocale;
+          msg.key = msg.key || key;
+          return msg;
+      }
+      if (messageCompiler == null) {
+          const msg = (() => format);
+          msg.locale = targetLocale;
+          msg.key = key;
+          return msg;
+      }
+      // for vue-devtools timeline event
+      let start = null;
+      let startTag;
+      let endTag;
+      if (inBrowser) {
+          start = window.performance.now();
+          startTag = 'intlify-message-compilation-start';
+          endTag = 'intlify-message-compilation-end';
+          mark && mark(startTag);
+      }
+      const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+      // for vue-devtools timeline event
+      if (inBrowser) {
+          const end = window.performance.now();
+          const emitter = context.__v_emitter;
+          if (emitter && start) {
+              emitter.emit("message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */, {
+                  type: "message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */,
+                  message: format,
+                  time: end - start,
+                  groupId: `${'translate'}:${key}`
+              });
+          }
+          if (startTag && endTag && mark && measure) {
+              mark(endTag);
+              measure('intlify message compilation', startTag, endTag);
+          }
+      }
+      msg.locale = targetLocale;
+      msg.key = key;
+      msg.source = format;
+      return msg;
+  }
+  function evaluateMessage(context, msg, msgCtx) {
+      // for vue-devtools timeline event
+      let start = null;
+      let startTag;
+      let endTag;
+      if (inBrowser) {
+          start = window.performance.now();
+          startTag = 'intlify-message-evaluation-start';
+          endTag = 'intlify-message-evaluation-end';
+          mark && mark(startTag);
+      }
+      const messaged = msg(msgCtx);
+      // for vue-devtools timeline event
+      if (inBrowser) {
+          const end = window.performance.now();
+          const emitter = context.__v_emitter;
+          if (emitter && start) {
+              emitter.emit("message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */, {
+                  type: "message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */,
+                  value: messaged,
+                  time: end - start,
+                  groupId: `${'translate'}:${msg.key}`
+              });
+          }
+          if (startTag && endTag && mark && measure) {
+              mark(endTag);
+              measure('intlify message evaluation', startTag, endTag);
+          }
+      }
+      return messaged;
+  }
+  /** @internal */
+  function parseTranslateArgs(...args) {
+      const [arg1, arg2, arg3] = args;
+      const options = {};
+      if (!isString(arg1) &&
+          !isNumber(arg1) &&
+          !isMessageFunction(arg1) &&
+          !isMessageAST(arg1)) {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      // prettier-ignore
+      const key = isNumber(arg1)
+          ? String(arg1)
+          : isMessageFunction(arg1)
+              ? arg1
+              : arg1;
+      if (isNumber(arg2)) {
+          options.plural = arg2;
+      }
+      else if (isString(arg2)) {
+          options.default = arg2;
+      }
+      else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
+          options.named = arg2;
+      }
+      else if (isArray(arg2)) {
+          options.list = arg2;
+      }
+      if (isNumber(arg3)) {
+          options.plural = arg3;
+      }
+      else if (isString(arg3)) {
+          options.default = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          assign(options, arg3);
+      }
+      return [key, options];
+  }
+  function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
+      return {
+          locale,
+          key,
+          warnHtmlMessage,
+          onError: (err) => {
+              onError && onError(err);
+              {
+                  const _source = getSourceForCodeFrame(source);
+                  const message = `Message compilation error: ${err.message}`;
+                  const codeFrame = err.location &&
+                      _source &&
+                      generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);
+                  const emitter = context.__v_emitter;
+                  if (emitter && _source) {
+                      emitter.emit("compile-error" /* VueDevToolsTimelineEvents.COMPILE_ERROR */, {
+                          message: _source,
+                          error: err.message,
+                          start: err.location && err.location.start.offset,
+                          end: err.location && err.location.end.offset,
+                          groupId: `${'translate'}:${key}`
+                      });
+                  }
+                  console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+              }
+          },
+          onCacheKey: (source) => generateFormatCacheKey(locale, key, source)
+      };
+  }
+  function getSourceForCodeFrame(source) {
+      if (isString(source)) {
+          return source;
+      }
+      else {
+          if (source.loc && source.loc.source) {
+              return source.loc.source;
+          }
+      }
+  }
+  function getMessageContextOptions(context, locale, message, options) {
+      const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+      const resolveMessage = (key) => {
+          let val = resolveValue(message, key);
+          // fallback to root context
+          if (val == null && fallbackContext) {
+              const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
+              val = resolveValue(message, key);
+          }
+          if (isString(val) || isMessageAST(val)) {
+              let occurred = false;
+              const onError = () => {
+                  occurred = true;
+              };
+              const msg = compileMessageFormat(context, key, locale, val, key, onError);
+              return !occurred
+                  ? msg
+                  : NOOP_MESSAGE_FUNCTION;
+          }
+          else if (isMessageFunction(val)) {
+              return val;
+          }
+          else {
+              // TODO: should be implemented warning message
+              return NOOP_MESSAGE_FUNCTION;
+          }
+      };
+      const ctxOptions = {
+          locale,
+          modifiers,
+          pluralRules,
+          messages: resolveMessage
+      };
+      if (context.processor) {
+          ctxOptions.processor = context.processor;
+      }
+      if (options.list) {
+          ctxOptions.list = options.list;
+      }
+      if (options.named) {
+          ctxOptions.named = options.named;
+      }
+      if (isNumber(options.plural)) {
+          ctxOptions.pluralIndex = options.plural;
+      }
+      return ctxOptions;
+  }
+
+  const intlDefined = typeof Intl !== 'undefined';
+  const Availabilities = {
+      dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
+      numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
+  };
+
+  // implementation of `datetime` function
+  function datetime(context, ...args) {
+      const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+      const { __datetimeFormatters } = context;
+      if (!Availabilities.dateTimeFormat) {
+          onWarn(getWarnMessage$1(CoreWarnCodes.CANNOT_FORMAT_DATE));
+          return MISSING_RESOLVE_VALUE;
+      }
+      const [key, value, options, overrides] = parseDateTimeArgs(...args);
+      const missingWarn = isBoolean(options.missingWarn)
+          ? options.missingWarn
+          : context.missingWarn;
+      const fallbackWarn = isBoolean(options.fallbackWarn)
+          ? options.fallbackWarn
+          : context.fallbackWarn;
+      const part = !!options.part;
+      const locale = getLocale(context, options);
+      const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+      fallbackLocale, locale);
+      if (!isString(key) || key === '') {
+          return new Intl.DateTimeFormat(locale, overrides).format(value);
+      }
+      // resolve format
+      let datetimeFormat = {};
+      let targetLocale;
+      let format = null;
+      let from = locale;
+      let to = null;
+      const type = 'datetime format';
+      for (let i = 0; i < locales.length; i++) {
+          targetLocale = to = locales[i];
+          if (locale !== targetLocale &&
+              isTranslateFallbackWarn(fallbackWarn, key)) {
+              onWarn(getWarnMessage$1(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+                  key,
+                  target: targetLocale
+              }));
+          }
+          // for vue-devtools timeline event
+          if (locale !== targetLocale) {
+              const emitter = context.__v_emitter;
+              if (emitter) {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                      type,
+                      key,
+                      from,
+                      to,
+                      groupId: `${type}:${key}`
+                  });
+              }
+          }
+          datetimeFormat =
+              datetimeFormats[targetLocale] || {};
+          format = datetimeFormat[key];
+          if (isPlainObject(format))
+              break;
+          handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+          from = to;
+      }
+      // checking format and target locale
+      if (!isPlainObject(format) || !isString(targetLocale)) {
+          return unresolving ? NOT_REOSLVED : key;
+      }
+      let id = `${targetLocale}__${key}`;
+      if (!isEmptyObject(overrides)) {
+          id = `${id}__${JSON.stringify(overrides)}`;
+      }
+      let formatter = __datetimeFormatters.get(id);
+      if (!formatter) {
+          formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
+          __datetimeFormatters.set(id, formatter);
+      }
+      return !part ? formatter.format(value) : formatter.formatToParts(value);
+  }
+  /** @internal */
+  const DATETIME_FORMAT_OPTIONS_KEYS = [
+      'localeMatcher',
+      'weekday',
+      'era',
+      'year',
+      'month',
+      'day',
+      'hour',
+      'minute',
+      'second',
+      'timeZoneName',
+      'formatMatcher',
+      'hour12',
+      'timeZone',
+      'dateStyle',
+      'timeStyle',
+      'calendar',
+      'dayPeriod',
+      'numberingSystem',
+      'hourCycle',
+      'fractionalSecondDigits'
+  ];
+  /** @internal */
+  function parseDateTimeArgs(...args) {
+      const [arg1, arg2, arg3, arg4] = args;
+      const options = {};
+      let overrides = {};
+      let value;
+      if (isString(arg1)) {
+          // Only allow ISO strings - other date formats are often supported,
+          // but may cause different results in different browsers.
+          const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+          if (!matches) {
+              throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+          }
+          // Some browsers can not parse the iso datetime separated by space,
+          // this is a compromise solution by replace the 'T'/' ' with 'T'
+          const dateTime = matches[3]
+              ? matches[3].trim().startsWith('T')
+                  ? `${matches[1].trim()}${matches[3].trim()}`
+                  : `${matches[1].trim()}T${matches[3].trim()}`
+              : matches[1].trim();
+          value = new Date(dateTime);
+          try {
+              // This will fail if the date is not valid
+              value.toISOString();
+          }
+          catch (e) {
+              throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+          }
+      }
+      else if (isDate(arg1)) {
+          if (isNaN(arg1.getTime())) {
+              throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+          }
+          value = arg1;
+      }
+      else if (isNumber(arg1)) {
+          value = arg1;
+      }
+      else {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      if (isString(arg2)) {
+          options.key = arg2;
+      }
+      else if (isPlainObject(arg2)) {
+          Object.keys(arg2).forEach(key => {
+              if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                  overrides[key] = arg2[key];
+              }
+              else {
+                  options[key] = arg2[key];
+              }
+          });
+      }
+      if (isString(arg3)) {
+          options.locale = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          overrides = arg3;
+      }
+      if (isPlainObject(arg4)) {
+          overrides = arg4;
+      }
+      return [options.key || '', value, options, overrides];
+  }
+  /** @internal */
+  function clearDateTimeFormat(ctx, locale, format) {
+      const context = ctx;
+      for (const key in format) {
+          const id = `${locale}__${key}`;
+          if (!context.__datetimeFormatters.has(id)) {
+              continue;
+          }
+          context.__datetimeFormatters.delete(id);
+      }
+  }
+
+  // implementation of `number` function
+  function number(context, ...args) {
+      const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+      const { __numberFormatters } = context;
+      if (!Availabilities.numberFormat) {
+          onWarn(getWarnMessage$1(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
+          return MISSING_RESOLVE_VALUE;
+      }
+      const [key, value, options, overrides] = parseNumberArgs(...args);
+      const missingWarn = isBoolean(options.missingWarn)
+          ? options.missingWarn
+          : context.missingWarn;
+      const fallbackWarn = isBoolean(options.fallbackWarn)
+          ? options.fallbackWarn
+          : context.fallbackWarn;
+      const part = !!options.part;
+      const locale = getLocale(context, options);
+      const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+      fallbackLocale, locale);
+      if (!isString(key) || key === '') {
+          return new Intl.NumberFormat(locale, overrides).format(value);
+      }
+      // resolve format
+      let numberFormat = {};
+      let targetLocale;
+      let format = null;
+      let from = locale;
+      let to = null;
+      const type = 'number format';
+      for (let i = 0; i < locales.length; i++) {
+          targetLocale = to = locales[i];
+          if (locale !== targetLocale &&
+              isTranslateFallbackWarn(fallbackWarn, key)) {
+              onWarn(getWarnMessage$1(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                  key,
+                  target: targetLocale
+              }));
+          }
+          // for vue-devtools timeline event
+          if (locale !== targetLocale) {
+              const emitter = context.__v_emitter;
+              if (emitter) {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                      type,
+                      key,
+                      from,
+                      to,
+                      groupId: `${type}:${key}`
+                  });
+              }
+          }
+          numberFormat =
+              numberFormats[targetLocale] || {};
+          format = numberFormat[key];
+          if (isPlainObject(format))
+              break;
+          handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+          from = to;
+      }
+      // checking format and target locale
+      if (!isPlainObject(format) || !isString(targetLocale)) {
+          return unresolving ? NOT_REOSLVED : key;
+      }
+      let id = `${targetLocale}__${key}`;
+      if (!isEmptyObject(overrides)) {
+          id = `${id}__${JSON.stringify(overrides)}`;
+      }
+      let formatter = __numberFormatters.get(id);
+      if (!formatter) {
+          formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));
+          __numberFormatters.set(id, formatter);
+      }
+      return !part ? formatter.format(value) : formatter.formatToParts(value);
+  }
+  /** @internal */
+  const NUMBER_FORMAT_OPTIONS_KEYS = [
+      'localeMatcher',
+      'style',
+      'currency',
+      'currencyDisplay',
+      'currencySign',
+      'useGrouping',
+      'minimumIntegerDigits',
+      'minimumFractionDigits',
+      'maximumFractionDigits',
+      'minimumSignificantDigits',
+      'maximumSignificantDigits',
+      'compactDisplay',
+      'notation',
+      'signDisplay',
+      'unit',
+      'unitDisplay',
+      'roundingMode',
+      'roundingPriority',
+      'roundingIncrement',
+      'trailingZeroDisplay'
+  ];
+  /** @internal */
+  function parseNumberArgs(...args) {
+      const [arg1, arg2, arg3, arg4] = args;
+      const options = {};
+      let overrides = {};
+      if (!isNumber(arg1)) {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      const value = arg1;
+      if (isString(arg2)) {
+          options.key = arg2;
+      }
+      else if (isPlainObject(arg2)) {
+          Object.keys(arg2).forEach(key => {
+              if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                  overrides[key] = arg2[key];
+              }
+              else {
+                  options[key] = arg2[key];
+              }
+          });
+      }
+      if (isString(arg3)) {
+          options.locale = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          overrides = arg3;
+      }
+      if (isPlainObject(arg4)) {
+          overrides = arg4;
+      }
+      return [options.key || '', value, options, overrides];
+  }
+  /** @internal */
+  function clearNumberFormat(ctx, locale, format) {
+      const context = ctx;
+      for (const key in format) {
+          const id = `${locale}__${key}`;
+          if (!context.__numberFormatters.has(id)) {
+              continue;
+          }
+          context.__numberFormatters.delete(id);
+      }
+  }
+
+  /**
+   * Vue I18n Version
+   *
+   * @remarks
+   * Semver format. Same format as the package.json `version` field.
+   *
+   * @VueI18nGeneral
+   */
+  const VERSION = '9.13.1';
+  /**
+   * This is only called development env
+   * istanbul-ignore-next
+   */
+  function initDev() {
+      {
+          {
+              console.info(`You are running a development build of vue-i18n.\n` +
+                  `Make sure to use the production build (*.prod.js) when deploying for production.`);
+          }
+      }
+  }
+
+  const code$1 = CoreWarnCodes.__EXTEND_POINT__;
+  const inc$1 = incrementer(code$1);
+  const I18nWarnCodes = {
+      FALLBACK_TO_ROOT: code$1, // 9
+      NOT_SUPPORTED_PRESERVE: inc$1(), // 10
+      NOT_SUPPORTED_FORMATTER: inc$1(), // 11
+      NOT_SUPPORTED_PRESERVE_DIRECTIVE: inc$1(), // 12
+      NOT_SUPPORTED_GET_CHOICE_INDEX: inc$1(), // 13
+      COMPONENT_NAME_LEGACY_COMPATIBLE: inc$1(), // 14
+      NOT_FOUND_PARENT_SCOPE: inc$1(), // 15
+      IGNORE_OBJ_FLATTEN: inc$1(), // 16
+      NOTICE_DROP_ALLOW_COMPOSITION: inc$1(), // 17
+      NOTICE_DROP_TRANSLATE_EXIST_COMPATIBLE_FLAG: inc$1() // 18
+  };
+  const warnMessages = {
+      [I18nWarnCodes.FALLBACK_TO_ROOT]: `Fall back to {type} '{key}' with root locale.`,
+      [I18nWarnCodes.NOT_SUPPORTED_PRESERVE]: `Not supported 'preserve'.`,
+      [I18nWarnCodes.NOT_SUPPORTED_FORMATTER]: `Not supported 'formatter'.`,
+      [I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE]: `Not supported 'preserveDirectiveContent'.`,
+      [I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX]: `Not supported 'getChoiceIndex'.`,
+      [I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE]: `Component name legacy compatible: '{name}' -> 'i18n'`,
+      [I18nWarnCodes.NOT_FOUND_PARENT_SCOPE]: `Not found parent scope. use the global scope.`,
+      [I18nWarnCodes.IGNORE_OBJ_FLATTEN]: `Ignore object flatten: '{key}' key has an string value`,
+      [I18nWarnCodes.NOTICE_DROP_ALLOW_COMPOSITION]: `'allowComposition' option will be dropped in the next major version. For more information, please see 👉 https://tinyurl.com/2p97mcze`,
+      [I18nWarnCodes.NOTICE_DROP_TRANSLATE_EXIST_COMPATIBLE_FLAG]: `'translateExistCompatible' option will be dropped in the next major version.`
+  };
+  function getWarnMessage(code, ...args) {
+      return format$1(warnMessages[code], ...args);
+  }
+
+  const code = CoreErrorCodes.__EXTEND_POINT__;
+  const inc = incrementer(code);
+  const I18nErrorCodes = {
+      // composer module errors
+      UNEXPECTED_RETURN_TYPE: code, // 24
+      // legacy module errors
+      INVALID_ARGUMENT: inc(), // 25
+      // i18n module errors
+      MUST_BE_CALL_SETUP_TOP: inc(), // 26
+      NOT_INSTALLED: inc(), // 27
+      NOT_AVAILABLE_IN_LEGACY_MODE: inc(), // 28
+      // directive module errors
+      REQUIRED_VALUE: inc(), // 29
+      INVALID_VALUE: inc(), // 30
+      // vue-devtools errors
+      CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN: inc(), // 31
+      NOT_INSTALLED_WITH_PROVIDE: inc(), // 32
+      // unexpected error
+      UNEXPECTED_ERROR: inc(), // 33
+      // not compatible legacy vue-i18n constructor
+      NOT_COMPATIBLE_LEGACY_VUE_I18N: inc(), // 34
+      // bridge support vue 2.x only
+      BRIDGE_SUPPORT_VUE_2_ONLY: inc(), // 35
+      // need to define `i18n` option in `allowComposition: true` and `useScope: 'local' at `useI18n``
+      MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION: inc(), // 36
+      // Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly
+      NOT_AVAILABLE_COMPOSITION_IN_LEGACY: inc(), // 37
+      // for enhancement
+      __EXTEND_POINT__: inc() // 38
+  };
+  function createI18nError(code, ...args) {
+      return createCompileError(code, null, { messages: errorMessages, args } );
+  }
+  const errorMessages = {
+      [I18nErrorCodes.UNEXPECTED_RETURN_TYPE]: 'Unexpected return type in composer',
+      [I18nErrorCodes.INVALID_ARGUMENT]: 'Invalid argument',
+      [I18nErrorCodes.MUST_BE_CALL_SETUP_TOP]: 'Must be called at the top of a `setup` function',
+      [I18nErrorCodes.NOT_INSTALLED]: 'Need to install with `app.use` function',
+      [I18nErrorCodes.UNEXPECTED_ERROR]: 'Unexpected error',
+      [I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE]: 'Not available in legacy mode',
+      [I18nErrorCodes.REQUIRED_VALUE]: `Required in value: {0}`,
+      [I18nErrorCodes.INVALID_VALUE]: `Invalid value`,
+      [I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN]: `Cannot setup vue-devtools plugin`,
+      [I18nErrorCodes.NOT_INSTALLED_WITH_PROVIDE]: 'Need to install with `provide` function',
+      [I18nErrorCodes.NOT_COMPATIBLE_LEGACY_VUE_I18N]: 'Not compatible legacy VueI18n.',
+      [I18nErrorCodes.BRIDGE_SUPPORT_VUE_2_ONLY]: 'vue-i18n-bridge support Vue 2.x only',
+      [I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION]: 'Must define ‘i18n’ option or custom block in Composition API with using local scope in Legacy API mode',
+      [I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY]: 'Not available Compostion API in Legacy API mode. Please make sure that the legacy API mode is working properly'
+  };
+
+  const TranslateVNodeSymbol = 
+  /* #__PURE__*/ makeSymbol('__translateVNode');
+  const DatetimePartsSymbol = /* #__PURE__*/ makeSymbol('__datetimeParts');
+  const NumberPartsSymbol = /* #__PURE__*/ makeSymbol('__numberParts');
+  const EnableEmitter = /* #__PURE__*/ makeSymbol('__enableEmitter');
+  const DisableEmitter = /* #__PURE__*/ makeSymbol('__disableEmitter');
+  const SetPluralRulesSymbol = makeSymbol('__setPluralRules');
+  const InejctWithOptionSymbol = 
+  /* #__PURE__*/ makeSymbol('__injectWithOption');
+  const DisposeSymbol = /* #__PURE__*/ makeSymbol('__dispose');
+  const __VUE_I18N_BRIDGE__ =  '__VUE_I18N_BRIDGE__';
+
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  /**
+   * Transform flat json in obj to normal json in obj
+   */
+  function handleFlatJson(obj) {
+      // check obj
+      if (!isObject(obj)) {
+          return obj;
+      }
+      for (const key in obj) {
+          // check key
+          if (!hasOwn(obj, key)) {
+              continue;
+          }
+          // handle for normal json
+          if (!key.includes('.')) {
+              // recursive process value if value is also a object
+              if (isObject(obj[key])) {
+                  handleFlatJson(obj[key]);
+              }
+          }
+          // handle for flat json, transform to normal json
+          else {
+              // go to the last object
+              const subKeys = key.split('.');
+              const lastIndex = subKeys.length - 1;
+              let currentObj = obj;
+              let hasStringValue = false;
+              for (let i = 0; i < lastIndex; i++) {
+                  if (!(subKeys[i] in currentObj)) {
+                      currentObj[subKeys[i]] = {};
+                  }
+                  if (!isObject(currentObj[subKeys[i]])) {
+                      warn(getWarnMessage(I18nWarnCodes.IGNORE_OBJ_FLATTEN, {
+                              key: subKeys[i]
+                          }));
+                      hasStringValue = true;
+                      break;
+                  }
+                  currentObj = currentObj[subKeys[i]];
+              }
+              // update last object value, delete old property
+              if (!hasStringValue) {
+                  currentObj[subKeys[lastIndex]] = obj[key];
+                  delete obj[key];
+              }
+              // recursive process value if value is also a object
+              if (isObject(currentObj[subKeys[lastIndex]])) {
+                  handleFlatJson(currentObj[subKeys[lastIndex]]);
+              }
+          }
+      }
+      return obj;
+  }
+  function getLocaleMessages(locale, options) {
+      const { messages, __i18n, messageResolver, flatJson } = options;
+      // prettier-ignore
+      const ret = (isPlainObject(messages)
+          ? messages
+          : isArray(__i18n)
+              ? {}
+              : { [locale]: {} });
+      // merge locale messages of i18n custom block
+      if (isArray(__i18n)) {
+          __i18n.forEach(custom => {
+              if ('locale' in custom && 'resource' in custom) {
+                  const { locale, resource } = custom;
+                  if (locale) {
+                      ret[locale] = ret[locale] || {};
+                      deepCopy(resource, ret[locale]);
+                  }
+                  else {
+                      deepCopy(resource, ret);
+                  }
+              }
+              else {
+                  isString(custom) && deepCopy(JSON.parse(custom), ret);
+              }
+          });
+      }
+      // handle messages for flat json
+      if (messageResolver == null && flatJson) {
+          for (const key in ret) {
+              if (hasOwn(ret, key)) {
+                  handleFlatJson(ret[key]);
+              }
+          }
+      }
+      return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function getComponentOptions(instance) {
+      return instance.type ;
+  }
+  function adjustI18nResources(gl, options, componentOptions // eslint-disable-line @typescript-eslint/no-explicit-any
+  ) {
+      let messages = isObject(options.messages) ? options.messages : {};
+      if ('__i18nGlobal' in componentOptions) {
+          messages = getLocaleMessages(gl.locale.value, {
+              messages,
+              __i18n: componentOptions.__i18nGlobal
+          });
+      }
+      // merge locale messages
+      const locales = Object.keys(messages);
+      if (locales.length) {
+          locales.forEach(locale => {
+              gl.mergeLocaleMessage(locale, messages[locale]);
+          });
+      }
+      {
+          // merge datetime formats
+          if (isObject(options.datetimeFormats)) {
+              const locales = Object.keys(options.datetimeFormats);
+              if (locales.length) {
+                  locales.forEach(locale => {
+                      gl.mergeDateTimeFormat(locale, options.datetimeFormats[locale]);
+                  });
+              }
+          }
+          // merge number formats
+          if (isObject(options.numberFormats)) {
+              const locales = Object.keys(options.numberFormats);
+              if (locales.length) {
+                  locales.forEach(locale => {
+                      gl.mergeNumberFormat(locale, options.numberFormats[locale]);
+                  });
+              }
+          }
+      }
+  }
+  function createTextNode(key) {
+      return vue.createVNode(vue.Text, null, key, 0)
+          ;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  // extend VNode interface
+  const DEVTOOLS_META = '__INTLIFY_META__';
+  const NOOP_RETURN_ARRAY = () => [];
+  const NOOP_RETURN_FALSE = () => false;
+  let composerID = 0;
+  function defineCoreMissingHandler(missing) {
+      return ((ctx, locale, key, type) => {
+          return missing(locale, key, vue.getCurrentInstance() || undefined, type);
+      });
+  }
+  // for Intlify DevTools
+  /* #__NO_SIDE_EFFECTS__ */
+  const getMetaInfo = () => {
+      const instance = vue.getCurrentInstance();
+      let meta = null; // eslint-disable-line @typescript-eslint/no-explicit-any
+      return instance && (meta = getComponentOptions(instance)[DEVTOOLS_META])
+          ? { [DEVTOOLS_META]: meta } // eslint-disable-line @typescript-eslint/no-explicit-any
+          : null;
+  };
+  /**
+   * Create composer interface factory
+   *
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  function createComposer(options = {}, VueI18nLegacy) {
+      const { __root, __injectWithOption } = options;
+      const _isGlobal = __root === undefined;
+      const flatJson = options.flatJson;
+      const _ref = inBrowser ? vue.ref : vue.shallowRef;
+      const translateExistCompatible = !!options.translateExistCompatible;
+      {
+          if (translateExistCompatible && !false) {
+              warnOnce(getWarnMessage(I18nWarnCodes.NOTICE_DROP_TRANSLATE_EXIST_COMPATIBLE_FLAG));
+          }
+      }
+      let _inheritLocale = isBoolean(options.inheritLocale)
+          ? options.inheritLocale
+          : true;
+      const _locale = _ref(
+      // prettier-ignore
+      __root && _inheritLocale
+          ? __root.locale.value
+          : isString(options.locale)
+              ? options.locale
+              : DEFAULT_LOCALE);
+      const _fallbackLocale = _ref(
+      // prettier-ignore
+      __root && _inheritLocale
+          ? __root.fallbackLocale.value
+          : isString(options.fallbackLocale) ||
+              isArray(options.fallbackLocale) ||
+              isPlainObject(options.fallbackLocale) ||
+              options.fallbackLocale === false
+              ? options.fallbackLocale
+              : _locale.value);
+      const _messages = _ref(getLocaleMessages(_locale.value, options));
+      // prettier-ignore
+      const _datetimeFormats = _ref(isPlainObject(options.datetimeFormats)
+              ? options.datetimeFormats
+              : { [_locale.value]: {} })
+          ;
+      // prettier-ignore
+      const _numberFormats = _ref(isPlainObject(options.numberFormats)
+              ? options.numberFormats
+              : { [_locale.value]: {} })
+          ;
+      // warning suppress options
+      // prettier-ignore
+      let _missingWarn = __root
+          ? __root.missingWarn
+          : isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+              ? options.missingWarn
+              : true;
+      // prettier-ignore
+      let _fallbackWarn = __root
+          ? __root.fallbackWarn
+          : isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+              ? options.fallbackWarn
+              : true;
+      // prettier-ignore
+      let _fallbackRoot = __root
+          ? __root.fallbackRoot
+          : isBoolean(options.fallbackRoot)
+              ? options.fallbackRoot
+              : true;
+      // configure fall back to root
+      let _fallbackFormat = !!options.fallbackFormat;
+      // runtime missing
+      let _missing = isFunction(options.missing) ? options.missing : null;
+      let _runtimeMissing = isFunction(options.missing)
+          ? defineCoreMissingHandler(options.missing)
+          : null;
+      // postTranslation handler
+      let _postTranslation = isFunction(options.postTranslation)
+          ? options.postTranslation
+          : null;
+      // prettier-ignore
+      let _warnHtmlMessage = __root
+          ? __root.warnHtmlMessage
+          : isBoolean(options.warnHtmlMessage)
+              ? options.warnHtmlMessage
+              : true;
+      let _escapeParameter = !!options.escapeParameter;
+      // custom linked modifiers
+      // prettier-ignore
+      const _modifiers = __root
+          ? __root.modifiers
+          : isPlainObject(options.modifiers)
+              ? options.modifiers
+              : {};
+      // pluralRules
+      let _pluralRules = options.pluralRules || (__root && __root.pluralRules);
+      // runtime context
+      // eslint-disable-next-line prefer-const
+      let _context;
+      const getCoreContext = () => {
+          _isGlobal && setFallbackContext(null);
+          const ctxOptions = {
+              version: VERSION,
+              locale: _locale.value,
+              fallbackLocale: _fallbackLocale.value,
+              messages: _messages.value,
+              modifiers: _modifiers,
+              pluralRules: _pluralRules,
+              missing: _runtimeMissing === null ? undefined : _runtimeMissing,
+              missingWarn: _missingWarn,
+              fallbackWarn: _fallbackWarn,
+              fallbackFormat: _fallbackFormat,
+              unresolving: true,
+              postTranslation: _postTranslation === null ? undefined : _postTranslation,
+              warnHtmlMessage: _warnHtmlMessage,
+              escapeParameter: _escapeParameter,
+              messageResolver: options.messageResolver,
+              messageCompiler: options.messageCompiler,
+              __meta: { framework: 'vue' }
+          };
+          {
+              ctxOptions.datetimeFormats = _datetimeFormats.value;
+              ctxOptions.numberFormats = _numberFormats.value;
+              ctxOptions.__datetimeFormatters = isPlainObject(_context)
+                  ? _context.__datetimeFormatters
+                  : undefined;
+              ctxOptions.__numberFormatters = isPlainObject(_context)
+                  ? _context.__numberFormatters
+                  : undefined;
+          }
+          {
+              ctxOptions.__v_emitter = isPlainObject(_context)
+                  ? _context.__v_emitter
+                  : undefined;
+          }
+          const ctx = createCoreContext(ctxOptions);
+          _isGlobal && setFallbackContext(ctx);
+          return ctx;
+      };
+      _context = getCoreContext();
+      updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+      // track reactivity
+      function trackReactivityValues() {
+          return [
+                  _locale.value,
+                  _fallbackLocale.value,
+                  _messages.value,
+                  _datetimeFormats.value,
+                  _numberFormats.value
+              ]
+              ;
+      }
+      // locale
+      const locale = vue.computed({
+          get: () => _locale.value,
+          set: val => {
+              _locale.value = val;
+              _context.locale = _locale.value;
+          }
+      });
+      // fallbackLocale
+      const fallbackLocale = vue.computed({
+          get: () => _fallbackLocale.value,
+          set: val => {
+              _fallbackLocale.value = val;
+              _context.fallbackLocale = _fallbackLocale.value;
+              updateFallbackLocale(_context, _locale.value, val);
+          }
+      });
+      // messages
+      const messages = vue.computed(() => _messages.value);
+      // datetimeFormats
+      const datetimeFormats = /* #__PURE__*/ vue.computed(() => _datetimeFormats.value);
+      // numberFormats
+      const numberFormats = /* #__PURE__*/ vue.computed(() => _numberFormats.value);
+      // getPostTranslationHandler
+      function getPostTranslationHandler() {
+          return isFunction(_postTranslation) ? _postTranslation : null;
+      }
+      // setPostTranslationHandler
+      function setPostTranslationHandler(handler) {
+          _postTranslation = handler;
+          _context.postTranslation = handler;
+      }
+      // getMissingHandler
+      function getMissingHandler() {
+          return _missing;
+      }
+      // setMissingHandler
+      function setMissingHandler(handler) {
+          if (handler !== null) {
+              _runtimeMissing = defineCoreMissingHandler(handler);
+          }
+          _missing = handler;
+          _context.missing = _runtimeMissing;
+      }
+      function isResolvedTranslateMessage(type, arg // eslint-disable-line @typescript-eslint/no-explicit-any
+      ) {
+          return type !== 'translate' || !arg.resolvedMessage;
+      }
+      const wrapWithDeps = (fn, argumentParser, warnType, fallbackSuccess, fallbackFail, successCondition) => {
+          trackReactivityValues(); // track reactive dependency
+          // NOTE: experimental !!
+          let ret;
+          try {
+              if (true || false) {
+                  setAdditionalMeta(getMetaInfo());
+              }
+              if (!_isGlobal) {
+                  _context.fallbackContext = __root
+                      ? getFallbackContext()
+                      : undefined;
+              }
+              ret = fn(_context);
+          }
+          finally {
+              if (!_isGlobal) {
+                  _context.fallbackContext = undefined;
+              }
+          }
+          if ((warnType !== 'translate exists' && // for not `te` (e.g `t`)
+              isNumber(ret) &&
+              ret === NOT_REOSLVED) ||
+              (warnType === 'translate exists' && !ret) // for `te`
+          ) {
+              const [key, arg2] = argumentParser();
+              if (__root &&
+                  isString(key) &&
+                  isResolvedTranslateMessage(warnType, arg2)) {
+                  if (_fallbackRoot &&
+                      (isTranslateFallbackWarn(_fallbackWarn, key) ||
+                          isTranslateMissingWarn(_missingWarn, key))) {
+                      warn(getWarnMessage(I18nWarnCodes.FALLBACK_TO_ROOT, {
+                          key,
+                          type: warnType
+                      }));
+                  }
+                  // for vue-devtools timeline event
+                  {
+                      const { __v_emitter: emitter } = _context;
+                      if (emitter && _fallbackRoot) {
+                          emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                              type: warnType,
+                              key,
+                              to: 'global',
+                              groupId: `${warnType}:${key}`
+                          });
+                      }
+                  }
+              }
+              return __root && _fallbackRoot
+                  ? fallbackSuccess(__root)
+                  : fallbackFail(key);
+          }
+          else if (successCondition(ret)) {
+              return ret;
+          }
+          else {
+              /* istanbul ignore next */
+              throw createI18nError(I18nErrorCodes.UNEXPECTED_RETURN_TYPE);
+          }
+      };
+      // t
+      function t(...args) {
+          return wrapWithDeps(context => Reflect.apply(translate, null, [context, ...args]), () => parseTranslateArgs(...args), 'translate', root => Reflect.apply(root.t, root, [...args]), key => key, val => isString(val));
+      }
+      // rt
+      function rt(...args) {
+          const [arg1, arg2, arg3] = args;
+          if (arg3 && !isObject(arg3)) {
+              throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+          }
+          return t(...[arg1, arg2, assign({ resolvedMessage: true }, arg3 || {})]);
+      }
+      // d
+      function d(...args) {
+          return wrapWithDeps(context => Reflect.apply(datetime, null, [context, ...args]), () => parseDateTimeArgs(...args), 'datetime format', root => Reflect.apply(root.d, root, [...args]), () => MISSING_RESOLVE_VALUE, val => isString(val));
+      }
+      // n
+      function n(...args) {
+          return wrapWithDeps(context => Reflect.apply(number, null, [context, ...args]), () => parseNumberArgs(...args), 'number format', root => Reflect.apply(root.n, root, [...args]), () => MISSING_RESOLVE_VALUE, val => isString(val));
+      }
+      // for custom processor
+      function normalize(values) {
+          return values.map(val => isString(val) || isNumber(val) || isBoolean(val)
+              ? createTextNode(String(val))
+              : val);
+      }
+      const interpolate = (val) => val;
+      const processor = {
+          normalize,
+          interpolate,
+          type: 'vnode'
+      };
+      // translateVNode, using for `i18n-t` component
+      function translateVNode(...args) {
+          return wrapWithDeps(context => {
+              let ret;
+              const _context = context;
+              try {
+                  _context.processor = processor;
+                  ret = Reflect.apply(translate, null, [_context, ...args]);
+              }
+              finally {
+                  _context.processor = null;
+              }
+              return ret;
+          }, () => parseTranslateArgs(...args), 'translate', 
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          root => root[TranslateVNodeSymbol](...args), key => [createTextNode(key)], val => isArray(val));
+      }
+      // numberParts, using for `i18n-n` component
+      function numberParts(...args) {
+          return wrapWithDeps(context => Reflect.apply(number, null, [context, ...args]), () => parseNumberArgs(...args), 'number format', 
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          root => root[NumberPartsSymbol](...args), NOOP_RETURN_ARRAY, val => isString(val) || isArray(val));
+      }
+      // datetimeParts, using for `i18n-d` component
+      function datetimeParts(...args) {
+          return wrapWithDeps(context => Reflect.apply(datetime, null, [context, ...args]), () => parseDateTimeArgs(...args), 'datetime format', 
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          root => root[DatetimePartsSymbol](...args), NOOP_RETURN_ARRAY, val => isString(val) || isArray(val));
+      }
+      function setPluralRules(rules) {
+          _pluralRules = rules;
+          _context.pluralRules = _pluralRules;
+      }
+      // te
+      function te(key, locale) {
+          return wrapWithDeps(() => {
+              if (!key) {
+                  return false;
+              }
+              const targetLocale = isString(locale) ? locale : _locale.value;
+              const message = getLocaleMessage(targetLocale);
+              const resolved = _context.messageResolver(message, key);
+              return !translateExistCompatible
+                  ? isMessageAST(resolved) ||
+                      isMessageFunction(resolved) ||
+                      isString(resolved)
+                  : resolved != null;
+          }, () => [key], 'translate exists', root => {
+              return Reflect.apply(root.te, root, [key, locale]);
+          }, NOOP_RETURN_FALSE, val => isBoolean(val));
+      }
+      function resolveMessages(key) {
+          let messages = null;
+          const locales = fallbackWithLocaleChain(_context, _fallbackLocale.value, _locale.value);
+          for (let i = 0; i < locales.length; i++) {
+              const targetLocaleMessages = _messages.value[locales[i]] || {};
+              const messageValue = _context.messageResolver(targetLocaleMessages, key);
+              if (messageValue != null) {
+                  messages = messageValue;
+                  break;
+              }
+          }
+          return messages;
+      }
+      // tm
+      function tm(key) {
+          const messages = resolveMessages(key);
+          // prettier-ignore
+          return messages != null
+              ? messages
+              : __root
+                  ? __root.tm(key) || {}
+                  : {};
+      }
+      // getLocaleMessage
+      function getLocaleMessage(locale) {
+          return (_messages.value[locale] || {});
+      }
+      // setLocaleMessage
+      function setLocaleMessage(locale, message) {
+          if (flatJson) {
+              const _message = { [locale]: message };
+              for (const key in _message) {
+                  if (hasOwn(_message, key)) {
+                      handleFlatJson(_message[key]);
+                  }
+              }
+              message = _message[locale];
+          }
+          _messages.value[locale] = message;
+          _context.messages = _messages.value;
+      }
+      // mergeLocaleMessage
+      function mergeLocaleMessage(locale, message) {
+          _messages.value[locale] = _messages.value[locale] || {};
+          const _message = { [locale]: message };
+          if (flatJson) {
+              for (const key in _message) {
+                  if (hasOwn(_message, key)) {
+                      handleFlatJson(_message[key]);
+                  }
+              }
+          }
+          message = _message[locale];
+          deepCopy(message, _messages.value[locale]);
+          _context.messages = _messages.value;
+      }
+      // getDateTimeFormat
+      function getDateTimeFormat(locale) {
+          return _datetimeFormats.value[locale] || {};
+      }
+      // setDateTimeFormat
+      function setDateTimeFormat(locale, format) {
+          _datetimeFormats.value[locale] = format;
+          _context.datetimeFormats = _datetimeFormats.value;
+          clearDateTimeFormat(_context, locale, format);
+      }
+      // mergeDateTimeFormat
+      function mergeDateTimeFormat(locale, format) {
+          _datetimeFormats.value[locale] = assign(_datetimeFormats.value[locale] || {}, format);
+          _context.datetimeFormats = _datetimeFormats.value;
+          clearDateTimeFormat(_context, locale, format);
+      }
+      // getNumberFormat
+      function getNumberFormat(locale) {
+          return _numberFormats.value[locale] || {};
+      }
+      // setNumberFormat
+      function setNumberFormat(locale, format) {
+          _numberFormats.value[locale] = format;
+          _context.numberFormats = _numberFormats.value;
+          clearNumberFormat(_context, locale, format);
+      }
+      // mergeNumberFormat
+      function mergeNumberFormat(locale, format) {
+          _numberFormats.value[locale] = assign(_numberFormats.value[locale] || {}, format);
+          _context.numberFormats = _numberFormats.value;
+          clearNumberFormat(_context, locale, format);
+      }
+      // for debug
+      composerID++;
+      // watch root locale & fallbackLocale
+      if (__root && inBrowser) {
+          vue.watch(__root.locale, (val) => {
+              if (_inheritLocale) {
+                  _locale.value = val;
+                  _context.locale = val;
+                  updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+              }
+          });
+          vue.watch(__root.fallbackLocale, (val) => {
+              if (_inheritLocale) {
+                  _fallbackLocale.value = val;
+                  _context.fallbackLocale = val;
+                  updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+              }
+          });
+      }
+      // define basic composition API!
+      const composer = {
+          id: composerID,
+          locale,
+          fallbackLocale,
+          get inheritLocale() {
+              return _inheritLocale;
+          },
+          set inheritLocale(val) {
+              _inheritLocale = val;
+              if (val && __root) {
+                  _locale.value = __root.locale.value;
+                  _fallbackLocale.value = __root.fallbackLocale.value;
+                  updateFallbackLocale(_context, _locale.value, _fallbackLocale.value);
+              }
+          },
+          get availableLocales() {
+              return Object.keys(_messages.value).sort();
+          },
+          messages,
+          get modifiers() {
+              return _modifiers;
+          },
+          get pluralRules() {
+              return _pluralRules || {};
+          },
+          get isGlobal() {
+              return _isGlobal;
+          },
+          get missingWarn() {
+              return _missingWarn;
+          },
+          set missingWarn(val) {
+              _missingWarn = val;
+              _context.missingWarn = _missingWarn;
+          },
+          get fallbackWarn() {
+              return _fallbackWarn;
+          },
+          set fallbackWarn(val) {
+              _fallbackWarn = val;
+              _context.fallbackWarn = _fallbackWarn;
+          },
+          get fallbackRoot() {
+              return _fallbackRoot;
+          },
+          set fallbackRoot(val) {
+              _fallbackRoot = val;
+          },
+          get fallbackFormat() {
+              return _fallbackFormat;
+          },
+          set fallbackFormat(val) {
+              _fallbackFormat = val;
+              _context.fallbackFormat = _fallbackFormat;
+          },
+          get warnHtmlMessage() {
+              return _warnHtmlMessage;
+          },
+          set warnHtmlMessage(val) {
+              _warnHtmlMessage = val;
+              _context.warnHtmlMessage = val;
+          },
+          get escapeParameter() {
+              return _escapeParameter;
+          },
+          set escapeParameter(val) {
+              _escapeParameter = val;
+              _context.escapeParameter = val;
+          },
+          t,
+          getLocaleMessage,
+          setLocaleMessage,
+          mergeLocaleMessage,
+          getPostTranslationHandler,
+          setPostTranslationHandler,
+          getMissingHandler,
+          setMissingHandler,
+          [SetPluralRulesSymbol]: setPluralRules
+      };
+      {
+          composer.datetimeFormats = datetimeFormats;
+          composer.numberFormats = numberFormats;
+          composer.rt = rt;
+          composer.te = te;
+          composer.tm = tm;
+          composer.d = d;
+          composer.n = n;
+          composer.getDateTimeFormat = getDateTimeFormat;
+          composer.setDateTimeFormat = setDateTimeFormat;
+          composer.mergeDateTimeFormat = mergeDateTimeFormat;
+          composer.getNumberFormat = getNumberFormat;
+          composer.setNumberFormat = setNumberFormat;
+          composer.mergeNumberFormat = mergeNumberFormat;
+          composer[InejctWithOptionSymbol] = __injectWithOption;
+          composer[TranslateVNodeSymbol] = translateVNode;
+          composer[DatetimePartsSymbol] = datetimeParts;
+          composer[NumberPartsSymbol] = numberParts;
+      }
+      // for vue-devtools timeline event
+      {
+          composer[EnableEmitter] = (emitter) => {
+              _context.__v_emitter = emitter;
+          };
+          composer[DisableEmitter] = () => {
+              _context.__v_emitter = undefined;
+          };
+      }
+      return composer;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  /**
+   * Convert to I18n Composer Options from VueI18n Options
+   *
+   * @internal
+   */
+  function convertComposerOptions(options) {
+      const locale = isString(options.locale) ? options.locale : DEFAULT_LOCALE;
+      const fallbackLocale = isString(options.fallbackLocale) ||
+          isArray(options.fallbackLocale) ||
+          isPlainObject(options.fallbackLocale) ||
+          options.fallbackLocale === false
+          ? options.fallbackLocale
+          : locale;
+      const missing = isFunction(options.missing) ? options.missing : undefined;
+      const missingWarn = isBoolean(options.silentTranslationWarn) ||
+          isRegExp(options.silentTranslationWarn)
+          ? !options.silentTranslationWarn
+          : true;
+      const fallbackWarn = isBoolean(options.silentFallbackWarn) ||
+          isRegExp(options.silentFallbackWarn)
+          ? !options.silentFallbackWarn
+          : true;
+      const fallbackRoot = isBoolean(options.fallbackRoot)
+          ? options.fallbackRoot
+          : true;
+      const fallbackFormat = !!options.formatFallbackMessages;
+      const modifiers = isPlainObject(options.modifiers) ? options.modifiers : {};
+      const pluralizationRules = options.pluralizationRules;
+      const postTranslation = isFunction(options.postTranslation)
+          ? options.postTranslation
+          : undefined;
+      const warnHtmlMessage = isString(options.warnHtmlInMessage)
+          ? options.warnHtmlInMessage !== 'off'
+          : true;
+      const escapeParameter = !!options.escapeParameterHtml;
+      const inheritLocale = isBoolean(options.sync) ? options.sync : true;
+      if (options.formatter) {
+          warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+      }
+      if (options.preserveDirectiveContent) {
+          warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+      }
+      let messages = options.messages;
+      if (isPlainObject(options.sharedMessages)) {
+          const sharedMessages = options.sharedMessages;
+          const locales = Object.keys(sharedMessages);
+          messages = locales.reduce((messages, locale) => {
+              const message = messages[locale] || (messages[locale] = {});
+              assign(message, sharedMessages[locale]);
+              return messages;
+          }, (messages || {}));
+      }
+      const { __i18n, __root, __injectWithOption } = options;
+      const datetimeFormats = options.datetimeFormats;
+      const numberFormats = options.numberFormats;
+      const flatJson = options.flatJson;
+      const translateExistCompatible = options
+          .translateExistCompatible;
+      return {
+          locale,
+          fallbackLocale,
+          messages,
+          flatJson,
+          datetimeFormats,
+          numberFormats,
+          missing,
+          missingWarn,
+          fallbackWarn,
+          fallbackRoot,
+          fallbackFormat,
+          modifiers,
+          pluralRules: pluralizationRules,
+          postTranslation,
+          warnHtmlMessage,
+          escapeParameter,
+          messageResolver: options.messageResolver,
+          inheritLocale,
+          translateExistCompatible,
+          __i18n,
+          __root,
+          __injectWithOption
+      };
+  }
+  /**
+   * create VueI18n interface factory
+   *
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  function createVueI18n(options = {}, VueI18nLegacy) {
+      {
+          const composer = createComposer(convertComposerOptions(options));
+          const { __extender } = options;
+          // defines VueI18n
+          const vueI18n = {
+              // id
+              id: composer.id,
+              // locale
+              get locale() {
+                  return composer.locale.value;
+              },
+              set locale(val) {
+                  composer.locale.value = val;
+              },
+              // fallbackLocale
+              get fallbackLocale() {
+                  return composer.fallbackLocale.value;
+              },
+              set fallbackLocale(val) {
+                  composer.fallbackLocale.value = val;
+              },
+              // messages
+              get messages() {
+                  return composer.messages.value;
+              },
+              // datetimeFormats
+              get datetimeFormats() {
+                  return composer.datetimeFormats.value;
+              },
+              // numberFormats
+              get numberFormats() {
+                  return composer.numberFormats.value;
+              },
+              // availableLocales
+              get availableLocales() {
+                  return composer.availableLocales;
+              },
+              // formatter
+              get formatter() {
+                  warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+                  // dummy
+                  return {
+                      interpolate() {
+                          return [];
+                      }
+                  };
+              },
+              set formatter(val) {
+                  warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_FORMATTER));
+              },
+              // missing
+              get missing() {
+                  return composer.getMissingHandler();
+              },
+              set missing(handler) {
+                  composer.setMissingHandler(handler);
+              },
+              // silentTranslationWarn
+              get silentTranslationWarn() {
+                  return isBoolean(composer.missingWarn)
+                      ? !composer.missingWarn
+                      : composer.missingWarn;
+              },
+              set silentTranslationWarn(val) {
+                  composer.missingWarn = isBoolean(val) ? !val : val;
+              },
+              // silentFallbackWarn
+              get silentFallbackWarn() {
+                  return isBoolean(composer.fallbackWarn)
+                      ? !composer.fallbackWarn
+                      : composer.fallbackWarn;
+              },
+              set silentFallbackWarn(val) {
+                  composer.fallbackWarn = isBoolean(val) ? !val : val;
+              },
+              // modifiers
+              get modifiers() {
+                  return composer.modifiers;
+              },
+              // formatFallbackMessages
+              get formatFallbackMessages() {
+                  return composer.fallbackFormat;
+              },
+              set formatFallbackMessages(val) {
+                  composer.fallbackFormat = val;
+              },
+              // postTranslation
+              get postTranslation() {
+                  return composer.getPostTranslationHandler();
+              },
+              set postTranslation(handler) {
+                  composer.setPostTranslationHandler(handler);
+              },
+              // sync
+              get sync() {
+                  return composer.inheritLocale;
+              },
+              set sync(val) {
+                  composer.inheritLocale = val;
+              },
+              // warnInHtmlMessage
+              get warnHtmlInMessage() {
+                  return composer.warnHtmlMessage ? 'warn' : 'off';
+              },
+              set warnHtmlInMessage(val) {
+                  composer.warnHtmlMessage = val !== 'off';
+              },
+              // escapeParameterHtml
+              get escapeParameterHtml() {
+                  return composer.escapeParameter;
+              },
+              set escapeParameterHtml(val) {
+                  composer.escapeParameter = val;
+              },
+              // preserveDirectiveContent
+              get preserveDirectiveContent() {
+                  warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+                  return true;
+              },
+              set preserveDirectiveContent(val) {
+                  warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE_DIRECTIVE));
+              },
+              // pluralizationRules
+              get pluralizationRules() {
+                  return composer.pluralRules || {};
+              },
+              // for internal
+              __composer: composer,
+              // t
+              t(...args) {
+                  const [arg1, arg2, arg3] = args;
+                  const options = {};
+                  let list = null;
+                  let named = null;
+                  if (!isString(arg1)) {
+                      throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+                  }
+                  const key = arg1;
+                  if (isString(arg2)) {
+                      options.locale = arg2;
+                  }
+                  else if (isArray(arg2)) {
+                      list = arg2;
+                  }
+                  else if (isPlainObject(arg2)) {
+                      named = arg2;
+                  }
+                  if (isArray(arg3)) {
+                      list = arg3;
+                  }
+                  else if (isPlainObject(arg3)) {
+                      named = arg3;
+                  }
+                  // return composer.t(key, (list || named || {}) as any, options)
+                  return Reflect.apply(composer.t, composer, [
+                      key,
+                      (list || named || {}),
+                      options
+                  ]);
+              },
+              rt(...args) {
+                  return Reflect.apply(composer.rt, composer, [...args]);
+              },
+              // tc
+              tc(...args) {
+                  const [arg1, arg2, arg3] = args;
+                  const options = { plural: 1 };
+                  let list = null;
+                  let named = null;
+                  if (!isString(arg1)) {
+                      throw createI18nError(I18nErrorCodes.INVALID_ARGUMENT);
+                  }
+                  const key = arg1;
+                  if (isString(arg2)) {
+                      options.locale = arg2;
+                  }
+                  else if (isNumber(arg2)) {
+                      options.plural = arg2;
+                  }
+                  else if (isArray(arg2)) {
+                      list = arg2;
+                  }
+                  else if (isPlainObject(arg2)) {
+                      named = arg2;
+                  }
+                  if (isString(arg3)) {
+                      options.locale = arg3;
+                  }
+                  else if (isArray(arg3)) {
+                      list = arg3;
+                  }
+                  else if (isPlainObject(arg3)) {
+                      named = arg3;
+                  }
+                  // return composer.t(key, (list || named || {}) as any, options)
+                  return Reflect.apply(composer.t, composer, [
+                      key,
+                      (list || named || {}),
+                      options
+                  ]);
+              },
+              // te
+              te(key, locale) {
+                  return composer.te(key, locale);
+              },
+              // tm
+              tm(key) {
+                  return composer.tm(key);
+              },
+              // getLocaleMessage
+              getLocaleMessage(locale) {
+                  return composer.getLocaleMessage(locale);
+              },
+              // setLocaleMessage
+              setLocaleMessage(locale, message) {
+                  composer.setLocaleMessage(locale, message);
+              },
+              // mergeLocaleMessage
+              mergeLocaleMessage(locale, message) {
+                  composer.mergeLocaleMessage(locale, message);
+              },
+              // d
+              d(...args) {
+                  return Reflect.apply(composer.d, composer, [...args]);
+              },
+              // getDateTimeFormat
+              getDateTimeFormat(locale) {
+                  return composer.getDateTimeFormat(locale);
+              },
+              // setDateTimeFormat
+              setDateTimeFormat(locale, format) {
+                  composer.setDateTimeFormat(locale, format);
+              },
+              // mergeDateTimeFormat
+              mergeDateTimeFormat(locale, format) {
+                  composer.mergeDateTimeFormat(locale, format);
+              },
+              // n
+              n(...args) {
+                  return Reflect.apply(composer.n, composer, [...args]);
+              },
+              // getNumberFormat
+              getNumberFormat(locale) {
+                  return composer.getNumberFormat(locale);
+              },
+              // setNumberFormat
+              setNumberFormat(locale, format) {
+                  composer.setNumberFormat(locale, format);
+              },
+              // mergeNumberFormat
+              mergeNumberFormat(locale, format) {
+                  composer.mergeNumberFormat(locale, format);
+              },
+              // getChoiceIndex
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              getChoiceIndex(choice, choicesLength) {
+                  warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_GET_CHOICE_INDEX));
+                  return -1;
+              }
+          };
+          vueI18n.__extender = __extender;
+          // for vue-devtools timeline event
+          {
+              vueI18n.__enableEmitter = (emitter) => {
+                  const __composer = composer;
+                  __composer[EnableEmitter] && __composer[EnableEmitter](emitter);
+              };
+              vueI18n.__disableEmitter = () => {
+                  const __composer = composer;
+                  __composer[DisableEmitter] && __composer[DisableEmitter]();
+              };
+          }
+          return vueI18n;
+      }
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  const baseFormatProps = {
+      tag: {
+          type: [String, Object]
+      },
+      locale: {
+          type: String
+      },
+      scope: {
+          type: String,
+          // NOTE: avoid https://github.com/microsoft/rushstack/issues/1050
+          validator: (val /* ComponentI18nScope */) => val === 'parent' || val === 'global',
+          default: 'parent' /* ComponentI18nScope */
+      },
+      i18n: {
+          type: Object
+      }
+  };
+
+  function getInterpolateArg(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  { slots }, // SetupContext,
+  keys) {
+      if (keys.length === 1 && keys[0] === 'default') {
+          // default slot with list
+          const ret = slots.default ? slots.default() : [];
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return ret.reduce((slot, current) => {
+              return [
+                  ...slot,
+                  // prettier-ignore
+                  ...(current.type === vue.Fragment ? current.children : [current]
+                      )
+              ];
+          }, []);
+      }
+      else {
+          // named slots
+          return keys.reduce((arg, key) => {
+              const slot = slots[key];
+              if (slot) {
+                  arg[key] = slot();
+              }
+              return arg;
+          }, {});
+      }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function getFragmentableTag(tag) {
+      return vue.Fragment ;
+  }
+
+  const TranslationImpl = /*#__PURE__*/ vue.defineComponent({
+      /* eslint-disable */
+      name: 'i18n-t',
+      props: assign({
+          keypath: {
+              type: String,
+              required: true
+          },
+          plural: {
+              type: [Number, String],
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              validator: (val) => isNumber(val) || !isNaN(val)
+          }
+      }, baseFormatProps),
+      /* eslint-enable */
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      setup(props, context) {
+          const { slots, attrs } = context;
+          // NOTE: avoid https://github.com/microsoft/rushstack/issues/1050
+          const i18n = props.i18n ||
+              useI18n({
+                  useScope: props.scope,
+                  __useComponent: true
+              });
+          return () => {
+              const keys = Object.keys(slots).filter(key => key !== '_');
+              const options = {};
+              if (props.locale) {
+                  options.locale = props.locale;
+              }
+              if (props.plural !== undefined) {
+                  options.plural = isString(props.plural) ? +props.plural : props.plural;
+              }
+              const arg = getInterpolateArg(context, keys);
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              const children = i18n[TranslateVNodeSymbol](props.keypath, arg, options);
+              const assignedAttrs = assign({}, attrs);
+              const tag = isString(props.tag) || isObject(props.tag)
+                  ? props.tag
+                  : getFragmentableTag();
+              return vue.h(tag, assignedAttrs, children);
+          };
+      }
+  });
+  /**
+   * export the public type for h/tsx inference
+   * also to avoid inline import() in generated d.ts files
+   */
+  /**
+   * Translation Component
+   *
+   * @remarks
+   * See the following items for property about details
+   *
+   * @VueI18nSee [TranslationProps](component#translationprops)
+   * @VueI18nSee [BaseFormatProps](component#baseformatprops)
+   * @VueI18nSee [Component Interpolation](../guide/advanced/component)
+   *
+   * @example
+   * ```html
+   * <div id="app">
+   *   <!-- ... -->
+   *   <i18n keypath="term" tag="label" for="tos">
+   *     <a :href="url" target="_blank">{{ $t('tos') }}</a>
+   *   </i18n>
+   *   <!-- ... -->
+   * </div>
+   * ```
+   * ```js
+   * import { createApp } from 'vue'
+   * import { createI18n } from 'vue-i18n'
+   *
+   * const messages = {
+   *   en: {
+   *     tos: 'Term of Service',
+   *     term: 'I accept xxx {0}.'
+   *   },
+   *   ja: {
+   *     tos: '利用規約',
+   *     term: '私は xxx の{0}に同意します。'
+   *   }
+   * }
+   *
+   * const i18n = createI18n({
+   *   locale: 'en',
+   *   messages
+   * })
+   *
+   * const app = createApp({
+   *   data: {
+   *     url: '/term'
+   *   }
+   * }).use(i18n).mount('#app')
+   * ```
+   *
+   * @VueI18nComponent
+   */
+  const Translation = TranslationImpl;
+  const I18nT = Translation;
+
+  function isVNode(target) {
+      return isArray(target) && !isString(target[0]);
+  }
+  function renderFormatter(props, context, slotKeys, partFormatter) {
+      const { slots, attrs } = context;
+      return () => {
+          const options = { part: true };
+          let overrides = {};
+          if (props.locale) {
+              options.locale = props.locale;
+          }
+          if (isString(props.format)) {
+              options.key = props.format;
+          }
+          else if (isObject(props.format)) {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              if (isString(props.format.key)) {
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  options.key = props.format.key;
+              }
+              // Filter out number format options only
+              overrides = Object.keys(props.format).reduce((options, prop) => {
+                  return slotKeys.includes(prop)
+                      ? assign({}, options, { [prop]: props.format[prop] }) // eslint-disable-line @typescript-eslint/no-explicit-any
+                      : options;
+              }, {});
+          }
+          const parts = partFormatter(...[props.value, options, overrides]);
+          let children = [options.key];
+          if (isArray(parts)) {
+              children = parts.map((part, index) => {
+                  const slot = slots[part.type];
+                  const node = slot
+                      ? slot({ [part.type]: part.value, index, parts })
+                      : [part.value];
+                  if (isVNode(node)) {
+                      node[0].key = `${part.type}-${index}`;
+                  }
+                  return node;
+              });
+          }
+          else if (isString(parts)) {
+              children = [parts];
+          }
+          const assignedAttrs = assign({}, attrs);
+          const tag = isString(props.tag) || isObject(props.tag)
+              ? props.tag
+              : getFragmentableTag();
+          return vue.h(tag, assignedAttrs, children);
+      };
+  }
+
+  const NumberFormatImpl = /*#__PURE__*/ vue.defineComponent({
+      /* eslint-disable */
+      name: 'i18n-n',
+      props: assign({
+          value: {
+              type: Number,
+              required: true
+          },
+          format: {
+              type: [String, Object]
+          }
+      }, baseFormatProps),
+      /* eslint-enable */
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      setup(props, context) {
+          const i18n = props.i18n ||
+              useI18n({
+                  useScope: props.scope,
+                  __useComponent: true
+              });
+          return renderFormatter(props, context, NUMBER_FORMAT_OPTIONS_KEYS, (...args) => 
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          i18n[NumberPartsSymbol](...args));
+      }
+  });
+  /**
+   * export the public type for h/tsx inference
+   * also to avoid inline import() in generated d.ts files
+   */
+  /**
+   * Number Format Component
+   *
+   * @remarks
+   * See the following items for property about details
+   *
+   * @VueI18nSee [FormattableProps](component#formattableprops)
+   * @VueI18nSee [BaseFormatProps](component#baseformatprops)
+   * @VueI18nSee [Custom Formatting](../guide/essentials/number#custom-formatting)
+   *
+   * @VueI18nDanger
+   * Not supported IE, due to no support `Intl.NumberFormat#formatToParts` in [IE](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/formatToParts)
+   *
+   * If you want to use it, you need to use [polyfill](https://github.com/formatjs/formatjs/tree/main/packages/intl-numberformat)
+   *
+   * @VueI18nComponent
+   */
+  const NumberFormat = NumberFormatImpl;
+  const I18nN = NumberFormat;
+
+  const DatetimeFormatImpl = /* #__PURE__*/ vue.defineComponent({
+      /* eslint-disable */
+      name: 'i18n-d',
+      props: assign({
+          value: {
+              type: [Number, Date],
+              required: true
+          },
+          format: {
+              type: [String, Object]
+          }
+      }, baseFormatProps),
+      /* eslint-enable */
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      setup(props, context) {
+          const i18n = props.i18n ||
+              useI18n({
+                  useScope: props.scope,
+                  __useComponent: true
+              });
+          return renderFormatter(props, context, DATETIME_FORMAT_OPTIONS_KEYS, (...args) => 
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          i18n[DatetimePartsSymbol](...args));
+      }
+  });
+  /**
+   * Datetime Format Component
+   *
+   * @remarks
+   * See the following items for property about details
+   *
+   * @VueI18nSee [FormattableProps](component#formattableprops)
+   * @VueI18nSee [BaseFormatProps](component#baseformatprops)
+   * @VueI18nSee [Custom Formatting](../guide/essentials/datetime#custom-formatting)
+   *
+   * @VueI18nDanger
+   * Not supported IE, due to no support `Intl.DateTimeFormat#formatToParts` in [IE](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts)
+   *
+   * If you want to use it, you need to use [polyfill](https://github.com/formatjs/formatjs/tree/main/packages/intl-datetimeformat)
+   *
+   * @VueI18nComponent
+   */
+  const DatetimeFormat = DatetimeFormatImpl;
+  const I18nD = DatetimeFormat;
+
+  function getComposer$2(i18n, instance) {
+      const i18nInternal = i18n;
+      if (i18n.mode === 'composition') {
+          return (i18nInternal.__getInstance(instance) || i18n.global);
+      }
+      else {
+          const vueI18n = i18nInternal.__getInstance(instance);
+          return vueI18n != null
+              ? vueI18n.__composer
+              : i18n.global.__composer;
+      }
+  }
+  function vTDirective(i18n) {
+      const _process = (binding) => {
+          const { instance, modifiers, value } = binding;
+          /* istanbul ignore if */
+          if (!instance || !instance.$) {
+              throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+          }
+          const composer = getComposer$2(i18n, instance.$);
+          if (modifiers.preserve) {
+              warn(getWarnMessage(I18nWarnCodes.NOT_SUPPORTED_PRESERVE));
+          }
+          const parsedValue = parseValue(value);
+          return [
+              Reflect.apply(composer.t, composer, [...makeParams(parsedValue)]),
+              composer
+          ];
+      };
+      const register = (el, binding) => {
+          const [textContent, composer] = _process(binding);
+          if (inBrowser && i18n.global === composer) {
+              // global scope only
+              el.__i18nWatcher = vue.watch(composer.locale, () => {
+                  binding.instance && binding.instance.$forceUpdate();
+              });
+          }
+          el.__composer = composer;
+          el.textContent = textContent;
+      };
+      const unregister = (el) => {
+          if (inBrowser && el.__i18nWatcher) {
+              el.__i18nWatcher();
+              el.__i18nWatcher = undefined;
+              delete el.__i18nWatcher;
+          }
+          if (el.__composer) {
+              el.__composer = undefined;
+              delete el.__composer;
+          }
+      };
+      const update = (el, { value }) => {
+          if (el.__composer) {
+              const composer = el.__composer;
+              const parsedValue = parseValue(value);
+              el.textContent = Reflect.apply(composer.t, composer, [
+                  ...makeParams(parsedValue)
+              ]);
+          }
+      };
+      const getSSRProps = (binding) => {
+          const [textContent] = _process(binding);
+          return { textContent };
+      };
+      return {
+          created: register,
+          unmounted: unregister,
+          beforeUpdate: update,
+          getSSRProps
+      };
+  }
+  function parseValue(value) {
+      if (isString(value)) {
+          return { path: value };
+      }
+      else if (isPlainObject(value)) {
+          if (!('path' in value)) {
+              throw createI18nError(I18nErrorCodes.REQUIRED_VALUE, 'path');
+          }
+          return value;
+      }
+      else {
+          throw createI18nError(I18nErrorCodes.INVALID_VALUE);
+      }
+  }
+  function makeParams(value) {
+      const { path, locale, args, choice, plural } = value;
+      const options = {};
+      const named = args || {};
+      if (isString(locale)) {
+          options.locale = locale;
+      }
+      if (isNumber(choice)) {
+          options.plural = choice;
+      }
+      if (isNumber(plural)) {
+          options.plural = plural;
+      }
+      return [path, named, options];
+  }
+
+  function apply(app, i18n, ...options) {
+      const pluginOptions = isPlainObject(options[0])
+          ? options[0]
+          : {};
+      const useI18nComponentName = !!pluginOptions.useI18nComponentName;
+      const globalInstall = isBoolean(pluginOptions.globalInstall)
+          ? pluginOptions.globalInstall
+          : true;
+      if (globalInstall && useI18nComponentName) {
+          warn(getWarnMessage(I18nWarnCodes.COMPONENT_NAME_LEGACY_COMPATIBLE, {
+              name: Translation.name
+          }));
+      }
+      if (globalInstall) {
+          [!useI18nComponentName ? Translation.name : 'i18n', 'I18nT'].forEach(name => app.component(name, Translation));
+          [NumberFormat.name, 'I18nN'].forEach(name => app.component(name, NumberFormat));
+          [DatetimeFormat.name, 'I18nD'].forEach(name => app.component(name, DatetimeFormat));
+      }
+      // install directive
+      {
+          app.directive('t', vTDirective(i18n));
+      }
+  }
+
+  var global$1 = (typeof global !== "undefined" ? global :
+              typeof self !== "undefined" ? self :
+              typeof window !== "undefined" ? window : {});
+
+  function getDevtoolsGlobalHook() {
+      return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+  }
+  function getTarget() {
+      // @ts-ignore
+      return (typeof navigator !== 'undefined' && typeof window !== 'undefined')
+          ? window
+          : typeof global$1 !== 'undefined'
+              ? global$1
+              : {};
+  }
+  const isProxyAvailable = typeof Proxy === 'function';
+
+  const HOOK_SETUP = 'devtools-plugin:setup';
+  const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';
+
+  let supported;
+  let perf;
+  function isPerformanceSupported() {
+      var _a;
+      if (supported !== undefined) {
+          return supported;
+      }
+      if (typeof window !== 'undefined' && window.performance) {
+          supported = true;
+          perf = window.performance;
+      }
+      else if (typeof global$1 !== 'undefined' && ((_a = global$1.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
+          supported = true;
+          perf = global$1.perf_hooks.performance;
+      }
+      else {
+          supported = false;
+      }
+      return supported;
+  }
+  function now() {
+      return isPerformanceSupported() ? perf.now() : Date.now();
+  }
+
+  class ApiProxy {
+      constructor(plugin, hook) {
+          this.target = null;
+          this.targetQueue = [];
+          this.onQueue = [];
+          this.plugin = plugin;
+          this.hook = hook;
+          const defaultSettings = {};
+          if (plugin.settings) {
+              for (const id in plugin.settings) {
+                  const item = plugin.settings[id];
+                  defaultSettings[id] = item.defaultValue;
+              }
+          }
+          const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
+          let currentSettings = Object.assign({}, defaultSettings);
+          try {
+              const raw = localStorage.getItem(localSettingsSaveId);
+              const data = JSON.parse(raw);
+              Object.assign(currentSettings, data);
+          }
+          catch (e) {
+              // noop
+          }
+          this.fallbacks = {
+              getSettings() {
+                  return currentSettings;
+              },
+              setSettings(value) {
+                  try {
+                      localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+                  }
+                  catch (e) {
+                      // noop
+                  }
+                  currentSettings = value;
+              },
+              now() {
+                  return now();
+              },
+          };
+          if (hook) {
+              hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+                  if (pluginId === this.plugin.id) {
+                      this.fallbacks.setSettings(value);
+                  }
+              });
+          }
+          this.proxiedOn = new Proxy({}, {
+              get: (_target, prop) => {
+                  if (this.target) {
+                      return this.target.on[prop];
+                  }
+                  else {
+                      return (...args) => {
+                          this.onQueue.push({
+                              method: prop,
+                              args,
+                          });
+                      };
+                  }
+              },
+          });
+          this.proxiedTarget = new Proxy({}, {
+              get: (_target, prop) => {
+                  if (this.target) {
+                      return this.target[prop];
+                  }
+                  else if (prop === 'on') {
+                      return this.proxiedOn;
+                  }
+                  else if (Object.keys(this.fallbacks).includes(prop)) {
+                      return (...args) => {
+                          this.targetQueue.push({
+                              method: prop,
+                              args,
+                              resolve: () => { },
+                          });
+                          return this.fallbacks[prop](...args);
+                      };
+                  }
+                  else {
+                      return (...args) => {
+                          return new Promise(resolve => {
+                              this.targetQueue.push({
+                                  method: prop,
+                                  args,
+                                  resolve,
+                              });
+                          });
+                      };
+                  }
+              },
+          });
+      }
+      async setRealTarget(target) {
+          this.target = target;
+          for (const item of this.onQueue) {
+              this.target.on[item.method](...item.args);
+          }
+          for (const item of this.targetQueue) {
+              item.resolve(await this.target[item.method](...item.args));
+          }
+      }
+  }
+
+  function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+      const descriptor = pluginDescriptor;
+      const target = getTarget();
+      const hook = getDevtoolsGlobalHook();
+      const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;
+      if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+          hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
+      }
+      else {
+          const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;
+          const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+          list.push({
+              pluginDescriptor: descriptor,
+              setupFn,
+              proxy,
+          });
+          if (proxy)
+              setupFn(proxy.proxiedTarget);
+      }
+  }
+
+  const VueDevToolsLabels = {
+      ["vue-devtools-plugin-vue-i18n" /* VueDevToolsIDs.PLUGIN */]: 'Vue I18n devtools',
+      ["vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */]: 'I18n Resources',
+      ["vue-i18n-timeline" /* VueDevToolsIDs.TIMELINE */]: 'Vue I18n'
+  };
+  const VueDevToolsPlaceholders = {
+      ["vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */]: 'Search for scopes ...'
+  };
+  const VueDevToolsTimelineColors = {
+      ["vue-i18n-timeline" /* VueDevToolsIDs.TIMELINE */]: 0xffcd19
+  };
+
+  const VUE_I18N_COMPONENT_TYPES = 'vue-i18n: composer properties';
+  let devtoolsApi;
+  async function enableDevTools(app, i18n) {
+      return new Promise((resolve, reject) => {
+          try {
+              setupDevtoolsPlugin({
+                  id: "vue-devtools-plugin-vue-i18n" /* VueDevToolsIDs.PLUGIN */,
+                  label: VueDevToolsLabels["vue-devtools-plugin-vue-i18n" /* VueDevToolsIDs.PLUGIN */],
+                  packageName: 'vue-i18n',
+                  homepage: 'https://vue-i18n.intlify.dev',
+                  logo: 'https://vue-i18n.intlify.dev/vue-i18n-devtools-logo.png',
+                  componentStateTypes: [VUE_I18N_COMPONENT_TYPES],
+                  app: app // eslint-disable-line @typescript-eslint/no-explicit-any
+              }, api => {
+                  devtoolsApi = api;
+                  api.on.visitComponentTree(({ componentInstance, treeNode }) => {
+                      updateComponentTreeTags(componentInstance, treeNode, i18n);
+                  });
+                  api.on.inspectComponent(({ componentInstance, instanceData }) => {
+                      if (componentInstance.vnode.el &&
+                          componentInstance.vnode.el.__VUE_I18N__ &&
+                          instanceData) {
+                          if (i18n.mode === 'legacy') {
+                              // ignore global scope on legacy mode
+                              if (componentInstance.vnode.el.__VUE_I18N__ !==
+                                  i18n.global.__composer) {
+                                  inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);
+                              }
+                          }
+                          else {
+                              inspectComposer(instanceData, componentInstance.vnode.el.__VUE_I18N__);
+                          }
+                      }
+                  });
+                  api.addInspector({
+                      id: "vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */,
+                      label: VueDevToolsLabels["vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */],
+                      icon: 'language',
+                      treeFilterPlaceholder: VueDevToolsPlaceholders["vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */]
+                  });
+                  api.on.getInspectorTree(payload => {
+                      if (payload.app === app &&
+                          payload.inspectorId === "vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */) {
+                          registerScope(payload, i18n);
+                      }
+                  });
+                  const roots = new Map();
+                  api.on.getInspectorState(async (payload) => {
+                      if (payload.app === app &&
+                          payload.inspectorId === "vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */) {
+                          api.unhighlightElement();
+                          inspectScope(payload, i18n);
+                          if (payload.nodeId === 'global') {
+                              if (!roots.has(payload.app)) {
+                                  const [root] = await api.getComponentInstances(payload.app);
+                                  roots.set(payload.app, root);
+                              }
+                              api.highlightElement(roots.get(payload.app));
+                          }
+                          else {
+                              const instance = getComponentInstance(payload.nodeId, i18n);
+                              instance && api.highlightElement(instance);
+                          }
+                      }
+                  });
+                  api.on.editInspectorState(payload => {
+                      if (payload.app === app &&
+                          payload.inspectorId === "vue-i18n-resource-inspector" /* VueDevToolsIDs.CUSTOM_INSPECTOR */) {
+                          editScope(payload, i18n);
+                      }
+                  });
+                  api.addTimelineLayer({
+                      id: "vue-i18n-timeline" /* VueDevToolsIDs.TIMELINE */,
+                      label: VueDevToolsLabels["vue-i18n-timeline" /* VueDevToolsIDs.TIMELINE */],
+                      color: VueDevToolsTimelineColors["vue-i18n-timeline" /* VueDevToolsIDs.TIMELINE */]
+                  });
+                  resolve(true);
+              });
+          }
+          catch (e) {
+              console.error(e);
+              reject(false);
+          }
+      });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function getI18nScopeLable(instance) {
+      return (instance.type.name ||
+          instance.type.displayName ||
+          instance.type.__file ||
+          'Anonymous');
+  }
+  function updateComponentTreeTags(instance, // eslint-disable-line @typescript-eslint/no-explicit-any
+  treeNode, i18n) {
+      // prettier-ignore
+      const global = i18n.mode === 'composition'
+          ? i18n.global
+          : i18n.global.__composer;
+      if (instance && instance.vnode.el && instance.vnode.el.__VUE_I18N__) {
+          // add custom tags local scope only
+          if (instance.vnode.el.__VUE_I18N__ !== global) {
+              const tag = {
+                  label: `i18n (${getI18nScopeLable(instance)} Scope)`,
+                  textColor: 0x000000,
+                  backgroundColor: 0xffcd19
+              };
+              treeNode.tags.push(tag);
+          }
+      }
+  }
+  function inspectComposer(instanceData, composer) {
+      const type = VUE_I18N_COMPONENT_TYPES;
+      instanceData.state.push({
+          type,
+          key: 'locale',
+          editable: true,
+          value: composer.locale.value
+      });
+      instanceData.state.push({
+          type,
+          key: 'availableLocales',
+          editable: false,
+          value: composer.availableLocales
+      });
+      instanceData.state.push({
+          type,
+          key: 'fallbackLocale',
+          editable: true,
+          value: composer.fallbackLocale.value
+      });
+      instanceData.state.push({
+          type,
+          key: 'inheritLocale',
+          editable: true,
+          value: composer.inheritLocale
+      });
+      instanceData.state.push({
+          type,
+          key: 'messages',
+          editable: false,
+          value: getLocaleMessageValue(composer.messages.value)
+      });
+      {
+          instanceData.state.push({
+              type,
+              key: 'datetimeFormats',
+              editable: false,
+              value: composer.datetimeFormats.value
+          });
+          instanceData.state.push({
+              type,
+              key: 'numberFormats',
+              editable: false,
+              value: composer.numberFormats.value
+          });
+      }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function getLocaleMessageValue(messages) {
+      const value = {};
+      Object.keys(messages).forEach((key) => {
+          const v = messages[key];
+          if (isFunction(v) && 'source' in v) {
+              value[key] = getMessageFunctionDetails(v);
+          }
+          else if (isMessageAST(v) && v.loc && v.loc.source) {
+              value[key] = v.loc.source;
+          }
+          else if (isObject(v)) {
+              value[key] = getLocaleMessageValue(v);
+          }
+          else {
+              value[key] = v;
+          }
+      });
+      return value;
+  }
+  const ESC = {
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '&': '&amp;'
+  };
+  function escape(s) {
+      return s.replace(/[<>"&]/g, escapeChar);
+  }
+  function escapeChar(a) {
+      return ESC[a] || a;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function getMessageFunctionDetails(func) {
+      const argString = func.source ? `("${escape(func.source)}")` : `(?)`;
+      return {
+          _custom: {
+              type: 'function',
+              display: `<span>ƒ</span> ${argString}`
+          }
+      };
+  }
+  function registerScope(payload, i18n) {
+      payload.rootNodes.push({
+          id: 'global',
+          label: 'Global Scope'
+      });
+      // prettier-ignore
+      const global = i18n.mode === 'composition'
+          ? i18n.global
+          : i18n.global.__composer;
+      for (const [keyInstance, instance] of i18n.__instances) {
+          // prettier-ignore
+          const composer = i18n.mode === 'composition'
+              ? instance
+              : instance.__composer;
+          if (global === composer) {
+              continue;
+          }
+          payload.rootNodes.push({
+              id: composer.id.toString(),
+              label: `${getI18nScopeLable(keyInstance)} Scope`
+          });
+      }
+  }
+  function getComponentInstance(nodeId, i18n) {
+      let instance = null;
+      if (nodeId !== 'global') {
+          for (const [component, composer] of i18n.__instances.entries()) {
+              if (composer.id.toString() === nodeId) {
+                  instance = component;
+                  break;
+              }
+          }
+      }
+      return instance;
+  }
+  function getComposer$1(nodeId, i18n) {
+      if (nodeId === 'global') {
+          return i18n.mode === 'composition'
+              ? i18n.global
+              : i18n.global.__composer;
+      }
+      else {
+          const instance = Array.from(i18n.__instances.values()).find(item => item.id.toString() === nodeId);
+          if (instance) {
+              return i18n.mode === 'composition'
+                  ? instance
+                  : instance.__composer;
+          }
+          else {
+              return null;
+          }
+      }
+  }
+  function inspectScope(payload, i18n
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ) {
+      const composer = getComposer$1(payload.nodeId, i18n);
+      if (composer) {
+          // TODO:
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          payload.state = makeScopeInspectState(composer);
+      }
+      return null;
+  }
+  function makeScopeInspectState(composer) {
+      const state = {};
+      const localeType = 'Locale related info';
+      const localeStates = [
+          {
+              type: localeType,
+              key: 'locale',
+              editable: true,
+              value: composer.locale.value
+          },
+          {
+              type: localeType,
+              key: 'fallbackLocale',
+              editable: true,
+              value: composer.fallbackLocale.value
+          },
+          {
+              type: localeType,
+              key: 'availableLocales',
+              editable: false,
+              value: composer.availableLocales
+          },
+          {
+              type: localeType,
+              key: 'inheritLocale',
+              editable: true,
+              value: composer.inheritLocale
+          }
+      ];
+      state[localeType] = localeStates;
+      const localeMessagesType = 'Locale messages info';
+      const localeMessagesStates = [
+          {
+              type: localeMessagesType,
+              key: 'messages',
+              editable: false,
+              value: getLocaleMessageValue(composer.messages.value)
+          }
+      ];
+      state[localeMessagesType] = localeMessagesStates;
+      {
+          const datetimeFormatsType = 'Datetime formats info';
+          const datetimeFormatsStates = [
+              {
+                  type: datetimeFormatsType,
+                  key: 'datetimeFormats',
+                  editable: false,
+                  value: composer.datetimeFormats.value
+              }
+          ];
+          state[datetimeFormatsType] = datetimeFormatsStates;
+          const numberFormatsType = 'Datetime formats info';
+          const numberFormatsStates = [
+              {
+                  type: numberFormatsType,
+                  key: 'numberFormats',
+                  editable: false,
+                  value: composer.numberFormats.value
+              }
+          ];
+          state[numberFormatsType] = numberFormatsStates;
+      }
+      return state;
+  }
+  function addTimelineEvent(event, payload) {
+      if (devtoolsApi) {
+          let groupId;
+          if (payload && 'groupId' in payload) {
+              groupId = payload.groupId;
+              delete payload.groupId;
+          }
+          devtoolsApi.addTimelineEvent({
+              layerId: "vue-i18n-timeline" /* VueDevToolsIDs.TIMELINE */,
+              event: {
+                  title: event,
+                  groupId,
+                  time: Date.now(),
+                  meta: {},
+                  data: payload || {},
+                  logType: event === "compile-error" /* VueDevToolsTimelineEvents.COMPILE_ERROR */
+                      ? 'error'
+                      : event === "fallback" /* VueDevToolsTimelineEvents.FALBACK */ ||
+                          event === "missing" /* VueDevToolsTimelineEvents.MISSING */
+                          ? 'warning'
+                          : 'default'
+              }
+          });
+      }
+  }
+  function editScope(payload, i18n) {
+      const composer = getComposer$1(payload.nodeId, i18n);
+      if (composer) {
+          const [field] = payload.path;
+          if (field === 'locale' && isString(payload.state.value)) {
+              composer.locale.value = payload.state.value;
+          }
+          else if (field === 'fallbackLocale' &&
+              (isString(payload.state.value) ||
+                  isArray(payload.state.value) ||
+                  isObject(payload.state.value))) {
+              composer.fallbackLocale.value = payload.state.value;
+          }
+          else if (field === 'inheritLocale' && isBoolean(payload.state.value)) {
+              composer.inheritLocale = payload.state.value;
+          }
+      }
+  }
+
+  /**
+   * Supports compatibility for legacy vue-i18n APIs
+   * This mixin is used when we use vue-i18n@v9.x or later
+   */
+  function defineMixin(vuei18n, composer, i18n) {
+      return {
+          beforeCreate() {
+              const instance = vue.getCurrentInstance();
+              /* istanbul ignore if */
+              if (!instance) {
+                  throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+              }
+              const options = this.$options;
+              if (options.i18n) {
+                  const optionsI18n = options.i18n;
+                  if (options.__i18n) {
+                      optionsI18n.__i18n = options.__i18n;
+                  }
+                  optionsI18n.__root = composer;
+                  if (this === this.$root) {
+                      // merge option and gttach global
+                      this.$i18n = mergeToGlobal(vuei18n, optionsI18n);
+                  }
+                  else {
+                      optionsI18n.__injectWithOption = true;
+                      optionsI18n.__extender = i18n.__vueI18nExtend;
+                      // atttach local VueI18n instance
+                      this.$i18n = createVueI18n(optionsI18n);
+                      // extend VueI18n instance
+                      const _vueI18n = this.$i18n;
+                      if (_vueI18n.__extender) {
+                          _vueI18n.__disposer = _vueI18n.__extender(this.$i18n);
+                      }
+                  }
+              }
+              else if (options.__i18n) {
+                  if (this === this.$root) {
+                      // merge option and gttach global
+                      this.$i18n = mergeToGlobal(vuei18n, options);
+                  }
+                  else {
+                      // atttach local VueI18n instance
+                      this.$i18n = createVueI18n({
+                          __i18n: options.__i18n,
+                          __injectWithOption: true,
+                          __extender: i18n.__vueI18nExtend,
+                          __root: composer
+                      });
+                      // extend VueI18n instance
+                      const _vueI18n = this.$i18n;
+                      if (_vueI18n.__extender) {
+                          _vueI18n.__disposer = _vueI18n.__extender(this.$i18n);
+                      }
+                  }
+              }
+              else {
+                  // attach global VueI18n instance
+                  this.$i18n = vuei18n;
+              }
+              if (options.__i18nGlobal) {
+                  adjustI18nResources(composer, options, options);
+              }
+              // defines vue-i18n legacy APIs
+              this.$t = (...args) => this.$i18n.t(...args);
+              this.$rt = (...args) => this.$i18n.rt(...args);
+              this.$tc = (...args) => this.$i18n.tc(...args);
+              this.$te = (key, locale) => this.$i18n.te(key, locale);
+              this.$d = (...args) => this.$i18n.d(...args);
+              this.$n = (...args) => this.$i18n.n(...args);
+              this.$tm = (key) => this.$i18n.tm(key);
+              i18n.__setInstance(instance, this.$i18n);
+          },
+          mounted() {
+              /* istanbul ignore if */
+              if (this.$el &&
+                  this.$i18n) {
+                  const _vueI18n = this.$i18n;
+                  this.$el.__VUE_I18N__ = _vueI18n.__composer;
+                  const emitter = (this.__v_emitter =
+                      createEmitter());
+                  _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);
+                  emitter.on('*', addTimelineEvent);
+              }
+          },
+          unmounted() {
+              const instance = vue.getCurrentInstance();
+              /* istanbul ignore if */
+              if (!instance) {
+                  throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+              }
+              const _vueI18n = this.$i18n;
+              /* istanbul ignore if */
+              if (this.$el &&
+                  this.$el.__VUE_I18N__) {
+                  if (this.__v_emitter) {
+                      this.__v_emitter.off('*', addTimelineEvent);
+                      delete this.__v_emitter;
+                  }
+                  if (this.$i18n) {
+                      _vueI18n.__disableEmitter && _vueI18n.__disableEmitter();
+                      delete this.$el.__VUE_I18N__;
+                  }
+              }
+              delete this.$t;
+              delete this.$rt;
+              delete this.$tc;
+              delete this.$te;
+              delete this.$d;
+              delete this.$n;
+              delete this.$tm;
+              if (_vueI18n.__disposer) {
+                  _vueI18n.__disposer();
+                  delete _vueI18n.__disposer;
+                  delete _vueI18n.__extender;
+              }
+              i18n.__deleteInstance(instance);
+              delete this.$i18n;
+          }
+      };
+  }
+  function mergeToGlobal(g, options) {
+      g.locale = options.locale || g.locale;
+      g.fallbackLocale = options.fallbackLocale || g.fallbackLocale;
+      g.missing = options.missing || g.missing;
+      g.silentTranslationWarn =
+          options.silentTranslationWarn || g.silentFallbackWarn;
+      g.silentFallbackWarn = options.silentFallbackWarn || g.silentFallbackWarn;
+      g.formatFallbackMessages =
+          options.formatFallbackMessages || g.formatFallbackMessages;
+      g.postTranslation = options.postTranslation || g.postTranslation;
+      g.warnHtmlInMessage = options.warnHtmlInMessage || g.warnHtmlInMessage;
+      g.escapeParameterHtml = options.escapeParameterHtml || g.escapeParameterHtml;
+      g.sync = options.sync || g.sync;
+      g.__composer[SetPluralRulesSymbol](options.pluralizationRules || g.pluralizationRules);
+      const messages = getLocaleMessages(g.locale, {
+          messages: options.messages,
+          __i18n: options.__i18n
+      });
+      Object.keys(messages).forEach(locale => g.mergeLocaleMessage(locale, messages[locale]));
+      if (options.datetimeFormats) {
+          Object.keys(options.datetimeFormats).forEach(locale => g.mergeDateTimeFormat(locale, options.datetimeFormats[locale]));
+      }
+      if (options.numberFormats) {
+          Object.keys(options.numberFormats).forEach(locale => g.mergeNumberFormat(locale, options.numberFormats[locale]));
+      }
+      return g;
+  }
+
+  /**
+   * Injection key for {@link useI18n}
+   *
+   * @remarks
+   * The global injection key for I18n instances with `useI18n`. this injection key is used in Web Components.
+   * Specify the i18n instance created by {@link createI18n} together with `provide` function.
+   *
+   * @VueI18nGeneral
+   */
+  const I18nInjectionKey = 
+  /* #__PURE__*/ makeSymbol('global-vue-i18n');
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  function createI18n(options = {}, VueI18nLegacy) {
+      // prettier-ignore
+      const __legacyMode = isBoolean(options.legacy)
+              ? options.legacy
+              : true;
+      // prettier-ignore
+      const __globalInjection = isBoolean(options.globalInjection)
+          ? options.globalInjection
+          : true;
+      // prettier-ignore
+      const __allowComposition = __legacyMode
+              ? !!options.allowComposition
+              : true;
+      const __instances = new Map();
+      const [globalScope, __global] = createGlobal(options, __legacyMode);
+      const symbol = /* #__PURE__*/ makeSymbol('vue-i18n' );
+      {
+          if (__legacyMode && __allowComposition && !false) {
+              warn(getWarnMessage(I18nWarnCodes.NOTICE_DROP_ALLOW_COMPOSITION));
+          }
+      }
+      function __getInstance(component) {
+          return __instances.get(component) || null;
+      }
+      function __setInstance(component, instance) {
+          __instances.set(component, instance);
+      }
+      function __deleteInstance(component) {
+          __instances.delete(component);
+      }
+      {
+          const i18n = {
+              // mode
+              get mode() {
+                  return __legacyMode
+                      ? 'legacy'
+                      : 'composition';
+              },
+              // allowComposition
+              get allowComposition() {
+                  return __allowComposition;
+              },
+              // install plugin
+              async install(app, ...options) {
+                  {
+                      app.__VUE_I18N__ = i18n;
+                  }
+                  // setup global provider
+                  app.__VUE_I18N_SYMBOL__ = symbol;
+                  app.provide(app.__VUE_I18N_SYMBOL__, i18n);
+                  // set composer & vuei18n extend hook options from plugin options
+                  if (isPlainObject(options[0])) {
+                      const opts = options[0];
+                      i18n.__composerExtend =
+                          opts.__composerExtend;
+                      i18n.__vueI18nExtend =
+                          opts.__vueI18nExtend;
+                  }
+                  // global method and properties injection for Composition API
+                  let globalReleaseHandler = null;
+                  if (!__legacyMode && __globalInjection) {
+                      globalReleaseHandler = injectGlobalFields(app, i18n.global);
+                  }
+                  // install built-in components and directive
+                  {
+                      apply(app, i18n, ...options);
+                  }
+                  // setup mixin for Legacy API
+                  if (__legacyMode) {
+                      app.mixin(defineMixin(__global, __global.__composer, i18n));
+                  }
+                  // release global scope
+                  const unmountApp = app.unmount;
+                  app.unmount = () => {
+                      globalReleaseHandler && globalReleaseHandler();
+                      i18n.dispose();
+                      unmountApp();
+                  };
+                  // setup vue-devtools plugin
+                  {
+                      const ret = await enableDevTools(app, i18n);
+                      if (!ret) {
+                          throw createI18nError(I18nErrorCodes.CANNOT_SETUP_VUE_DEVTOOLS_PLUGIN);
+                      }
+                      const emitter = createEmitter();
+                      if (__legacyMode) {
+                          const _vueI18n = __global;
+                          _vueI18n.__enableEmitter && _vueI18n.__enableEmitter(emitter);
+                      }
+                      else {
+                          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                          const _composer = __global;
+                          _composer[EnableEmitter] && _composer[EnableEmitter](emitter);
+                      }
+                      emitter.on('*', addTimelineEvent);
+                  }
+              },
+              // global accessor
+              get global() {
+                  return __global;
+              },
+              dispose() {
+                  globalScope.stop();
+              },
+              // @internal
+              __instances,
+              // @internal
+              __getInstance,
+              // @internal
+              __setInstance,
+              // @internal
+              __deleteInstance
+          };
+          return i18n;
+      }
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  function useI18n(options = {}) {
+      const instance = vue.getCurrentInstance();
+      if (instance == null) {
+          throw createI18nError(I18nErrorCodes.MUST_BE_CALL_SETUP_TOP);
+      }
+      if (!instance.isCE &&
+          instance.appContext.app != null &&
+          !instance.appContext.app.__VUE_I18N_SYMBOL__) {
+          throw createI18nError(I18nErrorCodes.NOT_INSTALLED);
+      }
+      const i18n = getI18nInstance(instance);
+      const gl = getGlobalComposer(i18n);
+      const componentOptions = getComponentOptions(instance);
+      const scope = getScope(options, componentOptions);
+      {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          if (i18n.mode === 'legacy' && !options.__useComponent) {
+              if (!i18n.allowComposition) {
+                  throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_IN_LEGACY_MODE);
+              }
+              return useI18nForLegacy(instance, scope, gl, options);
+          }
+      }
+      if (scope === 'global') {
+          adjustI18nResources(gl, options, componentOptions);
+          return gl;
+      }
+      if (scope === 'parent') {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          let composer = getComposer(i18n, instance, options.__useComponent);
+          if (composer == null) {
+              {
+                  warn(getWarnMessage(I18nWarnCodes.NOT_FOUND_PARENT_SCOPE));
+              }
+              composer = gl;
+          }
+          return composer;
+      }
+      const i18nInternal = i18n;
+      let composer = i18nInternal.__getInstance(instance);
+      if (composer == null) {
+          const composerOptions = assign({}, options);
+          if ('__i18n' in componentOptions) {
+              composerOptions.__i18n = componentOptions.__i18n;
+          }
+          if (gl) {
+              composerOptions.__root = gl;
+          }
+          composer = createComposer(composerOptions);
+          if (i18nInternal.__composerExtend) {
+              composer[DisposeSymbol] =
+                  i18nInternal.__composerExtend(composer);
+          }
+          setupLifeCycle(i18nInternal, instance, composer);
+          i18nInternal.__setInstance(instance, composer);
+      }
+      return composer;
+  }
+  /**
+   * Cast to VueI18n legacy compatible type
+   *
+   * @remarks
+   * This API is provided only with [vue-i18n-bridge](https://vue-i18n.intlify.dev/guide/migration/ways.html#what-is-vue-i18n-bridge).
+   *
+   * The purpose of this function is to convert an {@link I18n} instance created with {@link createI18n | createI18n(legacy: true)} into a `vue-i18n@v8.x` compatible instance of `new VueI18n` in a TypeScript environment.
+   *
+   * @param i18n - An instance of {@link I18n}
+   * @returns A i18n instance which is casted to {@link VueI18n} type
+   *
+   * @VueI18nTip
+   * :new: provided by **vue-i18n-bridge only**
+   *
+   * @VueI18nGeneral
+   */
+  /* #__NO_SIDE_EFFECTS__ */
+  const castToVueI18n = (i18n
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ) => {
+      if (!(__VUE_I18N_BRIDGE__ in i18n)) {
+          throw createI18nError(I18nErrorCodes.NOT_COMPATIBLE_LEGACY_VUE_I18N);
+      }
+      return i18n;
+  };
+  function createGlobal(options, legacyMode, VueI18nLegacy // eslint-disable-line @typescript-eslint/no-explicit-any
+  ) {
+      const scope = vue.effectScope();
+      {
+          const obj = legacyMode
+              ? scope.run(() => createVueI18n(options))
+              : scope.run(() => createComposer(options));
+          if (obj == null) {
+              throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+          }
+          return [scope, obj];
+      }
+  }
+  function getI18nInstance(instance) {
+      {
+          const i18n = vue.inject(!instance.isCE
+              ? instance.appContext.app.__VUE_I18N_SYMBOL__
+              : I18nInjectionKey);
+          /* istanbul ignore if */
+          if (!i18n) {
+              throw createI18nError(!instance.isCE
+                  ? I18nErrorCodes.UNEXPECTED_ERROR
+                  : I18nErrorCodes.NOT_INSTALLED_WITH_PROVIDE);
+          }
+          return i18n;
+      }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function getScope(options, componentOptions) {
+      // prettier-ignore
+      return isEmptyObject(options)
+          ? ('__i18n' in componentOptions)
+              ? 'local'
+              : 'global'
+          : !options.useScope
+              ? 'local'
+              : options.useScope;
+  }
+  function getGlobalComposer(i18n) {
+      // prettier-ignore
+      return i18n.mode === 'composition'
+              ? i18n.global
+              : i18n.global.__composer
+          ;
+  }
+  function getComposer(i18n, target, useComponent = false) {
+      let composer = null;
+      const root = target.root;
+      let current = getParentComponentInstance(target, useComponent);
+      while (current != null) {
+          const i18nInternal = i18n;
+          if (i18n.mode === 'composition') {
+              composer = i18nInternal.__getInstance(current);
+          }
+          else {
+              {
+                  const vueI18n = i18nInternal.__getInstance(current);
+                  if (vueI18n != null) {
+                      composer = vueI18n
+                          .__composer;
+                      if (useComponent &&
+                          composer &&
+                          !composer[InejctWithOptionSymbol] // eslint-disable-line @typescript-eslint/no-explicit-any
+                      ) {
+                          composer = null;
+                      }
+                  }
+              }
+          }
+          if (composer != null) {
+              break;
+          }
+          if (root === current) {
+              break;
+          }
+          current = current.parent;
+      }
+      return composer;
+  }
+  function getParentComponentInstance(target, useComponent = false) {
+      if (target == null) {
+          return null;
+      }
+      {
+          // if `useComponent: true` will be specified, we get lexical scope owner instance for use-case slots
+          return !useComponent
+              ? target.parent
+              : target.vnode.ctx || target.parent; // eslint-disable-line @typescript-eslint/no-explicit-any
+      }
+  }
+  function setupLifeCycle(i18n, target, composer) {
+      let emitter = null;
+      {
+          vue.onMounted(() => {
+              // inject composer instance to DOM for intlify-devtools
+              if (target.vnode.el) {
+                  target.vnode.el.__VUE_I18N__ = composer;
+                  emitter = createEmitter();
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  const _composer = composer;
+                  _composer[EnableEmitter] && _composer[EnableEmitter](emitter);
+                  emitter.on('*', addTimelineEvent);
+              }
+          }, target);
+          vue.onUnmounted(() => {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              const _composer = composer;
+              // remove composer instance from DOM for intlify-devtools
+              if (target.vnode.el &&
+                  target.vnode.el.__VUE_I18N__) {
+                  emitter && emitter.off('*', addTimelineEvent);
+                  _composer[DisableEmitter] && _composer[DisableEmitter]();
+                  delete target.vnode.el.__VUE_I18N__;
+              }
+              i18n.__deleteInstance(target);
+              // dispose extended resources
+              const dispose = _composer[DisposeSymbol];
+              if (dispose) {
+                  dispose();
+                  delete _composer[DisposeSymbol];
+              }
+          }, target);
+      }
+  }
+  function useI18nForLegacy(instance, scope, root, options = {} // eslint-disable-line @typescript-eslint/no-explicit-any
+  ) {
+      const isLocalScope = scope === 'local';
+      const _composer = vue.shallowRef(null);
+      if (isLocalScope &&
+          instance.proxy &&
+          !(instance.proxy.$options.i18n || instance.proxy.$options.__i18n)) {
+          throw createI18nError(I18nErrorCodes.MUST_DEFINE_I18N_OPTION_IN_ALLOW_COMPOSITION);
+      }
+      const _inheritLocale = isBoolean(options.inheritLocale)
+          ? options.inheritLocale
+          : !isString(options.locale);
+      const _locale = vue.ref(
+      // prettier-ignore
+      !isLocalScope || _inheritLocale
+          ? root.locale.value
+          : isString(options.locale)
+              ? options.locale
+              : DEFAULT_LOCALE);
+      const _fallbackLocale = vue.ref(
+      // prettier-ignore
+      !isLocalScope || _inheritLocale
+          ? root.fallbackLocale.value
+          : isString(options.fallbackLocale) ||
+              isArray(options.fallbackLocale) ||
+              isPlainObject(options.fallbackLocale) ||
+              options.fallbackLocale === false
+              ? options.fallbackLocale
+              : _locale.value);
+      const _messages = vue.ref(getLocaleMessages(_locale.value, options));
+      // prettier-ignore
+      const _datetimeFormats = vue.ref(isPlainObject(options.datetimeFormats)
+          ? options.datetimeFormats
+          : { [_locale.value]: {} });
+      // prettier-ignore
+      const _numberFormats = vue.ref(isPlainObject(options.numberFormats)
+          ? options.numberFormats
+          : { [_locale.value]: {} });
+      // prettier-ignore
+      const _missingWarn = isLocalScope
+          ? root.missingWarn
+          : isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+              ? options.missingWarn
+              : true;
+      // prettier-ignore
+      const _fallbackWarn = isLocalScope
+          ? root.fallbackWarn
+          : isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+              ? options.fallbackWarn
+              : true;
+      // prettier-ignore
+      const _fallbackRoot = isLocalScope
+          ? root.fallbackRoot
+          : isBoolean(options.fallbackRoot)
+              ? options.fallbackRoot
+              : true;
+      // configure fall back to root
+      const _fallbackFormat = !!options.fallbackFormat;
+      // runtime missing
+      const _missing = isFunction(options.missing) ? options.missing : null;
+      // postTranslation handler
+      const _postTranslation = isFunction(options.postTranslation)
+          ? options.postTranslation
+          : null;
+      // prettier-ignore
+      const _warnHtmlMessage = isLocalScope
+          ? root.warnHtmlMessage
+          : isBoolean(options.warnHtmlMessage)
+              ? options.warnHtmlMessage
+              : true;
+      const _escapeParameter = !!options.escapeParameter;
+      // prettier-ignore
+      const _modifiers = isLocalScope
+          ? root.modifiers
+          : isPlainObject(options.modifiers)
+              ? options.modifiers
+              : {};
+      // pluralRules
+      const _pluralRules = options.pluralRules || (isLocalScope && root.pluralRules);
+      // track reactivity
+      function trackReactivityValues() {
+          return [
+              _locale.value,
+              _fallbackLocale.value,
+              _messages.value,
+              _datetimeFormats.value,
+              _numberFormats.value
+          ];
+      }
+      // locale
+      const locale = vue.computed({
+          get: () => {
+              return _composer.value ? _composer.value.locale.value : _locale.value;
+          },
+          set: val => {
+              if (_composer.value) {
+                  _composer.value.locale.value = val;
+              }
+              _locale.value = val;
+          }
+      });
+      // fallbackLocale
+      const fallbackLocale = vue.computed({
+          get: () => {
+              return _composer.value
+                  ? _composer.value.fallbackLocale.value
+                  : _fallbackLocale.value;
+          },
+          set: val => {
+              if (_composer.value) {
+                  _composer.value.fallbackLocale.value = val;
+              }
+              _fallbackLocale.value = val;
+          }
+      });
+      // messages
+      const messages = vue.computed(() => {
+          if (_composer.value) {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              return _composer.value.messages.value;
+          }
+          else {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              return _messages.value;
+          }
+      });
+      const datetimeFormats = vue.computed(() => _datetimeFormats.value);
+      const numberFormats = vue.computed(() => _numberFormats.value);
+      function getPostTranslationHandler() {
+          return _composer.value
+              ? _composer.value.getPostTranslationHandler()
+              : _postTranslation;
+      }
+      function setPostTranslationHandler(handler) {
+          if (_composer.value) {
+              _composer.value.setPostTranslationHandler(handler);
+          }
+      }
+      function getMissingHandler() {
+          return _composer.value ? _composer.value.getMissingHandler() : _missing;
+      }
+      function setMissingHandler(handler) {
+          if (_composer.value) {
+              _composer.value.setMissingHandler(handler);
+          }
+      }
+      function warpWithDeps(fn) {
+          trackReactivityValues();
+          return fn();
+      }
+      function t(...args) {
+          return _composer.value
+              ? warpWithDeps(() => Reflect.apply(_composer.value.t, null, [...args]))
+              : warpWithDeps(() => '');
+      }
+      function rt(...args) {
+          return _composer.value
+              ? Reflect.apply(_composer.value.rt, null, [...args])
+              : '';
+      }
+      function d(...args) {
+          return _composer.value
+              ? warpWithDeps(() => Reflect.apply(_composer.value.d, null, [...args]))
+              : warpWithDeps(() => '');
+      }
+      function n(...args) {
+          return _composer.value
+              ? warpWithDeps(() => Reflect.apply(_composer.value.n, null, [...args]))
+              : warpWithDeps(() => '');
+      }
+      function tm(key) {
+          return _composer.value ? _composer.value.tm(key) : {};
+      }
+      function te(key, locale) {
+          return _composer.value ? _composer.value.te(key, locale) : false;
+      }
+      function getLocaleMessage(locale) {
+          return _composer.value ? _composer.value.getLocaleMessage(locale) : {};
+      }
+      function setLocaleMessage(locale, message) {
+          if (_composer.value) {
+              _composer.value.setLocaleMessage(locale, message);
+              _messages.value[locale] = message;
+          }
+      }
+      function mergeLocaleMessage(locale, message) {
+          if (_composer.value) {
+              _composer.value.mergeLocaleMessage(locale, message);
+          }
+      }
+      function getDateTimeFormat(locale) {
+          return _composer.value ? _composer.value.getDateTimeFormat(locale) : {};
+      }
+      function setDateTimeFormat(locale, format) {
+          if (_composer.value) {
+              _composer.value.setDateTimeFormat(locale, format);
+              _datetimeFormats.value[locale] = format;
+          }
+      }
+      function mergeDateTimeFormat(locale, format) {
+          if (_composer.value) {
+              _composer.value.mergeDateTimeFormat(locale, format);
+          }
+      }
+      function getNumberFormat(locale) {
+          return _composer.value ? _composer.value.getNumberFormat(locale) : {};
+      }
+      function setNumberFormat(locale, format) {
+          if (_composer.value) {
+              _composer.value.setNumberFormat(locale, format);
+              _numberFormats.value[locale] = format;
+          }
+      }
+      function mergeNumberFormat(locale, format) {
+          if (_composer.value) {
+              _composer.value.mergeNumberFormat(locale, format);
+          }
+      }
+      const wrapper = {
+          get id() {
+              return _composer.value ? _composer.value.id : -1;
+          },
+          locale,
+          fallbackLocale,
+          messages,
+          datetimeFormats,
+          numberFormats,
+          get inheritLocale() {
+              return _composer.value ? _composer.value.inheritLocale : _inheritLocale;
+          },
+          set inheritLocale(val) {
+              if (_composer.value) {
+                  _composer.value.inheritLocale = val;
+              }
+          },
+          get availableLocales() {
+              return _composer.value
+                  ? _composer.value.availableLocales
+                  : Object.keys(_messages.value);
+          },
+          get modifiers() {
+              return (_composer.value ? _composer.value.modifiers : _modifiers);
+          },
+          get pluralRules() {
+              return (_composer.value ? _composer.value.pluralRules : _pluralRules);
+          },
+          get isGlobal() {
+              return _composer.value ? _composer.value.isGlobal : false;
+          },
+          get missingWarn() {
+              return _composer.value ? _composer.value.missingWarn : _missingWarn;
+          },
+          set missingWarn(val) {
+              if (_composer.value) {
+                  _composer.value.missingWarn = val;
+              }
+          },
+          get fallbackWarn() {
+              return _composer.value ? _composer.value.fallbackWarn : _fallbackWarn;
+          },
+          set fallbackWarn(val) {
+              if (_composer.value) {
+                  _composer.value.missingWarn = val;
+              }
+          },
+          get fallbackRoot() {
+              return _composer.value ? _composer.value.fallbackRoot : _fallbackRoot;
+          },
+          set fallbackRoot(val) {
+              if (_composer.value) {
+                  _composer.value.fallbackRoot = val;
+              }
+          },
+          get fallbackFormat() {
+              return _composer.value ? _composer.value.fallbackFormat : _fallbackFormat;
+          },
+          set fallbackFormat(val) {
+              if (_composer.value) {
+                  _composer.value.fallbackFormat = val;
+              }
+          },
+          get warnHtmlMessage() {
+              return _composer.value
+                  ? _composer.value.warnHtmlMessage
+                  : _warnHtmlMessage;
+          },
+          set warnHtmlMessage(val) {
+              if (_composer.value) {
+                  _composer.value.warnHtmlMessage = val;
+              }
+          },
+          get escapeParameter() {
+              return _composer.value
+                  ? _composer.value.escapeParameter
+                  : _escapeParameter;
+          },
+          set escapeParameter(val) {
+              if (_composer.value) {
+                  _composer.value.escapeParameter = val;
+              }
+          },
+          t,
+          getPostTranslationHandler,
+          setPostTranslationHandler,
+          getMissingHandler,
+          setMissingHandler,
+          rt,
+          d,
+          n,
+          tm,
+          te,
+          getLocaleMessage,
+          setLocaleMessage,
+          mergeLocaleMessage,
+          getDateTimeFormat,
+          setDateTimeFormat,
+          mergeDateTimeFormat,
+          getNumberFormat,
+          setNumberFormat,
+          mergeNumberFormat
+      };
+      function sync(composer) {
+          composer.locale.value = _locale.value;
+          composer.fallbackLocale.value = _fallbackLocale.value;
+          Object.keys(_messages.value).forEach(locale => {
+              composer.mergeLocaleMessage(locale, _messages.value[locale]);
+          });
+          Object.keys(_datetimeFormats.value).forEach(locale => {
+              composer.mergeDateTimeFormat(locale, _datetimeFormats.value[locale]);
+          });
+          Object.keys(_numberFormats.value).forEach(locale => {
+              composer.mergeNumberFormat(locale, _numberFormats.value[locale]);
+          });
+          composer.escapeParameter = _escapeParameter;
+          composer.fallbackFormat = _fallbackFormat;
+          composer.fallbackRoot = _fallbackRoot;
+          composer.fallbackWarn = _fallbackWarn;
+          composer.missingWarn = _missingWarn;
+          composer.warnHtmlMessage = _warnHtmlMessage;
+      }
+      vue.onBeforeMount(() => {
+          if (instance.proxy == null || instance.proxy.$i18n == null) {
+              throw createI18nError(I18nErrorCodes.NOT_AVAILABLE_COMPOSITION_IN_LEGACY);
+          }
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const composer = (_composer.value = instance.proxy.$i18n
+              .__composer);
+          if (scope === 'global') {
+              _locale.value = composer.locale.value;
+              _fallbackLocale.value = composer.fallbackLocale.value;
+              _messages.value = composer.messages.value;
+              _datetimeFormats.value = composer.datetimeFormats.value;
+              _numberFormats.value = composer.numberFormats.value;
+          }
+          else if (isLocalScope) {
+              sync(composer);
+          }
+      });
+      return wrapper;
+  }
+  const globalExportProps = [
+      'locale',
+      'fallbackLocale',
+      'availableLocales'
+  ];
+  const globalExportMethods = ['t', 'rt', 'd', 'n', 'tm', 'te']
+      ;
+  function injectGlobalFields(app, composer) {
+      const i18n = Object.create(null);
+      globalExportProps.forEach(prop => {
+          const desc = Object.getOwnPropertyDescriptor(composer, prop);
+          if (!desc) {
+              throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+          }
+          const wrap = vue.isRef(desc.value) // check computed props
+              ? {
+                  get() {
+                      return desc.value.value;
+                  },
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  set(val) {
+                      desc.value.value = val;
+                  }
+              }
+              : {
+                  get() {
+                      return desc.get && desc.get();
+                  }
+              };
+          Object.defineProperty(i18n, prop, wrap);
+      });
+      app.config.globalProperties.$i18n = i18n;
+      globalExportMethods.forEach(method => {
+          const desc = Object.getOwnPropertyDescriptor(composer, method);
+          if (!desc || !desc.value) {
+              throw createI18nError(I18nErrorCodes.UNEXPECTED_ERROR);
+          }
+          Object.defineProperty(app.config.globalProperties, `$${method}`, desc);
+      });
+      const dispose = () => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          delete app.config.globalProperties.$i18n;
+          globalExportMethods.forEach(method => {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              delete app.config.globalProperties[`$${method}`];
+          });
+      };
+      return dispose;
+  }
+
+  // register message compiler at vue-i18n
+  {
+      registerMessageCompiler(compile);
+  }
+  // register message resolver at vue-i18n
+  registerMessageResolver(resolveValue);
+  // register fallback locale at vue-i18n
+  registerLocaleFallbacker(fallbackWithLocaleChain);
+  // NOTE: experimental !!
+  {
+      const target = getGlobalThis();
+      target.__INTLIFY__ = true;
+      setDevToolsHook(target.__INTLIFY_DEVTOOLS_GLOBAL_HOOK__);
+  }
+  {
+      initDev();
+  }
+
+  exports.DatetimeFormat = DatetimeFormat;
+  exports.I18nD = I18nD;
+  exports.I18nInjectionKey = I18nInjectionKey;
+  exports.I18nN = I18nN;
+  exports.I18nT = I18nT;
+  exports.NumberFormat = NumberFormat;
+  exports.Translation = Translation;
+  exports.VERSION = VERSION;
+  exports.castToVueI18n = castToVueI18n;
+  exports.createI18n = createI18n;
+  exports.useI18n = useI18n;
+  exports.vTDirective = vTDirective;
+
+  return exports;
+
+})({}, Vue);
diff --git a/modules/admin/app/controllers/authorities/HistoricalAgents.scala b/modules/admin/app/controllers/authorities/HistoricalAgents.scala
index 8143bb2fc8..696ad675dc 100644
--- a/modules/admin/app/controllers/authorities/HistoricalAgents.scala
+++ b/modules/admin/app/controllers/authorities/HistoricalAgents.scala
@@ -1,12 +1,10 @@
 package controllers.authorities
 
-import javax.inject._
 import controllers.AppComponents
 import controllers.base.AdminController
 import controllers.generic._
 import forms._
 import models._
-import forms.ConfigFormFieldHintsBuilder
 import play.api.i18n.Messages
 import play.api.mvc.{Action, AnyContent, ControllerComponents}
 import services.data.DataHelpers
@@ -14,12 +12,14 @@ import services.search.SearchConstants.RESTRICTED_FIELD
 import services.search._
 import utils.{PageParams, RangeParams}
 
+import javax.inject._
+
 
 @Singleton
 case class HistoricalAgents @Inject()(
   controllerComponents: ControllerComponents,
   appComponents: AppComponents,
-  dataHelpers: DataHelpers
+  dataHelpers: DataHelpers,
 ) extends AdminController
   with CRUD[HistoricalAgent]
   with Visibility[HistoricalAgent]
@@ -60,16 +60,16 @@ case class HistoricalAgents @Inject()(
     )
   }
 
-  private val formConfig: ConfigFormFieldHintsBuilder = ConfigFormFieldHintsBuilder(EntityType.HistoricalAgent, config)
-
   def search(params: SearchParams, paging: PageParams): Action[AnyContent] =
     SearchTypeAction(params, paging, facetBuilder = entityFacets).apply { implicit request =>
       Ok(views.html.admin.historicalAgent.search(request.result, histRoutes.search()))
     }
 
-  def get(id: String): Action[AnyContent] = ItemMetaAction(id).apply { implicit request =>
-    Ok(views.html.admin.historicalAgent.show(request.item, request.annotations, request.links))
-      .withPreferences(preferences.withRecentItem(id))
+  def get(id: String): Action[AnyContent] = ItemMetaAction(id).async { implicit request =>
+    entityTypeMetadata.listEntityTypeFields(EntityType.HistoricalAgent).map { fields =>
+      Ok(views.html.admin.historicalAgent.show(request.item, request.annotations, request.links, fields.validate(request.item.data)))
+        .withPreferences(preferences.withRecentItem(id))
+    }
   }
 
   def history(id: String, range: RangeParams): Action[AnyContent] = ItemHistoryAction(id, range).apply { implicit request =>
@@ -82,14 +82,14 @@ case class HistoricalAgents @Inject()(
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.historicalAgent.edit(
-      request.item, form.fill(request.item.data), formConfig.forUpdate, histRoutes.updatePost(id)))
+      request.item, form.fill(request.item.data), request.fieldHints, histRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) =>
         BadRequest(views.html.admin.historicalAgent
-          .edit(request.item, errorForm, formConfig.forUpdate, histRoutes.updatePost(id)))
+          .edit(request.item, errorForm, request.fieldHints, histRoutes.updatePost(id)))
       case Right(updated) => Redirect(histRoutes.get(updated.id))
         .flashing("success" -> "item.update.confirmation")
     }
diff --git a/modules/admin/app/controllers/countries/Countries.scala b/modules/admin/app/controllers/countries/Countries.scala
index 5de0677e6e..c0d5c57c2c 100644
--- a/modules/admin/app/controllers/countries/Countries.scala
+++ b/modules/admin/app/controllers/countries/Countries.scala
@@ -12,7 +12,7 @@ import play.api.libs.json.Json
 import play.api.mvc.{Action, AnyContent, ControllerComponents}
 import services.data.{DataHelpers, DataUser, IdGenerator}
 import services.geocoding.GeocodingService
-import services.search.{FacetBuilder, FacetDisplay, FacetSort, FieldFacetClass, SearchConstants, SearchIndexMediator, SearchParams}
+import services.search._
 import utils.{PageParams, RangeParams}
 
 import java.util.UUID
@@ -27,7 +27,7 @@ case class Countries @Inject()(
   dataHelpers: DataHelpers,
   searchIndexer: SearchIndexMediator,
   idGenerator: IdGenerator,
-  geocoder: GeocodingService
+  geocoder: GeocodingService,
 )(implicit actorSystem: ActorSystem, mat: Materializer) extends AdminController
   with CRUD[Country]
   with Creator[Repository, Country]
@@ -54,9 +54,7 @@ case class Countries @Inject()(
   /**
     * Content types that relate to this controller.
     */
-  override protected val targetContentTypes = Seq(ContentTypes.Repository, ContentTypes.DocumentaryUnit)
-
-  private val childFormConfig: ConfigFormFieldHintsBuilder = ConfigFormFieldHintsBuilder(EntityType.Repository, config)
+  override protected val targetContentTypes: Seq[ContentTypes.Value] = Seq(ContentTypes.Repository, ContentTypes.DocumentaryUnit)
   private val form = models.Country.form
   private val childForm = models.Repository.form
 
@@ -64,11 +62,15 @@ case class Countries @Inject()(
 
 
   def get(id: String, params: SearchParams, paging: PageParams): Action[AnyContent] = ItemMetaAction(id).async { implicit request =>
-    findType[Repository](params, paging, filters = Map(SearchConstants.COUNTRY_CODE -> request.item.id)).map { result =>
+    for {
+      result <- findType[Repository](params, paging, filters = Map(SearchConstants.COUNTRY_CODE -> request.item.id))
+      fieldMetadata <- entityTypeMetadata.listEntityTypeFields(EntityType.Country)
+      validation = fieldMetadata.validate(request.item.data)
+    } yield {
       if(isAjax) Ok(views.html.admin.search.inlineItemList(result = result))
         .withHeaders("more" -> result.page.hasMore.toString)
       else Ok(views.html.admin.country.show(request.item, result,
-        countryRoutes.get(id), request.annotations, request.links))
+        countryRoutes.get(id), request.annotations, request.links, validation))
         .withPreferences(preferences.withRecentItem(id))
     }
   }
@@ -83,15 +85,15 @@ case class Countries @Inject()(
     }
 
   def create: Action[AnyContent] = NewItemAction.apply { implicit request =>
-    Ok(views.html.admin.country.create(form, visibilityForm,
+    Ok(views.html.admin.country.create(form, visibilityForm, request.fieldHints,
       request.usersAndGroups, countryRoutes.createPost()))
   }
 
   def createPost: Action[AnyContent] = CreateItemAction(form).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.country.create(
-          errorForm, accForm, usersAndGroups, countryRoutes.createPost()))
+          errorForm, accForm, fieldHints, usersAndGroups, countryRoutes.createPost()))
       case Right(item) => Redirect(countryRoutes.get(item.id))
         .flashing("success" -> "item.create.confirmation")
     }
@@ -99,37 +101,36 @@ case class Countries @Inject()(
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.country.edit(
-      request.item, form.fill(request.item.data), countryRoutes.updatePost(id)))
+      request.item, form.fill(request.item.data), request.fieldHints, countryRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) => BadRequest(views.html.admin.country.edit(
-        request.item, errorForm, countryRoutes.updatePost(id)))
+        request.item, errorForm, request.fieldHints, countryRoutes.updatePost(id)))
       case Right(item) => Redirect(countryRoutes.get(item.id))
         .flashing("success" -> "item.update.confirmation")
     }
   }
 
   def createRepository(id: String): Action[AnyContent] = NewChildAction(id).async { implicit request =>
-
     // Beware! This is dubious because there could easily be contention
     // if two repositories get created at the same time.
     // Currently there is not way to notify the user that they should just
     // reset the form or increment the ID manually.
-    idGenerator.getNextNumericIdentifier(EntityType.Repository, "%06d").map { newid =>
-      val form = childForm.bind(Map(Entity.IDENTIFIER -> newid))
+    for {newId <- idGenerator.getNextNumericIdentifier(EntityType.Repository, "%06d")} yield {
+      val form = childForm.bind(Map(Entity.IDENTIFIER -> newId))
       Ok(views.html.admin.repository.create(
-        request.item, form, childFormConfig.forCreate, visibilityForm.fill(request.item.accessors.map(_.id)),
+        request.item, form, visibilityForm.fill(request.item.accessors.map(_.id)), request.fieldHints,
         request.usersAndGroups, countryRoutes.createRepositoryPost(id)))
     }
   }
 
   def createRepositoryPost(id: String): Action[AnyContent] = CreateChildAction(id, childForm).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.repository.create(request.item,
-          errorForm, childFormConfig.forCreate, accForm, usersAndGroups, countryRoutes.createRepositoryPost(id)))
+          errorForm, accForm, fieldHints, usersAndGroups, countryRoutes.createRepositoryPost(id)))
       case Right(citem) => Redirect(controllers.institutions.routes.Repositories.get(citem.id))
         .flashing("success" -> "item.create.confirmation")
     }
diff --git a/modules/admin/app/controllers/datamodel/EntityTypeMetadataApi.scala b/modules/admin/app/controllers/datamodel/EntityTypeMetadataApi.scala
index 2ab9bdeeda..5258927f29 100644
--- a/modules/admin/app/controllers/datamodel/EntityTypeMetadataApi.scala
+++ b/modules/admin/app/controllers/datamodel/EntityTypeMetadataApi.scala
@@ -41,7 +41,7 @@ case class EntityTypeMetadataApi @Inject()(
     }
   }
 
-  def delete(entityType: EntityType.Value, id: String): Action[AnyContent] = WithUserAction.async { implicit request =>
+  def delete(entityType: EntityType.Value): Action[AnyContent] = WithUserAction.async { implicit request =>
     entityTypeMetaService.delete(entityType).map { success =>
       if (success) NoContent else NotFound
     }
diff --git a/modules/admin/app/controllers/datasets/HarvestConfigs.scala b/modules/admin/app/controllers/datasets/HarvestConfigs.scala
index c067098b4c..1cfcc048a7 100644
--- a/modules/admin/app/controllers/datasets/HarvestConfigs.scala
+++ b/modules/admin/app/controllers/datasets/HarvestConfigs.scala
@@ -55,9 +55,9 @@ case class HarvestConfigs @Inject()(
     with WithOptionalUser
 
   private def DatasetAction(id: String, ds: String): ActionBuilder[DatasetRequest, AnyContent] =
-    EditAction(id) andThen new CoreActionTransformer[ItemPermissionRequest, DatasetRequest] {
-      override protected def transform[A](request: ItemPermissionRequest[A]): Future[DatasetRequest[A]] = {
-        implicit val req: ItemPermissionRequest[A] = request
+    EditAction(id) andThen new CoreActionTransformer[EditRequest, DatasetRequest] {
+      override protected def transform[A](request: EditRequest[A]): Future[DatasetRequest[A]] = {
+        implicit val req: EditRequest[A] = request
         datasets.get(id, ds).map { dataset =>
           DatasetRequest(req.item, req.userOpt, dataset, req)
         }
diff --git a/modules/admin/app/controllers/groups/Groups.scala b/modules/admin/app/controllers/groups/Groups.scala
index 34f5ce420b..26691394f8 100644
--- a/modules/admin/app/controllers/groups/Groups.scala
+++ b/modules/admin/app/controllers/groups/Groups.scala
@@ -4,8 +4,6 @@ import controllers.AppComponents
 import controllers.base.AdminController
 import controllers.generic._
 import forms._
-
-import javax.inject._
 import models.{Accessor, EntityType, Group, UserProfile}
 import play.api.data.{Form, Forms}
 import play.api.mvc.{Action, AnyContent, ControllerComponents, Request}
@@ -13,6 +11,8 @@ import services.data.{Constants, DataHelpers}
 import services.search.SearchParams
 import utils.{PageParams, RangeParams}
 
+import javax.inject._
+
 
 case class Groups @Inject()(
   controllerComponents: ControllerComponents,
@@ -68,7 +68,7 @@ case class Groups @Inject()(
 
   def createPost: Action[AnyContent] = CreateItemAction(form, memberExtractor).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, _, usersAndGroups)) =>
         BadRequest(views.html.admin.group.create(
           errorForm, accForm, usersAndGroups, groupRoutes.createPost()))
       case Right(item) => Redirect(groupRoutes.get(item.id))
diff --git a/modules/admin/app/controllers/institutions/Repositories.scala b/modules/admin/app/controllers/institutions/Repositories.scala
index 84c832c39e..15222b6bbb 100644
--- a/modules/admin/app/controllers/institutions/Repositories.scala
+++ b/modules/admin/app/controllers/institutions/Repositories.scala
@@ -5,13 +5,12 @@ import controllers.AppComponents
 import controllers.base.{AdminController, ImageHelpers, ResolutionTooHigh, UnrecognizedType}
 import controllers.generic._
 import forms._
-import models.{EntityType, _}
+import models.{ContentTypes, EntityType, _}
 import play.api.i18n.Messages
 import play.api.libs.Files.TemporaryFile
 import play.api.libs.json.Json
 import play.api.mvc._
 import services.data.DataHelpers
-import services.datamodel.EntityTypeMetadataService
 import services.ingest.{EadValidator, IngestService}
 import services.search._
 import services.storage.FileStorage
@@ -31,7 +30,6 @@ case class Repositories @Inject()(
   searchIndexer: SearchIndexMediator,
   fileStorage: FileStorage,
   eadValidator: EadValidator,
-  entityTypeMetadata: EntityTypeMetadataService
 )(
   implicit mat: Materializer
 ) extends AdminController
@@ -98,11 +96,8 @@ case class Repositories @Inject()(
     )
   }
 
-  override protected val targetContentTypes = Seq(ContentTypes.DocumentaryUnit)
-
-  private val formConfig: ConfigFormFieldHintsBuilder = ConfigFormFieldHintsBuilder(EntityType.Repository, config)
+  override protected val targetContentTypes: Seq[ContentTypes.Value] = Seq(ContentTypes.DocumentaryUnit)
   private val form = models.Repository.form
-  private val childFormDefaults: FieldMetaFormFieldHintsBuilder = FieldMetaFormFieldHintsBuilder(EntityType.DocumentaryUnit, entityTypeMetadata, config)
   private val childForm = models.DocumentaryUnit.form
   private val repositoryRoutes = controllers.institutions.routes.Repositories
 
@@ -119,12 +114,20 @@ case class Repositories @Inject()(
     val filters = (if (!hasActiveQuery(request)) Map(SearchConstants.TOP_LEVEL -> true) else Map.empty[String,Any]) ++
         Map(SearchConstants.HOLDER_ID -> request.item.id)
 
-    findType[DocumentaryUnit](params, paging, filters = filters,
-      facetBuilder = repositoryFacets, sort = SearchSort.Id).map { result =>
+    for {
+      result <- findType[DocumentaryUnit](
+        params,
+        paging,
+        filters = filters,
+        facetBuilder = repositoryFacets,
+        sort = SearchSort.Id)
+      fieldMetadata <- entityTypeMetadata.listEntityTypeFields(EntityType.Repository)
+       advisories = fieldMetadata.validate(request.item.data)
+    } yield {
       if(isAjax) Ok(views.html.admin.search.inlineItemList(result = result))
         .withHeaders("more" -> result.page.hasMore.toString)
       else Ok(views.html.admin.repository.show(request.item, result,
-        repositoryRoutes.get(id), request.annotations, request.links))
+        repositoryRoutes.get(id), request.annotations, request.links, advisories))
         .withPreferences(preferences.withRecentItem(id))
     }
   }
@@ -139,30 +142,30 @@ case class Repositories @Inject()(
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.repository.edit(request.item,
-      form.fill(request.item.data), formConfig.forUpdate, repositoryRoutes.updatePost(id)))
+      form.fill(request.item.data), request.fieldHints, repositoryRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) =>
         BadRequest(views.html.admin.repository.edit(
-          request.item, errorForm, formConfig.forUpdate, repositoryRoutes.updatePost(id)))
+          request.item, errorForm, request.fieldHints, repositoryRoutes.updatePost(id)))
       case Right(doc) => Redirect(repositoryRoutes.get(doc.id))
         .flashing("success" -> "item.update.confirmation")
     }
   }
 
   def createDoc(id: String): Action[AnyContent] = NewChildAction(id).apply { implicit request =>
-    Ok(views.html.admin.documentaryUnit.create(request.item, childForm, childFormDefaults.forCreate,
-      visibilityForm.fill(request.item.accessors.map(_.id)),
+    Ok(views.html.admin.documentaryUnit.create(request.item, childForm,
+      visibilityForm.fill(request.item.accessors.map(_.id)), request.fieldHints,
       request.usersAndGroups, repositoryRoutes.createDocPost(id)))
   }
 
   def createDocPost(id: String): Action[AnyContent] = CreateChildAction(id, childForm).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm,accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.documentaryUnit.create(request.item,
-          errorForm, childFormDefaults.forCreate, accForm,
+          errorForm, accForm, fieldHints,
           usersAndGroups, repositoryRoutes.createDocPost(id)))
       case Right(citem) => Redirect(controllers.units.routes.DocumentaryUnits.get(citem.id))
         .flashing("success" -> "item.create.confirmation")
diff --git a/modules/admin/app/controllers/keywords/Concepts.scala b/modules/admin/app/controllers/keywords/Concepts.scala
index 32229a0314..f9b902a72e 100644
--- a/modules/admin/app/controllers/keywords/Concepts.scala
+++ b/modules/admin/app/controllers/keywords/Concepts.scala
@@ -4,9 +4,7 @@ import controllers.AppComponents
 import controllers.base.AdminController
 import controllers.generic._
 import forms._
-
-import javax.inject._
-import models.{EntityType, _}
+import models._
 import play.api.data.Form
 import play.api.data.Forms._
 import play.api.i18n.Messages
@@ -16,6 +14,7 @@ import services.search._
 import utils.{PageParams, RangeParams}
 import views.Helpers
 
+import javax.inject._
 import scala.concurrent.Future.{successful => immediate}
 
 
@@ -58,7 +57,6 @@ case class Concepts @Inject()(
     )
   }
 
-
   def get(id: String, paging: PageParams): Action[AnyContent] = ItemMetaAction(id).async { implicit request =>
     userDataApi.children[Concept, Concept](id, paging).map { page =>
       Ok(views.html.admin.concept.show(request.item, page, paging, request.links, request.annotations))
@@ -80,13 +78,13 @@ case class Concepts @Inject()(
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.concept.edit(
-      request.item, form.fill(request.item.data), conceptRoutes.updatePost(id)))
+      request.item, form.fill(request.item.data), request.fieldHints, conceptRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) => BadRequest(views.html.admin.concept.edit(
-        request.item, errorForm, conceptRoutes.updatePost(id)))
+        request.item, errorForm, request.fieldHints, conceptRoutes.updatePost(id)))
       case Right(item) => Redirect(conceptRoutes.get(item.id))
         .flashing("success" -> "item.update.confirmation")
     }
@@ -94,15 +92,15 @@ case class Concepts @Inject()(
 
   def createConcept(id: String): Action[AnyContent] = NewChildAction(id).apply { implicit request =>
     Ok(views.html.admin.concept.create(
-      request.item, childForm, visibilityForm,
+      request.item, childForm, visibilityForm, request.fieldHints,
       request.usersAndGroups, conceptRoutes.createConceptPost(id)))
   }
 
   def createConceptPost(id: String): Action[AnyContent] = CreateChildAction(id, childForm).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.concept.create(request.item,
-          errorForm, accForm, usersAndGroups, conceptRoutes.createConceptPost(id)))
+          errorForm, accForm, fieldHints, usersAndGroups, conceptRoutes.createConceptPost(id)))
       case Right(citem) => Redirect(conceptRoutes.get(id))
         .flashing("success" -> "item.create.confirmation")
     }
diff --git a/modules/admin/app/controllers/sets/AuthoritativeSets.scala b/modules/admin/app/controllers/sets/AuthoritativeSets.scala
index b67b84677e..8c29a001ed 100644
--- a/modules/admin/app/controllers/sets/AuthoritativeSets.scala
+++ b/modules/admin/app/controllers/sets/AuthoritativeSets.scala
@@ -4,9 +4,6 @@ import controllers.AppComponents
 import controllers.base.AdminController
 import controllers.generic._
 import forms._
-
-import javax.inject._
-import forms.ConfigFormFieldHintsBuilder
 import models._
 import play.api.i18n.Messages
 import play.api.libs.ws.WSClient
@@ -16,6 +13,8 @@ import services.ingest.IngestService
 import services.search.{SearchConstants, SearchIndexMediator, SearchParams, SearchSort}
 import utils.{PageParams, RangeParams}
 
+import javax.inject._
+
 
 @Singleton
 case class
@@ -25,7 +24,7 @@ AuthoritativeSets @Inject()(
   dataHelpers: DataHelpers,
   searchIndexer: SearchIndexMediator,
   idGenerator: IdGenerator,
-  ws: WSClient
+  ws: WSClient,
 ) extends AdminController
   with CRUD[AuthoritativeSet]
   with DeleteChildren[HistoricalAgent, AuthoritativeSet]
@@ -36,9 +35,7 @@ AuthoritativeSets @Inject()(
   with Promotion[AuthoritativeSet]
   with Search {
 
-  private val formConfig: ConfigFormFieldHintsBuilder = ConfigFormFieldHintsBuilder(EntityType.HistoricalAgent, config)
-
-  val targetContentTypes = Seq(ContentTypes.HistoricalAgent)
+  protected val targetContentTypes: Seq[ContentTypes.Value] = Seq(ContentTypes.HistoricalAgent)
   private val form = models.AuthoritativeSet.form
   private val childForm = models.HistoricalAgent.form
   private val setRoutes = controllers.sets.routes.AuthoritativeSets
@@ -63,13 +60,13 @@ AuthoritativeSets @Inject()(
 
   def create: Action[AnyContent] = NewItemAction.apply { implicit request =>
     Ok(views.html.admin.authoritativeSet.create(form, visibilityForm,
-      request.usersAndGroups, setRoutes.createPost()))
+      request.fieldHints, request.usersAndGroups, setRoutes.createPost()))
   }
 
   def createPost: Action[AnyContent] = CreateItemAction(form).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
-        BadRequest(views.html.admin.authoritativeSet.create(errorForm, accForm,
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
+        BadRequest(views.html.admin.authoritativeSet.create(errorForm, accForm, fieldHints,
           usersAndGroups, setRoutes.createPost()))
       case Right(item) => Redirect(setRoutes.get(item.id))
         .flashing("success" -> "item.create.confirmation")
@@ -78,23 +75,25 @@ AuthoritativeSets @Inject()(
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.authoritativeSet.edit(
-      request.item, form.fill(request.item.data),setRoutes.updatePost(id)))
+      request.item, form.fill(request.item.data), request.fieldHints, setRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) => BadRequest(views.html.admin.authoritativeSet.edit(
-        request.item, errorForm, setRoutes.updatePost(id)))
+        request.item, errorForm, request.fieldHints, setRoutes.updatePost(id)))
       case Right(item) => Redirect(setRoutes.get(item.id))
         .flashing("success" -> "item.update.confirmation")
     }
   }
 
   def createHistoricalAgent(id: String): Action[AnyContent] = NewChildAction(id).async { implicit request =>
-    idGenerator.getNextChildNumericIdentifier(id, EntityType.HistoricalAgent, "%06d").map { newid =>
+    for {
+      newId <- idGenerator.getNextChildNumericIdentifier(id, EntityType.HistoricalAgent, "%06d")
+    } yield {
       Ok(views.html.admin.historicalAgent.create(
-        request.item, childForm.bind(Map(Entity.IDENTIFIER -> newid)),
-        formConfig.forCreate, visibilityForm.fill(request.item.accessors.map(_.id)),
+        request.item, childForm.bind(Map(Entity.IDENTIFIER -> newId)),
+        visibilityForm.fill(request.item.accessors.map(_.id)), request.fieldHints,
         request.usersAndGroups,
           setRoutes.createHistoricalAgentPost(id)))
     }
@@ -102,9 +101,9 @@ AuthoritativeSets @Inject()(
 
   def createHistoricalAgentPost(id: String): Action[AnyContent] = CreateChildAction(id, childForm).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm,accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.historicalAgent.create(request.item,
-          errorForm, formConfig.forCreate, accForm, usersAndGroups, setRoutes.createHistoricalAgentPost(id)))
+          errorForm, accForm, fieldHints, usersAndGroups, setRoutes.createHistoricalAgentPost(id)))
       case Right(citem) => Redirect(controllers.authorities.routes.HistoricalAgents.get(citem.id))
         .flashing("success" -> "item.create.confirmation")
     }
diff --git a/modules/admin/app/controllers/units/DocumentaryUnits.scala b/modules/admin/app/controllers/units/DocumentaryUnits.scala
index 8aac44b43a..7672ac0a16 100644
--- a/modules/admin/app/controllers/units/DocumentaryUnits.scala
+++ b/modules/admin/app/controllers/units/DocumentaryUnits.scala
@@ -4,13 +4,12 @@ import controllers.AppComponents
 import controllers.base.AdminController
 import controllers.generic._
 import forms._
-import models.{ContentTypes, EntityType, _}
+import models._
 import play.api.data.Form
 import play.api.data.Forms._
 import play.api.i18n.Messages
 import play.api.mvc.{Action, AnyContent, ControllerComponents}
 import services.data.DataHelpers
-import services.datamodel.EntityTypeMetadataService
 import services.ingest.{ImportLogService, IngestService}
 import services.search._
 import services.storage.FileStorage
@@ -19,8 +18,7 @@ import utils.{DateFacetUtils, PageParams, RangeParams}
 import views.Helpers
 
 import javax.inject._
-import scala.collection.immutable.ListMap
-import scala.concurrent.{Await, Future}
+import scala.concurrent.Future
 
 
 
@@ -32,7 +30,6 @@ case class DocumentaryUnits @Inject()(
   importLogs: ImportLogService,
   @Named("dam") damStorage: FileStorage,
   dfu: DateFacetUtils,
-  entityTypeMetadata: EntityTypeMetadataService
 ) extends AdminController
   with Read[DocumentaryUnit]
   with Visibility[DocumentaryUnit]
@@ -108,8 +105,6 @@ case class DocumentaryUnits @Inject()(
     )
   }
 
-//  private val formConfig: ConfigFormFieldHintsBuilder = ConfigFormFieldHintsBuilder(EntityType.DocumentaryUnit, config)
-  private val formConfig: FieldMetaFormFieldHintsBuilder = FieldMetaFormFieldHintsBuilder(EntityType.DocumentaryUnit, entityTypeMetadata, config)
   private val form = models.DocumentaryUnit.form
   private val childForm = models.DocumentaryUnit.form
 
@@ -131,12 +126,20 @@ case class DocumentaryUnits @Inject()(
   }
 
   def get(id: String, dlid: Option[String], params: SearchParams, paging: PageParams): Action[AnyContent] = ItemMetaAction(id).async { implicit request =>
-    findType[DocumentaryUnit](params, paging, filters = Map(SearchConstants.PARENT_ID -> request.item.id),
-      facetBuilder = entityFacets, sort = SearchSort.Id).map { result =>
-      if (isAjax) Ok(views.html.admin.search.inlineItemList(result = result))
-        .withHeaders("more" -> result.page.hasMore.toString)
-      else Ok(views.html.admin.documentaryUnit.show(request.item, result,
-        docRoutes.get(id), request.annotations, request.links, dlid))
+    for {
+      children <- findType[DocumentaryUnit](
+        params,
+        paging,
+        filters = Map(SearchConstants.PARENT_ID -> request.item.id),
+        facetBuilder = entityFacets,
+        sort = SearchSort.Id)
+      fieldMetadata <- entityTypeMetadata.listEntityTypeFields(EntityType.DocumentaryUnit)
+      errors = fieldMetadata.validate(request.item.data)
+    } yield {
+      if (isAjax) Ok(views.html.admin.search.inlineItemList(result = children))
+        .withHeaders("more" -> children.page.hasMore.toString)
+      else Ok(views.html.admin.documentaryUnit.show(request.item, children,
+        docRoutes.get(id), request.annotations, request.links, dlid, errors))
           .withPreferences(preferences.withRecentItem(id))
     }
   }
@@ -158,15 +161,15 @@ case class DocumentaryUnits @Inject()(
   }
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
-    Ok(views.html.admin.documentaryUnit.edit(
-      request.item, form.fill(request.item.data), formConfig.forUpdate, docRoutes.updatePost(id)))
+      Ok(views.html.admin.documentaryUnit.edit(
+        request.item, form.fill(request.item.data), request.fieldHints, docRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) =>
         BadRequest(views.html.admin.documentaryUnit.edit(request.item,
-          errorForm, formConfig.forUpdate, docRoutes.updatePost(id)))
+          errorForm, request.fieldHints, docRoutes.updatePost(id)))
       case Right(item) => Redirect(docRoutes.get(item.id))
         .flashing("success" -> "item.update.confirmation")
     }
@@ -208,32 +211,31 @@ case class DocumentaryUnits @Inject()(
 
   def createDoc(id: String): Action[AnyContent] = NewChildAction(id).apply { implicit request =>
     Ok(views.html.admin.documentaryUnit.create(
-      request.item, childForm, formConfig.forCreate, visibilityForm.fill(request.item.accessors.map(_.id)),
+      request.item, childForm, visibilityForm.fill(request.item.accessors.map(_.id)), request.fieldHints,
       request.usersAndGroups, docRoutes.createDocPost(id)))
   }
 
   def createDocPost(id: String): Action[AnyContent] = CreateChildAction(id, childForm).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.documentaryUnit.create(request.item,
-          errorForm, formConfig.forCreate, accForm, usersAndGroups,
+          errorForm, accForm, fieldHints, usersAndGroups,
           docRoutes.createDocPost(id)))
       case Right(doc) => Redirect(docRoutes.get(doc.id))
         .flashing("success" -> "item.create.confirmation")
     }
   }
 
-  def createDescription(id: String): Action[AnyContent] =
-    WithItemPermissionAction(id, PermissionType.Update).apply { implicit request =>
+  def createDescription(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
       Ok(views.html.admin.documentaryUnit.createDescription(request.item,
-        form.fill(request.item.data), formConfig.forCreate, docRoutes.createDescriptionPost(id)))
-    }
+        form.fill(request.item.data), request.fieldHints, docRoutes.createDescriptionPost(id)))
+  }
 
   def createDescriptionPost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) =>
         BadRequest(views.html.admin.documentaryUnit.createDescription(request.item,
-          errorForm, formConfig.forCreate, docRoutes.createDescriptionPost(id)))
+          errorForm, request.fieldHints, docRoutes.createDescriptionPost(id)))
       case Right(_) => Redirect(docRoutes.get(id))
         .flashing("success" -> "item.create.confirmation")
     }
@@ -241,14 +243,14 @@ case class DocumentaryUnits @Inject()(
 
   def updateDescription(id: String, did: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.documentaryUnit.editDescription(request.item,
-      form.fill(request.item.data), formConfig.forUpdate, did, docRoutes.updateDescriptionPost(id, did)))
+      form.fill(request.item.data), request.fieldHints, did, docRoutes.updateDescriptionPost(id, did)))
   }
 
   def updateDescriptionPost(id: String, did: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) =>
         BadRequest(views.html.admin.documentaryUnit.editDescription(request.item,
-          errorForm, formConfig.forUpdate, did, docRoutes.updateDescriptionPost(id, did)))
+          errorForm, request.fieldHints, did, docRoutes.updateDescriptionPost(id, did)))
       case Right(_) => Redirect(docRoutes.get(id))
         .flashing("success" -> "item.update.confirmation")
     }
diff --git a/modules/admin/app/controllers/virtual/VirtualUnits.scala b/modules/admin/app/controllers/virtual/VirtualUnits.scala
index 5a7fc648b1..a14a414de1 100644
--- a/modules/admin/app/controllers/virtual/VirtualUnits.scala
+++ b/modules/admin/app/controllers/virtual/VirtualUnits.scala
@@ -4,10 +4,7 @@ import controllers.AppComponents
 import controllers.base.{AdminController, SearchVC}
 import controllers.generic._
 import forms._
-
-import javax.inject._
 import models._
-import forms.ConfigFormFieldHintsBuilder
 import play.api.data.Form
 import play.api.data.Forms._
 import play.api.i18n.Messages
@@ -18,6 +15,7 @@ import services.search._
 import utils.{PageParams, RangeParams}
 import views.Helpers
 
+import javax.inject._
 import scala.concurrent.Future
 import scala.concurrent.Future.{successful => immediate}
 
@@ -28,7 +26,7 @@ case class VirtualUnits @Inject()(
   appComponents: AppComponents,
   dataHelpers: DataHelpers,
   idGenerator: IdGenerator,
-  cypher: CypherService
+  cypher: CypherService,
 ) extends AdminController
   with Read[VirtualUnit]
   with Visibility[VirtualUnit]
@@ -78,8 +76,8 @@ case class VirtualUnits @Inject()(
     )
   }
 
-  override protected val targetContentTypes = Seq(ContentTypes.VirtualUnit)
-  private val formConfig: ConfigFormFieldHintsBuilder = ConfigFormFieldHintsBuilder(EntityType.DocumentaryUnit, config)
+  override protected val targetContentTypes: Seq[ContentTypes.Value] = Seq(ContentTypes.VirtualUnit)
+  private val formConfig: FieldMetaFormFieldHintsBuilder = FieldMetaFormFieldHintsBuilder(EntityType.DocumentaryUnit, entityTypeMetadata, config)
   private val form: Form[VirtualUnitF] = models.VirtualUnit.form
   private val childForm: Form[VirtualUnitF] = models.VirtualUnit.form
 
@@ -144,29 +142,30 @@ case class VirtualUnits @Inject()(
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.virtualUnit.edit(
-      request.item, form.fill(request.item.data),formConfig.forUpdate, vuRoutes.updatePost(id)))
+      request.item, form.fill(request.item.data), request.fieldHints, vuRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) => BadRequest(views.html.admin.virtualUnit.edit(
-        request.item, errorForm, formConfig.forUpdate, vuRoutes.updatePost(id)))
+        request.item, errorForm, request.fieldHints, vuRoutes.updatePost(id)))
       case Right(item) => Redirect(vuRoutes.get(item.id))
         .flashing("success" -> "item.update.confirmation")
     }
   }
 
   def create: Action[AnyContent] = NewItemAction.async { implicit request =>
-    idGenerator.getNextNumericIdentifier(EntityType.VirtualUnit, "%06d").map { newId =>
-      Ok(views.html.admin.virtualUnit.create(None, form.bind(Map(Entity.IDENTIFIER -> makeId(newId))),
-        formConfig.forCreate, visibilityForm, request.usersAndGroups, vuRoutes.createPost()))
-    }
+    for {
+      newId <- idGenerator.getNextNumericIdentifier(EntityType.VirtualUnit, "%06d")
+      fieldHints <- formConfig.forCreate
+    } yield Ok (views.html.admin.virtualUnit.create (None, form.bind (Map (Entity.IDENTIFIER -> makeId (newId))),
+      visibilityForm, fieldHints, request.usersAndGroups, vuRoutes.createPost ()))
   }
 
   def createPost: Action[AnyContent] = CreateItemAction(form).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
-        BadRequest(views.html.admin.virtualUnit.create(None, errorForm, formConfig.forCreate, accForm,
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
+        BadRequest(views.html.admin.virtualUnit.create(None, errorForm, accForm, fieldHints,
           usersAndGroups, vuRoutes.createPost()))
       case Right(item) => Redirect(vuRoutes.get(item.id))
         .flashing("success" -> "item.create.confirmation")
@@ -174,19 +173,19 @@ case class VirtualUnits @Inject()(
   }
 
   def createChild(id: String): Action[AnyContent] = NewChildAction(id).async { implicit request =>
-    idGenerator.getNextNumericIdentifier(EntityType.VirtualUnit, "%06d").map { newId =>
-      Ok(views.html.admin.virtualUnit.create(
+    for {
+      newId <- idGenerator.getNextNumericIdentifier(EntityType.VirtualUnit, "%06d")
+    } yield Ok(views.html.admin.virtualUnit.create(
         Some(request.item), childForm.bind(Map(Entity.IDENTIFIER -> makeId(newId))),
-        formConfig.forCreate, visibilityForm.fill(request.item.accessors.map(_.id)),
+        visibilityForm.fill(request.item.accessors.map(_.id)), request.fieldHints,
         request.usersAndGroups, vuRoutes.createChildPost(id)))
-    }
   }
 
   def createChildPost(id: String): Action[AnyContent] = CreateChildAction(id, childForm).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.virtualUnit.create(Some(request.item),
-          errorForm, formConfig.forCreate, accForm, usersAndGroups,
+          errorForm, accForm, fieldHints, usersAndGroups,
           vuRoutes.createChildPost(id)))
       case Right(doc) => Redirect(vuRoutes.getInVc(id, doc.id))
         .flashing("success" -> "item.create.confirmation")
@@ -274,31 +273,36 @@ case class VirtualUnits @Inject()(
       .flashing("success" -> "item.delete.confirmation")
   }
 
-  def createDescription(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
-    Ok(views.html.admin.virtualUnit.createDescription(request.item,
-      form.fill(request.item.data), formConfig.forCreate, vuRoutes.createDescriptionPost(id)))
+  def createDescription(id: String): Action[AnyContent] = EditAction(id).async { implicit request =>
+    formConfig.forCreate.map { fieldHints =>
+      Ok(views.html.admin.virtualUnit.createDescription(request.item,
+        form.fill(request.item.data), fieldHints, vuRoutes.createDescriptionPost(id)))
+    }
   }
 
-  def createDescriptionPost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
-    request.formOrItem match {
-      case Left(errorForm) =>
-        Ok(views.html.admin.virtualUnit.createDescription(request.item,
-          errorForm, formConfig.forCreate, vuRoutes.createDescriptionPost(id)))
-      case Right(updated) => Redirect(vuRoutes.get(id))
-        .flashing("success" -> "item.create.confirmation")
+  def createDescriptionPost(id: String): Action[AnyContent] = UpdateAction(id, form).async { implicit request =>
+    formConfig.forCreate.map { fieldHints =>
+      request.formOrItem match {
+        case Left(errorForm) =>
+          Ok(views.html.admin.virtualUnit.createDescription(request.item,
+            errorForm, fieldHints, vuRoutes.createDescriptionPost(id)))
+        case Right(updated) => Redirect(vuRoutes.get(id))
+          .flashing("success" -> "item.create.confirmation")
+      }
     }
   }
 
   def updateDescription(id: String, did: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.virtualUnit.editDescription(request.item,
-      form.fill(request.item.data), formConfig.forUpdate, did, vuRoutes.updateDescriptionPost(id, did)))
+      form.fill(request.item.data), request.fieldHints, did, vuRoutes.updateDescriptionPost(id, did))
+    )
   }
 
   def updateDescriptionPost(id: String, did: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) =>
         Ok(views.html.admin.virtualUnit.editDescription(request.item,
-          errorForm, formConfig.forUpdate, did, vuRoutes.updateDescriptionPost(id, did)))
+          errorForm, request.fieldHints, did, vuRoutes.updateDescriptionPost(id, did)))
       case Right(updated) => Redirect(vuRoutes.get(id))
         .flashing("success" -> "item.update.confirmation")
     }
diff --git a/modules/admin/app/controllers/vocabularies/Vocabularies.scala b/modules/admin/app/controllers/vocabularies/Vocabularies.scala
index 9b94205e82..1d6147de2a 100644
--- a/modules/admin/app/controllers/vocabularies/Vocabularies.scala
+++ b/modules/admin/app/controllers/vocabularies/Vocabularies.scala
@@ -4,7 +4,7 @@ import controllers.AppComponents
 import controllers.base.AdminController
 import controllers.generic._
 import forms._
-import models.{EntityType, _}
+import models._
 import play.api.data.Form
 import play.api.i18n.Messages
 import play.api.libs.ws.WSClient
@@ -34,7 +34,7 @@ case class Vocabularies @Inject()(
   with Promotion[Vocabulary]
   with Search {
 
-  override protected val targetContentTypes = Seq(ContentTypes.Concept)
+  override protected val targetContentTypes: Seq[ContentTypes.Value] = Seq(ContentTypes.Concept)
   private val form: Form[VocabularyF] = models.Vocabulary.form
   private val childForm: Form[ConceptF] = models.Concept.form
 
@@ -59,14 +59,14 @@ case class Vocabularies @Inject()(
   }
 
   def create: Action[AnyContent] = NewItemAction.apply { implicit request =>
-    Ok(views.html.admin.vocabulary.create(form, visibilityForm,
+    Ok(views.html.admin.vocabulary.create(form, visibilityForm, request.fieldHints,
       request.usersAndGroups, vocabRoutes.createPost()))
   }
 
   def createPost: Action[AnyContent] = CreateItemAction(form).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
-        BadRequest(views.html.admin.vocabulary.create(errorForm, accForm,
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
+        BadRequest(views.html.admin.vocabulary.create(errorForm, accForm, fieldHints,
           usersAndGroups, vocabRoutes.createPost()))
       case Right(item) => Redirect(vocabRoutes.get(item.id))
         .flashing("success" -> "item.create.confirmation")
@@ -75,13 +75,13 @@ case class Vocabularies @Inject()(
 
   def update(id: String): Action[AnyContent] = EditAction(id).apply { implicit request =>
     Ok(views.html.admin.vocabulary.edit(
-      request.item, form.fill(request.item.data), vocabRoutes.updatePost(id)))
+      request.item, form.fill(request.item.data), request.fieldHints, vocabRoutes.updatePost(id)))
   }
 
   def updatePost(id: String): Action[AnyContent] = UpdateAction(id, form).apply { implicit request =>
     request.formOrItem match {
       case Left(errorForm) => BadRequest(views.html.admin.vocabulary.edit(
-        request.item, errorForm, vocabRoutes.updatePost(id)))
+        request.item, errorForm, request.fieldHints, vocabRoutes.updatePost(id)))
       case Right(item) => Redirect(vocabRoutes.get(item.id))
         .flashing("success" -> "item.update.confirmation")
     }
@@ -90,14 +90,14 @@ case class Vocabularies @Inject()(
   def createConcept(id: String): Action[AnyContent] = NewChildAction(id).apply { implicit request =>
     Ok(views.html.admin.concept.create(
       request.item, childForm, visibilityForm.fill(request.item.accessors.map(_.id)),
-      request.usersAndGroups, vocabRoutes.createConceptPost(id)))
+      request.fieldHints, request.usersAndGroups, vocabRoutes.createConceptPost(id)))
   }
 
   def createConceptPost(id: String): Action[AnyContent] = CreateChildAction(id, childForm).apply { implicit request =>
     request.formOrItem match {
-      case Left((errorForm, accForm, usersAndGroups)) =>
+      case Left((errorForm, accForm, fieldHints, usersAndGroups)) =>
         BadRequest(views.html.admin.concept.create(request.item,
-          errorForm, accForm, usersAndGroups, vocabRoutes.createConceptPost(id)))
+          errorForm, accForm, fieldHints, usersAndGroups, vocabRoutes.createConceptPost(id)))
       case Right(_) => Redirect(vocabRoutes.get(id))
         .flashing("success" -> "item.create.confirmation")
     }
diff --git a/modules/admin/app/views/admin/Helpers.scala b/modules/admin/app/views/admin/Helpers.scala
index 371d9f8054..ecf53b9a28 100644
--- a/modules/admin/app/views/admin/Helpers.scala
+++ b/modules/admin/app/views/admin/Helpers.scala
@@ -2,6 +2,7 @@ package views.admin
 
 import models.{EntityType, Model}
 import play.api.mvc.Call
+import views.html.helper.{FieldConstructor, FieldElements}
 
 /**
  * Admin view helpers.
@@ -73,4 +74,8 @@ object Helpers {
 
   def publicLinkTo(isA: EntityType.Value, id: String): Option[Call] =
     linkToOpt(isA, id).map(call => Call(call.method, call.url.replaceAll("^/admin", ""), call.fragment))
+
+  implicit def fieldConstructorWithHints(implicit config: Option[forms.FormFieldHints]): FieldConstructor = {
+    FieldConstructor((elts: FieldElements) => views.html.formHelpers.fieldTemplateWithHints(elts)(config))
+  }
 }
diff --git a/modules/admin/app/views/admin/authoritativeSet/create.scala.html b/modules/admin/app/views/admin/authoritativeSet/create.scala.html
index ac296018cd..18d2a212e6 100644
--- a/modules/admin/app/views/admin/authoritativeSet/create.scala.html
+++ b/modules/admin/app/views/admin/authoritativeSet/create.scala.html
@@ -1,12 +1,13 @@
-@(f: Form[AuthoritativeSetF], vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(f: Form[AuthoritativeSetF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
-@implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
+@** @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }*@
+@implicitField = @{views.admin.Helpers.fieldConstructorWithHints(Some(fieldHints))}
 
 @views.html.admin.layout.rightSidebar(Messages("authoritativeSet.create")) {
 	@helper.form(action = action) {
         @formHelpers.csrfToken()
         @formHelpers.lineInput(f(""), Entity.IDENTIFIER, 'autocomplete -> "off")
-        @views.html.admin.authoritativeSet.form(None, f)
+        @views.html.admin.authoritativeSet.form(None, f, fieldHints)
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("authoritativeSet.create.submit"))
diff --git a/modules/admin/app/views/admin/authoritativeSet/edit.scala.html b/modules/admin/app/views/admin/authoritativeSet/edit.scala.html
index 61ac38a524..d5cfcbc975 100644
--- a/modules/admin/app/views/admin/authoritativeSet/edit.scala.html
+++ b/modules/admin/app/views/admin/authoritativeSet/edit.scala.html
@@ -1,4 +1,4 @@
-@(item: AuthoritativeSet, f: play.api.data.Form[AuthoritativeSetF], action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: AuthoritativeSet, f: play.api.data.Form[AuthoritativeSetF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
@@ -6,7 +6,7 @@
 	@helper.form(action = action) {
         @formHelpers.csrfToken()
         @formHelpers.hiddenInput(f(Entity.IDENTIFIER))
-        @views.html.admin.authoritativeSet.form(Some(item), f)
+        @views.html.admin.authoritativeSet.form(Some(item), f, fieldHints)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("authoritativeSet.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
 	}
diff --git a/modules/admin/app/views/admin/authoritativeSet/form.scala.html b/modules/admin/app/views/admin/authoritativeSet/form.scala.html
index 1892390875..41abcfe3ea 100644
--- a/modules/admin/app/views/admin/authoritativeSet/form.scala.html
+++ b/modules/admin/app/views/admin/authoritativeSet/form.scala.html
@@ -1,7 +1,9 @@
-@(item: Option[AuthoritativeSet], f: Form[AuthoritativeSetF])(implicit fieldConstructor: helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
+@(item: Option[AuthoritativeSet], f: Form[AuthoritativeSetF], fieldHints: forms.FormFieldHints)(implicit fieldConstructor: helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
 
-@defining("authoritativeSet") { implicit fieldPrefix =>
-    @formHelpers.lineInput(f(""), AuthoritativeSetF.NAME)
-    @formHelpers.textInput(f(""), AuthoritativeSetF.DESCRIPTION)
-    @formHelpers.hiddenInput(f(AuthoritativeSetF.ALLOW_PUBLIC))
+@defining(Some(fieldHints)) { implicit implicitFieldHints =>
+    @defining("authoritativeSet") { implicit fieldPrefix =>
+        @formHelpers.lineInput(f(""), AuthoritativeSetF.NAME)
+        @formHelpers.textInput(f(""), AuthoritativeSetF.DESCRIPTION)
+        @formHelpers.hiddenInput(f(AuthoritativeSetF.ALLOW_PUBLIC))
+    }
 }
diff --git a/modules/admin/app/views/admin/common/validationErrors.scala.html b/modules/admin/app/views/admin/common/validationErrors.scala.html
new file mode 100644
index 0000000000..8fdaf0bbc6
--- /dev/null
+++ b/modules/admin/app/views/admin/common/validationErrors.scala.html
@@ -0,0 +1,34 @@
+@(validation: Seq[ValidationError], fieldPrefix: String, show: Boolean = true)(implicit userOpt: Option[UserProfile], messages: Messages)
+
+@if(show && validation.nonEmpty) {
+    <details class="metadata-validation">
+        <summary>@Messages("dataModel.advisories", validation.size)</summary>
+
+        <div class="metadata-validation-details">
+
+        @defining(validation.collect { case e@MissingMandatoryField(_) => e }, validation.collect { case e@MissingDesirableField(_) => e }) { case (mandatory, desirable) =>
+            @if(mandatory.nonEmpty) {
+                <div class="validation-errors">
+                    <header>@Messages("dataModel.missingMandatoryFields", mandatory.size)</header>
+                    <ul>
+                    @mandatory.map { e =>
+                        <li>@Messages(fieldPrefix + "." + e.id)</li>
+                    }
+                    </ul>
+                </div>
+            }
+            @if(desirable.nonEmpty) {
+
+                <div class="validation-warnings">
+                    <header>@Messages("dataModel.missingDesirableFields", desirable.size)</header>
+                    <ul>
+                    @desirable.map { e =>
+                        <li>@Messages(fieldPrefix + "." + e.id)</li>
+                    }
+                    </ul>
+                </div>
+            }
+        }
+        </div>
+    </details>
+}
diff --git a/modules/admin/app/views/admin/concept/create.scala.html b/modules/admin/app/views/admin/concept/create.scala.html
index e8764bcad8..1b9516acec 100644
--- a/modules/admin/app/views/admin/concept/create.scala.html
+++ b/modules/admin/app/views/admin/concept/create.scala.html
@@ -1,4 +1,4 @@
-@(item: Model, f: play.api.data.Form[ConceptF], vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Model, f: play.api.data.Form[ConceptF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
@@ -23,7 +23,7 @@
 
 	@helper.form(action = action) {
         @formHelpers.csrfToken()
-        @form(f)
+        @form(f, fieldHints)
 
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
 
diff --git a/modules/admin/app/views/admin/concept/edit.scala.html b/modules/admin/app/views/admin/concept/edit.scala.html
index 92ceffcf93..d442449ac1 100644
--- a/modules/admin/app/views/admin/concept/edit.scala.html
+++ b/modules/admin/app/views/admin/concept/edit.scala.html
@@ -1,4 +1,4 @@
-@(item: Concept, f: play.api.data.Form[ConceptF], action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Concept, f: play.api.data.Form[ConceptF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
@@ -6,7 +6,7 @@
 		
 	@helper.form(action = action) {
         @formHelpers.csrfToken()
-		@form(f)
+		@form(f, fieldHints)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("cvocConcept.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
 	}
diff --git a/modules/admin/app/views/admin/concept/form.scala.html b/modules/admin/app/views/admin/concept/form.scala.html
index e0119dcecb..4e9a73a383 100644
--- a/modules/admin/app/views/admin/concept/form.scala.html
+++ b/modules/admin/app/views/admin/concept/form.scala.html
@@ -1,4 +1,4 @@
-@(f: play.api.data.Form[ConceptF])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
+@(f: play.api.data.Form[ConceptF], fieldHints: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
 
 @import ConceptF._
 @import views.html.formHelpers._
@@ -8,7 +8,7 @@
 @lineInput(f(""), Entity.IDENTIFIER, 'autocomplete -> "off")
 
 @defining("cvocConcept") { implicit prefix =>
-    @defining(Option.empty[forms.FormFieldHints]) { implicit implicitConfig =>
+    @defining(Some(fieldHints)) { implicit implicitFieldHints =>
         @lineInput(f(""), URI)
         @lineInput(f(""), URL)
         @lineInput(f(""), LONGITUDE)
@@ -21,17 +21,17 @@ <h3>@Messages(prefix + ".descriptions")</h3>
                 <div class="inline-element-template form-template">
                     @descriptionForm(f("descriptions[IDX]"))
                 </div>
-                <div class="inline-element-list inline-element-block">
-                    @helper.repeat(f("descriptions"), min=math.max(f("descriptions").indexes.length, 1)) { desc =>
-                        @descriptionForm(desc)
-                    }
-                </div>
-                <div class="add-description">
-                    <a class="add-inline-element btn btn-success btn-xs" tabindex="-1" href="#">
-                        <i class="fa fa-plus" aria-hidden="true"></i>
-                        @Messages("cvocConcept.createDescription")
-                    </a>
+                <div class="control-elements">
+                    <div class="inline-element-list inline-element-block">
+                        @helper.repeat(f("descriptions"), min=math.max(f("descriptions").indexes.length, 1)) { desc =>
+                            @descriptionForm(desc)
+                        }
+                    </div>
                 </div>
+                <a class="add-inline-element add-concept btn btn-success btn-xs" tabindex="-1" href="#">
+                    <i class="fa fa-plus" aria-hidden="true"></i>
+                    @Messages("cvocConcept.createDescription")
+                </a>
             </div>
         </fieldset>
     }
diff --git a/modules/admin/app/views/admin/concept/inlineName.scala.html b/modules/admin/app/views/admin/concept/inlineName.scala.html
deleted file mode 100644
index 7862888d21..0000000000
--- a/modules/admin/app/views/admin/concept/inlineName.scala.html
+++ /dev/null
@@ -1,11 +0,0 @@
-@(field: play.api.data.Field)(implicit fieldPrefix: String, messages: Messages)
-
-<div class="inline-element">
-    <div class="control-group @{if(field.hasErrors) "error"}">
-        <div class="controls controls-row">
-            <input type="text" name="@field.name" id="@field.id" value="@field.value" />
-            <span class="help-inline errors">@field.errors.map(_.message).mkString(", ")</span>
-            <a class="remove-inline-element" title="@Messages("item.field.remove")" aria-label="@Messages("item.field.remove")" tabindex="-1" href="#">&times;</a>
-        </div>
-    </div>
-</div>
diff --git a/modules/admin/app/views/admin/concept/inlineNameSet.scala.html b/modules/admin/app/views/admin/concept/inlineNameSet.scala.html
deleted file mode 100644
index 8089ad0a53..0000000000
--- a/modules/admin/app/views/admin/concept/inlineNameSet.scala.html
+++ /dev/null
@@ -1,16 +0,0 @@
-@(field: play.api.data.Field, name: String)(implicit fieldPrefix: String, messages: Messages)
-
-<div class="inline-formset clearfix" data-prefix="@name">
-    <label class="control-label">
-        @Messages(fieldPrefix + "." + name)
-        <a href="#" class="add-inline-element"><i class="fa fa-plus-circle" aria-hidden="true"></i></a>
-    </label>
-    <div class="form-template inline-element-template">
-        @inlineName(field(name + "[IDX]"))
-    </div>
-    <div class="inline-element-list">
-	    @helper.repeat(field(name), min = 0) { field =>
-	        @inlineName(field)
-	    }
-    </div>
-</div>
diff --git a/modules/admin/app/views/admin/country/create.scala.html b/modules/admin/app/views/admin/country/create.scala.html
index 352db26fa9..fa4d1810ec 100644
--- a/modules/admin/app/views/admin/country/create.scala.html
+++ b/modules/admin/app/views/admin/country/create.scala.html
@@ -1,16 +1,16 @@
-@(f: Form[CountryF], vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(f: Form[CountryF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
-@implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
+@implicitField = @{views.admin.Helpers.fieldConstructorWithHints(Some(fieldHints))}
 
 @views.html.admin.layout.rightSidebarWithType(Messages("country.create"), EntityType.Country) {
-	@helper.form(action = action) {
+    @helper.form(action = action) {
         @formHelpers.csrfToken()
         @formHelpers.lineInput(f(""), Entity.IDENTIFIER, 'autocomplete -> "off")
-        @views.html.admin.country.form(None, f)
+        @views.html.admin.country.form(None, f, fieldHints)
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("country.create.submit"))
-	}
+    }
 } {
 
 }
diff --git a/modules/admin/app/views/admin/country/edit.scala.html b/modules/admin/app/views/admin/country/edit.scala.html
index ebc42bc4f1..8211500a8e 100644
--- a/modules/admin/app/views/admin/country/edit.scala.html
+++ b/modules/admin/app/views/admin/country/edit.scala.html
@@ -1,13 +1,13 @@
-@(item: Country, f: play.api.data.Form[CountryF], action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Country, f: play.api.data.Form[CountryF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @views.html.admin.layout.rightSidebarWithType(Messages("country.update"), item.isA, breadcrumbs = views.html.admin.common.breadcrumbs(List(item))) {
-	@helper.form(action = action) {
+    @helper.form(action = action) {
         @formHelpers.csrfToken()
         @formHelpers.hiddenInput(f(Entity.IDENTIFIER))
-        @views.html.admin.country.form(Some(item), f)
+        @views.html.admin.country.form(Some(item), f, fieldHints)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("country.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
-	}
+    }
 } {
 
 }
diff --git a/modules/admin/app/views/admin/country/form.scala.html b/modules/admin/app/views/admin/country/form.scala.html
index c5adc860ac..f9a6a9ed3c 100644
--- a/modules/admin/app/views/admin/country/form.scala.html
+++ b/modules/admin/app/views/admin/country/form.scala.html
@@ -1,11 +1,13 @@
-@(item: Option[Country], f: Form[CountryF])(implicit messages: Messages, md: MarkdownRenderer)
+@(item: Option[Country], f: Form[CountryF], fieldHints: forms.FormFieldHints)(implicit messages: Messages, md: MarkdownRenderer)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
-@defining("country") { implicit fieldPrefix =>
-    @formHelpers.textInput(f(""), CountryF.ABSTRACT)
-    @formHelpers.textInput(f(""), CountryF.HISTORY)
-    @formHelpers.textInput(f(""), CountryF.SITUATION)
-    @formHelpers.textInput(f(""), CountryF.DATA_SUMMARY)
-    @formHelpers.textInput(f(""), CountryF.DATA_EXTENSIVE)
+@defining(Some(fieldHints)) { implicit implicitFieldHints =>
+    @defining("country") { implicit fieldPrefix =>
+        @formHelpers.textInput(f(""), CountryF.ABSTRACT)
+        @formHelpers.textInput(f(""), CountryF.HISTORY)
+        @formHelpers.textInput(f(""), CountryF.SITUATION)
+        @formHelpers.textInput(f(""), CountryF.DATA_SUMMARY)
+        @formHelpers.textInput(f(""), CountryF.DATA_EXTENSIVE)
+    }
 }
diff --git a/modules/admin/app/views/admin/country/show.scala.html b/modules/admin/app/views/admin/country/show.scala.html
index 305eceb329..ecc450745e 100644
--- a/modules/admin/app/views/admin/country/show.scala.html
+++ b/modules/admin/app/views/admin/country/show.scala.html
@@ -1,12 +1,12 @@
-@(item: Country, result: services.search.SearchResult[(Model, services.search.SearchHit)], action: Call, annotations: Seq[Annotation], links: Seq[Link])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Country, result: services.search.SearchResult[(Model, services.search.SearchHit)], action: Call, annotations: Seq[Annotation], links: Seq[Link], validation: Seq[ValidationError])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @import CountryF._
 @import views.html.admin.common.textValue
 
 @views.html.admin.layout.rightSidebar(item.toStringLang, breadcrumbs = views.html.admin.common.breadcrumbs(List(item))) {
-
-    @views.html.admin.common.annotated(item, annotations) {
-        @defining("country") { implicit fieldPrefix =>
+    @defining("country") { implicit fieldPrefix =>
+        @views.html.admin.common.validationErrors(validation, fieldPrefix)
+        @views.html.admin.common.annotated(item, annotations) {
             @textValue(ABSTRACT, item.data.abs)
             @textValue(HISTORY, item.data.history)
             @textValue(SITUATION, item.data.situation)
diff --git a/modules/admin/app/views/admin/datamodel/editor.scala.html b/modules/admin/app/views/admin/datamodel/editor.scala.html
index 38316dde76..2f628cca32 100644
--- a/modules/admin/app/views/admin/datamodel/editor.scala.html
+++ b/modules/admin/app/views/admin/datamodel/editor.scala.html
@@ -19,10 +19,12 @@
         controllers.datamodel.routes.javascript.EntityTypeMetadataApi.listFields,
         controllers.datamodel.routes.javascript.EntityTypeMetadataApi.saveField,
         controllers.datamodel.routes.javascript.EntityTypeMetadataApi.deleteField,
+        controllers.datamodel.routes.javascript.EntityTypeMetadataApi.i18n,
         controllers.datamodel.routes.javascript.EntityTypeMetadataApi.templates
     )
 
     <script src="@controllers.admin.routes.AdminAssets.versioned("js/dmeditor/app.js")"></script>
+
     <script>
             window.SERVICE = {
                 list: dataModelApi.controllers.datamodel.EntityTypeMetadataApi.list,
@@ -32,14 +34,26 @@
                 getField: dataModelApi.controllers.datamodel.EntityTypeMetadataApi.getField,
                 saveField: dataModelApi.controllers.datamodel.EntityTypeMetadataApi.saveField,
                 deleteField: dataModelApi.controllers.datamodel.EntityTypeMetadataApi.deleteField,
+                i18n: dataModelApi.controllers.datamodel.EntityTypeMetadataApi.i18n,
                 templates: dataModelApi.controllers.datamodel.EntityTypeMetadataApi.templates,
             }
-            Vue.createApp({
-                render: function() {
-                    return Vue.h(App.default, {
-                        service: window.SERVICE
+            fetch(dataModelApi.controllers.datamodel.EntityTypeMetadataApi.i18n().url)
+                .then(response => response.json())
+                .then(data => {
+                    let messages = data;
+                    messages['en'] = messages['default'];
+                    delete messages['default'];
+                    let i18n = VueI18n.createI18n({
+                        locale: 'en',
+                        messages
                     });
-                },
-            }).mount("#vue-app");
+                    Vue.createApp({
+                        render: function() {
+                            return Vue.h(App.default, {
+                                service: window.SERVICE
+                            });
+                        },
+                    }).use(i18n).mount("#vue-app");
+                });
     </script>
 }
diff --git a/modules/admin/app/views/admin/documentaryUnit/create.scala.html b/modules/admin/app/views/admin/documentaryUnit/create.scala.html
index 2f1b044ca8..7553e60db9 100644
--- a/modules/admin/app/views/admin/documentaryUnit/create.scala.html
+++ b/modules/admin/app/views/admin/documentaryUnit/create.scala.html
@@ -1,4 +1,4 @@
-@(item: Model, f: Form[DocumentaryUnitF], config: forms.FormFieldHints, vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Model, f: Form[DocumentaryUnitF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f)}
 
@@ -22,10 +22,10 @@
 
     @helper.form(action = action) {
         @formHelpers.csrfToken()
-        @defining(Some(config)) { implicit implicitConfig =>
+        @defining(Some(fieldHints)) { implicit implicitFieldHints =>
             @formHelpers.lineInput(f(""), Entity.IDENTIFIER, 'autocomplete -> "off")
         }
-        @views.html.admin.documentaryUnit.form(f, config)
+        @views.html.admin.documentaryUnit.form(f, fieldHints)
 
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
         @formHelpers.submitButtonWithLogMessageInput(Messages("documentaryUnit.create.submit"), cancel = views.admin.Helpers.linkToOpt(item))
diff --git a/modules/admin/app/views/admin/documentaryUnit/createDescription.scala.html b/modules/admin/app/views/admin/documentaryUnit/createDescription.scala.html
index 04abde07b7..02b7fdd1e5 100644
--- a/modules/admin/app/views/admin/documentaryUnit/createDescription.scala.html
+++ b/modules/admin/app/views/admin/documentaryUnit/createDescription.scala.html
@@ -1,10 +1,10 @@
-@(item: DocumentaryUnit, f: Form[DocumentaryUnitF], config: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: DocumentaryUnit, f: Form[DocumentaryUnitF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("describedEntity.createDescription"), item.isA, breadcrumbs = breadcrumbs(item), scripts = formHelpers.dateJs()) {
     @defining("documentaryUnit") { implicit fieldPrefix =>
-        @defining(Some(config)) { implicit implicitConfig =>
+        @defining(Some(fieldHints)) { implicit implicitFieldHints =>
             @helper.form(action = action) {
                 @formHelpers.csrfToken()
                 @views.html.admin.documentaryUnit.hiddenFormWrapper(f) {
diff --git a/modules/admin/app/views/admin/documentaryUnit/description.scala.html b/modules/admin/app/views/admin/documentaryUnit/description.scala.html
index 9b811d9440..683f87644a 100644
--- a/modules/admin/app/views/admin/documentaryUnit/description.scala.html
+++ b/modules/admin/app/views/admin/documentaryUnit/description.scala.html
@@ -1,4 +1,4 @@
-@(item: DescribedModel, desc: DocumentaryUnitDescriptionF, links: Seq[Link], annotations: Seq[Annotation], actions: Html = Html(""), visible: Boolean)(implicit fieldPrefix: String, userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
+@(item: DescribedModel, desc: DocumentaryUnitDescriptionF, links: Seq[Link], annotations: Seq[Annotation], advisories: Html = Html(""), actions: Html = Html(""), visible: Boolean)(implicit fieldPrefix: String, userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
 
 @import Description.SOURCE_FILE_ID
 @import IsadG._
@@ -6,6 +6,7 @@
 
 @views.html.admin.common.descriptionOutline(item, desc, actions = actions, visible) {
     @views.html.common.itemHeader(desc.name)
+    @advisories
     @textValue(SOURCE_FILE_ID, desc.sourceFileId)
     @descriptionSection(IDENTITY_AREA) {
         @listValue(PARALLEL_FORMS_OF_NAME, desc.identity.parallelFormsOfName)
diff --git a/modules/admin/app/views/admin/documentaryUnit/edit.scala.html b/modules/admin/app/views/admin/documentaryUnit/edit.scala.html
index 7f8cb143d0..300f7e9fb5 100644
--- a/modules/admin/app/views/admin/documentaryUnit/edit.scala.html
+++ b/modules/admin/app/views/admin/documentaryUnit/edit.scala.html
@@ -1,4 +1,4 @@
-@(item: DocumentaryUnit, f: play.api.data.Form[DocumentaryUnitF], config: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: DocumentaryUnit, f: play.api.data.Form[DocumentaryUnitF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
@@ -11,7 +11,7 @@
         <p>@Messages("item.identifier"): <strong>@item.data.identifier</strong> [
             <a href="@controllers.units.routes.DocumentaryUnits.rename(item.id)">@Messages("item.rename.title")</a>]</p>
 
-        @views.html.admin.documentaryUnit.form(f, config)
+        @views.html.admin.documentaryUnit.form(f, fieldHints)
         @formHelpers.submitButtonWithLogMessageInput(Messages("documentaryUnit.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
 	}
 } {
diff --git a/modules/admin/app/views/admin/documentaryUnit/editDescription.scala.html b/modules/admin/app/views/admin/documentaryUnit/editDescription.scala.html
index 0343270e39..0bba26291b 100644
--- a/modules/admin/app/views/admin/documentaryUnit/editDescription.scala.html
+++ b/modules/admin/app/views/admin/documentaryUnit/editDescription.scala.html
@@ -1,11 +1,11 @@
-@(item: DocumentaryUnit, f: Form[DocumentaryUnitF], config: forms.FormFieldHints, did: String, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: DocumentaryUnit, f: Form[DocumentaryUnitF], fieldHints: forms.FormFieldHints, did: String, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("describedEntity.updateDescription"), item.isA, breadcrumbs = breadcrumbs(item), scripts = formHelpers.dateJs()) {
 
     @defining("documentaryUnit") { implicit fieldPrefix =>
-        @defining(Some(config)) { implicit implicitConfig =>
+        @defining(Some(fieldHints)) { implicit implicitFieldHints =>
             @helper.form(action = action) {
                 @formHelpers.csrfToken()
 
diff --git a/modules/admin/app/views/admin/documentaryUnit/form.scala.html b/modules/admin/app/views/admin/documentaryUnit/form.scala.html
index f34c320d7e..be5a27094d 100644
--- a/modules/admin/app/views/admin/documentaryUnit/form.scala.html
+++ b/modules/admin/app/views/admin/documentaryUnit/form.scala.html
@@ -1,11 +1,11 @@
-@(f: play.api.data.Form[DocumentaryUnitF], config: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
+@(f: play.api.data.Form[DocumentaryUnitF], fieldHints: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
 
 @import IsadG._
 @import DocumentaryUnitF._
 
 @implicitField = @{views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f)}
 
-@defining(Some(config)) { implicit implicitConfig =>
+@defining(Some(fieldHints)) { implicit implicitFieldHints =>
 
     @defining("documentaryUnit") { implicit fieldPrefix =>
         @formHelpers.inlineNameSet(f(""), OTHER_IDENTIFIERS)
diff --git a/modules/admin/app/views/admin/documentaryUnit/show.scala.html b/modules/admin/app/views/admin/documentaryUnit/show.scala.html
index 13e9701bd9..6b79673b9e 100644
--- a/modules/admin/app/views/admin/documentaryUnit/show.scala.html
+++ b/modules/admin/app/views/admin/documentaryUnit/show.scala.html
@@ -1,60 +1,70 @@
-@(item: DocumentaryUnit, result: services.search.SearchResult[(Model, services.search.SearchHit)], action: Call, annotations: Seq[Annotation], links: Seq[Link], dlid: Option[String])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: DocumentaryUnit, result: services.search.SearchResult[(Model, services.search.SearchHit)], action: Call, annotations: Seq[Annotation], links: Seq[Link], dlid: Option[String], validation: Seq[ValidationError])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
-@import IsadG._
-@import DocumentaryUnitF._
-@import views.html.admin.common.{descriptionSection, enumValue}
+    @import IsadG._
+    @import DocumentaryUnitF._
+    @import views.html.admin.common.{descriptionSection, enumValue, validationErrors}
 
-@views.html.admin.layout.adminLayout(item.toStringLang) {
-    @breadcrumbs(item)
-    @common.mainContent {
-        @common.itemDetails {
-            <div class="header-actions clearfix">
-                @item.holder.map { holder =>
-                <h4>@Messages("documentaryUnit.heldBy"):
-                    <a href="@controllers.institutions.routes.Repositories.get(holder.id)">@holder.toStringLang</a>
-                </h4>
-                }
-                @item.parent.map { parent =>
-                    <h4>@Messages("documentaryUnit.parentItem"):
-                        <a href="@controllers.units.routes.DocumentaryUnits.get(parent.id)">@parent.toStringLang</a>
-                    </h4>
-                }
-            </div>
-            @defining("documentaryUnit") { implicit fieldPrefix =>
-                @defining(item.data.descriptionsWithSelected(dlid)) { descriptions =>
-                    @common.descriptionContainer(descriptions) {
-                        @descriptions.map { case (desc, selected) =>
-                            @description(item, desc, links, annotations, actions = descriptionActions(item, desc), visible = selected)
-                        }
-                        @descriptionSection(ADMINISTRATION_AREA) {
-                            @enumValue(PUB_STATUS, item.data.publicationStatus)
-                            @enumValue(COPYRIGHT, item.data.copyrightStatus)
-                            @enumValue(SCOPE, item.data.scope)
-                        }
+    @views.html.admin.layout.adminLayout(item.toStringLang) {
+        @breadcrumbs(item)
+        @common.mainContent {
+            @common.itemDetails {
+                <div class="header-actions clearfix">
+                    @item.holder.map { holder =>
+                        <h4>@Messages("documentaryUnit.heldBy"):
+                        <a href="@controllers.institutions.routes.Repositories.get(holder.id)">@holder.toStringLang
+                        </a>
+                        </h4>
+                    }
+                    @item.parent.map { parent =>
+                        <h4>@Messages("documentaryUnit.parentItem"):
+                        <a href="@controllers.units.routes.DocumentaryUnits.get(parent.id)">@parent.toStringLang
+                        </a>
+                        </h4>
+                    }
+                </div>
+                @defining("documentaryUnit") { implicit fieldPrefix =>
+                    @defining(item.data.descriptionsWithSelected(dlid)) { descriptions =>
+                        @common.descriptionContainer(descriptions) {
+                            @descriptions.map { case (desc, selected) =>
+                                @description(
+                                    item,
+                                    desc,
+                                    links,
+                                    annotations,
+                                    advisories = validationErrors(validation, fieldPrefix, item.createdManually),
+                                    actions = descriptionActions(item, desc),
+                                    visible = selected
+                                )
+                            }
+                            @descriptionSection(ADMINISTRATION_AREA) {
+                                @enumValue(PUB_STATUS, item.data.publicationStatus)
+                                @enumValue(COPYRIGHT, item.data.copyrightStatus)
+                                @enumValue(SCOPE, item.data.scope)
+                            }
 
-                        @views.html.admin.link.annotationLinks(item, links)
-                        @views.html.admin.link.externalLinks(item, links)
-                    } {
-                        @common.typeLabel(item.isA) {
-                            @views.html.admin.common.publicButton(item)
+                            @views.html.admin.link.annotationLinks(item, links)
+                            @views.html.admin.link.externalLinks(item, links)
+                        } {
+                            @common.typeLabel(item.isA) {
+                                @views.html.admin.common.publicButton(item)
+                            }
+                            @views.html.common.childItemSidebar(item, EntityType.DocumentaryUnit)
+                        } {
+                            @views.html.admin.common.identifiers(item.data.identifier, item.data.otherIdentifiers)
+                            @views.html.admin.common.latestAction(item, controllers.units.routes.DocumentaryUnits.history(item.id))
+                            @views.html.admin.common.visibility(item, controllers.units.routes.DocumentaryUnits.visibility(item.id), ContentTypes.DocumentaryUnit)
+                            @adminActions(item)
                         }
-                        @views.html.common.childItemSidebar(item, EntityType.DocumentaryUnit)
-                    } {
-                        @views.html.admin.common.identifiers(item.data.identifier, item.data.otherIdentifiers)
-                        @views.html.admin.common.latestAction(item, controllers.units.routes.DocumentaryUnits.history(item.id))
-                        @views.html.admin.common.visibility(item, controllers.units.routes.DocumentaryUnits.visibility(item.id), ContentTypes.DocumentaryUnit)
-                        @adminActions(item)
                     }
                 }
-            }
 
-            @views.html.admin.search.searchSection(item, Messages("documentaryUnit.childItems", item.toStringAbbr(messages)), result) {
-                @views.html.common.search.searchForm(result, action, autofocus = false) {
-                    @views.html.admin.search.searchItemList(result)
-                } {
+                @views.html.admin.search.searchSection(item, Messages("documentaryUnit.childItems", item.toStringAbbr(messages)), result) {
+                    @views.html.common.search.searchForm(result, action, autofocus = false) {
+                        @views.html.admin.search.searchItemList(result)
+                    } {
 
+                    }
                 }
             }
         }
     }
-}
diff --git a/modules/admin/app/views/admin/historicalAgent/create.scala.html b/modules/admin/app/views/admin/historicalAgent/create.scala.html
index e3120ff9e8..1fcdb1c5f7 100644
--- a/modules/admin/app/views/admin/historicalAgent/create.scala.html
+++ b/modules/admin/app/views/admin/historicalAgent/create.scala.html
@@ -1,11 +1,11 @@
-@(item: AuthoritativeSet, f: Form[HistoricalAgentF], config: forms.FormFieldHints, vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: AuthoritativeSet, f: Form[HistoricalAgentF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("historicalAgent.create"), EntityType.HistoricalAgent) {
 	@helper.form(action = action) {
         @formHelpers.csrfToken()
-        @form(f, config)
+        @form(f, fieldHints)
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("historicalAgent.create.submit"), cancel = views.admin.Helpers.linkToOpt(item))
diff --git a/modules/admin/app/views/admin/historicalAgent/description.scala.html b/modules/admin/app/views/admin/historicalAgent/description.scala.html
index 035ef3ec7f..e1d290b839 100644
--- a/modules/admin/app/views/admin/historicalAgent/description.scala.html
+++ b/modules/admin/app/views/admin/historicalAgent/description.scala.html
@@ -1,4 +1,4 @@
-@(item: HistoricalAgent, desc: HistoricalAgentDescriptionF, links: Seq[Link], annotations: Seq[Annotation], actions: Html = Html(""))(implicit fieldPrefix: String, userOpt: Option[UserProfile], request: RequestHeader, messages: Messages, md: MarkdownRenderer, conf: AppConfig)
+@(item: HistoricalAgent, desc: HistoricalAgentDescriptionF, links: Seq[Link], annotations: Seq[Annotation], advisories: Html = Html(""), actions: Html = Html(""))(implicit fieldPrefix: String, userOpt: Option[UserProfile], request: RequestHeader, messages: Messages, md: MarkdownRenderer, conf: AppConfig)
 
 @import Isaar._
 @import views.html.admin.common.descriptionSection
@@ -6,6 +6,7 @@
 
 @views.html.admin.common.descriptionOutline(item, desc, actions = actions) {
     @views.html.common.itemHeader(desc.name)
+    @advisories
 
     @views.html.admin.common.dateSet(desc, DATES_OF_EXISTENCE)
 
diff --git a/modules/admin/app/views/admin/historicalAgent/edit.scala.html b/modules/admin/app/views/admin/historicalAgent/edit.scala.html
index ee58d31a06..2388e143da 100644
--- a/modules/admin/app/views/admin/historicalAgent/edit.scala.html
+++ b/modules/admin/app/views/admin/historicalAgent/edit.scala.html
@@ -1,11 +1,11 @@
-@(item: HistoricalAgent, f: play.api.data.Form[HistoricalAgentF], config: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: HistoricalAgent, f: play.api.data.Form[HistoricalAgentF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("historicalAgent.update"), item.isA, breadcrumbs = views.html.admin.common.breadcrumbs(List(item)), scripts = formHelpers.dateJs()) {
     @helper.form(action = action) {
         @formHelpers.csrfToken()
-        @form(f, config)
+        @form(f, fieldHints)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("historicalAgent.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
     }
diff --git a/modules/admin/app/views/admin/historicalAgent/form.scala.html b/modules/admin/app/views/admin/historicalAgent/form.scala.html
index 29d3d8ec6a..f47d388edb 100644
--- a/modules/admin/app/views/admin/historicalAgent/form.scala.html
+++ b/modules/admin/app/views/admin/historicalAgent/form.scala.html
@@ -1,4 +1,4 @@
-@(f: Form[HistoricalAgentF], config: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(f: Form[HistoricalAgentF], fieldHints: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @import Isaar._
 @import views.html.formHelpers._
@@ -6,7 +6,7 @@
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @defining("historicalAgent") { implicit fieldPrefix =>
-    @defining(Some(config)) { implicit implicitConfig =>
+    @defining(Some(fieldHints)) { implicit implicitFieldHints =>
         @lineInput(f(""), IDENTIFIER, 'autocomplete -> "off")
 
         @helper.repeat(f("descriptions"), min = math.max(f("descriptions").indexes.length, 1)) { desc =>
diff --git a/modules/admin/app/views/admin/historicalAgent/show.scala.html b/modules/admin/app/views/admin/historicalAgent/show.scala.html
index 9b0e77ea85..6f2dae5acd 100644
--- a/modules/admin/app/views/admin/historicalAgent/show.scala.html
+++ b/modules/admin/app/views/admin/historicalAgent/show.scala.html
@@ -1,5 +1,7 @@
-@(item: HistoricalAgent, annotations: Seq[Annotation], links: Seq[Link])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: HistoricalAgent, annotations: Seq[Annotation], links: Seq[Link], advisories: Seq[ValidationError])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
+@import views.html.admin.common.validationErrors
+@import views.html.admin.historicalAgent._
 
 @views.html.admin.layout.adminLayout(item.toStringLang) {
     @breadcrumbs(item)
@@ -9,7 +11,14 @@
                 @defining(item.data.descriptionsWithSelected()) { descriptions =>
                     @common.descriptionContainer(descriptions) {
                         @descriptions.map { case (desc, _) =>
-                            @description(item, desc, links, annotations, actions = descriptionActions(item, desc))
+                            @description(
+                                item,
+                                desc,
+                                links,
+                                annotations,
+                                validationErrors(advisories, fieldPrefix),
+                                descriptionActions(item, desc)
+                            )
                         }
 
                         @views.html.admin.link.annotationLinks(item, links)
diff --git a/modules/admin/app/views/admin/layout/adminSinglePageAppLayout.scala.html b/modules/admin/app/views/admin/layout/adminSinglePageAppLayout.scala.html
index 9260912a1d..9d49ff53cc 100644
--- a/modules/admin/app/views/admin/layout/adminSinglePageAppLayout.scala.html
+++ b/modules/admin/app/views/admin/layout/adminSinglePageAppLayout.scala.html
@@ -25,6 +25,7 @@
         @preScripts
 
         <script src="@controllers.admin.routes.AdminAssets.versioned("js/lib/vue.runtime.global.js")"></script>
+        <script src="@controllers.admin.routes.AdminAssets.versioned("js/lib/vue-i18n.global.js")"></script>
 
         <div class="app-wrapper">
             <header id="header" class="navigation">
diff --git a/modules/admin/app/views/admin/repository/addressForm.scala.html b/modules/admin/app/views/admin/repository/addressForm.scala.html
index 64ce7e3de3..bb6f80ecdb 100644
--- a/modules/admin/app/views/admin/repository/addressForm.scala.html
+++ b/modules/admin/app/views/admin/repository/addressForm.scala.html
@@ -1,4 +1,4 @@
-@(field: play.api.data.Field)(implicit fieldPrefix: String, fieldConstructor: views.html.helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
+@(field: play.api.data.Field)(implicit fieldPrefix: String, config: Option[forms.FormFieldHints] = None, fieldConstructor: views.html.helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
 
 @import Isdiah._
 @import views.html.formHelpers._
diff --git a/modules/admin/app/views/admin/repository/create.scala.html b/modules/admin/app/views/admin/repository/create.scala.html
index 0e9b26696e..658b7404a4 100644
--- a/modules/admin/app/views/admin/repository/create.scala.html
+++ b/modules/admin/app/views/admin/repository/create.scala.html
@@ -1,4 +1,4 @@
-@(item: Country, f: Form[RepositoryF], config: forms.FormFieldHints, vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Country, f: Form[RepositoryF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
@@ -7,7 +7,7 @@
         @formHelpers.csrfToken()
         @formHelpers.lineInput(f(""), Entity.IDENTIFIER, 'readonly -> true)
 
-        @views.html.admin.repository.form(f, config)
+        @views.html.admin.repository.form(f, fieldHints)
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
         @formHelpers.submitButtonWithLogMessageInput(Messages("repository.create.submit"), cancel = views.admin.Helpers.linkToOpt(item))
 	}
diff --git a/modules/admin/app/views/admin/repository/description.scala.html b/modules/admin/app/views/admin/repository/description.scala.html
index e336d97eac..15a80c4fec 100644
--- a/modules/admin/app/views/admin/repository/description.scala.html
+++ b/modules/admin/app/views/admin/repository/description.scala.html
@@ -1,4 +1,4 @@
-@(item: Repository, desc: RepositoryDescriptionF, links: Seq[Link], annotations: Seq[Annotation])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, fieldPrefix: String)
+@(item: Repository, desc: RepositoryDescriptionF, links: Seq[Link], annotations: Seq[Annotation], advisories: Html = Html(""))(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, fieldPrefix: String)
 
 @import Isdiah._
 @import views.html.admin.common.descriptionSection
@@ -6,6 +6,7 @@
 
 @views.html.admin.common.descriptionOutline(item, desc) {
     @views.html.common.itemHeader(desc.name)
+    @advisories
 
     @descriptionSection(IDENTITY_AREA) {
         @textValue(AUTHORIZED_FORM_OF_NAME, Some(desc.name))
diff --git a/modules/admin/app/views/admin/repository/descriptionForm.scala.html b/modules/admin/app/views/admin/repository/descriptionForm.scala.html
index 4e943d1d2e..7fc6e95ee9 100644
--- a/modules/admin/app/views/admin/repository/descriptionForm.scala.html
+++ b/modules/admin/app/views/admin/repository/descriptionForm.scala.html
@@ -18,17 +18,19 @@
     @descriptionFormSection(ADDRESS_AREA) {
         <div class="inline-formset" data-prefix="@ADDRESS_AREA">
             <script type="application/x-js-template" class="inline-element-template">
-            @addressForm(desc(ADDRESS_AREA + "[IDX]"))
+                @addressForm(desc(ADDRESS_AREA + "[IDX]"))
             </script>
-            <div class="inline-element-list">
-            @helper.repeat(desc(ADDRESS_AREA), min = 0) { desc =>
-                @addressForm(desc)
-            }
+            <div class="control-elements">
+                <div class="inline-element-list">
+                @helper.repeat(desc(ADDRESS_AREA), min = 0) { desc =>
+                    @addressForm(desc)
+                }
+                </div>
+                <a href="#" class="add-inline-element add-address btn btn-success">
+                    @Messages(fieldPrefix + ".addresses.create")
+                    <i class="fa fa-plus-circle" aria-hidden="true"></i>
+                </a>
             </div>
-            <a href="#" class="add-inline-element add-address btn btn-success">
-                @Messages(fieldPrefix + ".addresses.create")
-                <i class="fa fa-plus-circle" aria-hidden="true"></i>
-            </a>
         </div>
     }
 
diff --git a/modules/admin/app/views/admin/repository/edit.scala.html b/modules/admin/app/views/admin/repository/edit.scala.html
index 165286b821..a94ca13c04 100644
--- a/modules/admin/app/views/admin/repository/edit.scala.html
+++ b/modules/admin/app/views/admin/repository/edit.scala.html
@@ -1,4 +1,4 @@
-@(item: Repository, f: play.api.data.Form[RepositoryF], config: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Repository, f: play.api.data.Form[RepositoryF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
@@ -6,7 +6,7 @@
     @helper.form(action = action) {
         @formHelpers.csrfToken()
         @formHelpers.hiddenInput(f(Entity.IDENTIFIER))
-        @views.html.admin.repository.form(f, config)
+        @views.html.admin.repository.form(f, fieldHints)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("repository.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
     }
diff --git a/modules/admin/app/views/admin/repository/form.scala.html b/modules/admin/app/views/admin/repository/form.scala.html
index 5b7344b7c8..0751c25db8 100644
--- a/modules/admin/app/views/admin/repository/form.scala.html
+++ b/modules/admin/app/views/admin/repository/form.scala.html
@@ -1,4 +1,4 @@
-@(f: Form[RepositoryF], config: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(f: Form[RepositoryF], fieldHints: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @import Isdiah._
 @import RepositoryF._
@@ -10,7 +10,7 @@
 <script type="text/javascript" src="@controllers.portal.routes.PortalAssets.versioned("js/address.js")"></script>
 
 @defining("repository") { implicit fieldPrefix =>
-    @defining(Some(config)) { implicit implicitConfig =>
+    @defining(Some(fieldHints)) { implicit implicitFieldHints =>
         @helper.repeat(f("descriptions"), min = math.max(f("descriptions").indexes.length, 1)) { desc =>
             @descriptionForm(desc)
         }
diff --git a/modules/admin/app/views/admin/repository/inlineGeoname.scala.html b/modules/admin/app/views/admin/repository/inlineGeoname.scala.html
index d6c3a116f1..c9735f0f14 100644
--- a/modules/admin/app/views/admin/repository/inlineGeoname.scala.html
+++ b/modules/admin/app/views/admin/repository/inlineGeoname.scala.html
@@ -1,14 +1,16 @@
-@(desc: play.api.data.Field, fieldName: String, geonameRemote: String = "")(implicit prefix: String = "", defaults: Option[play.api.Configuration] = None, fieldConstructor: views.html.helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
-
+@(desc: play.api.data.Field, fieldName: String, geonameRemote: String, args: (Symbol, String)*)(implicit prefix: String = "", config: Option[forms.FormFieldHints] = None, defaults: Option[play.api.Configuration] = None, fieldConstructor: views.html.helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
 @*
- *	For convenience, this field take a data-remote parameter for GeoName remote plugin configured in `app/admin/views/repository/edit.scala.html
- *
- *
+* For convenience, this field take a data-remote parameter for GeoName remote plugin configured in `app/admin/views/repository/edit.scala.html
 *@
-@defining(desc(fieldName)) { field =>
+@views.html.formHelpers.configuredField(desc, fieldName, config) { field =>
     @helper.inputText(
-        field.copy(value = field.value.orElse(defaults.flatMap(_.getOptional[String](fieldName)))),
-        'title -> md.renderMarkdown(Messages((if (prefix != "") prefix + "." else "") + fieldName + ".description")),
-        'class -> "form-control typeahead", Symbol("data-remote") -> geonameRemote,
-        '_label -> Messages(if (prefix.isEmpty) fieldName else "%s.%s".format(prefix, fieldName)))
+        field = field.copy(value = field.value.orElse(defaults.flatMap(_.getOptional[String](fieldName)))),
+        args = views.Helpers.argsWithConfig(fieldName, views.Helpers.argsWithDefaults(
+            args.map { case (s, v) => if(s == 'class) s -> (v.toString + " form-control") else s -> v },
+            'title -> md.renderMarkdown(config.flatMap(_.description(fieldName)).getOrElse(Messages((if(prefix != "") prefix + "." else "") + fieldName + ".description"))),
+            '_label -> Messages(if(prefix.isEmpty) fieldName else "%s.%s".format(prefix, fieldName)),
+            'class -> "form-control typeahead",
+            Symbol("data-remote") -> geonameRemote
+        )): _*
+    )
 }
diff --git a/modules/admin/app/views/admin/repository/show.scala.html b/modules/admin/app/views/admin/repository/show.scala.html
index a8a5b01ffb..163de928ac 100644
--- a/modules/admin/app/views/admin/repository/show.scala.html
+++ b/modules/admin/app/views/admin/repository/show.scala.html
@@ -1,4 +1,6 @@
-@(item: Repository, result: services.search.SearchResult[(Model, services.search.SearchHit)], action: Call, annotations: Seq[Annotation], links: Seq[Link])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Repository, result: services.search.SearchResult[(Model, services.search.SearchHit)], action: Call, annotations: Seq[Annotation], links: Seq[Link], advisories: Seq[ValidationError])(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+
+@import views.html.admin.common.validationErrors
 
 @views.html.admin.layout.adminLayout(item.toStringLang) {
     @breadcrumbs(item)
@@ -8,7 +10,13 @@
                 @defining(item.data.descriptionsWithSelected()) { descriptions =>
                     @common.descriptionContainer(descriptions) {
                         @descriptions.map { case (desc, _) =>
-                            @description(item, desc, links, annotations)
+                            @description(
+                                item,
+                                desc,
+                                links,
+                                annotations,
+                                validationErrors(advisories, fieldPrefix)
+                            )
                         }
 
                         @views.html.admin.link.annotationLinks(item, links)
diff --git a/modules/admin/app/views/admin/virtualUnit/create.scala.html b/modules/admin/app/views/admin/virtualUnit/create.scala.html
index a3d65512cf..319c55a0f6 100644
--- a/modules/admin/app/views/admin/virtualUnit/create.scala.html
+++ b/modules/admin/app/views/admin/virtualUnit/create.scala.html
@@ -1,4 +1,4 @@
-@(item: Option[Model], f: Form[VirtualUnitF], config: forms.FormFieldHints, vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Option[Model], f: Form[VirtualUnitF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
@@ -14,7 +14,7 @@
 
 	@helper.form(action = action) {
         @formHelpers.csrfToken()
-		@form(f, config)
+		@form(f, fieldHints)
 
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
         @formHelpers.submitButtonWithLogMessageInput(Messages("virtualUnit.create.submit"), cancel = item.map(i => views.admin.Helpers.linkTo(i)))
diff --git a/modules/admin/app/views/admin/virtualUnit/createDescription.scala.html b/modules/admin/app/views/admin/virtualUnit/createDescription.scala.html
index 10157d58b8..97f6d38bba 100644
--- a/modules/admin/app/views/admin/virtualUnit/createDescription.scala.html
+++ b/modules/admin/app/views/admin/virtualUnit/createDescription.scala.html
@@ -1,10 +1,10 @@
-@(item: VirtualUnit, f: Form[VirtualUnitF], config: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: VirtualUnit, f: Form[VirtualUnitF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("describedEntity.createDescription"), item.isA, breadcrumbs = breadcrumbs(item), scripts = formHelpers.dateJs()) {
     @defining("documentaryUnit") { implicit fieldPrefix =>
-        @defining(Some(config)) { implicit implicitConfig =>
+        @defining(Some(fieldHints)) { implicit implicitFieldHints =>
             @helper.form(action = action) {
                 @formHelpers.csrfToken()
 
diff --git a/modules/admin/app/views/admin/virtualUnit/edit.scala.html b/modules/admin/app/views/admin/virtualUnit/edit.scala.html
index bdb34265ab..4f4c7c42f9 100644
--- a/modules/admin/app/views/admin/virtualUnit/edit.scala.html
+++ b/modules/admin/app/views/admin/virtualUnit/edit.scala.html
@@ -1,11 +1,11 @@
-@(item: VirtualUnit, f: play.api.data.Form[VirtualUnitF], config: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: VirtualUnit, f: play.api.data.Form[VirtualUnitF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("virtualUnit.update"), item.isA, breadcrumbs = breadcrumbs(item), scripts = formHelpers.dateJs()) {
 	@helper.form(action = action) {
         @formHelpers.csrfToken()
-		@form(f, config)
+		@form(f, fieldHints)
         @formHelpers.submitButtonWithLogMessageInput(Messages("virtualUnit.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
 	}
 } {
diff --git a/modules/admin/app/views/admin/virtualUnit/editDescription.scala.html b/modules/admin/app/views/admin/virtualUnit/editDescription.scala.html
index a2e0e7d624..f9af7cb3f5 100644
--- a/modules/admin/app/views/admin/virtualUnit/editDescription.scala.html
+++ b/modules/admin/app/views/admin/virtualUnit/editDescription.scala.html
@@ -1,11 +1,11 @@
-@(item: VirtualUnit, f: Form[VirtualUnitF], config: forms.FormFieldHints, did: String, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: VirtualUnit, f: Form[VirtualUnitF], fieldHints: forms.FormFieldHints, did: String, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
  
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebar(Messages("describedEntity.updateDescription"), breadcrumbs = breadcrumbs(item), scripts = formHelpers.dateJs()) {
 
     @defining("documentaryUnit") { implicit fieldPrefix =>
-        @defining(Some(config)) { implicit implicitConfig =>
+        @defining(Some(fieldHints)) { implicit implicitFieldHints =>
             @helper.form(action = action) {
                 @formHelpers.csrfToken()
 
diff --git a/modules/admin/app/views/admin/virtualUnit/form.scala.html b/modules/admin/app/views/admin/virtualUnit/form.scala.html
index 12346de5c9..d6071f886f 100644
--- a/modules/admin/app/views/admin/virtualUnit/form.scala.html
+++ b/modules/admin/app/views/admin/virtualUnit/form.scala.html
@@ -1,9 +1,9 @@
-@(f: play.api.data.Form[VirtualUnitF], config: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
+@(f: play.api.data.Form[VirtualUnitF], fieldHints: forms.FormFieldHints)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @defining("virtualUnit") { implicit fieldPrefix =>
-    @defining(Some(config)) { implicit implicitConfig =>
+    @defining(Some(fieldHints)) { implicit implicitFieldHints =>
         @formHelpers.lineInput(f(""), Entity.IDENTIFIER, 'autocomplete -> "off")
 
         @helper.repeat(f("descriptions"), min = math.max(f("descriptions").indexes.length, 1)) { desc =>
diff --git a/modules/admin/app/views/admin/vocabulary/create.scala.html b/modules/admin/app/views/admin/vocabulary/create.scala.html
index 5e1c6b5f1d..f94ad326cd 100644
--- a/modules/admin/app/views/admin/vocabulary/create.scala.html
+++ b/modules/admin/app/views/admin/vocabulary/create.scala.html
@@ -1,16 +1,16 @@
-@(f: Form[VocabularyF], vf: Form[Seq[String]], usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(f: Form[VocabularyF], vf: Form[Seq[String]], fieldHints: forms.FormFieldHints, usersAndGroups: UsersAndGroups, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("cvocVocabulary.create"), EntityType.Vocabulary) {
-	@helper.form(action = action) {
+    @helper.form(action = action) {
         @formHelpers.csrfToken()
         @formHelpers.lineInput(f(""), Entity.IDENTIFIER, 'autocomplete -> "off")
-        @views.html.admin.vocabulary.form(None, f)
+        @views.html.admin.vocabulary.form(None, f, fieldHints)
         @views.html.admin.permissions.visibilityForm(vf, usersAndGroups)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("cvocVocabulary.create.submit"))
-	}
+    }
 } {
 
 }
diff --git a/modules/admin/app/views/admin/vocabulary/edit.scala.html b/modules/admin/app/views/admin/vocabulary/edit.scala.html
index d75b27a2f8..bb55167d81 100644
--- a/modules/admin/app/views/admin/vocabulary/edit.scala.html
+++ b/modules/admin/app/views/admin/vocabulary/edit.scala.html
@@ -1,15 +1,15 @@
-@(item: Vocabulary, f: play.api.data.Form[VocabularyF], action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
+@(item: Vocabulary, f: play.api.data.Form[VocabularyF], fieldHints: forms.FormFieldHints, action: Call)(implicit userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages, md: MarkdownRenderer, prefs: SessionPrefs, flash: Flash)
 
 @implicitField = @{ views.html.helper.FieldConstructor(formHelpers.fieldTemplate.f) }
 
 @views.html.admin.layout.rightSidebarWithType(Messages("cvocVocabulary.update"), EntityType.Vocabulary, breadcrumbs = views.html.admin.common.breadcrumbs(List(item))) {
-	@helper.form(action = action) {
+    @helper.form(action = action) {
         @formHelpers.csrfToken()
         @formHelpers.hiddenInput(f(Entity.IDENTIFIER))
-        @views.html.admin.vocabulary.form(Some(item), f)
+        @views.html.admin.vocabulary.form(Some(item), f, fieldHints)
 
         @formHelpers.submitButtonWithLogMessageInput(Messages("cvocVocabulary.update.submit"), cancel = views.admin.Helpers.linkToOpt(item))
-	}
+    }
 } {
 
 }
diff --git a/modules/admin/app/views/admin/vocabulary/form.scala.html b/modules/admin/app/views/admin/vocabulary/form.scala.html
index 02e01e8d44..aa187a3889 100644
--- a/modules/admin/app/views/admin/vocabulary/form.scala.html
+++ b/modules/admin/app/views/admin/vocabulary/form.scala.html
@@ -1,7 +1,9 @@
-@(item: Option[Vocabulary], f: Form[VocabularyF])(implicit fieldConstructor: helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
+@(item: Option[Vocabulary], f: Form[VocabularyF], fieldHints: forms.FormFieldHints)(implicit fieldConstructor: helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
 
-@defining("cvocVocabulary") { implicit fieldPrefix =>
-    @formHelpers.lineInput(f(""), VocabularyF.NAME)
-    @formHelpers.textInput(f(""), VocabularyF.DESCRIPTION)
-    @formHelpers.hiddenInput(f(VocabularyF.ALLOW_PUBLIC))
+@defining(Some(fieldHints)) { implicit implicitFieldHints =>
+    @defining("cvocVocabulary") { implicit fieldPrefix =>
+        @formHelpers.lineInput(f(""), VocabularyF.NAME)
+        @formHelpers.textInput(f(""), VocabularyF.DESCRIPTION)
+        @formHelpers.hiddenInput(f(VocabularyF.ALLOW_PUBLIC))
+    }
 }
diff --git a/modules/admin/app/views/formHelpers/enumChoiceInput.scala.html b/modules/admin/app/views/formHelpers/enumChoiceInput.scala.html
index a969be77d1..5db7272ef0 100644
--- a/modules/admin/app/views/formHelpers/enumChoiceInput.scala.html
+++ b/modules/admin/app/views/formHelpers/enumChoiceInput.scala.html
@@ -1,9 +1,15 @@
-@(f: play.api.data.Field, fieldName: String, enum: Enumeration, args: (Symbol,Any)*)(implicit fieldPrefix: String = "", config: Option[forms.FormFieldHints] = None, fieldConstructor: views.html.helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
+@(f: play.api.data.Field, fieldName: String, enum: Enumeration, args: (Symbol,Any)*)(implicit prefix: String = "", config: Option[forms.FormFieldHints] = None, fieldConstructor: views.html.helper.FieldConstructor, messages: Messages, md: MarkdownRenderer)
 
-@formHelpers.choiceInput(
-  f,
-  fieldName,
-  enum.values.toList.sortBy(_.id).map(m => (m.toString,
-        Messages(if (fieldPrefix.isEmpty) m.toString else fieldPrefix + "." + m.toString))),
-  args: _*
-)
+@views.html.formHelpers.configuredField(f, fieldName, config) { field =>
+    @formHelpers.choiceInput(
+        f,
+        fieldName,
+        enum.values.toList.sortBy(_.id).map(m => (m.toString, Messages(if(prefix.isEmpty) m.toString else prefix + "." + m.toString))),
+        args = views.Helpers.argsWithConfig(fieldName, views.Helpers.argsWithDefaults(
+            args.map { case (s, v) => if(s == 'class) s -> (v.toString + " form-control") else s -> v },
+            '_label -> config.flatMap(_.name(fieldName)).getOrElse(Messages(if(prefix.isEmpty) fieldName else s"$prefix.$fieldName")),
+            'title -> md.renderMarkdown(config.flatMap(_.description(fieldName)).getOrElse(Messages((if(prefix != "") prefix + "." else "") + fieldName + ".description"))),
+            'class -> "form-control"
+        )): _*
+    )
+}
diff --git a/modules/admin/app/views/formHelpers/fieldTemplate.scala.html b/modules/admin/app/views/formHelpers/fieldTemplate.scala.html
index 39ff39d039..576f134697 100644
--- a/modules/admin/app/views/formHelpers/fieldTemplate.scala.html
+++ b/modules/admin/app/views/formHelpers/fieldTemplate.scala.html
@@ -1,7 +1,8 @@
 @(elements: helper.FieldElements)
 
+@** TODO: convert to fieldTemplateWithHints, which has the hints parameter available **@
 <div class="form-group @if(elements.hasErrors) {has-error}">
-@defining(List(Messages("constraints.mandatory")(elements.p), Messages("constraints.desirable")(elements.p))) { usage =>
+@defining(List(Messages("constraints.mandatory")(elements.p), Messages("error.required")(elements.p), Messages("constraints.desirable")(elements.p))) { usage =>
     <label class="control-label" for="@elements.id">
         @elements.label
     </label>
@@ -10,6 +11,9 @@
         @if(elements.infos.contains(usage.head)) {
             <span class="input-mandatory">@usage.head</span>
         }
+        @if(elements.infos.contains(usage(1))) {
+            <span class="input-mandatory">@usage.head</span>
+        }
         @if(elements.infos.contains(usage.last)) {
             <span class="input-desirable">@usage.last</span>
         }
diff --git a/modules/admin/app/views/formHelpers/fieldTemplateWithHints.scala.html b/modules/admin/app/views/formHelpers/fieldTemplateWithHints.scala.html
new file mode 100644
index 0000000000..4dcb263629
--- /dev/null
+++ b/modules/admin/app/views/formHelpers/fieldTemplateWithHints.scala.html
@@ -0,0 +1,28 @@
+@(elements: helper.FieldElements)(implicit config: Option[forms.FormFieldHints])
+
+<div class="form-group @if(elements.hasErrors) {has-error} @config.flatMap(_.usage(elements.id)).map(_.toString).getOrElse("")">
+    @defining(Messages("error.required")(elements.p)) { requiredText =>
+        <label class="control-label" for="@elements.id">@elements.label</label>
+        <div class="control-elements">
+            @elements.input
+            @if(config.flatMap(_.usage(elements.id)).contains(FieldMetadata.Usage.Mandatory) || elements.infos.contains(requiredText)) {
+                <span class="input-mandatory">@Messages("constraints.mandatory")(elements.p)</span>
+            }
+            @if(config.flatMap(_.usage(elements.id)).contains(FieldMetadata.Usage.Desirable)) {
+                <span class="input-mandatory">@Messages("constraints.desirable")(elements.p)</span>
+            }
+            @if(elements.hasErrors) {
+                <span class="help-block invalid-feedback">@elements.errors.mkString(" / ")</span>
+            } else {
+                @elements.args.get('_hint).map { hint =>
+                    <span class="help-block info">
+                        @hint
+                    </span>
+                }
+                <span class="help-block">
+                    @elements.infos.filterNot(_ == requiredText).map(i => Messages(i.toString)(elements.p)).mkString(", ")
+                </span>
+            }
+        </div>
+    }
+</div>
diff --git a/modules/admin/app/views/formHelpers/inlineDateSet.scala.html b/modules/admin/app/views/formHelpers/inlineDateSet.scala.html
index c689000988..ab415fa9e4 100644
--- a/modules/admin/app/views/formHelpers/inlineDateSet.scala.html
+++ b/modules/admin/app/views/formHelpers/inlineDateSet.scala.html
@@ -1,26 +1,28 @@
 @(field: play.api.data.Field, key: String)(implicit fieldPrefix: String, config: Option[forms.FormFieldHints] = None, userOpt: Option[UserProfile], req: RequestHeader, conf: AppConfig, messages: Messages)
 
-<div class="inline-formset form-group clearfix" data-prefix="@key">
+<div class="inline-formset form-group date-set" data-prefix="@key">
     @* Template for adding inline date forms via JS *@
     <label class="control-label">
         @Messages(fieldPrefix + "." + key)
-        <a href="#" class="add-inline-element" title="@Messages("item.field.add")" aria-label="@Messages("item.field.add")">
-            <i class="fa fa-plus-circle" aria-hidden="true"></i>
-        </a>
     </label>
     <div class="inline-element-template form-template">
         @formHelpers.inlineDate(field(key + "[IDX]"), key)
     </div>
-    <div class="inline-element-list control-elements">
+    <div class="control-elements">
         @* NB: we render the usage label here differently to the translated way used when using the fieldTemplate
         * because the usage label is not translated in the same way as the field label.
         *@
         @config.flatMap(_.usage(key)).map { usage =>
             <span class="input-@usage">@usage.toString.capitalize</span>
         }
-        @helper.repeat(field(key), min = 0) { nfield =>
-            @formHelpers.inlineDate(nfield, key)
-        }
+        <div class="inline-element-list">
+            @helper.repeat(field(key), min = 0) { nfield =>
+                @formHelpers.inlineDate(nfield, key)
+            }
+        </div>
+        <a href="#" class="add-inline-element" title="@Messages("item.field.add")" aria-label="@Messages("item.field.add")">
+            <i class="fa fa-plus-circle" aria-hidden="true"></i>
+        </a>
     </div>
 </div>
 
diff --git a/modules/admin/app/views/formHelpers/inlineNameSet.scala.html b/modules/admin/app/views/formHelpers/inlineNameSet.scala.html
index 641fd6ea97..d65a58f53e 100644
--- a/modules/admin/app/views/formHelpers/inlineNameSet.scala.html
+++ b/modules/admin/app/views/formHelpers/inlineNameSet.scala.html
@@ -1,25 +1,27 @@
 @(field: play.api.data.Field, key: String)(implicit fieldPrefix: String, config: Option[forms.FormFieldHints] = None, messages: Messages, md: MarkdownRenderer, fieldConstructor: views.html.helper.FieldConstructor)
 
-<div class="inline-formset form-group clearfix @{if(field(key).hasErrors) "has-error"}" data-prefix="@key">
+<div class="inline-formset form-group @{if(field(key).hasErrors) "has-error"}" data-prefix="@key">
     <label class="control-label">
         @config.flatMap(_.name(key)).getOrElse(Messages(fieldPrefix + "." + key))
-        <a href="#" class="add-inline-element" title="@Messages("item.field.add")" aria-label="@Messages("item.field.add")">
-            <i class="fa fa-plus-circle" aria-hidden="true"></i>
-        </a>
     </label>
 
     <div class="inline-element-template form-template">
         @formHelpers.inlineName(field(key + "[IDX]"), key)
     </div>
-    <div class="inline-element-list control-elements">
+    <div class="control-elements">
         @* NB: we render the usage label here differently to the translated way used when using the fieldTemplate
         * because the usage label is not translated in the same way as the field label.
         *@
         @config.flatMap(_.usage(key)).map { usage =>
             <span class="input-@usage">@usage.toString.capitalize</span>
         }
-        @helper.repeat(field(key), min = 0) { f =>
-            @formHelpers.inlineName(f, key)
-        }
+        <div class="inline-element-list">
+            @helper.repeat(field(key), min = 0) { f =>
+                @formHelpers.inlineName(f, key)
+            }
+        </div>
+        <a href="#" class="add-inline-element" title="@Messages("item.field.add")" aria-label="@Messages("item.field.add")">
+            <i class="fa fa-plus-circle" aria-hidden="true"></i>
+        </a>
     </div>
 </div>
diff --git a/modules/admin/app/views/formHelpers/inlineTextSet.scala.html b/modules/admin/app/views/formHelpers/inlineTextSet.scala.html
index 7b09eb8173..5b7823182e 100644
--- a/modules/admin/app/views/formHelpers/inlineTextSet.scala.html
+++ b/modules/admin/app/views/formHelpers/inlineTextSet.scala.html
@@ -4,22 +4,25 @@
         <!-- Template for adding inline date forms via JS -->
         <label class="inline-label control-label">
             @config.flatMap(_.name(key)).getOrElse(Messages(fieldPrefix + "." + key))
-            <a href="#" class="add-inline-element" title="@Messages("item.field.add")" aria-label="@Messages("item.field.add")">
-                <i class="fa fa-plus-circle" aria-hidden="true"></i>
-            </a>
         </label>
         <div class="inline-element-template form-template ">
             @formHelpers.inlineText(field(key + "[IDX]"), key, rows)
         </div>
-        <div class="inline-element-list control-elements">
+        <div class="control-elements">
             @* NB: we render the usage label here differently to the translated way used when using the fieldTemplate
-             * because the usage label is not translated in the same way as the field label.
-             *@
+            * because the usage label is not translated in the same way as the field label.
+            *@
             @config.flatMap(_.usage(key)).map { usage =>
                 <span class="input-@usage">@usage.toString.capitalize</span>
             }
-            @helper.repeat(field(key), min = 0) { nfield =>
-                @formHelpers.inlineText(nfield, key, rows)
-            }
+            <div class="inline-element-list">
+                @helper.repeat(field(key), min = 0) { nfield =>
+                    @formHelpers.inlineText(nfield, key, rows)
+                }
+            </div>
+            <a href="#" class="add-inline-element" title="@Messages("item.field.add")" aria-label="@Messages("item.field.add")">
+                <i class="fa fa-plus-circle" aria-hidden="true"></i>
+            </a>
+
         </div>
 </div>
diff --git a/modules/admin/conf/datamodel.routes b/modules/admin/conf/datamodel.routes
index 142f63fe82..1c2bdb68b0 100644
--- a/modules/admin/conf/datamodel.routes
+++ b/modules/admin/conf/datamodel.routes
@@ -6,7 +6,7 @@ GET           /i18n                             @controllers.datamodel.EntityTyp
 GET           /entities                         @controllers.datamodel.EntityTypeMetadataApi.list()
 GET           /entities/:entityType             @controllers.datamodel.EntityTypeMetadataApi.get(entityType :models.EntityType.Value)
 POST          /entities/:entityType             @controllers.datamodel.EntityTypeMetadataApi.save(entityType: models.EntityType.Value)
-DELETE        /entities/:entityType             @controllers.datamodel.EntityTypeMetadataApi.delete(entityType: models.EntityType.Value, id: String)
+DELETE        /entities/:entityType             @controllers.datamodel.EntityTypeMetadataApi.delete(entityType: models.EntityType.Value)
 GET           /fields                           @controllers.datamodel.EntityTypeMetadataApi.listFields(entityType: Option[models.EntityType.Value] ?= None)
 GET           /fields/:entityType/:id           @controllers.datamodel.EntityTypeMetadataApi.getField(entityType: models.EntityType.Value, id: String)
 POST          /fields/:entityType/:id           @controllers.datamodel.EntityTypeMetadataApi.saveField(entityType: models.EntityType.Value, id: String)
diff --git a/modules/admin/conf/messages b/modules/admin/conf/messages
index 357bb75f78..c04252981e 100644
--- a/modules/admin/conf/messages
+++ b/modules/admin/conf/messages
@@ -1574,3 +1574,6 @@ cleanup.done=Cleanup complete
 # Data Model
 #
 dataModel=Data Model
+dataModel.advisories={0,choice,0#No advisories|1#1 Metadata quality advisory|1<{0,number,integer} Metadata quality advisories}
+dataModel.missingMandatoryFields={0,choice,0#No missing mandatory fields|1#1 missing mandatory field|1<{0,number,integer} missing mandatory fields}
+dataModel.missingDesirableFields={0,choice,0#No missing desirable fields|1#1 missing desirable field|1<{0,number,integer} missing desirable fields}
diff --git a/modules/api/app/controllers/api/v1/ApiV1.scala b/modules/api/app/controllers/api/v1/ApiV1.scala
index 754ec6fa5b..6e9523c325 100644
--- a/modules/api/app/controllers/api/v1/ApiV1.scala
+++ b/modules/api/app/controllers/api/v1/ApiV1.scala
@@ -21,6 +21,7 @@ import services.RateLimitChecker
 import services.accounts.AccountManager
 import services.cypher.CypherService
 import services.data._
+import services.datamodel.EntityTypeMetadataService
 import services.redirects.MovedPageLookup
 import services.search.SearchConstants._
 import services.search._
@@ -73,6 +74,7 @@ case class ApiV1 @Inject()(
   protected val authHandler: AuthHandler = appComponents.authHandler
   protected val searchEngine: SearchEngine = appComponents.searchEngine
   protected val searchResolver: SearchItemResolver = appComponents.searchResolver
+  protected val entityTypeMetadata: EntityTypeMetadataService = appComponents.entityTypeMetadata
 
   protected def itemLifecycle: ItemLifecycle = appComponents.itemLifecycle
 
diff --git a/modules/core/src/main/scala/controllers/base/CoreActionBuilders.scala b/modules/core/src/main/scala/controllers/base/CoreActionBuilders.scala
index 5f1704e23c..01095d3e9a 100644
--- a/modules/core/src/main/scala/controllers/base/CoreActionBuilders.scala
+++ b/modules/core/src/main/scala/controllers/base/CoreActionBuilders.scala
@@ -9,6 +9,7 @@ import play.api.mvc.WebSocket.MessageFlowTransformer
 import play.api.mvc.{Result, _}
 import services.accounts.AccountManager
 import services.data.{AuthenticatedUser, DataService, DataServiceBuilder, DataUser}
+import services.datamodel.EntityTypeMetadataService
 
 import java.time.ZonedDateTime
 import scala.concurrent.Future.{successful => immediate}
@@ -34,6 +35,8 @@ trait CoreActionBuilders extends BaseController with ControllerHelpers {
 
   protected def itemLifecycle: ItemLifecycle
 
+  protected def entityTypeMetadata: EntityTypeMetadataService
+
   protected def conf: AppConfig
 
   protected implicit val implicitEc: ExecutionContext = controllerComponents.executionContext
diff --git a/modules/core/src/main/scala/controllers/generic/Create.scala b/modules/core/src/main/scala/controllers/generic/Create.scala
index 461940eb6e..a3835cebcb 100644
--- a/modules/core/src/main/scala/controllers/generic/Create.scala
+++ b/modules/core/src/main/scala/controllers/generic/Create.scala
@@ -24,7 +24,8 @@ trait Create[MT <: Model{type T <: ModelData with Persistable}] extends Read[MT]
     * @param request        the underlying request
     * @tparam A the type of the underlying request
     */
-  case class UserGroupsRequest[A](
+  case class NewItemRequest[A](
+    fieldHints: FormFieldHints,
     usersAndGroups: UsersAndGroups,
     user: UserProfile,
     request: Request[A]
@@ -32,18 +33,20 @@ trait Create[MT <: Model{type T <: ModelData with Persistable}] extends Read[MT]
     with WithUser
 
   case class CreateRequest[A](
-    formOrItem: Either[(Form[MT#T], Form[Seq[String]], UsersAndGroups), MT],
+    formOrItem: Either[(Form[MT#T], Form[Seq[String]], FormFieldHints, UsersAndGroups), MT],
     user: UserProfile,
     request: Request[A]
   ) extends WrappedRequest[A](request)
     with WithUser
 
-  protected def NewItemAction(implicit ct: ContentType[MT]): ActionBuilder[UserGroupsRequest, AnyContent] =
-    WithContentPermissionAction(PermissionType.Create, ct.contentType) andThen new CoreActionTransformer[WithUserRequest, UserGroupsRequest] {
-      override protected def transform[A](request: WithUserRequest[A]): Future[UserGroupsRequest[A]] = {
-        dataHelpers.getUserAndGroupList.map { usersAndGroups =>
-          UserGroupsRequest(usersAndGroups, request.user, request)
-        }
+  protected def NewItemAction(implicit ct: ContentType[MT]): ActionBuilder[NewItemRequest, AnyContent] =
+    WithContentPermissionAction(PermissionType.Create, ct.contentType) andThen new CoreActionTransformer[WithUserRequest, NewItemRequest] {
+      override protected def transform[A](request: WithUserRequest[A]): Future[NewItemRequest[A]] = {
+        val formConfig = FieldMetaFormFieldHintsBuilder(ct.entityType, entityTypeMetadata, config)
+        for {
+          fieldHints <- formConfig.forCreate
+          usersAndGroups <- dataHelpers.getUserAndGroupList
+        } yield NewItemRequest(fieldHints, usersAndGroups, request.user, request)
       }
     }
 
@@ -53,10 +56,12 @@ trait Create[MT <: Model{type T <: ModelData with Persistable}] extends Read[MT]
       def transform[A](request: WithUserRequest[A]): Future[CreateRequest[A]] = {
         implicit val req: WithUserRequest[A] = request
         val visForm = visibilityForm.bindFromRequest()
+        val formConfig = FieldMetaFormFieldHintsBuilder(ct.entityType, entityTypeMetadata, config)
         form.bindFromRequest().fold(
-          errorForm => dataHelpers.getUserAndGroupList.map { usersAndGroups =>
-            CreateRequest(Left((errorForm, visForm, usersAndGroups)), request.user, request.request)
-          },
+          errorForm => for {
+            fieldHints <- formConfig.forCreate
+            usersAndGroups <- dataHelpers.getUserAndGroupList
+          } yield CreateRequest(Left((errorForm, visForm, fieldHints, usersAndGroups)), request.user, request.request),
           doc => {
             val accessors = visForm.value.getOrElse(Nil)
             (for {
@@ -69,9 +74,10 @@ trait Create[MT <: Model{type T <: ModelData with Persistable}] extends Read[MT]
               // and redisplay it...
               case ValidationError(errorSet) =>
                 val filledForm = doc.getFormErrors(errorSet, form.fill(doc))
-                dataHelpers.getUserAndGroupList.map { usersAndGroups =>
-                  CreateRequest(Left((filledForm, visForm, usersAndGroups)), request.user, request)
-                }
+                for {
+                  fieldHints <- formConfig.forCreate
+                  usersAndGroups <- dataHelpers.getUserAndGroupList
+                } yield CreateRequest(Left((filledForm, visForm, fieldHints, usersAndGroups)), request.user, request)
             }
           }
         )
diff --git a/modules/core/src/main/scala/controllers/generic/Creator.scala b/modules/core/src/main/scala/controllers/generic/Creator.scala
index b315502c99..5e00ac72b9 100644
--- a/modules/core/src/main/scala/controllers/generic/Creator.scala
+++ b/modules/core/src/main/scala/controllers/generic/Creator.scala
@@ -9,27 +9,30 @@ import services.data.{DataHelpers, ValidationError}
 import scala.concurrent.Future
 
 /**
- * Controller trait for extending Entity classes which server as
- * context for the creation of DocumentaryUnits, i.e. Repository and
- * DocumentaryUnit itself.
- */
-trait Creator[CMT <: Model{type T <: ModelData with Persistable}, MT <: Model] extends Read[MT] with Write {
+  * Controller trait for extending Entity classes which server as
+  * context for the creation of DocumentaryUnits, i.e. Repository and
+  * DocumentaryUnit itself.
+  */
+trait Creator[CMT <: Model {type T <: ModelData with Persistable}, MT <: Model] extends Read[MT] with Write {
 
   protected def dataHelpers: DataHelpers
 
   case class NewChildRequest[A](
     item: MT,
+    fieldHints: FormFieldHints,
     usersAndGroups: UsersAndGroups,
     userOpt: Option[UserProfile],
     request: Request[A]
-    ) extends WrappedRequest[A](request)
-  with WithOptionalUser
+  ) extends WrappedRequest[A](request)
+    with WithOptionalUser
 
-  private[generic] def NewChildTransformer = new CoreActionTransformer[ItemPermissionRequest, NewChildRequest] {
+  private[generic] def NewChildTransformer(implicit cct: ContentType[CMT]) = new CoreActionTransformer[ItemPermissionRequest, NewChildRequest] {
     override protected def transform[A](request: ItemPermissionRequest[A]): Future[NewChildRequest[A]] = {
-      dataHelpers.getUserAndGroupList.map { usersAndGroups =>
-        NewChildRequest(request.item, usersAndGroups, request.userOpt, request)
-      }
+      val formConfig = FieldMetaFormFieldHintsBuilder(cct.entityType, entityTypeMetadata, config)
+      for {
+        fieldHints <- formConfig.forCreate
+        usersAndGroups <- dataHelpers.getUserAndGroupList
+      } yield NewChildRequest(request.item, fieldHints, usersAndGroups, request.userOpt, request)
     }
   }
 
@@ -37,12 +40,12 @@ trait Creator[CMT <: Model{type T <: ModelData with Persistable}, MT <: Model] e
     WithParentPermissionAction(itemId, PermissionType.Create, cct.contentType) andThen NewChildTransformer
 
   case class CreateChildRequest[A](
-     item: MT,
-     formOrItem: Either[(Form[CMT#T],Form[Seq[String]], UsersAndGroups),CMT],
-     userOpt: Option[UserProfile],
-     request: Request[A]
-     ) extends WrappedRequest[A](request)
-  with WithOptionalUser
+    item: MT,
+    formOrItem: Either[(Form[CMT#T], Form[Seq[String]], FormFieldHints, UsersAndGroups), CMT],
+    userOpt: Option[UserProfile],
+    request: Request[A]
+  ) extends WrappedRequest[A](request)
+    with WithOptionalUser
 
   private[generic] def CreateChildTransformer(id: String, form: Form[CMT#T], extraParams: ExtraParams = defaultExtra)(implicit ct: ContentType[MT], fmt: Writable[CMT#T], cct: ContentType[CMT]) =
     new CoreActionTransformer[ItemPermissionRequest, CreateChildRequest] {
@@ -50,10 +53,13 @@ trait Creator[CMT <: Model{type T <: ModelData with Persistable}, MT <: Model] e
         implicit val req: ItemPermissionRequest[A] = request
         val extra = extraParams.apply(request.request)
         val visForm = visibilityForm.bindFromRequest()
+        val formConfig = FieldMetaFormFieldHintsBuilder(cct.entityType, entityTypeMetadata, config)
         form.bindFromRequest().fold(
-          errorForm => dataHelpers.getUserAndGroupList.map { usersAndGroups =>
-            CreateChildRequest(request.item, Left((errorForm, visForm, usersAndGroups)), request.userOpt, request.request)
-          },
+          errorForm => for {
+            fieldHints <- formConfig.forCreate
+            usersAndGroups <- dataHelpers.getUserAndGroupList
+          } yield CreateChildRequest(request.item, Left((errorForm, visForm, fieldHints, usersAndGroups)), request.userOpt, request.request),
+
           citem => {
             val accessors = visForm.value.getOrElse(Nil)
             (for {
@@ -63,9 +69,10 @@ trait Creator[CMT <: Model{type T <: ModelData with Persistable}, MT <: Model] e
             } yield CreateChildRequest(request.item, Right(post), request.userOpt, request)) recoverWith {
               case ValidationError(errorSet) =>
                 val filledForm = citem.getFormErrors(errorSet, form.fill(citem))
-                dataHelpers.getUserAndGroupList.map { usersAndGroups =>
-                  CreateChildRequest(request.item, Left((filledForm, visForm, usersAndGroups)), request.userOpt, request)
-                }
+                for {
+                  fieldHints <- formConfig.forCreate
+                  usersAndGroups <- dataHelpers.getUserAndGroupList
+                } yield CreateChildRequest(request.item, Left((filledForm, visForm, fieldHints, usersAndGroups)), request.userOpt, request)
             }
           }
         )
@@ -74,12 +81,12 @@ trait Creator[CMT <: Model{type T <: ModelData with Persistable}, MT <: Model] e
 
   protected def CreateChildAction(id: String, form: Form[CMT#T], extraParams: ExtraParams = defaultExtra)(implicit ct: ContentType[MT], fmt: Writable[CMT#T], cct: ContentType[CMT]): ActionBuilder[CreateChildRequest, AnyContent] =
     WithParentPermissionAction(id, PermissionType.Create, cct.contentType) andThen CreateChildTransformer(id, form, extraParams)
-  
-  
+
+
   /**
-   * Functor to extract arbitrary DAO params from a request...
-   */
-  type ExtraParams = Request[_] => Map[String,Seq[String]]
+    * Functor to extract arbitrary DAO params from a request...
+    */
+  type ExtraParams = Request[_] => Map[String, Seq[String]]
 
   protected def defaultExtra: ExtraParams = (_: Request[_]) => Map.empty
 }
diff --git a/modules/core/src/main/scala/controllers/generic/Update.scala b/modules/core/src/main/scala/controllers/generic/Update.scala
index 8e8620a60c..353a75f21e 100644
--- a/modules/core/src/main/scala/controllers/generic/Update.scala
+++ b/modules/core/src/main/scala/controllers/generic/Update.scala
@@ -1,5 +1,6 @@
 package controllers.generic
 
+import forms.{FieldMetaFormFieldHintsBuilder, FormFieldHints}
 import models.{ContentType, EventType, Model, ModelData, PermissionType, Persistable, UserProfile, Writable}
 import play.api.data.Form
 import play.api.mvc._
@@ -9,37 +10,55 @@ import scala.concurrent.Future
 import scala.concurrent.Future.{successful => immediate}
 
 /**
-  * Controller trait which updates an AccessibleEntity.
+  * Controller trait which updates items based on data from a submitted form,
+  * wrapped with preSave and postSave lifecycle handlers.
   */
 trait Update[MT <: Model{type T <: ModelData with Persistable}] extends Read[MT] with Write {
 
+  case class EditRequest[A](
+    item: MT,
+    fieldHints: FormFieldHints,
+    userOpt: Option[UserProfile],
+    request: Request[A]
+  ) extends WrappedRequest[A](request)
+    with WithOptionalUser
+
   case class UpdateRequest[A](
     item: MT,
     formOrItem: Either[Form[MT#T], MT],
+    fieldHints: FormFieldHints,
     userOpt: Option[UserProfile],
     request: Request[A]
   ) extends WrappedRequest[A](request)
     with WithOptionalUser
 
-  protected def EditAction(itemId: String)(implicit ct: ContentType[MT]): ActionBuilder[ItemPermissionRequest, AnyContent] =
-    WithItemPermissionAction(itemId, PermissionType.Update)
+  protected def EditAction(itemId: String)(implicit ct: ContentType[MT]): ActionBuilder[EditRequest, AnyContent] =
+    WithItemPermissionAction(itemId, PermissionType.Update) andThen new CoreActionTransformer[ItemPermissionRequest, EditRequest] {
+      def transform[A](request: ItemPermissionRequest[A]): Future[EditRequest[A]] = {
+        implicit val req: ItemPermissionRequest[A] = request
+        val formConfig = FieldMetaFormFieldHintsBuilder(ct.entityType, entityTypeMetadata, conf.configuration)
+        formConfig.forUpdate.map { fieldHints =>
+          EditRequest(request.item, fieldHints, request.userOpt, request.request)
+        }
+      }
+    }
 
   protected def UpdateAction(id: String, form: Form[MT#T])(
     implicit ct: ContentType[MT], wd: Writable[MT#T]): ActionBuilder[UpdateRequest, AnyContent] =
-    EditAction(id) andThen new CoreActionTransformer[ItemPermissionRequest, UpdateRequest] {
-      def transform[A](request: ItemPermissionRequest[A]): Future[UpdateRequest[A]] = {
-        implicit val req: ItemPermissionRequest[A] = request
+    EditAction(id) andThen new CoreActionTransformer[EditRequest, UpdateRequest] {
+      def transform[A](request: EditRequest[A]): Future[UpdateRequest[A]] = {
+        implicit val req: EditRequest[A] = request
         form.bindFromRequest().fold(
-          errorForm => immediate(UpdateRequest(request.item, Left(errorForm), request.userOpt, request.request)),
+          errorForm => immediate(UpdateRequest(request.item, Left(errorForm),  request.fieldHints, request.userOpt, request.request)),
           mod => {
             (for {
               pre <- itemLifecycle.preSave(Some(id), Some(request.item), mod, EventType.modification)
               saved <- userDataApi.update[MT, MT#T](id, pre, logMsg = getLogMessage)
               post <- itemLifecycle.postSave(id, saved, EventType.modification)
-            } yield UpdateRequest(request.item, Right(post), request.userOpt, request)) recover {
+            } yield UpdateRequest(request.item, Right(post), request.fieldHints, request.userOpt, request)) recover {
               case ValidationError(errorSet) =>
                 val filledForm = mod.getFormErrors(errorSet, form.fill(mod))
-                UpdateRequest(request.item, Left(filledForm), request.userOpt, request)
+                UpdateRequest(request.item, Left(filledForm), request.fieldHints, request.userOpt, request)
             }
           }
         )
diff --git a/modules/portal/app/forms/FormFieldHints.scala b/modules/core/src/main/scala/forms/FormFieldHints.scala
similarity index 75%
rename from modules/portal/app/forms/FormFieldHints.scala
rename to modules/core/src/main/scala/forms/FormFieldHints.scala
index 453578afef..021c7de9c4 100644
--- a/modules/portal/app/forms/FormFieldHints.scala
+++ b/modules/core/src/main/scala/forms/FormFieldHints.scala
@@ -4,9 +4,13 @@ import models.{EntityType, FieldMetadata, FieldMetadataSet}
 import play.api.Configuration
 import services.datamodel.EntityTypeMetadataService
 
-import scala.collection.immutable.ListMap
-import scala.concurrent.{Await, ExecutionContext}
+import scala.concurrent.{ExecutionContext, Future}
 
+/**
+  * This trait provides a set of hints for form fields, including
+  * whether they should be hidden, have a default value, hint, description,
+  * number of rows, and whether they are required.
+  */
 trait FormFieldHints {
   def name(field: String): Option[String] = None
 
@@ -53,10 +57,13 @@ case class ConfigFormFieldHints(private val config: Option[Configuration], updat
 
 case class ConfigFormFieldHintsBuilder(et: EntityType.Value, config: Configuration) {
   private val path = s"formConfig.$et"
-  def forUpdate: FormFieldHints = ConfigFormFieldHints(config.getOptional[Configuration](path), update = true)
-  def forCreate: FormFieldHints = ConfigFormFieldHints(config.getOptional[Configuration](path), update = false)
+  def forUpdate: Future[FormFieldHints] = Future.successful(ConfigFormFieldHints(config.getOptional[Configuration](path), update = true))
+  def forCreate: Future[FormFieldHints] = Future.successful(ConfigFormFieldHints(config.getOptional[Configuration](path), update = false))
 }
 
+/**
+  * Field hints that are based on the field metadata, with configuration as a fallback.
+  */
 case class FieldMetaFormFieldHints(base: FormFieldHints, meta: FieldMetadataSet, update: Boolean) extends FormFieldHints {
 
   override def name(field: String): Option[String] = meta
@@ -92,13 +99,15 @@ case class FieldMetaFormFieldHints(base: FormFieldHints, meta: FieldMetadataSet,
 }
 
 case class FieldMetaFormFieldHintsBuilder(et: EntityType.Value, ets: EntityTypeMetadataService, config: Configuration)(implicit ec: ExecutionContext) {
-  import scala.concurrent.duration._
-  private def getData = Await.result(ets.listFields(Some(et))
-    .map(_.getOrElse(et, FieldMetadataSet(ListMap.empty[String, FieldMetadata]))), 2.seconds)
-
   // Legacy config fallback...
   private val baseBuilder = ConfigFormFieldHintsBuilder(et, config)
 
-  def forUpdate: FormFieldHints = FieldMetaFormFieldHints(baseBuilder.forUpdate, getData, update = true)
-  def forCreate: FormFieldHints = FieldMetaFormFieldHints(baseBuilder.forCreate, getData, update = false)
+  def forUpdate: Future[FormFieldHints] = for {
+    meta <- ets.listEntityTypeFields(et)
+    base <- baseBuilder.forUpdate} yield FieldMetaFormFieldHints(base, meta, update = true)
+
+  def forCreate: Future[FormFieldHints] = for {
+    meta <- ets.listEntityTypeFields(et)
+    base <- baseBuilder.forCreate
+  } yield FieldMetaFormFieldHints(base, meta, update = false)
 }
diff --git a/modules/core/src/main/scala/forms/mappings/package.scala b/modules/core/src/main/scala/forms/mappings/package.scala
new file mode 100644
index 0000000000..3cc0674ac8
--- /dev/null
+++ b/modules/core/src/main/scala/forms/mappings/package.scala
@@ -0,0 +1,38 @@
+package forms
+
+import models.Entity
+import play.api.data.Forms.{optional, text}
+
+package object mappings {
+
+  import play.api.data.format.Formatter
+  import play.api.data.{FormError, Forms, Mapping}
+  import play.api.libs.json.Json
+
+  /**
+    * Constructs a simple mapping for a text field (mapped as `JsObject`)
+    *
+    * For example:
+    * {{{
+    *   Form("randomData" -> jsonObj(Status))
+    * }}}
+    */
+  val entityForm: Mapping[Entity] = Forms.of(new Formatter[Entity] {
+    def bind(key: String, data: Map[String, String]): Either[Seq[FormError], Entity] = {
+      play.api.data.format.Formats.stringFormat.bind(key, data).right.flatMap { s =>
+        scala.util.control.Exception.allCatch[Entity]
+          .either(Json.parse(s).as[Entity](Entity.entityReads))
+          .left.map(e => Seq(FormError(key, "error.jsonObj", Nil)))
+      }
+    }
+
+    def unbind(key: String, value: Entity): Map[String, String] = Map(key -> Json.stringify(Json.toJson(value)(Entity.entityWrites)))
+  })
+
+
+  /**
+    * A mapping for optional text values that become `None` if they are empty or contain only whitespace.
+    */
+  val optionalText: Mapping[Option[String]] = optional(text).transform(_.filter(_.trim.nonEmpty), identity)
+
+}
diff --git a/modules/core/src/main/scala/forms/package.scala b/modules/core/src/main/scala/forms/package.scala
index 935ea778a6..9490c63474 100644
--- a/modules/core/src/main/scala/forms/package.scala
+++ b/modules/core/src/main/scala/forms/package.scala
@@ -20,30 +20,6 @@ package object forms {
     case _: MalformedURLException => false
   }
 
-  import play.api.data.format.Formatter
-  import play.api.data.{FormError, Forms, Mapping}
-  import play.api.libs.json.Json
-
-  /**
-    * Constructs a simple mapping for a text field (mapped as `JsObject`)
-    *
-    * For example:
-    * {{{
-    *   Form("randomData" -> jsonObj(Status))
-    * }}}
-    */
-  val entityForm: Mapping[Entity] = Forms.of(new Formatter[Entity] {
-    def bind(key: String, data: Map[String, String]): Either[Seq[FormError], Entity] = {
-      play.api.data.format.Formats.stringFormat.bind(key, data).right.flatMap { s =>
-        scala.util.control.Exception.allCatch[Entity]
-          .either(Json.parse(s).as[Entity](Entity.entityReads))
-          .left.map(e => Seq(FormError(key, "error.jsonObj", Nil)))
-      }
-    }
-
-    def unbind(key: String, value: Entity) = Map(key -> Json.stringify(Json.toJson(value)(Entity.entityWrites)))
-  })
-
   /**
     * Form for a set of user or group identifiers that can
     * access a given resource.
diff --git a/modules/core/src/main/scala/models/AuthoritativeSet.scala b/modules/core/src/main/scala/models/AuthoritativeSet.scala
index ce5150f794..896c391791 100644
--- a/modules/core/src/main/scala/models/AuthoritativeSet.scala
+++ b/modules/core/src/main/scala/models/AuthoritativeSet.scala
@@ -1,6 +1,7 @@
 package models
 
 import eu.ehri.project.definitions.Ontology
+import forms.mappings.optionalText
 import models.json._
 import play.api.i18n.Messages
 import play.api.libs.json._
@@ -73,7 +74,7 @@ object AuthoritativeSet {
       ID -> optional(nonEmptyText),
       IDENTIFIER -> nonEmptyText(minLength=3),
       NAME -> optional(nonEmptyText),
-      DESCRIPTION -> optional(nonEmptyText),
+      DESCRIPTION -> optionalText,
       ALLOW_PUBLIC -> default(boolean, true)
     )(AuthoritativeSetF.apply)(AuthoritativeSetF.unapply)
   )
diff --git a/modules/core/src/main/scala/models/ConceptDescription.scala b/modules/core/src/main/scala/models/ConceptDescription.scala
index 8b6364b723..e266af042c 100644
--- a/modules/core/src/main/scala/models/ConceptDescription.scala
+++ b/modules/core/src/main/scala/models/ConceptDescription.scala
@@ -5,7 +5,7 @@ import play.api.libs.functional.syntax._
 import play.api.libs.json._
 import play.api.data.Form
 import play.api.data.Forms._
-import forms._
+import forms.mappings._
 import eu.ehri.project.definitions.Ontology
 import Description._
 
diff --git a/modules/core/src/main/scala/models/Country.scala b/modules/core/src/main/scala/models/Country.scala
index 351ff53aa5..58b8e25478 100644
--- a/modules/core/src/main/scala/models/Country.scala
+++ b/modules/core/src/main/scala/models/Country.scala
@@ -1,11 +1,13 @@
 package models
 
+import forms.mappings.optionalText
 import models.json._
 import play.api.i18n.Messages
 import play.api.libs.json._
 import play.api.libs.functional.syntax._
-import play.api.data.Form
+import play.api.data.{Form, Mapping}
 import play.api.data.Forms._
+import play.api.data.validation.Constraints
 import play.api.libs.json.JsObject
 
 
@@ -72,16 +74,16 @@ object Country {
     val restReads: Reads[Country] = metaReads
   }
 
-  val form = Form(
+  val form: Form[CountryF] = Form(
     mapping(
       ISA -> ignored(EntityType.Country),
       ID -> optional(nonEmptyText),
-      IDENTIFIER -> nonEmptyText(minLength=2,maxLength=2), // ISO 2-letter field
-      ABSTRACT -> optional(nonEmptyText),
-      HISTORY -> optional(nonEmptyText),
-      SITUATION -> optional(nonEmptyText),
-      DATA_SUMMARY -> optional(nonEmptyText),
-      DATA_EXTENSIVE -> optional(nonEmptyText)
+      IDENTIFIER -> text(minLength=2,maxLength=2).verifying(Constraints.nonEmpty(errorMessage="constraints.mandatory")), // ISO 2-letter field
+      ABSTRACT -> optionalText,
+      HISTORY -> optionalText,
+      SITUATION -> optionalText,
+      DATA_SUMMARY -> optionalText,
+      DATA_EXTENSIVE -> optionalText
     )(CountryF.apply)(CountryF.unapply)
   )
 }
diff --git a/modules/core/src/main/scala/models/DocumentaryUnit.scala b/modules/core/src/main/scala/models/DocumentaryUnit.scala
index 662b029483..95d04101c7 100644
--- a/modules/core/src/main/scala/models/DocumentaryUnit.scala
+++ b/modules/core/src/main/scala/models/DocumentaryUnit.scala
@@ -4,6 +4,7 @@ import models.json._
 import play.api.libs.json._
 import play.api.libs.functional.syntax._
 import eu.ehri.project.definitions.Ontology
+import models.Description.CreationProcess
 
 import java.net.URL
 import play.api.data.Form
@@ -145,4 +146,6 @@ case class DocumentaryUnit(
     desc <- descriptions
     url <- desc.externalLink(this)
   } yield new URL(url)).headOption
+
+  def createdManually: Boolean = descriptions.exists(_.creationProcess == CreationProcess.Manual)
 }
diff --git a/modules/core/src/main/scala/models/DocumentaryUnitDescription.scala b/modules/core/src/main/scala/models/DocumentaryUnitDescription.scala
index 31930ffcb0..e44e796298 100644
--- a/modules/core/src/main/scala/models/DocumentaryUnitDescription.scala
+++ b/modules/core/src/main/scala/models/DocumentaryUnitDescription.scala
@@ -7,7 +7,7 @@ import play.api.data.Form
 import play.api.data.Forms._
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import forms._
+import forms.mappings._
 
 case class IsadGIdentity(
   name: String,
diff --git a/modules/core/src/main/scala/models/Entity.scala b/modules/core/src/main/scala/models/Entity.scala
index 727cb0aab5..1d079368ca 100644
--- a/modules/core/src/main/scala/models/Entity.scala
+++ b/modules/core/src/main/scala/models/Entity.scala
@@ -4,7 +4,6 @@ import play.api.libs.functional.syntax._
 import play.api.libs.json._
 import utils.EnumUtils
 
-
 object Entity {
 
   val ID = "id"
@@ -23,7 +22,7 @@ object Entity {
     (__ \ ID).read[String] and
     (__ \ TYPE).read[EntityType.Type](EnumUtils.enumReads(EntityType)) and
     (__ \ DATA).lazyRead(Reads.map[JsValue]) and
-    (__ \ RELATIONSHIPS).lazyRead(Reads.map[Seq[Entity]](Reads.seq(entityReads)))
+    (__ \ RELATIONSHIPS).lazyReadNullable(Reads.map[Seq[Entity]]).map(_.getOrElse(Map.empty)) // can be missing
   )(Entity.apply _)
 
   /**
diff --git a/modules/portal/app/models/EntityTypeMetadata.scala b/modules/core/src/main/scala/models/EntityTypeMetadata.scala
similarity index 100%
rename from modules/portal/app/models/EntityTypeMetadata.scala
rename to modules/core/src/main/scala/models/EntityTypeMetadata.scala
diff --git a/modules/portal/app/models/FieldMetadata.scala b/modules/core/src/main/scala/models/FieldMetadata.scala
similarity index 100%
rename from modules/portal/app/models/FieldMetadata.scala
rename to modules/core/src/main/scala/models/FieldMetadata.scala
index 621d704186..22e9d33050 100644
--- a/modules/portal/app/models/FieldMetadata.scala
+++ b/modules/core/src/main/scala/models/FieldMetadata.scala
@@ -2,9 +2,9 @@ package models
 
 import play.api.libs.json.{Format, Reads}
 import utils.EnumUtils.enumFormat
+import utils.db.StorableEnum
 
 import java.time.Instant
-import utils.db.StorableEnum
 
 /**
   * This class contains information about fields in the database. The entity type
diff --git a/modules/core/src/main/scala/models/FieldMetadataSet.scala b/modules/core/src/main/scala/models/FieldMetadataSet.scala
new file mode 100644
index 0000000000..2d89189ff1
--- /dev/null
+++ b/modules/core/src/main/scala/models/FieldMetadataSet.scala
@@ -0,0 +1,68 @@
+package models
+
+import play.api.Logger
+import play.api.libs.json._
+
+import scala.collection.immutable.ListMap
+
+sealed trait ValidationError
+case class MissingMandatoryField(id: String) extends ValidationError
+case class MissingDesirableField(id: String) extends ValidationError
+
+case class FieldMetadataSet(fieldMetadata: ListMap[String, FieldMetadata]) {
+  private val logger: Logger = Logger(this.getClass)
+
+  def toSeq: Seq[FieldMetadata] = fieldMetadata.values.toSeq
+
+  def get(id: String): Option[FieldMetadata] = fieldMetadata.get(id)
+
+  def nonEmpty: Boolean = fieldMetadata.nonEmpty
+
+  def grouped: Seq[(Option[String], Iterable[FieldMetadata])] = {
+    import utils.collections.GroupByOrderedImplicitImpl
+    fieldMetadata.values.groupByOrdered(_.category)
+  }
+
+  def withCategory(cat: String): Seq[FieldMetadata] = fieldMetadata.values.filter(_.category.contains(cat)).toSeq
+
+  def noCategory: Seq[FieldMetadata] = fieldMetadata.values.filter(_.category.isEmpty).toSeq
+
+  def validate[T: Writable](data: T): Seq[ValidationError] = {
+    def flattenEntity(e: Entity): Seq[String] = {
+      // gather all populated keys in the entity and its child relationships. This
+      // might lead to some missed attributes, because keys may be shared. But it's
+      // good enough for now.
+      e.data.keys.toSeq ++
+        e.relationships.values.toSeq.flatten.flatMap { r => flattenEntity(r) }
+    }
+
+    val json = Json.toJson(data)(implicitly[Writable[T]].restFormat)
+    json.validate[Entity] match {
+      case JsSuccess(entity, _) =>
+        val fms = fieldMetadata.values.filter(_.entityType == entity.isA).toSeq
+        val allKeys = flattenEntity(entity)
+        fms.filter(_.usage.contains(FieldMetadata.Usage.Mandatory)).flatMap { fm =>
+          if (!allKeys.contains(fm.id)) Some(MissingMandatoryField(fm.id))
+          else None
+        } ++ fms.filter(_.usage.contains(FieldMetadata.Usage.Desirable)).flatMap { fm =>
+          if (!allKeys.contains(fm.id)) Some(MissingDesirableField(fm.id))
+          else None
+        }
+      case JsError(errors) =>
+        logger.error(s"FieldMetadataSet.validate: failed to parse entity data: ${Json.prettyPrint(json)}: $errors")
+        Seq.empty
+    }
+  }
+}
+
+object FieldMetadataSet {
+  implicit val _writes: Writes[FieldMetadataSet] = Writes(fieldMetadataSet => {
+    import play.api.libs.json.Json
+    Json.toJson(fieldMetadataSet.fieldMetadata.values.toSeq)
+  })
+  implicit val _reads: Reads[FieldMetadataSet] = Reads(json => {
+    import play.api.libs.json.Json
+    Json.fromJson[Seq[FieldMetadata]](json).map(f => FieldMetadataSet(ListMap(f.map(fm => fm.id -> fm): _*)))
+  })
+  implicit val _format: Format[FieldMetadataSet] = Format(_reads, _writes)
+}
diff --git a/modules/core/src/main/scala/models/Group.scala b/modules/core/src/main/scala/models/Group.scala
index 3f94d20a63..8b4c81ac92 100644
--- a/modules/core/src/main/scala/models/Group.scala
+++ b/modules/core/src/main/scala/models/Group.scala
@@ -7,6 +7,7 @@ import play.api.libs.functional.syntax._
 import play.api.data.Form
 import play.api.data.Forms._
 import eu.ehri.project.definitions.Ontology
+import forms.mappings.optionalText
 import play.api.libs.json.JsObject
 
 
@@ -65,7 +66,7 @@ object Group {
       ID -> optional(text),
       IDENTIFIER -> nonEmptyText,
       NAME -> nonEmptyText,
-      DESCRIPTION -> optional(nonEmptyText)
+      DESCRIPTION -> optionalText
     )(GroupF.apply)(GroupF.unapply)
   )
 }
diff --git a/modules/core/src/main/scala/models/HistoricalAgentDescription.scala b/modules/core/src/main/scala/models/HistoricalAgentDescription.scala
index 41b184fc6d..f91cff23d0 100644
--- a/modules/core/src/main/scala/models/HistoricalAgentDescription.scala
+++ b/modules/core/src/main/scala/models/HistoricalAgentDescription.scala
@@ -7,6 +7,7 @@ import eu.ehri.project.definitions.Ontology
 import play.api.data.Form
 import play.api.data.Forms._
 import Description._
+import forms.mappings._
 
 
 case class IsaarDetail(
@@ -143,7 +144,7 @@ object HistoricalAgentDescription {
       CREATION_PROCESS -> default(enumMapping(CreationProcess), CreationProcess.Manual),
       ACCESS_POINTS -> seq(AccessPoint.form.mapping),
       MAINTENANCE_EVENTS -> seq(MaintenanceEventF.form.mapping),
-      UNKNOWN_DATA -> seq(forms.entityForm)
+      UNKNOWN_DATA -> seq(entityForm)
     )(HistoricalAgentDescriptionF.apply)(HistoricalAgentDescriptionF.unapply)
   )
 }
diff --git a/modules/core/src/main/scala/models/IsadG.scala b/modules/core/src/main/scala/models/IsadG.scala
index e725f3052b..c6a6343b82 100644
--- a/modules/core/src/main/scala/models/IsadG.scala
+++ b/modules/core/src/main/scala/models/IsadG.scala
@@ -1,5 +1,8 @@
 package models
 
+import models.Description.LANG_CODE
+import models.DocumentaryUnitF.{COPYRIGHT, SCOPE}
+import models.Entity.IDENTIFIER
 import play.api.libs.json.Format
 import utils.EnumUtils
 
@@ -78,6 +81,10 @@ case object IsadG {
   val ACCESS_POINTS = "accessPoints"
 
   val FIELDS: Seq[(String, Seq[String])] = List(
+    "_" -> List(
+      IDENTIFIER,
+      LANG_CODE
+    ),
     IDENTITY_AREA -> List(
       TITLE,
       PARALLEL_FORMS_OF_NAME,
@@ -124,6 +131,11 @@ case object IsadG {
       DATES_DESCRIPTIONS,
       PROCESS_INFO,
       SOURCES
+    ),
+    ADMINISTRATION_AREA -> List(
+      PUB_STATUS,
+      COPYRIGHT,
+      SCOPE
     )
   )
 }
diff --git a/modules/core/src/main/scala/models/Isdiah.scala b/modules/core/src/main/scala/models/Isdiah.scala
index 1718adb5d0..8c2790f096 100644
--- a/modules/core/src/main/scala/models/Isdiah.scala
+++ b/modules/core/src/main/scala/models/Isdiah.scala
@@ -1,5 +1,7 @@
 package models
 
+import models.Description.LANG_CODE
+
 /**
   * ISDIAH Field definitions
   */
@@ -71,8 +73,11 @@ case object Isdiah {
   val ACCESS_POINTS = "accessPoints"
 
   val FIELDS: Seq[(String, Seq[String])] = List(
-    IDENTITY_AREA -> Seq(
+    "_" -> Seq(
       IDENTIFIER,
+      LANG_CODE,
+    ),
+    IDENTITY_AREA -> Seq(
       AUTHORIZED_FORM_OF_NAME,
       OTHER_FORMS_OF_NAME,
       PARALLEL_FORMS_OF_NAME,
diff --git a/modules/core/src/main/scala/models/RepositoryDescription.scala b/modules/core/src/main/scala/models/RepositoryDescription.scala
index c489c0a1b5..3887b01b34 100644
--- a/modules/core/src/main/scala/models/RepositoryDescription.scala
+++ b/modules/core/src/main/scala/models/RepositoryDescription.scala
@@ -7,7 +7,7 @@ import play.api.data.Form
 import play.api.data.Forms._
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import forms._
+import forms.mappings._
 
 case class IsdiahDetails(
   history: Option[String] = None,
diff --git a/modules/core/src/main/scala/models/Vocabulary.scala b/modules/core/src/main/scala/models/Vocabulary.scala
index e0765bf247..9a795fe119 100644
--- a/modules/core/src/main/scala/models/Vocabulary.scala
+++ b/modules/core/src/main/scala/models/Vocabulary.scala
@@ -1,6 +1,7 @@
 package models
 
 import eu.ehri.project.definitions.Ontology
+import forms.mappings.optionalText
 import models.json._
 import play.api.data.Form
 import play.api.data.Forms._
@@ -75,7 +76,7 @@ object Vocabulary {
       ID -> optional(nonEmptyText),
       IDENTIFIER -> nonEmptyText(minLength=3),
       NAME -> optional(nonEmptyText),
-      DESCRIPTION -> optional(nonEmptyText),
+      DESCRIPTION -> optionalText,
       ALLOW_PUBLIC -> default(boolean, true)
     )(VocabularyF.apply)(VocabularyF.unapply)
   )
diff --git a/modules/portal/app/services/datamodel/EntityTypeMetadataService.scala b/modules/core/src/main/scala/services/datamodel/EntityTypeMetadataService.scala
similarity index 95%
rename from modules/portal/app/services/datamodel/EntityTypeMetadataService.scala
rename to modules/core/src/main/scala/services/datamodel/EntityTypeMetadataService.scala
index 85ed5646ae..7f320bf9fc 100644
--- a/modules/portal/app/services/datamodel/EntityTypeMetadataService.scala
+++ b/modules/core/src/main/scala/services/datamodel/EntityTypeMetadataService.scala
@@ -49,6 +49,11 @@ trait EntityTypeMetadataService {
     */
   def listFields(entityType: Option[EntityType.Value] = None): Future[Map[EntityType.Value, FieldMetadataSet]]
 
+  /**
+    * List field metadata for a specific entity type.
+    */
+  def listEntityTypeFields(entityType: EntityType.Value): Future[FieldMetadataSet]
+
   /**
     * Retrieves a field metadata entry.
     *
diff --git a/modules/portal/app/services/datamodel/SqlEntityTypeMetadataService.scala b/modules/core/src/main/scala/services/datamodel/SqlEntityTypeMetadataService.scala
similarity index 84%
rename from modules/portal/app/services/datamodel/SqlEntityTypeMetadataService.scala
rename to modules/core/src/main/scala/services/datamodel/SqlEntityTypeMetadataService.scala
index 70524cbefa..4004a7a8a0 100644
--- a/modules/portal/app/services/datamodel/SqlEntityTypeMetadataService.scala
+++ b/modules/core/src/main/scala/services/datamodel/SqlEntityTypeMetadataService.scala
@@ -64,7 +64,7 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
   )
 
 
-  def list(): Future[Map[EntityType.Value, EntityTypeMetadata]] = Future {
+  override def list(): Future[Map[EntityType.Value, EntityTypeMetadata]] = Future {
     db.withConnection { implicit conn =>
       SQL"""
       SELECT * FROM entity_type_meta
@@ -73,7 +73,7 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
     }
   }(ec)
 
-  def get(entityType: EntityType.Value): Future[Option[EntityTypeMetadata]] = Future {
+  override def get(entityType: EntityType.Value): Future[Option[EntityTypeMetadata]] = Future {
     db.withConnection { implicit conn =>
       SQL"""
         SELECT * FROM entity_type_meta
@@ -82,7 +82,7 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
     }
   }(ec)
 
-  def save(entityType: EntityType.Value, info: EntityTypeMetadataInfo): Future[EntityTypeMetadata] = Future {
+  override def save(entityType: EntityType.Value, info: EntityTypeMetadataInfo): Future[EntityTypeMetadata] = Future {
     db.withConnection { implicit conn =>
       SQL"""
             INSERT INTO entity_type_meta(entity_type, name, description)
@@ -100,7 +100,7 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
     }
   }(ec)
 
-  def delete(entityType: EntityType.Value): Future[Boolean] = Future {
+  override def delete(entityType: EntityType.Value): Future[Boolean] = Future {
     db.withConnection { implicit conn =>
       SQL"""
             DELETE FROM entity_type_meta
@@ -109,7 +109,7 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
     }
   }(ec)
 
-  def listFields(entityType: Option[EntityType.Value] = None): Future[Map[EntityType.Value, FieldMetadataSet]] = Future {
+  override def listFields(entityType: Option[EntityType.Value] = None): Future[Map[EntityType.Value, FieldMetadataSet]] = Future {
     templates().map { tmpl =>
       val unordered = db.withConnection { implicit conn =>
         SQL"""
@@ -130,7 +130,10 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
     }
   }(ec).flatten
 
-  def getField(entityType: EntityType.Value, id: String): Future[Option[FieldMetadata]] = Future {
+  override def listEntityTypeFields(entityType: EntityType.Value): Future[FieldMetadataSet] =
+    listFields(Some(entityType)).map(_.getOrElse(entityType, FieldMetadataSet(ListMap.empty)))
+
+  override def getField(entityType: EntityType.Value, id: String): Future[Option[FieldMetadata]] = Future {
     db.withConnection { implicit conn =>
       SQL"""
             SELECT * FROM field_meta
@@ -140,7 +143,7 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
     }
   }(ec)
 
-  def saveField(entityType: EntityType.Value, id: String, info: FieldMetadataInfo): Future[FieldMetadata] = Future {
+  override def saveField(entityType: EntityType.Value, id: String, info: FieldMetadataInfo): Future[FieldMetadata] = Future {
     db.withConnection { implicit conn =>
       SQL"""
             INSERT INTO field_meta(entity_type, id, name, description, usage, category, default_val, see_also)
@@ -167,7 +170,7 @@ case class SqlEntityTypeMetadataService @Inject()(db: Database, actorSystem: Act
     }
   }(ec)
 
-  def deleteField(entityType: EntityType.Value, id: String): Future[Boolean] = Future {
+  override def deleteField(entityType: EntityType.Value, id: String): Future[Boolean] = Future {
     db.withConnection { implicit conn =>
       SQL"""
             DELETE FROM field_meta
diff --git a/modules/portal/app/assets/css/portal/_layout.scss b/modules/portal/app/assets/css/portal/_layout.scss
index 4efa8ce3e3..802e35eeec 100644
--- a/modules/portal/app/assets/css/portal/_layout.scss
+++ b/modules/portal/app/assets/css/portal/_layout.scss
@@ -265,8 +265,7 @@ ul.pagination {
       @include make-col(3);
     }
 
-    > .control-elements,
-    .inline-element-list {
+    > .control-elements {
       @include make-col-ready();
       @include make-col(9);
     }
diff --git a/modules/portal/app/assets/css/portal/_style.scss b/modules/portal/app/assets/css/portal/_style.scss
index 062e50e6c1..f41d2a5dea 100644
--- a/modules/portal/app/assets/css/portal/_style.scss
+++ b/modules/portal/app/assets/css/portal/_style.scss
@@ -1094,6 +1094,18 @@ body.home {
   @include badge-variant($historical-agent-color);
 }
 
+.badge-mandatory {
+  @include badge-variant(#fba8a6);
+}
+
+.badge-desirable {
+  @include badge-variant(#f8dab1);
+}
+
+.badge-optional {
+  @include badge-variant(#f5f5f5);
+}
+
 // Pagination
 ul.pagination {
   // On the rare occasions pagination is
diff --git a/modules/portal/app/controllers/AppComponents.scala b/modules/portal/app/controllers/AppComponents.scala
index cd547504b6..18ab44fc2c 100644
--- a/modules/portal/app/controllers/AppComponents.scala
+++ b/modules/portal/app/controllers/AppComponents.scala
@@ -9,6 +9,7 @@ import play.api.Configuration
 import play.api.cache.SyncCacheApi
 import services.accounts.AccountManager
 import services.data.DataServiceBuilder
+import services.datamodel.EntityTypeMetadataService
 import services.redirects.MovedPageLookup
 import services.search.{SearchEngine, SearchItemResolver}
 import views.html.MarkdownRenderer
@@ -22,31 +23,45 @@ import javax.inject.Inject
 @ImplementedBy(classOf[DefaultAppComponents])
 trait AppComponents {
   def materializer: Materializer
+
   def dataApi: DataServiceBuilder
+
   def accounts: AccountManager
+
   def authHandler: AuthHandler
+
   def cacheApi: SyncCacheApi
+
   def config: Configuration
+
   def conf: AppConfig
+
   def markdown: MarkdownRenderer
+
   def pageRelocator: MovedPageLookup
+
   def searchEngine: SearchEngine
+
   def searchResolver: SearchItemResolver
+
   def itemLifecycle: ItemLifecycle
+
+  def entityTypeMetadata: EntityTypeMetadataService
 }
 
-case class DefaultAppComponents @Inject ()(
-                                            accounts: AccountManager,
-                                            authHandler: AuthHandler,
-                                            cacheApi: SyncCacheApi,
-                                            config: Configuration,
-                                            dataApi: DataServiceBuilder,
-                                            conf: AppConfig,
-                                            markdown: MarkdownRenderer,
-                                            materializer: Materializer,
-                                            pageRelocator: MovedPageLookup,
-                                            searchEngine: SearchEngine,
-                                            searchResolver: SearchItemResolver,
-                                            itemLifecycle: ItemLifecycle,
+case class DefaultAppComponents @Inject()(
+  accounts: AccountManager,
+  authHandler: AuthHandler,
+  cacheApi: SyncCacheApi,
+  config: Configuration,
+  dataApi: DataServiceBuilder,
+  conf: AppConfig,
+  markdown: MarkdownRenderer,
+  materializer: Materializer,
+  pageRelocator: MovedPageLookup,
+  searchEngine: SearchEngine,
+  searchResolver: SearchItemResolver,
+  itemLifecycle: ItemLifecycle,
+  entityTypeMetadata: EntityTypeMetadataService
 ) extends AppComponents
 
diff --git a/modules/portal/app/controllers/portal/base/PortalController.scala b/modules/portal/app/controllers/portal/base/PortalController.scala
index 2577ade8f9..dbdc4351db 100644
--- a/modules/portal/app/controllers/portal/base/PortalController.scala
+++ b/modules/portal/app/controllers/portal/base/PortalController.scala
@@ -14,6 +14,7 @@ import play.api.mvc.{Result, _}
 import play.api.{Configuration, Logger}
 import services.accounts.AccountManager
 import services.data.{DataServiceBuilder, DataUser}
+import services.datamodel.EntityTypeMetadataService
 import services.search.{SearchEngine, SearchItemResolver}
 import utils._
 import views.html.MarkdownRenderer
@@ -45,6 +46,7 @@ trait PortalController
   protected def dataApi: DataServiceBuilder = appComponents.dataApi
   protected def authHandler: AuthHandler = appComponents.authHandler
   protected def itemLifecycle: ItemLifecycle = appComponents.itemLifecycle
+  protected def entityTypeMetadata: EntityTypeMetadataService = appComponents.entityTypeMetadata
 
   protected def searchEngine: SearchEngine = appComponents.searchEngine
   protected def searchResolver: SearchItemResolver = appComponents.searchResolver
diff --git a/modules/portal/app/models/FieldMetadataSet.scala b/modules/portal/app/models/FieldMetadataSet.scala
deleted file mode 100644
index b1c5447187..0000000000
--- a/modules/portal/app/models/FieldMetadataSet.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-package models
-
-import play.api.libs.json.{Format, Reads, Writes}
-
-import scala.collection.immutable.ListMap
-
-case class FieldMetadataSet(fieldMetadata: ListMap[String, FieldMetadata]) {
-  def toSeq: Seq[FieldMetadata] = fieldMetadata.values.toSeq
-
-  def get(id: String): Option[FieldMetadata] = fieldMetadata.get(id)
-
-  def nonEmpty: Boolean = fieldMetadata.nonEmpty
-
-  def grouped: Seq[(Option[String], Iterable[FieldMetadata])] = {
-    import utils.collections.GroupByOrderedImplicitImpl
-    fieldMetadata.values.groupByOrdered(_.category)
-  }
-}
-
-object FieldMetadataSet {
-  implicit val _writes: Writes[FieldMetadataSet] = Writes(fieldMetadataSet => {
-    import play.api.libs.json.Json
-    Json.toJson(fieldMetadataSet.fieldMetadata.values.toSeq)
-  })
-  implicit val _reads: Reads[FieldMetadataSet] = Reads(json => {
-    import play.api.libs.json.Json
-    Json.fromJson[Seq[FieldMetadata]](json).map(f => FieldMetadataSet(ListMap(f.map(fm => fm.id -> fm): _*)))
-  })
-  implicit val _format: Format[FieldMetadataSet] = Format(_reads, _writes)
-}
diff --git a/modules/portal/app/views/common/footer.scala.html b/modules/portal/app/views/common/footer.scala.html
index d81d56482f..b38b6782ea 100644
--- a/modules/portal/app/views/common/footer.scala.html
+++ b/modules/portal/app/views/common/footer.scala.html
@@ -58,6 +58,7 @@ <h3>@Messages("mailingList.prompt")</h3>
                 <a href="/api">API</a>
             </li>
             @footerLink(controllers.portal.routes.Portal.externalPage("faq"), "help.faq")
+            @footerLink(controllers.portal.routes.Portal.dataModel(), "help.dataModel")
         </ul>
     </div>
 </footer>
diff --git a/modules/portal/app/views/dataModel.scala.html b/modules/portal/app/views/dataModel.scala.html
index 5c98768e68..fea0de03af 100644
--- a/modules/portal/app/views/dataModel.scala.html
+++ b/modules/portal/app/views/dataModel.scala.html
@@ -2,29 +2,49 @@
 
 @extraStyles = {
     <style>
-        .data-model-category {
-            background-color: #f5f5f5;
-            font-weight: bold;
-        }
-        .data-model-see-also a {
-            display: inline-block;
-        }
-        .data-model-entity-type {
-            margin-bottom: 2rem;
-        }
-        .data-model-usage {
-            white-space: nowrap;
-        }
-        .badge-mandatory {
-            background-color: #fba8a6;
+            .data-model-category {
+                background-color: #f5f5f5;
+                font-weight: bold;
+            }
+
+            .data-model-see-also a {
+                display: inline-block;
+            }
+
+            .data-model-entity-type {
+                margin-bottom: 2rem;
+            }
+
+            .data-model-usage {
+                white-space: nowrap;
+            }
+    </style>
+}
+
+@fieldRow(field: FieldMetadata) = {
+    <tr class="data-model-field @field.usage.map(_.toString).getOrElse("")">
+        <td class="data-model-name">
+            <div>@field.name</div>
+        </td>
+        <td class="data-model-usage">
+        @field.usage.map { usage =>
+        <span class="badge badge-@usage">@Messages(s"dataModel.field.usage.$usage")</span>
+        }.getOrElse {
+            <span class="badge badge-optional">@Messages("dataModel.field.usage.optional")</span>
         }
-        .badge-desirable {
-            background-color: #f8dab1;
+        </td>
+        <td class="data-model-description">
+        @field.description.map { desc =>
+            @Markdown(desc)
         }
-        .badge-optional {
-            background-color: #f5f5f5;
+        </td>
+        <td class="data-model-see-also">
+        @field.seeAlso.map { sa =>
+            <a href="@sa" target="_blank">@sa</a>
         }
-    </style>
+        </td>
+    </tr>
+
 }
 
 @views.html.layout.textLayout(Messages("dataModel"), styles = extraStyles) {
@@ -36,64 +56,47 @@ <h2>@Messages("dataModel")</h2>
         </div>
     </div>
 
-    @for((entityType, fieldSet) <- fieldMetadata) {
+    @for((entityType, categories) <- templates) {
         <div class="row data-model-entity-type">
             <div class="col-md-12">
-                <h3>@entityTypeMetadata.get(entityType).map(_.name).getOrElse(Messages(s"type.$entityType"))</h3>
-                @entityTypeMetadata.get(entityType).flatMap(_.description).map { desc =>
-                    @Markdown(desc)
+                @entityTypeMetadata.get(entityType).map { metadata =>
+                    <h3>@metadata.name</h3>
+                    @metadata.description.map { desc =>
+                        @Markdown(desc)
+                    }
                 }
 
-                <table class="table table-bordered table-condensed">
-                    <thead>
-                        <tr>
-                            <th>@Messages("dataModel.field.name")</th>
-                            <th>@Messages("dataModel.field.usage")</th>
-                            <th>@Messages("dataModel.field.description")</th>
-                            <th>@Messages("dataModel.field.seeAlso")</th>
-                        </tr>
-                    </thead>
-                    <tbody>
-                    @fieldSet.grouped.map { case (category, catFields) =>
-                        @category.map { cat =>
+                @fieldMetadata.get(entityType).map { fieldSet =>
+                    <table class="table table-bordered table-condensed">
+                        <thead>
                             <tr>
-                                <td colspan="4" class="data-model-category"><strong>@Messages(s"dataModel.$entityType.$cat")</strong></td>
+                                <th>@Messages("dataModel.field.name")</th>
+                                <th>@Messages("dataModel.field.usage")</th>
+                                <th>@Messages("dataModel.field.description")</th>
+                                <th>@Messages("dataModel.field.seeAlso")</th>
                             </tr>
-                        }
-
-                        @for(field <- catFields) {
-                            <tr class="data-model-field @field.usage.map(_.toString).getOrElse("")">
-                                <td class="data-model-name">
-                                    <div>@field.name</div>
-                                </td>
-                                <td class="data-model-usage">
-                                    @field.usage.map { usage =>
-                                        <span class="badge badge-@usage">@Messages(s"dataModel.field.usage.$usage")</span>
-                                    }.getOrElse {
-                                        <span class="badge badge-optional">@Messages("dataModel.field.usage.optional")</span>
-                                    }
-                                </td>
-                                <td class="data-model-description">
-                                    @field.description.map { desc =>
-                                        @Markdown(desc)
-                                    }
-                                </td>
-                                <td class="data-model-see-also">
-                                    @field.seeAlso.map { sa =>
-                                        <a href="@sa" target="_blank">@sa</a>
+                        </thead>
+                        <tbody>
+                        @categories.keys.toSeq.map { category =>
+                            @if(category.equals("_")) {
+                                @for(field <- fieldSet.noCategory) {
+                                    @fieldRow(field)
+                                }
+                            } else {
+                                @if(fieldSet.withCategory(category).nonEmpty) {
+                                    <tr>
+                                        <td colspan="4" class="data-model-category"><strong>@Messages(s"dataModel.$entityType.$category")</strong></td>
+                                    </tr>
+                                    @for(field <- fieldSet.withCategory(category)) {
+                                        @fieldRow(field)
                                     }
-                                </td>
-                            </tr>
+                                }
+                            }
                         }
-                    }
-                    </tbody>
-                </table>
+                        </tbody>
+                    </table>
+                }
             </div>
         </div>
     }
-
-    <script>
-        // Enable hiding fields based on usage
-
-    </script>
 }
diff --git a/modules/portal/app/views/formHelpers/lineInput.scala.html b/modules/portal/app/views/formHelpers/lineInput.scala.html
index 2fdc2a0fda..06836f835d 100644
--- a/modules/portal/app/views/formHelpers/lineInput.scala.html
+++ b/modules/portal/app/views/formHelpers/lineInput.scala.html
@@ -5,8 +5,8 @@
         field = field,
         args = views.Helpers.argsWithConfig(fieldName, views.Helpers.argsWithDefaults(
             args.map { case (s, v) => if(s == 'class) s -> (v.toString + " form-control") else s -> v },
-            '_label -> Messages(if(prefix.isEmpty) fieldName else s"$prefix.$fieldName"),
-            'title -> md.renderMarkdown(Messages((if(prefix != "") prefix + "." else "") + fieldName + ".description")),
+            '_label -> config.flatMap(_.name(fieldName)).getOrElse(Messages(if(prefix.isEmpty) fieldName else s"$prefix.$fieldName")),
+            'title -> md.renderMarkdown(config.flatMap(_.description(fieldName)).getOrElse(Messages((if(prefix != "") prefix + "." else "") + fieldName + ".description"))),
             'class -> "form-control"
         )): _*
     )
diff --git a/modules/portal/conf/messages b/modules/portal/conf/messages
index 76471b1052..edf3004b5c 100644
--- a/modules/portal/conf/messages
+++ b/modules/portal/conf/messages
@@ -30,6 +30,7 @@ help=Help
 help.manual=Online Manual
 help.faq=Frequently Asked Questions
 help.contact=Contact EHRI
+help.dataModel=Data Model
 
 #
 # Landing page: https://portal.ehri-project.eu
@@ -1311,6 +1312,7 @@ dataModel.DocumentaryUnit.conditionsArea=Conditions Area
 dataModel.DocumentaryUnit.materialsArea=Materials Area
 dataModel.DocumentaryUnit.notesArea=Notes Area
 dataModel.DocumentaryUnit.controlArea=Control Area
+dataModel.DocumentaryUnit.administrationArea=Administration Area
 dataModel.Repository.identityArea=Identity Area
 dataModel.Repository.addressArea=Address Area
 dataModel.Repository.descriptionArea=Description Area
diff --git a/modules/portal/test/models/FieldMetadataSetSpec.scala b/modules/portal/test/models/FieldMetadataSetSpec.scala
index 4da7ebcd93..ac48eaa903 100644
--- a/modules/portal/test/models/FieldMetadataSetSpec.scala
+++ b/modules/portal/test/models/FieldMetadataSetSpec.scala
@@ -1,12 +1,13 @@
 package models
 
+import helpers.ResourceUtils
 import play.api.test.PlaySpecification
 
 import scala.collection.immutable.ListMap
 
-class FieldMetadataSetSpec extends PlaySpecification {
+class FieldMetadataSetSpec extends PlaySpecification with ResourceUtils {
 
-  private val et = EntityType.RepositoryDescription
+  private val et = EntityType.Repository
   private val fm1 = FieldMetadata(et, "1", "test1", Some("description"), Option.empty[FieldMetadata.Usage.Value], Some("info"), None, Seq("seeAlso"))
   private val fm2 = FieldMetadata(et, "2", "test2", Some("description"), Option.empty[FieldMetadata.Usage.Value], None, None, Seq("seeAlso"))
   private val templates = Seq("" -> Seq("2"), "info" -> Seq("1"))
@@ -27,13 +28,24 @@ class FieldMetadataSetSpec extends PlaySpecification {
     "serialize to JSON" in {
       val fieldMetadataSet = FieldMetadataSet(ListMap("2" -> fm2, "1" -> fm1))
       val json = play.api.libs.json.Json.toJson(fieldMetadataSet)
-      json.toString must_== """[{"entityType":"RepositoryDescription","id":"2","name":"test2","description":"description","seeAlso":["seeAlso"]},{"entityType":"RepositoryDescription","id":"1","name":"test1","description":"description","category":"info","seeAlso":["seeAlso"]}]"""
+      json.toString must_== """[{"entityType":"Repository","id":"2","name":"test2","description":"description","seeAlso":["seeAlso"]},{"entityType":"Repository","id":"1","name":"test1","description":"description","category":"info","seeAlso":["seeAlso"]}]"""
     }
     "deserialize from JSON" in {
-      val json = play.api.libs.json.Json.parse("""[{"entityType":"RepositoryDescription","id":"2","name":"test2","description":"description","seeAlso":["seeAlso"]},{"entityType":"RepositoryDescription","id":"1","name":"test1","description":"description","category":"info","seeAlso":["seeAlso"]}]""")
+      val json = play.api.libs.json.Json.parse("""[{"entityType":"Repository","id":"2","name":"test2","description":"description","seeAlso":["seeAlso"]},{"entityType":"Repository","id":"1","name":"test1","description":"description","category":"info","seeAlso":["seeAlso"]}]""")
       val fieldMetadataSet = json.as[FieldMetadataSet]
       fieldMetadataSet.toSeq must_== Seq(fm2, fm1)
       fieldMetadataSet.grouped must_== Seq((None, Seq(fm2)), (Some("info"), Seq(fm1)))
     }
+    "validate a doc unit" in {
+      import IsadG._
+      val fms = FieldMetadataSet(
+        ListMap(
+          LOCATION_ORIGINALS -> FieldMetadata(EntityType.DocumentaryUnit, LOCATION_ORIGINALS, "Location of Originals", Some("The physical location of the original documents."), Some(FieldMetadata.Usage.Mandatory)),
+          ARCH_HIST -> FieldMetadata(EntityType.DocumentaryUnit, ARCH_HIST, "Archival History", Some("A description of the custodial history of the documents."), Some(FieldMetadata.Usage.Desirable))
+        )
+      )
+      val doc = readResource(EntityType.DocumentaryUnit).as[DocumentaryUnitF]
+      fms.validate(doc) must_== Seq(MissingMandatoryField(LOCATION_ORIGINALS), MissingDesirableField(ARCH_HIST))
+    }
   }
 }
diff --git a/package-lock.json b/package-lock.json
index 10d22edb0b..1100721690 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -32,6 +32,7 @@
         "sortablejs": "^1.13.0",
         "tiny-emitter": "^2.1.0",
         "vue": "3.4.33",
+        "vue-i18n": "^9.13.1",
         "vue-virtual-scroller": "^2.0.0-beta.8",
         "vuedraggable": "^4.1.0",
         "xterm": "^4.18.0",
@@ -1501,6 +1502,47 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@intlify/core-base": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/@intlify/core-base/-/core-base-9.13.1.tgz",
+      "integrity": "sha512-+bcQRkJO9pcX8d0gel9ZNfrzU22sZFSA0WVhfXrf5jdJOS24a+Bp8pozuS9sBI9Hk/tGz83pgKfmqcn/Ci7/8w==",
+      "dependencies": {
+        "@intlify/message-compiler": "9.13.1",
+        "@intlify/shared": "9.13.1"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/kazupon"
+      }
+    },
+    "node_modules/@intlify/message-compiler": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/@intlify/message-compiler/-/message-compiler-9.13.1.tgz",
+      "integrity": "sha512-SKsVa4ajYGBVm7sHMXd5qX70O2XXjm55zdZB3VeMFCvQyvLew/dLvq3MqnaIsTMF1VkkOb9Ttr6tHcMlyPDL9w==",
+      "dependencies": {
+        "@intlify/shared": "9.13.1",
+        "source-map-js": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/kazupon"
+      }
+    },
+    "node_modules/@intlify/shared": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/@intlify/shared/-/shared-9.13.1.tgz",
+      "integrity": "sha512-u3b6BKGhE6j/JeRU6C/RL2FgyJfy6LakbtfeVF8fJXURpZZTzfh3e05J0bu0XPw447Q6/WUp3C4ajv4TMS4YsQ==",
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/kazupon"
+      }
+    },
     "node_modules/@isaacs/cliui": {
       "version": "8.0.2",
       "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
@@ -2789,6 +2831,11 @@
         "@vue/shared": "3.4.33"
       }
     },
+    "node_modules/@vue/devtools-api": {
+      "version": "6.6.3",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.3.tgz",
+      "integrity": "sha512-0MiMsFma/HqA6g3KLKn+AGpL1kgKhFWszC9U29NfpWK5LE7bjeXxySWJrOJ77hBz+TBrBQ7o4QJqbPbqbs8rJw=="
+    },
     "node_modules/@vue/reactivity": {
       "version": "3.4.33",
       "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.4.33.tgz",
@@ -11053,6 +11100,25 @@
       "integrity": "sha512-hoK0UsKXrXDY9zdpdk+drqOqYHpPhbmfQUJ2mFYK57+l73mQxcYyCteQsolllwGaxhWihT077+OA/FR5ZPTceg==",
       "dev": true
     },
+    "node_modules/vue-i18n": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/vue-i18n/-/vue-i18n-9.13.1.tgz",
+      "integrity": "sha512-mh0GIxx0wPtPlcB1q4k277y0iKgo25xmDPWioVVYanjPufDBpvu5ySTjP5wOrSvlYQ2m1xI+CFhGdauv/61uQg==",
+      "dependencies": {
+        "@intlify/core-base": "9.13.1",
+        "@intlify/shared": "9.13.1",
+        "@vue/devtools-api": "^6.5.0"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/kazupon"
+      },
+      "peerDependencies": {
+        "vue": "^3.0.0"
+      }
+    },
     "node_modules/vue-loader": {
       "version": "17.4.2",
       "resolved": "https://registry.npmjs.org/vue-loader/-/vue-loader-17.4.2.tgz",
@@ -12810,6 +12876,29 @@
       "integrity": "sha512-HyYEUDeIj5rRQU2Hk5HTB2uHsbRQpF70nvMhVzi+VJR0X+xNEhjPui4/kBf3VeH/wqD28PT4sVOm8qqLjBrSZg==",
       "dev": true
     },
+    "@intlify/core-base": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/@intlify/core-base/-/core-base-9.13.1.tgz",
+      "integrity": "sha512-+bcQRkJO9pcX8d0gel9ZNfrzU22sZFSA0WVhfXrf5jdJOS24a+Bp8pozuS9sBI9Hk/tGz83pgKfmqcn/Ci7/8w==",
+      "requires": {
+        "@intlify/message-compiler": "9.13.1",
+        "@intlify/shared": "9.13.1"
+      }
+    },
+    "@intlify/message-compiler": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/@intlify/message-compiler/-/message-compiler-9.13.1.tgz",
+      "integrity": "sha512-SKsVa4ajYGBVm7sHMXd5qX70O2XXjm55zdZB3VeMFCvQyvLew/dLvq3MqnaIsTMF1VkkOb9Ttr6tHcMlyPDL9w==",
+      "requires": {
+        "@intlify/shared": "9.13.1",
+        "source-map-js": "^1.0.2"
+      }
+    },
+    "@intlify/shared": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/@intlify/shared/-/shared-9.13.1.tgz",
+      "integrity": "sha512-u3b6BKGhE6j/JeRU6C/RL2FgyJfy6LakbtfeVF8fJXURpZZTzfh3e05J0bu0XPw447Q6/WUp3C4ajv4TMS4YsQ=="
+    },
     "@isaacs/cliui": {
       "version": "8.0.2",
       "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
@@ -13866,6 +13955,11 @@
         "@vue/shared": "3.4.33"
       }
     },
+    "@vue/devtools-api": {
+      "version": "6.6.3",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.3.tgz",
+      "integrity": "sha512-0MiMsFma/HqA6g3KLKn+AGpL1kgKhFWszC9U29NfpWK5LE7bjeXxySWJrOJ77hBz+TBrBQ7o4QJqbPbqbs8rJw=="
+    },
     "@vue/reactivity": {
       "version": "3.4.33",
       "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.4.33.tgz",
@@ -20028,6 +20122,16 @@
       "integrity": "sha512-hoK0UsKXrXDY9zdpdk+drqOqYHpPhbmfQUJ2mFYK57+l73mQxcYyCteQsolllwGaxhWihT077+OA/FR5ZPTceg==",
       "dev": true
     },
+    "vue-i18n": {
+      "version": "9.13.1",
+      "resolved": "https://registry.npmjs.org/vue-i18n/-/vue-i18n-9.13.1.tgz",
+      "integrity": "sha512-mh0GIxx0wPtPlcB1q4k277y0iKgo25xmDPWioVVYanjPufDBpvu5ySTjP5wOrSvlYQ2m1xI+CFhGdauv/61uQg==",
+      "requires": {
+        "@intlify/core-base": "9.13.1",
+        "@intlify/shared": "9.13.1",
+        "@vue/devtools-api": "^6.5.0"
+      }
+    },
     "vue-loader": {
       "version": "17.4.2",
       "resolved": "https://registry.npmjs.org/vue-loader/-/vue-loader-17.4.2.tgz",
diff --git a/package.json b/package.json
index 41f97dcec9..8378326fae 100644
--- a/package.json
+++ b/package.json
@@ -31,6 +31,7 @@
     "sortablejs": "^1.13.0",
     "tiny-emitter": "^2.1.0",
     "vue": "3.4.33",
+    "vue-i18n": "^9.13.1",
     "vue-virtual-scroller": "^2.0.0-beta.8",
     "vuedraggable": "^4.1.0",
     "xterm": "^4.18.0",
diff --git a/test/services/datamodel/SqlEntityTypeMetadataServiceSpec.scala b/test/services/datamodel/SqlEntityTypeMetadataServiceSpec.scala
index ce79ab3d8f..7e2da92713 100644
--- a/test/services/datamodel/SqlEntityTypeMetadataServiceSpec.scala
+++ b/test/services/datamodel/SqlEntityTypeMetadataServiceSpec.scala
@@ -46,8 +46,11 @@ class SqlEntityTypeMetadataServiceSpec extends IntegrationTestRunner {
     }
 
     "locate fields by entity type" in new DBTestApp("entity-type-metadata-fixtures.sql") {
-      val ds = await(service.listFields(Some(EntityType.Repository)))
-      ds.size must_== 1
+      val ds = await(service.listEntityTypeFields(EntityType.Repository))
+      ds.fieldMetadata.size must_== 1
+      ds.fieldMetadata.get("history") must beSome.which { (d:FieldMetadata) =>
+        d.name must_== "History"
+      }
     }
 
     "get fields" in new DBTestApp("entity-type-metadata-fixtures.sql") {