Saving all progress

node_modules/@unhead/vue/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Harlan Wilton <harlan@harlanzw.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@unhead/vue/dist/components.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+const vue = require('vue');
+const injectHead = require('./shared/vue.DWlmwWrc.cjs');
+require('unhead');
+require('@unhead/shared');
+
+function addVNodeToHeadObj(node, obj) {
+  const nodeType = !injectHead.Vue3 ? node.tag : node.type;
+  const type = nodeType === "html" ? "htmlAttrs" : nodeType === "body" ? "bodyAttrs" : nodeType;
+  if (typeof type !== "string" || !(type in obj))
+    return;
+  const nodeData = !injectHead.Vue3 ? node.data : node;
+  const props = (!injectHead.Vue3 ? nodeData.attrs : node.props) || {};
+  if (!injectHead.Vue3) {
+    if (nodeData.staticClass)
+      props.class = nodeData.staticClass;
+    if (nodeData.staticStyle)
+      props.style = Object.entries(nodeData.staticStyle).map(([key, value]) => `${key}:${value}`).join(";");
+  }
+  if (node.children) {
+    const childrenAttr = !injectHead.Vue3 ? "text" : "children";
+    props.children = Array.isArray(node.children) ? node.children[0][childrenAttr] : node[childrenAttr];
+  }
+  if (Array.isArray(obj[type]))
+    obj[type].push(props);
+  else if (type === "title")
+    obj.title = props.children;
+  else
+    obj[type] = props;
+}
+function vnodesToHeadObj(nodes) {
+  const obj = {
+    title: void 0,
+    htmlAttrs: void 0,
+    bodyAttrs: void 0,
+    base: void 0,
+    meta: [],
+    link: [],
+    style: [],
+    script: [],
+    noscript: []
+  };
+  for (const node of nodes) {
+    if (typeof node.type === "symbol" && Array.isArray(node.children)) {
+      for (const childNode of node.children)
+        addVNodeToHeadObj(childNode, obj);
+    } else {
+      addVNodeToHeadObj(node, obj);
+    }
+  }
+  return obj;
+}
+const Head = /* @__PURE__ */ vue.defineComponent({
+  name: "Head",
+  setup(_, { slots }) {
+    const head = injectHead.injectHead();
+    const obj = vue.ref({});
+    const entry = head.push(obj);
+    vue.onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    return () => {
+      vue.watchEffect(() => {
+        if (!slots.default)
+          return;
+        entry.patch(vnodesToHeadObj(slots.default()));
+      });
+      return null;
+    };
+  }
+});
+
+exports.Head = Head;

node_modules/@unhead/vue/dist/components.d.cts

@@ -0,0 +1,5 @@
+import { DefineComponent } from 'vue';
+
+declare const Head: DefineComponent;
+
+export { Head };

node_modules/@unhead/vue/dist/components.d.mts

@@ -0,0 +1,5 @@
+import { DefineComponent } from 'vue';
+
+declare const Head: DefineComponent;
+
+export { Head };

node_modules/@unhead/vue/dist/components.d.ts

@@ -0,0 +1,5 @@
+import { DefineComponent } from 'vue';
+
+declare const Head: DefineComponent;
+
+export { Head };

node_modules/@unhead/vue/dist/components.mjs

@@ -0,0 +1,72 @@
+import { defineComponent, ref, onBeforeUnmount, watchEffect } from 'vue';
+import { i as injectHead, V as Vue3 } from './shared/vue.ziyDaVMR.mjs';
+import 'unhead';
+import '@unhead/shared';
+
+function addVNodeToHeadObj(node, obj) {
+  const nodeType = !Vue3 ? node.tag : node.type;
+  const type = nodeType === "html" ? "htmlAttrs" : nodeType === "body" ? "bodyAttrs" : nodeType;
+  if (typeof type !== "string" || !(type in obj))
+    return;
+  const nodeData = !Vue3 ? node.data : node;
+  const props = (!Vue3 ? nodeData.attrs : node.props) || {};
+  if (!Vue3) {
+    if (nodeData.staticClass)
+      props.class = nodeData.staticClass;
+    if (nodeData.staticStyle)
+      props.style = Object.entries(nodeData.staticStyle).map(([key, value]) => `${key}:${value}`).join(";");
+  }
+  if (node.children) {
+    const childrenAttr = !Vue3 ? "text" : "children";
+    props.children = Array.isArray(node.children) ? node.children[0][childrenAttr] : node[childrenAttr];
+  }
+  if (Array.isArray(obj[type]))
+    obj[type].push(props);
+  else if (type === "title")
+    obj.title = props.children;
+  else
+    obj[type] = props;
+}
+function vnodesToHeadObj(nodes) {
+  const obj = {
+    title: void 0,
+    htmlAttrs: void 0,
+    bodyAttrs: void 0,
+    base: void 0,
+    meta: [],
+    link: [],
+    style: [],
+    script: [],
+    noscript: []
+  };
+  for (const node of nodes) {
+    if (typeof node.type === "symbol" && Array.isArray(node.children)) {
+      for (const childNode of node.children)
+        addVNodeToHeadObj(childNode, obj);
+    } else {
+      addVNodeToHeadObj(node, obj);
+    }
+  }
+  return obj;
+}
+const Head = /* @__PURE__ */ defineComponent({
+  name: "Head",
+  setup(_, { slots }) {
+    const head = injectHead();
+    const obj = ref({});
+    const entry = head.push(obj);
+    onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    return () => {
+      watchEffect(() => {
+        if (!slots.default)
+          return;
+        entry.patch(vnodesToHeadObj(slots.default()));
+      });
+      return null;
+    };
+  }
+});
+
+export { Head };

node_modules/@unhead/vue/dist/index.cjs

