unhead 1.3.0-beta.0 → 1.3.0-beta.1

package/dist/index.cjs

@@ -257,14 +257,9 @@ function createHeadCore(options = {}) {
   options.plugins.forEach((p) => hooks.addHooks(p.hooks || {}));
   options.document = options.document || (shared.IsBrowser ? document : void 0);
   const ssr = !options.document;
+  const updated = () => hooks.callHook("entries:updated", head);
   let entryCount = 0;
-  let entries = new Proxy([], {
-    set(target, prop, value) {
-      target[prop] = value;
-      hooks.callHook("entries:updated", head);
-      return true;
-    }
-  });
+  let entries = [];
   const head = {
     resolvedOptions: options,
     hooks,
@@ -284,11 +279,15 @@ function createHeadCore(options = {}) {
       const mode = activeEntry?.mode || options.mode;
       if (mode)
         activeEntry.mode = mode;
-      if (options.mode === "server" && ssr || options.mode === "client" && !ssr || !options.mode)
+      if (options.mode === "server" && ssr || options.mode === "client" && !ssr || !options.mode) {
         entries.push(activeEntry);
+        updated();
+      }
       return {
         dispose() {
           entries = entries.filter((e) => e._i !== activeEntry._i);
+          hooks.callHook("entries:updated", head);
+          updated();
         },
         // a patch is the same as creating a new entry, just a nice DX
         patch(input2) {
@@ -298,6 +297,7 @@ function createHeadCore(options = {}) {
             }
             return e;
           });
+          updated();
         }
       };
     },

package/dist/index.d.ts

@@ -1,506 +1,40 @@
 import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateHeadOptions, Unhead, HeadEntryOptions, ActiveHeadEntry, HeadSafe, MetaFlatInput, Title, TitleTemplate } from '@unhead/schema';
-import require$$0 from 'hookable';
-import require$$1 from '@unhead/dom';
-import require$$2 from '@unhead/shared';
+import { Head, CreateHeadOptions, Unhead, HeadEntryOptions, ActiveHeadEntry, HeadSafe, UseSeoMetaInput } from '@unhead/schema';
 export { composableNames } from '@unhead/shared';
 
-declare function createHead$1<T extends {} = Head>(options?: CreateHeadOptions): Unhead<T>;
-declare function createServerHead$1<T extends {} = Head>(options?: CreateHeadOptions): Unhead<T>;
+declare function createHead<T extends {} = Head>(options?: CreateHeadOptions): Unhead<T>;
+declare function createServerHead<T extends {} = Head>(options?: CreateHeadOptions): Unhead<T>;
 /**
  * Creates a core instance of unhead. Does not provide a global ctx for composables to work
  * and does not register DOM plugins.
  *
  * @param options
  */
-declare function createHeadCore$1<T extends {} = Head>(options?: CreateHeadOptions): Unhead<T>;
+declare function createHeadCore<T extends {} = Head>(options?: CreateHeadOptions): Unhead<T>;
 
-declare function HashHydrationPlugin$1(): _unhead_schema.HeadPlugin;
+declare function HashHydrationPlugin(): _unhead_schema.HeadPlugin;
 
