chore(release): 3.0.0-alpha.8

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [3.0.0-alpha.8](https://github.com/nuxt/vue-meta/compare/v3.0.0-alpha.7...v3.0.0-alpha.8) (2021-06-06)
+
+
+### Features
+
+* add plugin for options api support ([0745f16](https://github.com/nuxt/vue-meta/commit/0745f1668388c85d9a4eb50a26a350f8278b490c))
+
+
+### Bug Fixes
+
+* remove unsupported meta types from v2 ([1bf1184](https://github.com/nuxt/vue-meta/commit/1bf1184c6e1ffe488c17b75ac54b7711d84f8fd9))
+
 ## [3.0.0-alpha.7](https://github.com/nuxt/vue-meta/compare/v3.0.0-alpha.6...v3.0.0-alpha.7) (2021-05-23)
 
 

dist/vue-meta.cjs.js

@@ -1,5 +1,5 @@
 /**
- * vue-meta v3.0.0-alpha.7
+ * vue-meta v3.0.0-alpha.8
  * (c) 2021
  * - Pim (@pimlie)
  * - All the amazing contributors
@@ -799,9 +799,12 @@ function addVnode(isSSR, teleports, to, vnodes) {
 }
 const createMetaManager = (isSSR = false, config, resolver) => MetaManager.create(isSSR, config || defaultConfig, resolver || defaultResolver);
 class MetaManager {
+    isSSR = false;
+    config;
+    target;
+    resolver;
+    ssrCleanedUp = false;
     constructor(isSSR, config, target, resolver) {
-        this.isSSR = false;
-        this.ssrCleanedUp = false;
         this.isSSR = isSSR;
         this.config = config;
         this.target = target;
@@ -809,6 +812,19 @@ class MetaManager {
             this.resolver = resolver;
         }
     }
+    static create = (isSSR, config, resolver) => {
+        const resolve = (options, contexts, active, key, pathSegments) => {
+            if (isFunction(resolver)) {
+                return resolver(options, contexts, active, key, pathSegments);
+            }
+            return resolver.resolve(options, contexts, active, key, pathSegments);
+        };
+        const active = vue.reactive({});
+        const mergedObject = createMergedObject(resolve, active);
+        // TODO: validate resolver
+        const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        return manager;
+    };
     install(app) {
         app.component('Metainfo', Metainfo);
         app.config.globalProperties.$metaManager = this;
@@ -932,25 +948,37 @@ class MetaManager {
             return vue.h(vue.Teleport, { to }, teleport);
         });
     }
-}
+}
-MetaManager.create = (isSSR, config, resolver) => {
+
-    const resolve = (options, contexts, active, key, pathSegments) => {
+const defaultOptions = {
-        if (isFunction(resolver)) {
+    keyName: 'metaInfo'
-            return resolver(options, contexts, active, key, pathSegments);
+};
+const createMixin = options => ({
+    created() {
+        const instance = vue.getCurrentInstance();
+        if (!instance?.type || !(options.keyName in instance.type)) {
+            return;
         }
-        return resolver.resolve(options, contexts, active, key, pathSegments);
+        const metaInfo = instance.type[options.keyName];
-    };
+        if (isFunction(metaInfo)) {
-    const active = vue.reactive({});
+            const computedMetaInfo = vue.computed(metaInfo);
-    const mergedObject = createMergedObject(resolve, active);
+            useMeta(computedMetaInfo);
-    // TODO: validate resolver
+        }
-    const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        else {
-    return manager;
+            useMeta(metaInfo);
+        }
+    }
+});
+const install = (app, _options = {}) => {
+    const options = Object.assign({}, defaultOptions, _options);
+    app.mixin(createMixin(options));
 };
 
 exports.createMetaManager = createMetaManager;
 exports.deepestResolver = defaultResolver;
 exports.defaultConfig = defaultConfig;
 exports.getCurrentManager = getCurrentManager;
+exports.plugin = install;
 exports.resolveOption = resolveOption;
 exports.useActiveMeta = useActiveMeta;
 exports.useMeta = useMeta;

dist/vue-meta.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
- * vue-meta v3.0.0-alpha.7
+ * vue-meta v3.0.0-alpha.8
  * (c) 2021
  * - Pim (@pimlie)
  * - All the amazing contributors
@@ -779,9 +779,12 @@ function addVnode(isSSR, teleports, to, vnodes) {
 }
 const createMetaManager = (isSSR = false, config, resolver) => MetaManager.create(isSSR, config || defaultConfig, resolver || defaultResolver);
 class MetaManager {
+    isSSR = false;
+    config;
+    target;
+    resolver;
+    ssrCleanedUp = false;
     constructor(isSSR, config, target, resolver) {
-        this.isSSR = false;
-        this.ssrCleanedUp = false;
         this.isSSR = isSSR;
         this.config = config;
         this.target = target;
@@ -789,6 +792,19 @@ class MetaManager {
             this.resolver = resolver;
         }
     }
+    static create = (isSSR, config, resolver) => {
+        const resolve = (options, contexts, active, key, pathSegments) => {
+            if (isFunction(resolver)) {
+                return resolver(options, contexts, active, key, pathSegments);
+            }
+            return resolver.resolve(options, contexts, active, key, pathSegments);
+        };
+        const active = vue.reactive({});
+        const mergedObject = createMergedObject(resolve, active);
+        // TODO: validate resolver
+        const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        return manager;
+    };
     install(app) {
         app.component('Metainfo', Metainfo);
         app.config.globalProperties.$metaManager = this;
@@ -912,25 +928,37 @@ class MetaManager {
             return vue.h(vue.Teleport, { to }, teleport);
         });
     }
-}
+}
-MetaManager.create = (isSSR, config, resolver) => {
+
-    const resolve = (options, contexts, active, key, pathSegments) => {
+const defaultOptions = {
-        if (isFunction(resolver)) {
+    keyName: 'metaInfo'
-            return resolver(options, contexts, active, key, pathSegments);
+};
+const createMixin = options => ({
+    created() {
+        const instance = vue.getCurrentInstance();
+        if (!instance?.type || !(options.keyName in instance.type)) {
+            return;
         }
-        return resolver.resolve(options, contexts, active, key, pathSegments);
+        const metaInfo = instance.type[options.keyName];
-    };
+        if (isFunction(metaInfo)) {
-    const active = vue.reactive({});
+            const computedMetaInfo = vue.computed(metaInfo);
-    const mergedObject = createMergedObject(resolve, active);
+            useMeta(computedMetaInfo);
-    // TODO: validate resolver
+        }
-    const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        else {
-    return manager;
+            useMeta(metaInfo);
+        }
+    }
+});
+const install = (app, _options = {}) => {
+    const options = Object.assign({}, defaultOptions, _options);
+    app.mixin(createMixin(options));
 };
 
 exports.createMetaManager = createMetaManager;
 exports.deepestResolver = defaultResolver;
 exports.defaultConfig = defaultConfig;
 exports.getCurrentManager = getCurrentManager;
+exports.plugin = install;
 exports.resolveOption = resolveOption;
 exports.useActiveMeta = useActiveMeta;
 exports.useMeta = useMeta;

dist/vue-meta.d.ts

@@ -1,5 +1,5 @@
 /**
- * vue-meta v3.0.0-alpha.7
+ * vue-meta v3.0.0-alpha.8
  * (c) 2021
  * - Pim (@pimlie)
  * - All the amazing contributors
@@ -64,6 +64,110 @@ declare class MetaManager {
     }): VNode[];
 }
 
+interface AttributeProperty {
+    [key: string]: string | string[];
+}
+interface MetaDataProperty {
+    vmid?: string;
+    once?: boolean;
+    skip?: boolean;
+    body?: boolean;
+    pbody?: boolean;
+    [key: string]: any;
+}
+interface MetaPropertyCharset extends MetaDataProperty {
+    charset: string;
+}
+interface MetaPropertyEquiv extends MetaDataProperty {
+    httpEquiv: string;
+    content: string;
+}
+interface MetaPropertyTrueEquiv extends MetaDataProperty {
+    'http-equiv': string;
+    content: string;
+}
+interface MetaPropertyName extends MetaDataProperty {
+    name: string;
+    content: string;
+}
+interface MetaPropertyMicrodata extends MetaDataProperty {
+    itemprop: string;
+    content: string;
+}
+interface MetaPropertyProperty extends MetaDataProperty {
+    property: string;
+    content: string;
+}
+interface LinkPropertyBase extends MetaDataProperty {
+    rel: string;
+    crossOrigin?: string | null;
+    media?: string;
+    nonce?: string;
+    referrerPolicy?: string;
+    rev?: string;
+    type?: string;
+}
+interface LinkPropertyHref extends LinkPropertyBase {
+    href?: string;
+    hreflang?: string;
+    callback?: void;
+}
+interface LinkPropertyHrefCallback extends LinkPropertyBase {
+    vmid: string;
+    href?: string;
+    hreflang?: string;
+}
+interface StyleProperty extends MetaDataProperty {
+    cssText: string;
+    media?: string;
+    nonce?: string;
+    type?: string;
+}
+interface ScriptPropertyBase extends MetaDataProperty {
+    type?: string;
+    charset?: string;
+    async?: boolean;
+    defer?: boolean;
+    crossOrigin?: string;
+    nonce?: string;
+}
+interface ScriptPropertyText extends ScriptPropertyBase {
+    innerHTML: string;
+}
+interface ScriptPropertySrc extends ScriptPropertyBase {
+    src: string;
+    callback?: void;
+}
+interface ScriptPropertySrcCallback extends ScriptPropertyBase {
+    vmid: string;
+}
+declare type JsonVal = string | number | boolean | JsonObj | JsonObj[] | null;
+interface JsonObj {
+    [key: string]: JsonVal | JsonVal[];
+}
+interface ScriptPropertyJson extends ScriptPropertyBase {
+    json: JsonObj;
+}
+interface NoScriptProperty extends MetaDataProperty {
+    innerHTML: string;
+}
+interface ComponentMetaInfo {
+    title?: string;
+    htmlAttrs?: AttributeProperty;
+    headAttrs?: AttributeProperty;
+    bodyAttrs?: AttributeProperty;
+    base?: {
+        target: string;
+        href: string;
+    };
+    meta?: (MetaPropertyCharset | MetaPropertyEquiv | MetaPropertyTrueEquiv | MetaPropertyName | MetaPropertyMicrodata | MetaPropertyProperty)[];
+    link?: (LinkPropertyBase | LinkPropertyHref | LinkPropertyHrefCallback)[];
+    style?: StyleProperty[];
+    script?: (ScriptPropertyText | ScriptPropertySrc | ScriptPropertySrcCallback | ScriptPropertyJson)[];
+    noscript?: NoScriptProperty[];
+}
+declare type ComponentOptionsMetaInfo = ComponentMetaInfo | (() => ComponentMetaInfo);
+
 declare type MetaConfigSectionKey = 'tag' | 'to' | 'keyAttribute' | 'valueAttribute' | 'nameless' | 'group' | 'namespaced' | 'namespacedAttribute' | 'attributesFor';
 interface MetaConfigSectionTag {
     tag?: string;
@@ -191,6 +295,9 @@ declare module '@vue/runtime-core' {
         $metaManager: MetaManager;
         $metaGuards: MetaGuards;
     }
+    interface ComponentCustomOptions {
+        metaInfo?: ComponentOptionsMetaInfo;
+    }
 }
 
 declare const setup: MetaResolveSetup;
@@ -207,6 +314,11 @@ declare namespace deepest_d {
 
 declare const defaultConfig: MetaConfig;
 
+declare type PluginOptions = {
+    keyName: string;
+};
+declare const install: (app: App, _options?: Partial<PluginOptions>) => void;
+
 interface ResolveOptionPredicament<T, U> {
     (currentValue: T | undefined, context: U): T;
 }
@@ -216,4 +328,4 @@ declare function getCurrentManager(vm?: ComponentInternalInstance): MetaManager
 declare function useMeta(source: MetaSource, manager?: MetaManager): MetaProxy;
 declare function useActiveMeta(): MetaActive;
 
-export { ExcludesFalsy, MetaActive, MetaConfig, MetaConfigSection, MetaConfigSectionAttribute, MetaConfigSectionGroup, MetaConfigSectionKey, MetaConfigSectionTag, MetaGroupConfig, MetaGuardRemoved, MetaGuards, MetaProxy, MetaRenderContext, MetaRendered, MetaRenderedNode, MetaResolveContext, MetaResolveSetup, MetaResolver, MetaResolverSetup, MetaSource, MetaSourceProxy, MetaTagConfig, MetaTagConfigKey, MetaTagName, MetaTagsConfig, MetaTeleports, Modify, SlotScopeProperties, TODO, Truthy, createMetaManager, deepest_d as deepestResolver, defaultConfig, getCurrentManager, resolveOption, useActiveMeta, useMeta };
+export { ExcludesFalsy, MetaActive, MetaConfig, MetaConfigSection, MetaConfigSectionAttribute, MetaConfigSectionGroup, MetaConfigSectionKey, MetaConfigSectionTag, MetaGroupConfig, MetaGuardRemoved, MetaGuards, MetaProxy, MetaRenderContext, MetaRendered, MetaRenderedNode, MetaResolveContext, MetaResolveSetup, MetaResolver, MetaResolverSetup, MetaSource, MetaSourceProxy, MetaTagConfig, MetaTagConfigKey, MetaTagName, MetaTagsConfig, MetaTeleports, Modify, SlotScopeProperties, TODO, Truthy, createMetaManager, deepest_d as deepestResolver, defaultConfig, getCurrentManager, install as plugin, resolveOption, useActiveMeta, useMeta };

dist/vue-meta.esm-browser.js

@@ -1,12 +1,12 @@
 /**
- * vue-meta v3.0.0-alpha.7
+ * vue-meta v3.0.0-alpha.8
  * (c) 2021
  * - Pim (@pimlie)
  * - All the amazing contributors
  * @license MIT
  */
 
-import { markRaw, h, getCurrentInstance, isProxy, watch, inject, defineComponent, onUnmounted, Teleport, reactive, Comment } from 'vue';
+import { markRaw, h, getCurrentInstance, isProxy, watch, inject, defineComponent, reactive, onUnmounted, Teleport, Comment, computed } from 'vue';
 
 const resolveOption = (predicament, initialValue) => (options, contexts) => {
     let resolvedIndex = -1;
@@ -795,9 +795,12 @@ function addVnode(isSSR, teleports, to, vnodes) {
 }
 const createMetaManager = (isSSR = false, config, resolver) => MetaManager.create(isSSR, config || defaultConfig, resolver || defaultResolver);
 class MetaManager {
+    isSSR = false;
+    config;
+    target;
+    resolver;
+    ssrCleanedUp = false;
     constructor(isSSR, config, target, resolver) {
-        this.isSSR = false;
-        this.ssrCleanedUp = false;
         this.isSSR = isSSR;
         this.config = config;
         this.target = target;
@@ -805,6 +808,19 @@ class MetaManager {
             this.resolver = resolver;
         }
     }
+    static create = (isSSR, config, resolver) => {
+        const resolve = (options, contexts, active, key, pathSegments) => {
+            if (isFunction(resolver)) {
+                return resolver(options, contexts, active, key, pathSegments);
+            }
+            return resolver.resolve(options, contexts, active, key, pathSegments);
+        };
+        const active = reactive({});
+        const mergedObject = createMergedObject(resolve, active);
+        // TODO: validate resolver
+        const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        return manager;
+    };
     install(app) {
         app.component('Metainfo', Metainfo);
         app.config.globalProperties.$metaManager = this;
@@ -928,19 +944,30 @@ class MetaManager {
             return h(Teleport, { to }, teleport);
         });
     }
-}
+}
-MetaManager.create = (isSSR, config, resolver) => {
+
-    const resolve = (options, contexts, active, key, pathSegments) => {
+const defaultOptions = {
-        if (isFunction(resolver)) {
+    keyName: 'metaInfo'
-            return resolver(options, contexts, active, key, pathSegments);
+};
+const createMixin = options => ({
+    created() {
+        const instance = getCurrentInstance();
+        if (!instance?.type || !(options.keyName in instance.type)) {
+            return;
         }
-        return resolver.resolve(options, contexts, active, key, pathSegments);
+        const metaInfo = instance.type[options.keyName];
-    };
+        if (isFunction(metaInfo)) {
-    const active = reactive({});
+            const computedMetaInfo = computed(metaInfo);
-    const mergedObject = createMergedObject(resolve, active);
+            useMeta(computedMetaInfo);
-    // TODO: validate resolver
+        }
-    const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        else {
-    return manager;
+            useMeta(metaInfo);
+        }
+    }
+});
+const install = (app, _options = {}) => {
+    const options = Object.assign({}, defaultOptions, _options);
+    app.mixin(createMixin(options));
 };
 
-export { createMetaManager, defaultResolver as deepestResolver, defaultConfig, getCurrentManager, resolveOption, useActiveMeta, useMeta };
+export { createMetaManager, defaultResolver as deepestResolver, defaultConfig, getCurrentManager, install as plugin, resolveOption, useActiveMeta, useMeta };

dist/vue-meta.esm-bundler.js

@@ -1,12 +1,12 @@
 /**
- * vue-meta v3.0.0-alpha.7
+ * vue-meta v3.0.0-alpha.8
  * (c) 2021
  * - Pim (@pimlie)
  * - All the amazing contributors
  * @license MIT
  */
 
-import { markRaw, h, getCurrentInstance, isProxy, watch, inject, defineComponent, onUnmounted, Teleport, reactive, Comment } from 'vue';
+import { markRaw, h, getCurrentInstance, isProxy, watch, inject, defineComponent, reactive, onUnmounted, Teleport, Comment, computed } from 'vue';
 
 const resolveOption = (predicament, initialValue) => (options, contexts) => {
     let resolvedIndex = -1;
@@ -795,9 +795,12 @@ function addVnode(isSSR, teleports, to, vnodes) {
 }
 const createMetaManager = (isSSR = false, config, resolver) => MetaManager.create(isSSR, config || defaultConfig, resolver || defaultResolver);
 class MetaManager {
+    isSSR = false;
+    config;
+    target;
+    resolver;
+    ssrCleanedUp = false;
     constructor(isSSR, config, target, resolver) {
-        this.isSSR = false;
-        this.ssrCleanedUp = false;
         this.isSSR = isSSR;
         this.config = config;
         this.target = target;
@@ -805,6 +808,19 @@ class MetaManager {
             this.resolver = resolver;
         }
     }
+    static create = (isSSR, config, resolver) => {
+        const resolve = (options, contexts, active, key, pathSegments) => {
+            if (isFunction(resolver)) {
+                return resolver(options, contexts, active, key, pathSegments);
+            }
+            return resolver.resolve(options, contexts, active, key, pathSegments);
+        };
+        const active = reactive({});
+        const mergedObject = createMergedObject(resolve, active);
+        // TODO: validate resolver
+        const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        return manager;
+    };
     install(app) {
         app.component('Metainfo', Metainfo);
         app.config.globalProperties.$metaManager = this;
@@ -928,19 +944,30 @@ class MetaManager {
             return h(Teleport, { to }, teleport);
         });
     }
-}
+}
-MetaManager.create = (isSSR, config, resolver) => {
+
-    const resolve = (options, contexts, active, key, pathSegments) => {
+const defaultOptions = {
-        if (isFunction(resolver)) {
+    keyName: 'metaInfo'
-            return resolver(options, contexts, active, key, pathSegments);
+};
+const createMixin = options => ({
+    created() {
+        const instance = getCurrentInstance();
+        if (!instance?.type || !(options.keyName in instance.type)) {
+            return;
         }
-        return resolver.resolve(options, contexts, active, key, pathSegments);
+        const metaInfo = instance.type[options.keyName];
-    };
+        if (isFunction(metaInfo)) {
-    const active = reactive({});
+            const computedMetaInfo = computed(metaInfo);
-    const mergedObject = createMergedObject(resolve, active);
+            useMeta(computedMetaInfo);
-    // TODO: validate resolver
+        }
-    const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+        else {
-    return manager;
+            useMeta(metaInfo);
+        }
+    }
+});
+const install = (app, _options = {}) => {
+    const options = Object.assign({}, defaultOptions, _options);
+    app.mixin(createMixin(options));
 };
 
-export { createMetaManager, defaultResolver as deepestResolver, defaultConfig, getCurrentManager, resolveOption, useActiveMeta, useMeta };
+export { createMetaManager, defaultResolver as deepestResolver, defaultConfig, getCurrentManager, install as plugin, resolveOption, useActiveMeta, useMeta };

dist/vue-meta.global.js

@@ -1,5 +1,5 @@
 /**
- * vue-meta v3.0.0-alpha.7
+ * vue-meta v3.0.0-alpha.8
  * (c) 2021
  * - Pim (@pimlie)
  * - All the amazing contributors
@@ -796,9 +796,12 @@ var VueMeta = (function (exports, vue) {
   }
   const createMetaManager = (isSSR = false, config, resolver) => MetaManager.create(isSSR, config || defaultConfig, resolver || defaultResolver);
   class MetaManager {
+      isSSR = false;
+      config;
+      target;
+      resolver;
+      ssrCleanedUp = false;
       constructor(isSSR, config, target, resolver) {
-          this.isSSR = false;
-          this.ssrCleanedUp = false;
           this.isSSR = isSSR;
           this.config = config;
           this.target = target;
@@ -806,6 +809,19 @@ var VueMeta = (function (exports, vue) {
               this.resolver = resolver;
           }
       }
+      static create = (isSSR, config, resolver) => {
+          const resolve = (options, contexts, active, key, pathSegments) => {
+              if (isFunction(resolver)) {
+                  return resolver(options, contexts, active, key, pathSegments);
+              }
+              return resolver.resolve(options, contexts, active, key, pathSegments);
+          };
+          const active = vue.reactive({});
+          const mergedObject = createMergedObject(resolve, active);
+          // TODO: validate resolver
+          const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+          return manager;
+      };
       install(app) {
           app.component('Metainfo', Metainfo);
           app.config.globalProperties.$metaManager = this;
@@ -929,25 +945,37 @@ var VueMeta = (function (exports, vue) {
               return vue.h(vue.Teleport, { to }, teleport);
           });
       }
-  }
+  }
-  MetaManager.create = (isSSR, config, resolver) => {
+
-      const resolve = (options, contexts, active, key, pathSegments) => {
+  const defaultOptions = {
-          if (isFunction(resolver)) {
+      keyName: 'metaInfo'
-              return resolver(options, contexts, active, key, pathSegments);
+  };
+  const createMixin = options => ({
+      created() {
+          const instance = vue.getCurrentInstance();
+          if (!instance?.type || !(options.keyName in instance.type)) {
+              return;
           }
-          return resolver.resolve(options, contexts, active, key, pathSegments);
+          const metaInfo = instance.type[options.keyName];
-      };
+          if (isFunction(metaInfo)) {
-      const active = vue.reactive({});
+              const computedMetaInfo = vue.computed(metaInfo);
-      const mergedObject = createMergedObject(resolve, active);
+              useMeta(computedMetaInfo);
-      // TODO: validate resolver
+          }
-      const manager = new MetaManager(isSSR, config, mergedObject, resolver);
+          else {
-      return manager;
+              useMeta(metaInfo);
+          }
+      }
+  });
+  const install = (app, _options = {}) => {
+      const options = Object.assign({}, defaultOptions, _options);
+      app.mixin(createMixin(options));
   };
 
   exports.createMetaManager = createMetaManager;
   exports.deepestResolver = defaultResolver;
   exports.defaultConfig = defaultConfig;
   exports.getCurrentManager = getCurrentManager;
+  exports.plugin = install;
   exports.resolveOption = resolveOption;
   exports.useActiveMeta = useActiveMeta;
   exports.useMeta = useMeta;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-meta",
-  "version": "3.0.0-alpha.7",
+  "version": "3.0.0-alpha.8",
   "description": "Manage HTML metadata in Vue.js components with SSR support",
   "main": "dist/vue-meta.cjs.js",
   "browser": "dist/vue-meta.esm-browser.min.js",