@@ -0,0 +1,179 @@
+'use strict';
+
+const unhead = require('unhead');
+const injectHead = require('./shared/vue.DWlmwWrc.cjs');
+const shared = require('@unhead/shared');
+const useHead = require('./shared/vue.BmMjB48i.cjs');
+const vue = require('vue');
+
+const coreComposableNames = [
+  "injectHead"
+];
+const unheadVueComposablesImports = {
+  "@unhead/vue": [...coreComposableNames, ...shared.composableNames]
+};
+
+function useHeadSafe(input, options = {}) {
+  return useHead.useHead(input, { ...options, transform: shared.whitelistSafeInput });
+}
+
+function registerVueScopeHandlers(script, scope) {
+  if (!scope) {
+    return;
+  }
+  const _registerCb = (key, cb) => {
+    if (!script._cbs[key]) {
+      cb(script.instance);
+      return () => {
+      };
+    }
+    let i = script._cbs[key].push(cb);
+    const destroy = () => {
+      if (i) {
+        script._cbs[key]?.splice(i - 1, 1);
+        i = null;
+      }
+    };
+    vue.onScopeDispose(destroy);
+    return destroy;
+  };
+  script.onLoaded = (cb) => _registerCb("loaded", cb);
+  script.onError = (cb) => _registerCb("error", cb);
+  vue.onScopeDispose(() => {
+    script._triggerAbortController?.abort();
+  });
+}
+function useScript(_input, _options) {
+  const input = typeof _input === "string" ? { src: _input } : _input;
+  const options = _options || {};
+  const head = options?.head || injectHead.injectHead();
+  options.head = head;
+  const scope = vue.getCurrentInstance();
+  options.eventContext = scope;
+  if (scope && typeof options.trigger === "undefined") {
+    options.trigger = vue.onMounted;
+  } else if (vue.isRef(options.trigger)) {
+    const refTrigger = options.trigger;
+    let off;
+    options.trigger = new Promise((resolve) => {
+      off = vue.watch(refTrigger, (val) => {
+        if (val) {
+          resolve(true);
+        }
+      }, {
+        immediate: true
+      });
+      vue.onScopeDispose(() => resolve(false), true);
+    }).then((val) => {
+      off?.();
+      return val;
+    });
+  }
+  head._scriptStatusWatcher = head._scriptStatusWatcher || head.hooks.hook("script:updated", ({ script: s }) => {
+    s._statusRef.value = s.status;
+  });
+  const script = unhead.useScript(input, options);
+  script._statusRef = script._statusRef || vue.ref(script.status);
+  registerVueScopeHandlers(script, scope);
+  return new Proxy(script, {
+    get(_, key, a) {
+      return Reflect.get(_, key === "status" ? "_statusRef" : key, a);
+    }
+  });
+}
+
+function useSeoMeta(input, options) {
+  const { title, titleTemplate, ...meta } = input;
+  return useHead.useHead({
+    title,
+    titleTemplate,
+    // @ts-expect-error runtime type
+    _flatMeta: meta
+  }, {
+    ...options,
+    transform(t) {
+      const meta2 = shared.unpackMeta({ ...t._flatMeta });
+      delete t._flatMeta;
+      return {
+        // @ts-expect-error runtime type
+        ...t,
+        meta: meta2
+      };
+    }
+  });
+}
+
+function useServerHead(input, options = {}) {
+  const head = options.head || injectHead.injectHead();
+  delete options.head;
+  if (head)
+    return head.push(input, { ...options, mode: "server" });
+}
+
+function useServerHeadSafe(input, options = {}) {
+  return useHeadSafe(input, { ...options, mode: "server" });
+}
+
+function useServerSeoMeta(input, options) {
+  return useSeoMeta(input, { ...options, mode: "server" });
+}
+
+const Vue2ProvideUnheadPlugin = (_Vue, head) => {
+  _Vue.mixin({
+    beforeCreate() {
+      const options = this.$options;
+      const origProvide = options.provide;
+      options.provide = function() {
+        let origProvideResult;
+        if (typeof origProvide === "function")
+          origProvideResult = origProvide.call(this);
+        else
+          origProvideResult = origProvide || {};
+        return {
+          ...origProvideResult,
+          [injectHead.headSymbol]: head
+        };
+      };
+    }
+  });
+};
+
+const VueHeadMixin = {
+  created() {
+    let source = false;
+    if (injectHead.Vue3) {
+      const instance = vue.getCurrentInstance();
+      if (!instance)
+        return;
+      const options = instance.type;
+      if (!options || !("head" in options))
+        return;
+      source = typeof options.head === "function" ? () => options.head.call(instance.proxy) : options.head;
+    } else {
+      const head = this.$options.head;
+      if (head) {
+        source = typeof head === "function" ? () => head.call(this) : head;
+      }
+    }
+    source && useHead.useHead(source);
+  }
+};
+
+exports.CapoPlugin = unhead.CapoPlugin;
+exports.HashHydrationPlugin = unhead.HashHydrationPlugin;
+exports.createHeadCore = unhead.createHeadCore;
+exports.createHead = injectHead.createHead;
+exports.createServerHead = injectHead.createServerHead;
+exports.injectHead = injectHead.injectHead;
+exports.resolveUnrefHeadInput = injectHead.resolveUnrefHeadInput;
+exports.setHeadInjectionHandler = injectHead.setHeadInjectionHandler;
+exports.useHead = useHead.useHead;
+exports.Vue2ProvideUnheadPlugin = Vue2ProvideUnheadPlugin;
+exports.VueHeadMixin = VueHeadMixin;
+exports.unheadVueComposablesImports = unheadVueComposablesImports;
+exports.useHeadSafe = useHeadSafe;
+exports.useScript = useScript;
+exports.useSeoMeta = useSeoMeta;
+exports.useServerHead = useServerHead;
+exports.useServerHeadSafe = useServerHeadSafe;
+exports.useServerSeoMeta = useServerSeoMeta;

node_modules/@unhead/vue/dist/index.d.cts