-declare function CapoPlugin$1(options: {
+declare function CapoPlugin(options: {
     track?: boolean;
 }): _unhead_schema.HeadPlugin;
 
-declare const unheadComposablesImports$1: {
+declare const unheadComposablesImports: {
     from: string;
     imports: string[];
 }[];
 
-declare function getActiveHead$1(): _unhead_schema.Unhead<any> | undefined;
+declare function getActiveHead(): _unhead_schema.Unhead<any> | undefined;
 
-declare function useHead$1<T extends Head>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
+declare function useHead<T extends Head>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
 
-declare function useHeadSafe$1(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe> | void;
+declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe> | void;
 
-declare function useServerHead$1<T extends Head>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
+declare function useServerHead<T extends Head>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
 
-declare function useServerHeadSafe$1<T extends HeadSafe>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
+declare function useServerHeadSafe<T extends HeadSafe>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
 
-type UseSeoMetaInput = MetaFlatInput & {
-    title?: Title;
-    titleTemplate?: TitleTemplate;
-};
-declare function useSeoMeta$1(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-var dist = {};
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-const hookable = require$$0;
-const dom = require$$1;
-const shared = require$$2;
-
-const UsesMergeStrategy = ["templateParams", "htmlAttrs", "bodyAttrs"];
-const DedupePlugin = shared.defineHeadPlugin({
-  hooks: {
-    "tag:normalise": function({ tag }) {
-      ["hid", "vmid", "key"].forEach((key) => {
-        if (tag.props[key]) {
-          tag.key = tag.props[key];
-          delete tag.props[key];
-        }
-      });
-      const generatedKey = shared.tagDedupeKey(tag);
-      const dedupe = generatedKey || (tag.key ? `${tag.tag}:${tag.key}` : false);
-      if (dedupe)
-        tag._d = dedupe;
-    },
-    "tags:resolve": function(ctx) {
-      const deduping = {};
-      ctx.tags.forEach((tag) => {
-        const dedupeKey = (tag.key ? `${tag.tag}:${tag.key}` : tag._d) || tag._p;
-        const dupedTag = deduping[dedupeKey];
-        if (dupedTag) {
-          let strategy = tag?.tagDuplicateStrategy;
-          if (!strategy && UsesMergeStrategy.includes(tag.tag))
-            strategy = "merge";
-          if (strategy === "merge") {
-            const oldProps = dupedTag.props;
-            ["class", "style"].forEach((key) => {
-              if (tag.props[key] && oldProps[key]) {
-                if (key === "style" && !oldProps[key].endsWith(";"))
-                  oldProps[key] += ";";
-                tag.props[key] = `${oldProps[key]} ${tag.props[key]}`;
-              }
-            });
-            deduping[dedupeKey].props = {
-              ...oldProps,
-              ...tag.props
-            };
-            return;
-          } else if (tag._e === dupedTag._e) {
-            dupedTag._duped = dupedTag._duped || [];
-            tag._d = `${dupedTag._d}:${dupedTag._duped.length + 1}`;
-            dupedTag._duped.push(tag);
-            return;
-          } else if (shared.tagWeight(tag) > shared.tagWeight(dupedTag)) {
-            return;
-          }
-        }
-        const propCount = Object.keys(tag.props).length + (tag.innerHTML ? 1 : 0) + (tag.textContent ? 1 : 0);
-        if (shared.HasElementTags.includes(tag.tag) && propCount === 0) {
-          delete deduping[dedupeKey];
-          return;
-        }
-        deduping[dedupeKey] = tag;
-      });
-      const newTags = [];
-      Object.values(deduping).forEach((tag) => {
-        const dupes = tag._duped;
-        delete tag._duped;
-        newTags.push(tag);
-        if (dupes)
-          newTags.push(...dupes);
-      });
-      ctx.tags = newTags;
-    }
-  }
-});
-
-const ValidEventTags = ["script", "link", "bodyAttrs"];
-function stripEventHandlers(tag) {
-  const props = {};
-  const eventHandlers = {};
-  Object.entries(tag.props).forEach(([key, value]) => {
-    if (key.startsWith("on") && typeof value === "function")
-      eventHandlers[key] = value;
-    else
-      props[key] = value;
-  });
-  return { props, eventHandlers };
-}
-const EventHandlersPlugin = shared.defineHeadPlugin({
-  hooks: {
-    "ssr:render": function(ctx) {
-      ctx.tags = ctx.tags.map((tag) => {
-        if (!ValidEventTags.includes(tag.tag))
-          return tag;
-        if (!Object.entries(tag.props).find(([key, value]) => key.startsWith("on") && typeof value === "function"))
-          return tag;
-        tag.props = stripEventHandlers(tag).props;
-        return tag;
-      });
-    },
-    "tags:resolve": function(ctx) {
-      ctx.tags = ctx.tags.map((tag) => {
-        if (!ValidEventTags.includes(tag.tag))
-          return tag;
-        const { props, eventHandlers } = stripEventHandlers(tag);
-        if (Object.keys(eventHandlers).length) {
-          tag.props = props;
-          tag._eventHandlers = eventHandlers;
-        }
-        return tag;
-      });
-    },
-    "dom:renderTag": function(ctx, dom, track) {
-      if (!ctx.tag._eventHandlers)
-        return;
-      const $eventListenerTarget = ctx.tag.tag === "bodyAttrs" ? dom.defaultView : ctx.$el;
-      Object.entries(ctx.tag._eventHandlers).forEach(([k, value]) => {
-        const sdeKey = `${ctx.tag._d || ctx.tag._p}:${k}`;
-        const eventName = k.slice(2).toLowerCase();
-        const eventDedupeKey = `data-h-${eventName}`;
-        track(ctx.id, sdeKey, () => {
-        });
-        if (ctx.$el.hasAttribute(eventDedupeKey))
-          return;
-        const handler = value;
-        ctx.$el.setAttribute(eventDedupeKey, "");
-        $eventListenerTarget.addEventListener(eventName, handler);
-        if (ctx.entry) {
-          track(ctx.id, sdeKey, () => {
-            $eventListenerTarget.removeEventListener(eventName, handler);
-            ctx.$el.removeAttribute(eventDedupeKey);
-          });
-        }
-      });
-    }
-  }
-});
-
-const DupeableTags = ["link", "style", "script", "noscript"];
-const HashKeyedPLugin = shared.defineHeadPlugin({
-  hooks: {
-    "tag:normalise": ({ tag }) => {
-      if (tag.key && DupeableTags.includes(tag.tag)) {
-        tag.props["data-hid"] = tag._h = shared.hashCode(tag.key);
-      }
-    }
-  }
-});
-
-const SortPLugin = shared.defineHeadPlugin({
-  hooks: {
-    "tags:resolve": (ctx) => {
-      const tagPositionForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
-      for (const { prefix, offset } of shared.SortModifiers) {
-        for (const tag of ctx.tags.filter((tag2) => typeof tag2.tagPriority === "string" && tag2.tagPriority.startsWith(prefix))) {
-          const position = tagPositionForKey(
-            tag.tagPriority.replace(prefix, "")
-          );
-          if (typeof position !== "undefined")
-            tag._p = position + offset;
-        }
-      }
-      ctx.tags.sort((a, b) => a._p - b._p).sort((a, b) => shared.tagWeight(a) - shared.tagWeight(b));
-    }
-  }
-});
-
-const TemplateParamsPlugin = shared.defineHeadPlugin({
-  hooks: {
-    "tags:resolve": (ctx) => {
-      const { tags } = ctx;
-      const title = tags.find((tag) => tag.tag === "title")?.textContent;
-      const idx = tags.findIndex((tag) => tag.tag === "templateParams");
-      const params = idx !== -1 ? tags[idx].props : {};
-      params.separator = params.separator || "|";
-      params.pageTitle = shared.processTemplateParams(params.pageTitle || title || "", params);
-      for (const tag of tags) {
-        if (["titleTemplate", "title"].includes(tag.tag) && typeof tag.textContent === "string") {
-          tag.textContent = shared.processTemplateParams(tag.textContent, params);
-        } else if (tag.tag === "meta" && typeof tag.props.content === "string") {
-          tag.props.content = shared.processTemplateParams(tag.props.content, params);
-        } else if (tag.tag === "link" && typeof tag.props.href === "string") {
-          tag.props.href = shared.processTemplateParams(tag.props.href, params);
-        } else if (tag.tag === "script" && ["application/json", "application/ld+json"].includes(tag.props.type) && typeof tag.innerHTML === "string") {
-          try {
-            tag.innerHTML = JSON.stringify(JSON.parse(tag.innerHTML), (key, val) => {
-              if (typeof val === "string")
-                return shared.processTemplateParams(val, params);
-              return val;
-            });
-          } catch {
-          }
-        }
-      }
-      ctx.tags = tags.filter((tag) => tag.tag !== "templateParams");
-    }
-  }
-});
-
-const TitleTemplatePlugin = shared.defineHeadPlugin({
-  hooks: {
-    "tags:resolve": (ctx) => {
-      const { tags } = ctx;
-      let titleTemplateIdx = tags.findIndex((i) => i.tag === "titleTemplate");
-      const titleIdx = tags.findIndex((i) => i.tag === "title");
-      if (titleIdx !== -1 && titleTemplateIdx !== -1) {
-        const newTitle = shared.resolveTitleTemplate(
-          tags[titleTemplateIdx].textContent,
-          tags[titleIdx].textContent
-        );
-        if (newTitle !== null) {
-          tags[titleIdx].textContent = newTitle || tags[titleIdx].textContent;
-        } else {
-          delete tags[titleIdx];
-        }
-      } else if (titleTemplateIdx !== -1) {
-        const newTitle = shared.resolveTitleTemplate(
-          tags[titleTemplateIdx].textContent
-        );
-        if (newTitle !== null) {
-          tags[titleTemplateIdx].textContent = newTitle;
-          tags[titleTemplateIdx].tag = "title";
-          titleTemplateIdx = -1;
-        }
-      }
-      if (titleTemplateIdx !== -1) {
-        delete tags[titleTemplateIdx];
-      }
-      ctx.tags = tags.filter(Boolean);
-    }
-  }
-});
-
-let activeHead;
-function createHead(options = {}) {
-  const head = createHeadCore(options);
-  if (!head.ssr)
-    head.use(dom.PatchDomOnEntryUpdatesPlugin());
-  return activeHead = head;
-}
-function createServerHead(options = {}) {
-  const head = createHeadCore({
-    ...options,
-    mode: "server"
-  });
-  return activeHead = head;
-}
-function createHeadCore(options = {}) {
-  const hooks = hookable.createHooks();
-  hooks.addHooks(options.hooks || {});
-  options.plugins = [
-    DedupePlugin,
-    EventHandlersPlugin,
-    HashKeyedPLugin,
-    SortPLugin,
-    TemplateParamsPlugin,
-    TitleTemplatePlugin,
-    ...options?.plugins || []
-  ];
-  options.plugins.forEach((p) => hooks.addHooks(p.hooks || {}));
-  options.document = options.document || (shared.IsBrowser ? document : void 0);
-  const ssr = !options.document;
-  let entryCount = 0;
-  let entries = new Proxy([], {
-    set(target, prop, value) {
-      target[prop] = value;
-      hooks.callHook("entries:updated", head);
-      return true;
-    }
-  });
-  const head = {
-    resolvedOptions: options,
-    hooks,
-    headEntries() {
-      return entries;
-    },
-    use(plugin) {
-      if (plugin.hooks)
-        hooks.addHooks(plugin.hooks);
-    },
-    push(input, entryOptions) {
-      const activeEntry = {
-        _i: entryCount++,
-        input,
-        ...entryOptions
-      };
-      const mode = activeEntry?.mode || options.mode;
-      if (mode)
-        activeEntry.mode = mode;
-      if (options.mode === "server" && ssr || options.mode === "client" && !ssr || !options.mode)
-        entries.push(activeEntry);
-      return {
-        dispose() {
-          entries = entries.filter((e) => e._i !== activeEntry._i);
-        },
-        // a patch is the same as creating a new entry, just a nice DX
-        patch(input2) {
-          entries = entries.map((e) => {
-            if (e._i === activeEntry._i) {
-              activeEntry.input = e.input = input2;
-            }
-            return e;
-          });
-        }
-      };
-    },
-    async resolveTags() {
-      const resolveCtx = { tags: [], entries: [...entries] };
-      await hooks.callHook("entries:resolve", resolveCtx);
-      for (const entry of resolveCtx.entries) {
-        const resolved = entry.resolvedInput || entry.input;
-        entry.resolvedInput = await (entry.transform ? entry.transform(resolved) : resolved);
-        if (entry.resolvedInput) {
-          for (const tag of await shared.normaliseEntryTags(entry)) {
-            const tagCtx = { tag, entry, resolvedOptions: head.resolvedOptions };
-            await hooks.callHook("tag:normalise", tagCtx);
-            resolveCtx.tags.push(tagCtx.tag);
-          }
-        }
-      }
-      await hooks.callHook("tags:beforeResolve", resolveCtx);
-      await hooks.callHook("tags:resolve", resolveCtx);
-      return resolveCtx.tags;
-    },
-    ssr
-  };
-  head.hooks.callHook("init", head);
-  return head;
-}
-
-function HashHydrationPlugin() {
-  let prevHash = false;
-  let dirty = false;
-  let head;
-  return shared.defineHeadPlugin({
-    hooks: {
-      "init": function(_head) {
-        head = _head;
-        prevHash = head.resolvedOptions.document?.head.querySelector('meta[name="unhead:ssr"]')?.getAttribute("content") || false;
-      },
-      "tags:resolve": function({ tags }) {
-        const hash = shared.hashCode(
-          tags.filter((tag) => {
-            const entry = head.headEntries().find((e) => e._i === tag._e);
-            return entry && entry.mode !== "server";
-          }).map((tag) => shared.hashTag(tag)).join("")
-        );
-        if (prevHash !== hash && prevHash !== false)
-          dirty = true;
-        else
-          prevHash = hash;
-      },
-      "dom:beforeRender": function(ctx) {
-        ctx.shouldRender = dirty;
-        dirty = false;
-      },
-      "ssr:render": function({ tags }) {
-        tags.push({ tag: "meta", props: { name: "unhead:ssr", content: String(prevHash) } });
-      }
-    }
-  });
-}
-
-const importRe = /@import/;
-function CapoPlugin(options) {
-  return shared.defineHeadPlugin({
-    hooks: {
-      "tags:beforeResolve": function({ tags }) {
-        for (const tag of tags) {
-          if (tag.tagPriority || tag.tagPosition && tag.tagPosition !== "head")
-            continue;
-          const isTruthy = (val) => val === "";
-          const isScript = tag.tag === "script";
-          const isLink = tag.tag === "link";
-          if (isScript && isTruthy(tag.props.async)) {
-            tag.tagPriority = 3;
-          } else if (tag.tag === "style" && tag.innerHTML && importRe.test(tag.innerHTML)) {
-            tag.tagPriority = 4;
-          } else if (isScript && tag.props.src && !isTruthy(tag.props.defer) && !isTruthy(tag.props.async) && tag.props.type !== "module" && !tag.props.type?.endsWith("json")) {
-            tag.tagPriority = 5;
-          } else if (isLink && tag.props.rel === "stylesheet" || tag.tag === "style") {
-            tag.tagPriority = 6;
-          } else if (isLink && ["preload", "modulepreload"].includes(tag.props.rel)) {
-            tag.tagPriority = 7;
-          } else if (isScript && isTruthy(tag.props.defer) && tag.props.src && !isTruthy(tag.props.async)) {
-            tag.tagPriority = 8;
-          } else if (isLink && ["prefetch", "dns-prefetch", "prerender"].includes(tag.props.rel)) {
-            tag.tagPriority = 9;
-          }
-        }
-        options?.track && tags.push({
-          tag: "htmlAttrs",
-          props: {
-            "data-capo": ""
-          }
-        });
-      }
-    }
-  });
-}
-
-const unheadComposablesImports = [
-  {
-    from: "unhead",
-    imports: shared.composableNames
-  }
-];
-
-function getActiveHead() {
-  return activeHead;
-}
-
-function useHead(input, options = {}) {
-  return getActiveHead()?.push(input, options);
-}
-
-function useHeadSafe(input, options = {}) {
-  return useHead(input, {
-    ...options || {},
-    transform: shared.whitelistSafeInput
-  });
-}
-
-function useServerHead(input, options = {}) {
-  return useHead(input, { ...options, mode: "server" });
-}
-
-function useServerHeadSafe(input, options = {}) {
-  return useHeadSafe(input, { ...options, mode: "server" });
-}
-
-function useSeoMeta(input, options) {
-  const { title, titleTemplate, ...meta } = input;
-  return useHead({
-    title,
-    titleTemplate,
-    meta: shared.unpackMeta(meta)
-  }, options);
-}
-
-function useServerSeoMeta$1(input, options) {
-  return useSeoMeta(input, {
-    ...options || {},
-    mode: "server"
-  });
-}
-
-dist.composableNames = shared.composableNames;
-dist.CapoPlugin = CapoPlugin;
-dist.HashHydrationPlugin = HashHydrationPlugin;
-dist.createHead = createHead;
-dist.createHeadCore = createHeadCore;
-dist.createServerHead = createServerHead;
-dist.getActiveHead = getActiveHead;
-dist.unheadComposablesImports = unheadComposablesImports;
-dist.useHead = useHead;
-dist.useHeadSafe = useHeadSafe;
-dist.useSeoMeta = useSeoMeta;
-dist.useServerHead = useServerHead;
-dist.useServerHeadSafe = useServerHeadSafe;
-dist.useServerSeoMeta = useServerSeoMeta$1;
-
-declare function useServerSeoMeta(input: dist.UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
-
-export { CapoPlugin$1 as CapoPlugin, HashHydrationPlugin$1 as HashHydrationPlugin, UseSeoMetaInput, createHead$1 as createHead, createHeadCore$1 as createHeadCore, createServerHead$1 as createServerHead, getActiveHead$1 as getActiveHead, unheadComposablesImports$1 as unheadComposablesImports, useHead$1 as useHead, useHeadSafe$1 as useHeadSafe, useSeoMeta$1 as useSeoMeta, useServerHead$1 as useServerHead, useServerHeadSafe$1 as useServerHeadSafe, useServerSeoMeta };
+export { CapoPlugin, HashHydrationPlugin, createHead, createHeadCore, createServerHead, getActiveHead, unheadComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.mjs

@@ -256,14 +256,9 @@ function createHeadCore(options = {}) {
   options.plugins.forEach((p) => hooks.addHooks(p.hooks || {}));
   options.document = options.document || (IsBrowser ? document : void 0);
   const ssr = !options.document;
+  const updated = () => hooks.callHook("entries:updated", head);
   let entryCount = 0;
-  let entries = new Proxy([], {
-    set(target, prop, value) {
-      target[prop] = value;
-      hooks.callHook("entries:updated", head);
-      return true;
-    }
-  });
+  let entries = [];
   const head = {
     resolvedOptions: options,
     hooks,
@@ -283,11 +278,15 @@ function createHeadCore(options = {}) {
       const mode = activeEntry?.mode || options.mode;
       if (mode)
         activeEntry.mode = mode;
-      if (options.mode === "server" && ssr || options.mode === "client" && !ssr || !options.mode)
+      if (options.mode === "server" && ssr || options.mode === "client" && !ssr || !options.mode) {
         entries.push(activeEntry);
+        updated();
+      }
       return {
         dispose() {
           entries = entries.filter((e) => e._i !== activeEntry._i);
+          hooks.callHook("entries:updated", head);
+          updated();
         },
         // a patch is the same as creating a new entry, just a nice DX
         patch(input2) {
@@ -297,6 +296,7 @@ function createHeadCore(options = {}) {
             }
             return e;
           });
+          updated();
         }
       };
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unhead",
   "type": "module",
-  "version": "1.3.0-beta.0",
+  "version": "1.3.0-beta.1",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/harlan-zw",
@@ -30,9 +30,9 @@
   ],
   "dependencies": {
     "hookable": "^5.5.3",
-    "@unhead/dom": "1.3.0-beta.0",
-    "@unhead/schema": "1.3.0-beta.0",
-    "@unhead/shared": "1.3.0-beta.0"
+    "@unhead/dom": "1.3.0-beta.1",
+    "@unhead/schema": "1.3.0-beta.1",
+    "@unhead/shared": "1.3.0-beta.1"
   },
   "scripts": {
     "build": "unbuild .",