@@ -0,0 +1,78 @@
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
+import * as _unhead_schema from '@unhead/schema';
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr, MergeHead, CreateHeadOptions, ActiveHeadEntry, ScriptInstance, UseScriptStatus, ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, UseScriptOptions as UseScriptOptions$1, AsAsyncFunctionValues, UseFunctionType } from '@unhead/schema';
+export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, Unhead } from '@unhead/schema';
+import { R as ReactiveHead, M as MaybeComputedRefEntries, a as MaybeComputedRef, V as VueHeadClient, U as UseHeadInput, b as UseHeadOptions, c as MaybeComputedRefEntriesOnly, d as UseSeoMetaInput } from './shared/vue.fwis0K4Q.cjs';
+export { f as Base, B as BodyAttr, j as BodyAttributes, H as HtmlAttr, i as HtmlAttributes, L as Link, l as MaybeComputedRefOrFalsy, m as MaybeComputedRefOrPromise, k as MaybeReadonlyRef, g as Meta, N as Noscript, h as Script, S as Style, T as Title, e as TitleTemplate } from './shared/vue.fwis0K4Q.cjs';
+import { Ref, Plugin } from 'vue';
+
+interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
+    meta?: MaybeComputedRefEntries<SafeMeta>[];
+    link?: MaybeComputedRefEntries<SafeLink>[];
+    noscript?: MaybeComputedRefEntries<SafeNoscript>[];
+    script?: MaybeComputedRefEntries<SafeScript>[];
+    htmlAttrs?: MaybeComputedRefEntries<SafeHtmlAttr>;
+    bodyAttrs?: MaybeComputedRefEntries<SafeBodyAttr>;
+}
+type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
+
+declare function createServerHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
+declare function createHead<T extends MergeHead>(options?: CreateHeadOptions): VueHeadClient<T>;
+
+declare function resolveUnrefHeadInput(ref: any): any;
+
+declare const unheadVueComposablesImports: {
+    '@unhead/vue': string[];
+};
+
+declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
+declare function injectHead<T extends MergeHead>(): VueHeadClient<T>;
+
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
+
+interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
+    status: Ref<UseScriptStatus>;
+}
+type UseScriptInput = string | (MaybeComputedRefEntriesOnly<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
+    src: string;
+});
+interface UseScriptOptions<T extends Record<symbol | string, any> = {}, U = {}> extends HeadEntryOptions, Pick<UseScriptOptions$1<T, U>, 'use' | 'stub' | 'eventContext' | 'beforeInit'> {
+    /**
+     * The trigger to load the script:
+     * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
+     * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
+     * - `Promise` - Load the script when the promise resolves, exists only on the client.
+     * - `Function` - Register a callback function to load the script, exists only on the client.
+     * - `server` - Have the script injected on the server.
+     * - `ref` - Load the script when the ref is true.
+     */
+    trigger?: UseScriptOptions$1['trigger'] | Ref<boolean>;
+}
+type UseScriptContext<T extends Record<symbol | string, any>> = (Promise<T> & VueScriptInstance<T>) & AsAsyncFunctionValues<T> & {
+    /**
+     * @deprecated Use top-level functions instead.
+     */
+    $script: Promise<T> & VueScriptInstance<T>;
+};
+declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>, U = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T, U>): UseScriptContext<UseFunctionType<UseScriptOptions<T, U>, T>>;
+
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): _unhead_schema.ActiveHeadEntry<MaybeComputedRef<ReactiveHead<any>>> | undefined;
+
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): void | _unhead_schema.ActiveHeadEntry<UseHeadSafeInput>;
+
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+/**
+ * @deprecated Import { UnheadPlugin } from `@unhead/vue/vue2` and use Vue.mixin(UnheadPlugin(head)) instead.
+ */
+declare const Vue2ProvideUnheadPlugin: Plugin;
+
+declare const VueHeadMixin: {
+    created(): void;
+};
+
+export { type HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, MaybeComputedRefEntriesOnly, ReactiveHead, UseHeadInput, UseHeadOptions, type UseHeadSafeInput, type UseScriptContext, type UseScriptInput, type UseScriptOptions, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, type VueScriptInstance, createHead, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, unheadVueComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

node_modules/@unhead/vue/dist/index.d.mts

@@ -0,0 +1,78 @@
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
+import * as _unhead_schema from '@unhead/schema';
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr, MergeHead, CreateHeadOptions, ActiveHeadEntry, ScriptInstance, UseScriptStatus, ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, UseScriptOptions as UseScriptOptions$1, AsAsyncFunctionValues, UseFunctionType } from '@unhead/schema';
+export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, Unhead } from '@unhead/schema';
+import { R as ReactiveHead, M as MaybeComputedRefEntries, a as MaybeComputedRef, V as VueHeadClient, U as UseHeadInput, b as UseHeadOptions, c as MaybeComputedRefEntriesOnly, d as UseSeoMetaInput } from './shared/vue.fwis0K4Q.mjs';
+export { f as Base, B as BodyAttr, j as BodyAttributes, H as HtmlAttr, i as HtmlAttributes, L as Link, l as MaybeComputedRefOrFalsy, m as MaybeComputedRefOrPromise, k as MaybeReadonlyRef, g as Meta, N as Noscript, h as Script, S as Style, T as Title, e as TitleTemplate } from './shared/vue.fwis0K4Q.mjs';
+import { Ref, Plugin } from 'vue';
+
+interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
+    meta?: MaybeComputedRefEntries<SafeMeta>[];
+    link?: MaybeComputedRefEntries<SafeLink>[];
+    noscript?: MaybeComputedRefEntries<SafeNoscript>[];
+    script?: MaybeComputedRefEntries<SafeScript>[];
+    htmlAttrs?: MaybeComputedRefEntries<SafeHtmlAttr>;
+    bodyAttrs?: MaybeComputedRefEntries<SafeBodyAttr>;
+}
+type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
+
+declare function createServerHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
+declare function createHead<T extends MergeHead>(options?: CreateHeadOptions): VueHeadClient<T>;
+
+declare function resolveUnrefHeadInput(ref: any): any;
+
+declare const unheadVueComposablesImports: {
+    '@unhead/vue': string[];
+};
+
+declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
+declare function injectHead<T extends MergeHead>(): VueHeadClient<T>;
+
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
+
+interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
+    status: Ref<UseScriptStatus>;
+}
+type UseScriptInput = string | (MaybeComputedRefEntriesOnly<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
+    src: string;
+});
+interface UseScriptOptions<T extends Record<symbol | string, any> = {}, U = {}> extends HeadEntryOptions, Pick<UseScriptOptions$1<T, U>, 'use' | 'stub' | 'eventContext' | 'beforeInit'> {
+    /**
+     * The trigger to load the script:
+     * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
+     * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
+     * - `Promise` - Load the script when the promise resolves, exists only on the client.
+     * - `Function` - Register a callback function to load the script, exists only on the client.
+     * - `server` - Have the script injected on the server.
+     * - `ref` - Load the script when the ref is true.
+     */
+    trigger?: UseScriptOptions$1['trigger'] | Ref<boolean>;
+}
+type UseScriptContext<T extends Record<symbol | string, any>> = (Promise<T> & VueScriptInstance<T>) & AsAsyncFunctionValues<T> & {
+    /**
+     * @deprecated Use top-level functions instead.
+     */
+    $script: Promise<T> & VueScriptInstance<T>;
+};
+declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>, U = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T, U>): UseScriptContext<UseFunctionType<UseScriptOptions<T, U>, T>>;
+
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): _unhead_schema.ActiveHeadEntry<MaybeComputedRef<ReactiveHead<any>>> | undefined;
+
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): void | _unhead_schema.ActiveHeadEntry<UseHeadSafeInput>;
+
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+/**
+ * @deprecated Import { UnheadPlugin } from `@unhead/vue/vue2` and use Vue.mixin(UnheadPlugin(head)) instead.
+ */
+declare const Vue2ProvideUnheadPlugin: Plugin;
+
+declare const VueHeadMixin: {
+    created(): void;
+};
+
+export { type HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, MaybeComputedRefEntriesOnly, ReactiveHead, UseHeadInput, UseHeadOptions, type UseHeadSafeInput, type UseScriptContext, type UseScriptInput, type UseScriptOptions, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, type VueScriptInstance, createHead, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, unheadVueComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

node_modules/@unhead/vue/dist/index.d.ts

@@ -0,0 +1,78 @@
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
+import * as _unhead_schema from '@unhead/schema';
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr, MergeHead, CreateHeadOptions, ActiveHeadEntry, ScriptInstance, UseScriptStatus, ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, UseScriptOptions as UseScriptOptions$1, AsAsyncFunctionValues, UseFunctionType } from '@unhead/schema';
+export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, Unhead } from '@unhead/schema';
+import { R as ReactiveHead, M as MaybeComputedRefEntries, a as MaybeComputedRef, V as VueHeadClient, U as UseHeadInput, b as UseHeadOptions, c as MaybeComputedRefEntriesOnly, d as UseSeoMetaInput } from './shared/vue.fwis0K4Q.js';
+export { f as Base, B as BodyAttr, j as BodyAttributes, H as HtmlAttr, i as HtmlAttributes, L as Link, l as MaybeComputedRefOrFalsy, m as MaybeComputedRefOrPromise, k as MaybeReadonlyRef, g as Meta, N as Noscript, h as Script, S as Style, T as Title, e as TitleTemplate } from './shared/vue.fwis0K4Q.js';
+import { Ref, Plugin } from 'vue';
+
+interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
+    meta?: MaybeComputedRefEntries<SafeMeta>[];
+    link?: MaybeComputedRefEntries<SafeLink>[];
+    noscript?: MaybeComputedRefEntries<SafeNoscript>[];
+    script?: MaybeComputedRefEntries<SafeScript>[];
+    htmlAttrs?: MaybeComputedRefEntries<SafeHtmlAttr>;
+    bodyAttrs?: MaybeComputedRefEntries<SafeBodyAttr>;
+}
+type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
+
+declare function createServerHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
+declare function createHead<T extends MergeHead>(options?: CreateHeadOptions): VueHeadClient<T>;
+
+declare function resolveUnrefHeadInput(ref: any): any;
+
+declare const unheadVueComposablesImports: {
+    '@unhead/vue': string[];
+};
+
+declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
+declare function injectHead<T extends MergeHead>(): VueHeadClient<T>;
+
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
+
+interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
+    status: Ref<UseScriptStatus>;
+}
+type UseScriptInput = string | (MaybeComputedRefEntriesOnly<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
+    src: string;
+});
+interface UseScriptOptions<T extends Record<symbol | string, any> = {}, U = {}> extends HeadEntryOptions, Pick<UseScriptOptions$1<T, U>, 'use' | 'stub' | 'eventContext' | 'beforeInit'> {
+    /**
+     * The trigger to load the script:
+     * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
+     * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
+     * - `Promise` - Load the script when the promise resolves, exists only on the client.
+     * - `Function` - Register a callback function to load the script, exists only on the client.
+     * - `server` - Have the script injected on the server.
+     * - `ref` - Load the script when the ref is true.
+     */
+    trigger?: UseScriptOptions$1['trigger'] | Ref<boolean>;
+}
+type UseScriptContext<T extends Record<symbol | string, any>> = (Promise<T> & VueScriptInstance<T>) & AsAsyncFunctionValues<T> & {
+    /**
+     * @deprecated Use top-level functions instead.
+     */
+    $script: Promise<T> & VueScriptInstance<T>;
+};
+declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>, U = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T, U>): UseScriptContext<UseFunctionType<UseScriptOptions<T, U>, T>>;
+
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): _unhead_schema.ActiveHeadEntry<MaybeComputedRef<ReactiveHead<any>>> | undefined;
+
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): void | _unhead_schema.ActiveHeadEntry<UseHeadSafeInput>;
+
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+/**
+ * @deprecated Import { UnheadPlugin } from `@unhead/vue/vue2` and use Vue.mixin(UnheadPlugin(head)) instead.
+ */
+declare const Vue2ProvideUnheadPlugin: Plugin;
+
+declare const VueHeadMixin: {
+    created(): void;
+};
+
+export { type HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, MaybeComputedRefEntriesOnly, ReactiveHead, UseHeadInput, UseHeadOptions, type UseHeadSafeInput, type UseScriptContext, type UseScriptInput, type UseScriptOptions, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, type VueScriptInstance, createHead, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, unheadVueComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

node_modules/@unhead/vue/dist/index.mjs

@@ -0,0 +1,162 @@
+import { useScript as useScript$1 } from 'unhead';
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
+import { i as injectHead, h as headSymbol, V as Vue3 } from './shared/vue.ziyDaVMR.mjs';
+export { c as createHead, a as createServerHead, r as resolveUnrefHeadInput, s as setHeadInjectionHandler } from './shared/vue.ziyDaVMR.mjs';
+import { composableNames, whitelistSafeInput, unpackMeta } from '@unhead/shared';
+import { u as useHead } from './shared/vue.-sixQ7xP.mjs';
+import { getCurrentInstance, onMounted, isRef, watch, onScopeDispose, ref } from 'vue';
+
+const coreComposableNames = [
+  "injectHead"
+];
+const unheadVueComposablesImports = {
+  "@unhead/vue": [...coreComposableNames, ...composableNames]
+};
+
+function useHeadSafe(input, options = {}) {
+  return useHead(input, { ...options, transform: whitelistSafeInput });
+}
+
+function registerVueScopeHandlers(script, scope) {
+  if (!scope) {
+    return;
+  }
+  const _registerCb = (key, cb) => {
+    if (!script._cbs[key]) {
+      cb(script.instance);
+      return () => {
+      };
+    }
+    let i = script._cbs[key].push(cb);
+    const destroy = () => {
+      if (i) {
+        script._cbs[key]?.splice(i - 1, 1);
+        i = null;
+      }
+    };
+    onScopeDispose(destroy);
+    return destroy;
+  };
+  script.onLoaded = (cb) => _registerCb("loaded", cb);
+  script.onError = (cb) => _registerCb("error", cb);
+  onScopeDispose(() => {
+    script._triggerAbortController?.abort();
+  });
+}
+function useScript(_input, _options) {
+  const input = typeof _input === "string" ? { src: _input } : _input;
+  const options = _options || {};
+  const head = options?.head || injectHead();
+  options.head = head;
+  const scope = getCurrentInstance();
+  options.eventContext = scope;
+  if (scope && typeof options.trigger === "undefined") {
+    options.trigger = onMounted;
+  } else if (isRef(options.trigger)) {
+    const refTrigger = options.trigger;
+    let off;
+    options.trigger = new Promise((resolve) => {
+      off = watch(refTrigger, (val) => {
+        if (val) {
+          resolve(true);
+        }
+      }, {
+        immediate: true
+      });
+      onScopeDispose(() => resolve(false), true);
+    }).then((val) => {
+      off?.();
+      return val;
+    });
+  }
+  head._scriptStatusWatcher = head._scriptStatusWatcher || head.hooks.hook("script:updated", ({ script: s }) => {
+    s._statusRef.value = s.status;
+  });
+  const script = useScript$1(input, options);
+  script._statusRef = script._statusRef || ref(script.status);
+  registerVueScopeHandlers(script, scope);
+  return new Proxy(script, {
+    get(_, key, a) {
+      return Reflect.get(_, key === "status" ? "_statusRef" : key, a);
+    }
+  });
+}
+
+function useSeoMeta(input, options) {
+  const { title, titleTemplate, ...meta } = input;
+  return useHead({
+    title,
+    titleTemplate,
+    // @ts-expect-error runtime type
+    _flatMeta: meta
+  }, {
+    ...options,
+    transform(t) {
+      const meta2 = unpackMeta({ ...t._flatMeta });
+      delete t._flatMeta;
+      return {
+        // @ts-expect-error runtime type
+        ...t,
+        meta: meta2
+      };
+    }
+  });
+}
+
+function useServerHead(input, options = {}) {
+  const head = options.head || injectHead();
+  delete options.head;
+  if (head)
+    return head.push(input, { ...options, mode: "server" });
+}
+
+function useServerHeadSafe(input, options = {}) {
+  return useHeadSafe(input, { ...options, mode: "server" });
+}
+
+function useServerSeoMeta(input, options) {
+  return useSeoMeta(input, { ...options, mode: "server" });
+}
+
+const Vue2ProvideUnheadPlugin = (_Vue, head) => {
+  _Vue.mixin({
+    beforeCreate() {
+      const options = this.$options;
+      const origProvide = options.provide;
+      options.provide = function() {
+        let origProvideResult;
+        if (typeof origProvide === "function")
+          origProvideResult = origProvide.call(this);
+        else
+          origProvideResult = origProvide || {};
+        return {
+          ...origProvideResult,
+          [headSymbol]: head
+        };
+      };
+    }
+  });
+};
+
+const VueHeadMixin = {
+  created() {
+    let source = false;
+    if (Vue3) {
+      const instance = getCurrentInstance();
+      if (!instance)
+        return;
+      const options = instance.type;
+      if (!options || !("head" in options))
+        return;
+      source = typeof options.head === "function" ? () => options.head.call(instance.proxy) : options.head;
+    } else {
+      const head = this.$options.head;
+      if (head) {
+        source = typeof head === "function" ? () => head.call(this) : head;
+      }
+    }
+    source && useHead(source);
+  }
+};
+
+export { Vue2ProvideUnheadPlugin, VueHeadMixin, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

node_modules/@unhead/vue/dist/polyfill.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const useHead = require('./shared/vue.BmMjB48i.cjs');
+require('vue');
+require('./shared/vue.DWlmwWrc.cjs');
+require('unhead');
+require('@unhead/shared');
+
+function polyfillAsVueUseHead(head) {
+  const polyfilled = head;
+  polyfilled.headTags = head.resolveTags;
+  polyfilled.addEntry = head.push;
+  polyfilled.addHeadObjs = head.push;
+  polyfilled.addReactiveEntry = (input, options) => {
+    const api = useHead.useHead(input, options);
+    if (api !== void 0)
+      return api.dispose;
+    return () => {
+    };
+  };
+  polyfilled.removeHeadObjs = () => {
+  };
+  polyfilled.updateDOM = () => {
+    head.hooks.callHook("entries:updated", head);
+  };
+  polyfilled.unhead = head;
+  return polyfilled;
+}
+
+exports.polyfillAsVueUseHead = polyfillAsVueUseHead;

node_modules/@unhead/vue/dist/polyfill.d.cts

@@ -0,0 +1,40 @@
+import { MergeHead } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput, b as UseHeadOptions } from './shared/vue.fwis0K4Q.cjs';
+import 'vue';
+
+type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {
+    /**
+     * @deprecated use `resolveTags`
+     */
+    headTags: VueHeadClient<T>['resolveTags'];
+    /**
+     * @deprecated use `push`
+     */
+    addEntry: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `push`
+     */
+    addHeadObjs: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `useHead`
+     */
+    addReactiveEntry: (input: UseHeadInput<T>, options?: UseHeadOptions) => (() => void);
+    /**
+     * @deprecated Use useHead API.
+     */
+    removeHeadObjs: () => void;
+    /**
+     * @deprecated Call hook `entries:resolve` or update an entry
+     */
+    updateDOM: () => void;
+    /**
+     * @deprecated Access unhead properties directly.
+     */
+    unhead: VueHeadClient<T>;
+};
+/**
+ * @deprecated Will be removed in v2.
+ */
+declare function polyfillAsVueUseHead<T extends MergeHead>(head: VueHeadClient<T>): VueHeadClientPollyFill<T>;
+
+export { type VueHeadClientPollyFill, polyfillAsVueUseHead };

node_modules/@unhead/vue/dist/polyfill.d.mts

@@ -0,0 +1,40 @@
+import { MergeHead } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput, b as UseHeadOptions } from './shared/vue.fwis0K4Q.mjs';
+import 'vue';
+
+type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {
+    /**
+     * @deprecated use `resolveTags`
+     */
+    headTags: VueHeadClient<T>['resolveTags'];
+    /**
+     * @deprecated use `push`
+     */
+    addEntry: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `push`
+     */
+    addHeadObjs: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `useHead`
+     */
+    addReactiveEntry: (input: UseHeadInput<T>, options?: UseHeadOptions) => (() => void);
+    /**
+     * @deprecated Use useHead API.
+     */
+    removeHeadObjs: () => void;
+    /**
+     * @deprecated Call hook `entries:resolve` or update an entry
+     */
+    updateDOM: () => void;
+    /**
+     * @deprecated Access unhead properties directly.
+     */
+    unhead: VueHeadClient<T>;
+};
+/**
+ * @deprecated Will be removed in v2.
+ */
+declare function polyfillAsVueUseHead<T extends MergeHead>(head: VueHeadClient<T>): VueHeadClientPollyFill<T>;
+
+export { type VueHeadClientPollyFill, polyfillAsVueUseHead };

node_modules/@unhead/vue/dist/polyfill.d.ts

@@ -0,0 +1,40 @@
+import { MergeHead } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput, b as UseHeadOptions } from './shared/vue.fwis0K4Q.js';
+import 'vue';
+
+type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {
+    /**
+     * @deprecated use `resolveTags`
+     */
+    headTags: VueHeadClient<T>['resolveTags'];
+    /**
+     * @deprecated use `push`
+     */
+    addEntry: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `push`
+     */
+    addHeadObjs: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `useHead`
+     */
+    addReactiveEntry: (input: UseHeadInput<T>, options?: UseHeadOptions) => (() => void);
+    /**
+     * @deprecated Use useHead API.
+     */
+    removeHeadObjs: () => void;
+    /**
+     * @deprecated Call hook `entries:resolve` or update an entry
+     */
+    updateDOM: () => void;
+    /**
+     * @deprecated Access unhead properties directly.
+     */
+    unhead: VueHeadClient<T>;
+};
+/**
+ * @deprecated Will be removed in v2.
+ */
+declare function polyfillAsVueUseHead<T extends MergeHead>(head: VueHeadClient<T>): VueHeadClientPollyFill<T>;
+
+export { type VueHeadClientPollyFill, polyfillAsVueUseHead };

node_modules/@unhead/vue/dist/polyfill.mjs

@@ -0,0 +1,28 @@
+import { u as useHead } from './shared/vue.-sixQ7xP.mjs';
+import 'vue';
+import './shared/vue.ziyDaVMR.mjs';
+import 'unhead';
+import '@unhead/shared';
+
+function polyfillAsVueUseHead(head) {
+  const polyfilled = head;
+  polyfilled.headTags = head.resolveTags;
+  polyfilled.addEntry = head.push;
+  polyfilled.addHeadObjs = head.push;
+  polyfilled.addReactiveEntry = (input, options) => {
+    const api = useHead(input, options);
+    if (api !== void 0)
+      return api.dispose;
+    return () => {
+    };
+  };
+  polyfilled.removeHeadObjs = () => {
+  };
+  polyfilled.updateDOM = () => {
+    head.hooks.callHook("entries:updated", head);
+  };
+  polyfilled.unhead = head;
+  return polyfilled;
+}
+
+export { polyfillAsVueUseHead };

node_modules/@unhead/vue/dist/shared/vue.-sixQ7xP.mjs

@@ -0,0 +1,37 @@
+import { ref, watchEffect, watch, getCurrentInstance, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
+import { i as injectHead, r as resolveUnrefHeadInput } from './vue.ziyDaVMR.mjs';
+
+function useHead(input, options = {}) {
+  const head = options.head || injectHead();
+  if (head) {
+    if (!head.ssr)
+      return clientUseHead(head, input, options);
+    return head.push(input, options);
+  }
+}
+function clientUseHead(head, input, options = {}) {
+  const deactivated = ref(false);
+  const resolvedInput = ref({});
+  watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : resolveUnrefHeadInput(input);
+  });
+  const entry = head.push(resolvedInput.value, options);
+  watch(resolvedInput, (e) => {
+    entry.patch(e);
+  });
+  const vm = getCurrentInstance();
+  if (vm) {
+    onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    onDeactivated(() => {
+      deactivated.value = true;
+    });
+    onActivated(() => {
+      deactivated.value = false;
+    });
+  }
+  return entry;
+}
+
+export { useHead as u };

node_modules/@unhead/vue/dist/shared/vue.BmMjB48i.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+const vue = require('vue');
+const injectHead = require('./vue.DWlmwWrc.cjs');
+
+function useHead(input, options = {}) {
+  const head = options.head || injectHead.injectHead();
+  if (head) {
+    if (!head.ssr)
+      return clientUseHead(head, input, options);
+    return head.push(input, options);
+  }
+}
+function clientUseHead(head, input, options = {}) {
+  const deactivated = vue.ref(false);
+  const resolvedInput = vue.ref({});
+  vue.watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : injectHead.resolveUnrefHeadInput(input);
+  });
+  const entry = head.push(resolvedInput.value, options);
+  vue.watch(resolvedInput, (e) => {
+    entry.patch(e);
+  });
+  const vm = vue.getCurrentInstance();
+  if (vm) {
+    vue.onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    vue.onDeactivated(() => {
+      deactivated.value = true;
+    });
+    vue.onActivated(() => {
+      deactivated.value = false;
+    });
+  }
+  return entry;
+}
+
+exports.useHead = useHead;

node_modules/@unhead/vue/dist/shared/vue.DWlmwWrc.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+const unhead = require('unhead');
+const vue = require('vue');
+const shared = require('@unhead/shared');
+
+const Vue3 = vue.version[0] === "3";
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : vue.unref(r);
+}
+function resolveUnrefHeadInput(ref) {
+  if (ref instanceof Promise || ref instanceof Date || ref instanceof RegExp)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r));
+  if (typeof root === "object") {
+    const resolved = {};
+    for (const k in root) {
+      if (!Object.prototype.hasOwnProperty.call(root, k)) {
+        continue;
+      }
+      if (k === "titleTemplate" || k[0] === "o" && k[1] === "n") {
+        resolved[k] = vue.unref(root[k]);
+        continue;
+      }
+      resolved[k] = resolveUnrefHeadInput(root[k]);
+    }
+    return resolved;
+  }
+  return root;
+}
+
+const VueReactivityPlugin = shared.defineHeadPlugin({
+  hooks: {
+    "entries:resolve": (ctx) => {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+const headSymbol = "usehead";
+function vueInstall(head) {
+  const plugin = {
+    install(app) {
+      if (Vue3) {
+        app.config.globalProperties.$unhead = head;
+        app.config.globalProperties.$head = head;
+        app.provide(headSymbol, head);
+      }
+    }
+  };
+  return plugin.install;
+}
+function createServerHead(options = {}) {
+  const head = unhead.createServerHead(options);
+  head.use(VueReactivityPlugin);
+  head.install = vueInstall(head);
+  return head;
+}
+function createHead(options = {}) {
+  options.domDelayFn = options.domDelayFn || ((fn) => vue.nextTick(() => setTimeout(() => fn(), 0)));
+  const head = unhead.createHead(options);
+  head.use(VueReactivityPlugin);
+  head.install = vueInstall(head);
+  return head;
+}
+
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__unhead_injection_handler__";
+function setHeadInjectionHandler(handler) {
+  _global[globalKey] = handler;
+}
+function injectHead() {
+  if (globalKey in _global) {
+    return _global[globalKey]();
+  }
+  const head = vue.inject(headSymbol);
+  if (!head && process.env.NODE_ENV !== "production")
+    console.warn("Unhead is missing Vue context, falling back to shared context. This may have unexpected results.");
+  return head || unhead.getActiveHead();
+}
+
+exports.Vue3 = Vue3;
+exports.createHead = createHead;
+exports.createServerHead = createServerHead;
+exports.headSymbol = headSymbol;
+exports.injectHead = injectHead;
+exports.resolveUnrefHeadInput = resolveUnrefHeadInput;
+exports.setHeadInjectionHandler = setHeadInjectionHandler;

node_modules/@unhead/vue/dist/shared/vue.fwis0K4Q.d.cts

@@ -0,0 +1,132 @@
+import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeFunctionEntries, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
+import { ComputedRef, Ref, Plugin } from 'vue';
+
+type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrFalsy<T> = undefined | false | null | T | MaybeReadonlyRef<T> | Ref<T>;
+/**
+ * @deprecated Use MaybeComputedRefOrFalsy
+ */
+type MaybeComputedRefOrPromise<T> = MaybeComputedRefOrFalsy<T>;
+type MaybeComputedRefEntries<T> = MaybeComputedRef<T> | {
+    [key in keyof T]?: MaybeComputedRefOrFalsy<T[key]>;
+};
+type MaybeComputedRefEntriesOnly<T> = {
+    [key in keyof T]?: MaybeComputedRefOrFalsy<T[key]>;
+};
+
+interface HtmlAttr extends Omit<BaseHtmlAttr, 'class'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+}
+interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    style?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<string | boolean>>;
+}
+type Title = MaybeComputedRef<Title$1>;
+type TitleTemplate = TitleTemplate$1 | Ref<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
+type Base<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
+type Link<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Link$1<E>>;
+type Meta<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Meta$1<E>>;
+type Style<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Style$1<E>>;
+type Script<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Script$1<E>>;
+type Noscript<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Noscript$1<E>>;
+type HtmlAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
+type BodyAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeFunctionEntries<BodyEvents>>;
+interface ReactiveHead<E extends MergeHead = MergeHead> {
+    /**
+     * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
+     * It only contains text; tags within the element are ignored.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
+     */
+    title?: Title;
+    /**
+     * Generate the title from a template.
+     */
+    titleTemplate?: TitleTemplate;
+    /**
+     * Variables used to substitute in the title and meta content.
+     */
+    templateParams?: MaybeComputedRefEntries<{
+        separator?: '|' | '-' | '·' | string;
+    } & Record<string, null | string | MaybeComputedRefEntries<Record<string, null | string>>>>;
+    /**
+     * The `<base>` HTML element specifies the base URL to use for all relative URLs in a document.
+     * There can be only one <base> element in a document.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+     */
+    base?: Base<E['base']>;
+    /**
+     * The `<link>` HTML element specifies relationships between the current document and an external resource.
+     * This element is most commonly used to link to stylesheets, but is also used to establish site icons
+     * (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+     */
+    link?: MaybeComputedRef<Link<E['link']>[]>;
+    /**
+     * The `<meta>` element represents metadata that cannot be expressed in other HTML elements, like `<link>` or `<script>`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
+     */
+    meta?: MaybeComputedRef<Meta<E['meta']>[]>;
+    /**
+     * The `<style>` HTML element contains style information for a document, or part of a document.
+     * It contains CSS, which is applied to the contents of the document containing the `<style>` element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style
+     */
+    style?: MaybeComputedRef<(Style<E['style']> | string)[]>;
+    /**
+     * The `<script>` HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
+     */
+    script?: MaybeComputedRef<(Script<E['script']> | string)[]>;
+    /**
+     * The `<noscript>` HTML element defines a section of HTML to be inserted if a script type on the page is unsupported
+     * or if scripting is currently turned off in the browser.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
+     */
+    noscript?: MaybeComputedRef<(Noscript<E['noscript']> | string)[]>;
+    /**
+     * Attributes for the `<html>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
+     */
+    htmlAttrs?: HtmlAttributes<E['htmlAttrs']>;
+    /**
+     * Attributes for the `<body>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
+     */
+    bodyAttrs?: BodyAttributes<E['bodyAttrs']>;
+}
+type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
+    head?: VueHeadClient<any>;
+};
+type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
+type UseSeoMetaInput = MaybeComputedRefEntriesOnly<MetaFlatInput> & {
+    title?: ReactiveHead['title'];
+    titleTemplate?: ReactiveHead['titleTemplate'];
+};
+type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
+
+export type { BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRefEntries as M, Noscript as N, ReactiveHead as R, Style as S, Title as T, UseHeadInput as U, VueHeadClient as V, MaybeComputedRef as a, UseHeadOptions as b, MaybeComputedRefEntriesOnly as c, UseSeoMetaInput as d, TitleTemplate as e, Base as f, Meta as g, Script as h, HtmlAttributes as i, BodyAttributes as j, MaybeReadonlyRef as k, MaybeComputedRefOrFalsy as l, MaybeComputedRefOrPromise as m };

node_modules/@unhead/vue/dist/shared/vue.fwis0K4Q.d.mts

@@ -0,0 +1,132 @@
+import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeFunctionEntries, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
+import { ComputedRef, Ref, Plugin } from 'vue';
+
+type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrFalsy<T> = undefined | false | null | T | MaybeReadonlyRef<T> | Ref<T>;
+/**
+ * @deprecated Use MaybeComputedRefOrFalsy
+ */
+type MaybeComputedRefOrPromise<T> = MaybeComputedRefOrFalsy<T>;
+type MaybeComputedRefEntries<T> = MaybeComputedRef<T> | {
+    [key in keyof T]?: MaybeComputedRefOrFalsy<T[key]>;
+};
+type MaybeComputedRefEntriesOnly<T> = {
+    [key in keyof T]?: MaybeComputedRefOrFalsy<T[key]>;
+};
+
+interface HtmlAttr extends Omit<BaseHtmlAttr, 'class'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+}
+interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    style?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<string | boolean>>;
+}
+type Title = MaybeComputedRef<Title$1>;
+type TitleTemplate = TitleTemplate$1 | Ref<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
+type Base<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
+type Link<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Link$1<E>>;
+type Meta<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Meta$1<E>>;
+type Style<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Style$1<E>>;
+type Script<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Script$1<E>>;
+type Noscript<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Noscript$1<E>>;
+type HtmlAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
+type BodyAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeFunctionEntries<BodyEvents>>;
+interface ReactiveHead<E extends MergeHead = MergeHead> {
+    /**
+     * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
+     * It only contains text; tags within the element are ignored.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
+     */
+    title?: Title;
+    /**
+     * Generate the title from a template.
+     */
+    titleTemplate?: TitleTemplate;
+    /**
+     * Variables used to substitute in the title and meta content.
+     */
+    templateParams?: MaybeComputedRefEntries<{
+        separator?: '|' | '-' | '·' | string;
+    } & Record<string, null | string | MaybeComputedRefEntries<Record<string, null | string>>>>;
+    /**
+     * The `<base>` HTML element specifies the base URL to use for all relative URLs in a document.
+     * There can be only one <base> element in a document.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+     */
+    base?: Base<E['base']>;
+    /**
+     * The `<link>` HTML element specifies relationships between the current document and an external resource.
+     * This element is most commonly used to link to stylesheets, but is also used to establish site icons
+     * (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+     */
+    link?: MaybeComputedRef<Link<E['link']>[]>;
+    /**
+     * The `<meta>` element represents metadata that cannot be expressed in other HTML elements, like `<link>` or `<script>`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
+     */
+    meta?: MaybeComputedRef<Meta<E['meta']>[]>;
+    /**
+     * The `<style>` HTML element contains style information for a document, or part of a document.
+     * It contains CSS, which is applied to the contents of the document containing the `<style>` element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style
+     */
+    style?: MaybeComputedRef<(Style<E['style']> | string)[]>;
+    /**
+     * The `<script>` HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
+     */
+    script?: MaybeComputedRef<(Script<E['script']> | string)[]>;
+    /**
+     * The `<noscript>` HTML element defines a section of HTML to be inserted if a script type on the page is unsupported
+     * or if scripting is currently turned off in the browser.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
+     */
+    noscript?: MaybeComputedRef<(Noscript<E['noscript']> | string)[]>;
+    /**
+     * Attributes for the `<html>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
+     */
+    htmlAttrs?: HtmlAttributes<E['htmlAttrs']>;
+    /**
+     * Attributes for the `<body>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
+     */
+    bodyAttrs?: BodyAttributes<E['bodyAttrs']>;
+}
+type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
+    head?: VueHeadClient<any>;
+};
+type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
+type UseSeoMetaInput = MaybeComputedRefEntriesOnly<MetaFlatInput> & {
+    title?: ReactiveHead['title'];
+    titleTemplate?: ReactiveHead['titleTemplate'];
+};
+type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
+
+export type { BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRefEntries as M, Noscript as N, ReactiveHead as R, Style as S, Title as T, UseHeadInput as U, VueHeadClient as V, MaybeComputedRef as a, UseHeadOptions as b, MaybeComputedRefEntriesOnly as c, UseSeoMetaInput as d, TitleTemplate as e, Base as f, Meta as g, Script as h, HtmlAttributes as i, BodyAttributes as j, MaybeReadonlyRef as k, MaybeComputedRefOrFalsy as l, MaybeComputedRefOrPromise as m };

node_modules/@unhead/vue/dist/shared/vue.fwis0K4Q.d.ts

@@ -0,0 +1,132 @@
+import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeFunctionEntries, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
+import { ComputedRef, Ref, Plugin } from 'vue';
+
+type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrFalsy<T> = undefined | false | null | T | MaybeReadonlyRef<T> | Ref<T>;
+/**
+ * @deprecated Use MaybeComputedRefOrFalsy
+ */
+type MaybeComputedRefOrPromise<T> = MaybeComputedRefOrFalsy<T>;
+type MaybeComputedRefEntries<T> = MaybeComputedRef<T> | {
+    [key in keyof T]?: MaybeComputedRefOrFalsy<T[key]>;
+};
+type MaybeComputedRefEntriesOnly<T> = {
+    [key in keyof T]?: MaybeComputedRefOrFalsy<T[key]>;
+};
+
+interface HtmlAttr extends Omit<BaseHtmlAttr, 'class'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+}
+interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    style?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<string | boolean>>;
+}
+type Title = MaybeComputedRef<Title$1>;
+type TitleTemplate = TitleTemplate$1 | Ref<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
+type Base<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
+type Link<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Link$1<E>>;
+type Meta<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Meta$1<E>>;
+type Style<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Style$1<E>>;
+type Script<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Script$1<E>>;
+type Noscript<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Noscript$1<E>>;
+type HtmlAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
+type BodyAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeFunctionEntries<BodyEvents>>;
+interface ReactiveHead<E extends MergeHead = MergeHead> {
+    /**
+     * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
+     * It only contains text; tags within the element are ignored.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
+     */
+    title?: Title;
+    /**
+     * Generate the title from a template.
+     */
+    titleTemplate?: TitleTemplate;
+    /**
+     * Variables used to substitute in the title and meta content.
+     */
+    templateParams?: MaybeComputedRefEntries<{
+        separator?: '|' | '-' | '·' | string;
+    } & Record<string, null | string | MaybeComputedRefEntries<Record<string, null | string>>>>;
+    /**
+     * The `<base>` HTML element specifies the base URL to use for all relative URLs in a document.
+     * There can be only one <base> element in a document.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+     */
+    base?: Base<E['base']>;
+    /**
+     * The `<link>` HTML element specifies relationships between the current document and an external resource.
+     * This element is most commonly used to link to stylesheets, but is also used to establish site icons
+     * (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+     */
+    link?: MaybeComputedRef<Link<E['link']>[]>;
+    /**
+     * The `<meta>` element represents metadata that cannot be expressed in other HTML elements, like `<link>` or `<script>`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
+     */
+    meta?: MaybeComputedRef<Meta<E['meta']>[]>;
+    /**
+     * The `<style>` HTML element contains style information for a document, or part of a document.
+     * It contains CSS, which is applied to the contents of the document containing the `<style>` element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style
+     */
+    style?: MaybeComputedRef<(Style<E['style']> | string)[]>;
+    /**
+     * The `<script>` HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
+     */
+    script?: MaybeComputedRef<(Script<E['script']> | string)[]>;
+    /**
+     * The `<noscript>` HTML element defines a section of HTML to be inserted if a script type on the page is unsupported
+     * or if scripting is currently turned off in the browser.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
+     */
+    noscript?: MaybeComputedRef<(Noscript<E['noscript']> | string)[]>;
+    /**
+     * Attributes for the `<html>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
+     */
+    htmlAttrs?: HtmlAttributes<E['htmlAttrs']>;
+    /**
+     * Attributes for the `<body>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
+     */
+    bodyAttrs?: BodyAttributes<E['bodyAttrs']>;
+}
+type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
+    head?: VueHeadClient<any>;
+};
+type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
+type UseSeoMetaInput = MaybeComputedRefEntriesOnly<MetaFlatInput> & {
+    title?: ReactiveHead['title'];
+    titleTemplate?: ReactiveHead['titleTemplate'];
+};
+type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
+
+export type { BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRefEntries as M, Noscript as N, ReactiveHead as R, Style as S, Title as T, UseHeadInput as U, VueHeadClient as V, MaybeComputedRef as a, UseHeadOptions as b, MaybeComputedRefEntriesOnly as c, UseSeoMetaInput as d, TitleTemplate as e, Base as f, Meta as g, Script as h, HtmlAttributes as i, BodyAttributes as j, MaybeReadonlyRef as k, MaybeComputedRefOrFalsy as l, MaybeComputedRefOrPromise as m };

node_modules/@unhead/vue/dist/shared/vue.ziyDaVMR.mjs

@@ -0,0 +1,86 @@
+import { createServerHead as createServerHead$1, createHead as createHead$1, getActiveHead } from 'unhead';
+import { version, unref, nextTick, inject } from 'vue';
+import { defineHeadPlugin } from '@unhead/shared';
+
+const Vue3 = version[0] === "3";
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+function resolveUnrefHeadInput(ref) {
+  if (ref instanceof Promise || ref instanceof Date || ref instanceof RegExp)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r));
+  if (typeof root === "object") {
+    const resolved = {};
+    for (const k in root) {
+      if (!Object.prototype.hasOwnProperty.call(root, k)) {
+        continue;
+      }
+      if (k === "titleTemplate" || k[0] === "o" && k[1] === "n") {
+        resolved[k] = unref(root[k]);
+        continue;
+      }
+      resolved[k] = resolveUnrefHeadInput(root[k]);
+    }
+    return resolved;
+  }
+  return root;
+}
+
+const VueReactivityPlugin = defineHeadPlugin({
+  hooks: {
+    "entries:resolve": (ctx) => {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+const headSymbol = "usehead";
+function vueInstall(head) {
+  const plugin = {
+    install(app) {
+      if (Vue3) {
+        app.config.globalProperties.$unhead = head;
+        app.config.globalProperties.$head = head;
+        app.provide(headSymbol, head);
+      }
+    }
+  };
+  return plugin.install;
+}
+function createServerHead(options = {}) {
+  const head = createServerHead$1(options);
+  head.use(VueReactivityPlugin);
+  head.install = vueInstall(head);
+  return head;
+}
+function createHead(options = {}) {
+  options.domDelayFn = options.domDelayFn || ((fn) => nextTick(() => setTimeout(() => fn(), 0)));
+  const head = createHead$1(options);
+  head.use(VueReactivityPlugin);
+  head.install = vueInstall(head);
+  return head;
+}
+
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__unhead_injection_handler__";
+function setHeadInjectionHandler(handler) {
+  _global[globalKey] = handler;
+}
+function injectHead() {
+  if (globalKey in _global) {
+    return _global[globalKey]();
+  }
+  const head = inject(headSymbol);
+  if (!head && process.env.NODE_ENV !== "production")
+    console.warn("Unhead is missing Vue context, falling back to shared context. This may have unexpected results.");
+  return head || getActiveHead();
+}
+
+export { Vue3 as V, createServerHead as a, createHead as c, headSymbol as h, injectHead as i, resolveUnrefHeadInput as r, setHeadInjectionHandler as s };

node_modules/@unhead/vue/dist/vue2.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+const useHead = require('./shared/vue.BmMjB48i.cjs');
+const injectHead = require('./shared/vue.DWlmwWrc.cjs');
+require('vue');
+require('unhead');
+require('@unhead/shared');
+
+const UnheadPlugin = (_Vue) => {
+  _Vue.config.optionMergeStrategies.head = function(toVal, fromVal) {
+    return [toVal, fromVal].flat().filter(Boolean);
+  };
+  _Vue.mixin({
+    created() {
+      const head = this.$options.head;
+      if (head) {
+        if (Array.isArray(head)) {
+          head.forEach((h) => {
+            useHead.useHead(typeof h === "function" ? h.call(this) : h);
+          });
+        } else {
+          useHead.useHead(typeof head === "function" ? head.call(this) : head);
+        }
+      }
+    },
+    beforeCreate() {
+      const options = this.$options;
+      if (options.unhead) {
+        const origProvide = options.provide;
+        options.provide = function() {
+          let origProvideResult;
+          if (typeof origProvide === "function")
+            origProvideResult = origProvide.call(this);
+          else
+            origProvideResult = origProvide || {};
+          return {
+            ...origProvideResult,
+            [injectHead.headSymbol]: options.unhead
+          };
+        };
+      }
+    }
+  });
+};
+
+exports.UnheadPlugin = UnheadPlugin;

node_modules/@unhead/vue/dist/vue2.d.cts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vue';
+
+declare const UnheadPlugin: Plugin;
+
+export { UnheadPlugin };

node_modules/@unhead/vue/dist/vue2.d.mts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vue';
+
+declare const UnheadPlugin: Plugin;
+
+export { UnheadPlugin };

node_modules/@unhead/vue/dist/vue2.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vue';
+
+declare const UnheadPlugin: Plugin;
+
+export { UnheadPlugin };

node_modules/@unhead/vue/dist/vue2.mjs

@@ -0,0 +1,44 @@
+import { u as useHead } from './shared/vue.-sixQ7xP.mjs';
+import { h as headSymbol } from './shared/vue.ziyDaVMR.mjs';
+import 'vue';
+import 'unhead';
+import '@unhead/shared';
+
+const UnheadPlugin = (_Vue) => {
+  _Vue.config.optionMergeStrategies.head = function(toVal, fromVal) {
+    return [toVal, fromVal].flat().filter(Boolean);
+  };
+  _Vue.mixin({
+    created() {
+      const head = this.$options.head;
+      if (head) {
+        if (Array.isArray(head)) {
+          head.forEach((h) => {
+            useHead(typeof h === "function" ? h.call(this) : h);
+          });
+        } else {
+          useHead(typeof head === "function" ? head.call(this) : head);
+        }
+      }
+    },
+    beforeCreate() {
+      const options = this.$options;
+      if (options.unhead) {
+        const origProvide = options.provide;
+        options.provide = function() {
+          let origProvideResult;
+          if (typeof origProvide === "function")
+            origProvideResult = origProvide.call(this);
+          else
+            origProvideResult = origProvide || {};
+          return {
+            ...origProvideResult,
+            [headSymbol]: options.unhead
+          };
+        };
+      }
+    }
+  });
+};
+
+export { UnheadPlugin };

node_modules/@unhead/vue/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@unhead/vue",
+  "type": "module",
+  "version": "1.11.20",
+  "author": "Harlan Wilton <harlan@harlanzw.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/harlan-zw",
+  "homepage": "https://unhead.unjs.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unjs/unhead.git",
+    "directory": "packages/vue"
+  },
+  "bugs": {
+    "url": "https://github.com/unjs/unhead/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./polyfill": {
+      "types": "./dist/polyfill.d.ts",
+      "import": "./dist/polyfill.mjs",
+      "require": "./dist/polyfill.cjs"
+    },
+    "./vue2": {
+      "types": "./dist/vue2.d.ts",
+      "import": "./dist/vue2.mjs",
+      "require": "./dist/vue2.cjs"
+    },
+    "./components": {
+      "types": "./dist/components.d.ts",
+      "import": "./dist/components.mjs",
+      "require": "./dist/components.cjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "dist/components"
+      ],
+      "vue2": [
+        "dist/vue2"
+      ],
+      "polyfill": [
+        "dist/polyfill"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "vue": ">=2.7 || >=3"
+  },
+  "build": {
+    "external": [
+      "vue"
+    ]
+  },
+  "dependencies": {
+    "hookable": "^5.5.3",
+    "@unhead/schema": "1.11.20",
+    "@unhead/shared": "1.11.20",
+    "unhead": "1.11.20"
+  },
+  "scripts": {
+    "build": "unbuild .",
+    "stub": "unbuild . --stub",
+    "export:sizes": "npx export-size . -r"
+  }
+}