@unhead/vue 2.0.0-alpha.8 → 2.0.0-beta.0

package/dist/client.d.mts

@@ -1,8 +1,9 @@
-import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
-import { VueHeadClient } from '@unhead/vue';
+import { CreateClientHeadOptions } from 'unhead/types';
 export { V as VueHeadMixin } from './shared/vue.DnywREVF.mjs';
-export * from 'unhead/client';
+export { renderDOMHead } from 'unhead/client';
+import { V as VueHeadClient } from './shared/vue.C1egIkvG.mjs';
+import 'vue';
 
-declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): VueHeadClient<T>;
+declare function createHead(options?: CreateClientHeadOptions): VueHeadClient;
 
 export { createHead };

package/dist/client.d.ts

@@ -1,8 +1,9 @@
-import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
-import { VueHeadClient } from '@unhead/vue';
+import { CreateClientHeadOptions } from 'unhead/types';
 export { V as VueHeadMixin } from './shared/vue.DnywREVF.js';
-export * from 'unhead/client';
+export { renderDOMHead } from 'unhead/client';
+import { V as VueHeadClient } from './shared/vue.C1egIkvG.js';
+import 'vue';
 
-declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): VueHeadClient<T>;
+declare function createHead(options?: CreateClientHeadOptions): VueHeadClient;
 
 export { createHead };

package/dist/client.mjs

@@ -1,21 +1,18 @@
-import { createHead as createHead$1 } from 'unhead/client';
-export * from 'unhead/client';
+import { createHead as createHead$1, createDebouncedFn, renderDOMHead } from 'unhead/client';
+export { renderDOMHead } from 'unhead/client';
 import { nextTick } from 'vue';
-import { v as vueInstall } from './shared/vue.D2UzSD_b.mjs';
-import { V as VueReactivityPlugin } from './shared/vue.51u-UkLG.mjs';
-export { V as VueHeadMixin } from './shared/vue.CNiRntV8.mjs';
-import '@unhead/shared';
+import { v as vueInstall } from './shared/vue.BYLJNEcq.mjs';
+export { V as VueHeadMixin } from './shared/vue.nvpYXC6D.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import './shared/vue.N9zWjxoK.mjs';
 
 function createHead(options = {}) {
   const head = createHead$1({
     domOptions: {
-      delayFn: (fn) => nextTick(() => setTimeout(() => fn(), 0))
+      render: createDebouncedFn(() => renderDOMHead(head), nextTick)
     },
-    ...options,
-    plugins: [
-      ...options.plugins || [],
-      VueReactivityPlugin
-    ]
+    ...options
   });
   head.install = vueInstall(head);
   return head;

package/dist/components.mjs

@@ -1,6 +1,8 @@
 import { defineComponent, ref, onBeforeUnmount, watchEffect } from 'vue';
-import { u as useHead } from './shared/vue.D2UzSD_b.mjs';
-import '@unhead/shared';
+import { u as useHead } from './shared/vue.BYLJNEcq.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import './shared/vue.N9zWjxoK.mjs';
 
 function addVNodeToHeadObj(node, obj) {
   const nodeType = node.type;
@@ -21,10 +23,10 @@ function addVNodeToHeadObj(node, obj) {
 }
 function vnodesToHeadObj(nodes) {
   const obj = {
-    title: undefined,
-    htmlAttrs: undefined,
-    bodyAttrs: undefined,
-    base: undefined,
+    title: void 0,
+    htmlAttrs: void 0,
+    bodyAttrs: void 0,
+    base: void 0,
     meta: [],
     link: [],
     style: [],

package/dist/index.d.mts

@@ -1,26 +1,45 @@
-export { createHeadCore } from 'unhead';
-export { r as resolveUnrefHeadInput } from './shared/vue.BF-HCrO8.mjs';
-import { MergeHead, ActiveHeadEntry } from '@unhead/schema';
-export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, ResolvedHead, Unhead } from '@unhead/schema';
-import { VueHeadClient, UseHeadInput, UseHeadOptions, UseHeadSafeInput, UseSeoMetaInput } from './types.mjs';
-export { Base, BodyAttr, BodyAttributes, HeadSafe, HtmlAttr, HtmlAttributes, Link, MaybeComputedRef, Meta, Noscript, ReactiveHead, ResolvableArray, ResolvableProperties, Script, Style, Title, TitleTemplate } from './types.mjs';
+import { createUnhead } from 'unhead';
+export { createUnhead } from 'unhead';
+import { ActiveHeadEntry } from 'unhead/types';
+export { ActiveHeadEntry, AriaAttributes, BodyAttributesWithoutEvents, BodyEvents, DataKeys, GlobalAttributes, Head, HeadEntryOptions, HeadTag, HttpEventAttributes, LinkWithoutEvents, MergeHead, MetaFlat, MetaFlatInput, RawInput, RenderSSRHeadOptions, ResolvableHead, ScriptWithoutEvents, SerializableHead, SpeculationRules, Unhead } from 'unhead/types';
+import { V as VueHeadClient, U as UseHeadInput, a as UseHeadOptions, b as UseSeoMetaInput } from './shared/vue.C1egIkvG.mjs';
+export { B as BodyAttr, H as HtmlAttr, M as MaybeFalsy, l as ReactiveHead, n as ResolvableArray, d as ResolvableBase, k as ResolvableBodyAttributes, j as ResolvableHtmlAttributes, e as ResolvableLink, f as ResolvableMeta, i as ResolvableNoscript, o as ResolvableProperties, h as ResolvableScript, g as ResolvableStyle, R as ResolvableTitle, c as ResolvableTitleTemplate, m as ResolvableValue } from './shared/vue.C1egIkvG.mjs';
+import { U as UseHeadSafeInput } from './shared/vue.Ds_C3mXu.mjs';
+export { H as HeadSafe, S as SafeBodyAttr, a as SafeHtmlAttr, c as SafeLink, b as SafeMeta, e as SafeNoscript, d as SafeScript, f as SafeStyle } from './shared/vue.Ds_C3mXu.mjs';
+export { Base, BodyAttributes, HtmlAttributes, Link, Meta, Noscript, Script, Style } from './types.mjs';
+export { resolveUnrefHeadInput } from './utils.mjs';
 export { V as VueHeadMixin } from './shared/vue.DnywREVF.mjs';
+export { useScript } from './scripts.mjs';
 import 'vue';
+import 'unhead/utils';
+import 'unhead/scripts';
 
 declare const unheadVueComposablesImports: {
     '@unhead/vue': string[];
 };
 
-declare function injectHead(): VueHeadClient<MergeHead>;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>>;
-declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<UseSeoMetaInput>;
+declare function injectHead(): VueHeadClient;
+declare function useHead<I = UseHeadInput>(input?: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<I>;
+declare function useHeadSafe(input?: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput>;
+declare function useSeoMeta(input?: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<UseSeoMetaInput>;
+/**
+ * @deprecated use `useHead` instead.Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHead<I = UseHeadInput>(input?: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<I>;
+/**
+ * @deprecated use `useHeadSafe` instead.Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHeadSafe(input?: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput>;
+/**
+ * @deprecated use `useSeoMeta` instead.Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerSeoMeta(input?: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<UseSeoMetaInput>;
 
 declare const headSymbol = "usehead";
 
-declare const CapoPlugin: () => {};
+/**
+ * @deprecated Use createUnhead
+ */
+declare const createCoreHead: typeof createUnhead;
 
-export { CapoPlugin, UseHeadInput, UseHeadOptions, UseHeadSafeInput, UseSeoMetaInput, VueHeadClient, headSymbol, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { UseHeadInput, UseHeadOptions, UseHeadSafeInput, UseSeoMetaInput, VueHeadClient, createCoreHead, headSymbol, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.d.ts

@@ -1,26 +1,45 @@
-export { createHeadCore } from 'unhead';
-export { r as resolveUnrefHeadInput } from './shared/vue.BF-HCrO8.js';
-import { MergeHead, ActiveHeadEntry } from '@unhead/schema';
-export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, ResolvedHead, Unhead } from '@unhead/schema';
-import { VueHeadClient, UseHeadInput, UseHeadOptions, UseHeadSafeInput, UseSeoMetaInput } from './types.js';
-export { Base, BodyAttr, BodyAttributes, HeadSafe, HtmlAttr, HtmlAttributes, Link, MaybeComputedRef, Meta, Noscript, ReactiveHead, ResolvableArray, ResolvableProperties, Script, Style, Title, TitleTemplate } from './types.js';
+import { createUnhead } from 'unhead';
+export { createUnhead } from 'unhead';
+import { ActiveHeadEntry } from 'unhead/types';
+export { ActiveHeadEntry, AriaAttributes, BodyAttributesWithoutEvents, BodyEvents, DataKeys, GlobalAttributes, Head, HeadEntryOptions, HeadTag, HttpEventAttributes, LinkWithoutEvents, MergeHead, MetaFlat, MetaFlatInput, RawInput, RenderSSRHeadOptions, ResolvableHead, ScriptWithoutEvents, SerializableHead, SpeculationRules, Unhead } from 'unhead/types';
+import { V as VueHeadClient, U as UseHeadInput, a as UseHeadOptions, b as UseSeoMetaInput } from './shared/vue.C1egIkvG.js';
+export { B as BodyAttr, H as HtmlAttr, M as MaybeFalsy, l as ReactiveHead, n as ResolvableArray, d as ResolvableBase, k as ResolvableBodyAttributes, j as ResolvableHtmlAttributes, e as ResolvableLink, f as ResolvableMeta, i as ResolvableNoscript, o as ResolvableProperties, h as ResolvableScript, g as ResolvableStyle, R as ResolvableTitle, c as ResolvableTitleTemplate, m as ResolvableValue } from './shared/vue.C1egIkvG.js';
+import { U as UseHeadSafeInput } from './shared/vue.A6QPXQyg.js';
+export { H as HeadSafe, S as SafeBodyAttr, a as SafeHtmlAttr, c as SafeLink, b as SafeMeta, e as SafeNoscript, d as SafeScript, f as SafeStyle } from './shared/vue.A6QPXQyg.js';
+export { Base, BodyAttributes, HtmlAttributes, Link, Meta, Noscript, Script, Style } from './types.js';
+export { resolveUnrefHeadInput } from './utils.js';
 export { V as VueHeadMixin } from './shared/vue.DnywREVF.js';
+export { useScript } from './scripts.js';
 import 'vue';
+import 'unhead/utils';
+import 'unhead/scripts';
 
 declare const unheadVueComposablesImports: {
     '@unhead/vue': string[];
 };
 
-declare function injectHead(): VueHeadClient<MergeHead>;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>>;
-declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<UseSeoMetaInput>;
+declare function injectHead(): VueHeadClient;
+declare function useHead<I = UseHeadInput>(input?: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<I>;
+declare function useHeadSafe(input?: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput>;
+declare function useSeoMeta(input?: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<UseSeoMetaInput>;
+/**
+ * @deprecated use `useHead` instead.Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHead<I = UseHeadInput>(input?: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<I>;
+/**
+ * @deprecated use `useHeadSafe` instead.Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHeadSafe(input?: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput>;
+/**
+ * @deprecated use `useSeoMeta` instead.Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerSeoMeta(input?: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<UseSeoMetaInput>;
 
 declare const headSymbol = "usehead";
 
-declare const CapoPlugin: () => {};
+/**
+ * @deprecated Use createUnhead
+ */
+declare const createCoreHead: typeof createUnhead;
 
-export { CapoPlugin, UseHeadInput, UseHeadOptions, UseHeadSafeInput, UseSeoMetaInput, VueHeadClient, headSymbol, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { UseHeadInput, UseHeadOptions, UseHeadSafeInput, UseSeoMetaInput, VueHeadClient, createCoreHead, headSymbol, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.mjs

@@ -1,13 +1,19 @@
-export { createHeadCore } from 'unhead';
-export { h as headSymbol, i as injectHead, r as resolveUnrefHeadInput, u as useHead, a as useHeadSafe, b as useSeoMeta, c as useServerHead, d as useServerHeadSafe, e as useServerSeoMeta } from './shared/vue.D2UzSD_b.mjs';
-import { composableNames } from '@unhead/shared';
-export { V as VueHeadMixin } from './shared/vue.CNiRntV8.mjs';
+import { createUnhead } from 'unhead';
+export { createUnhead } from 'unhead';
+export { h as headSymbol, i as injectHead, u as useHead, a as useHeadSafe, b as useSeoMeta, c as useServerHead, d as useServerHeadSafe, e as useServerSeoMeta } from './shared/vue.BYLJNEcq.mjs';
+export { resolveUnrefHeadInput } from './utils.mjs';
+export { V as VueHeadMixin } from './shared/vue.nvpYXC6D.mjs';
+export { u as useScript } from './shared/vue.cHBs6zvy.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
 import 'vue';
+import './shared/vue.N9zWjxoK.mjs';
+import 'unhead/scripts';
 
 const unheadVueComposablesImports = {
-  "@unhead/vue": ["injectHead", ...composableNames]
+  "@unhead/vue": ["injectHead", "useHead", "useSeoMeta", "useHeadSafe", "useServerHead", "useServerSeoMeta", "useServerHeadSafe"]
 };
 
-const CapoPlugin = () => ({});
+const createCoreHead = createUnhead;
 
-export { CapoPlugin, unheadVueComposablesImports };
+export { createCoreHead, unheadVueComposablesImports };

package/dist/legacy.d.mts

@@ -1,52 +1,34 @@
-import * as _unhead_schema from '@unhead/schema';
-import { ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, MergeHead, CreateClientHeadOptions, ActiveHeadEntry } from '@unhead/schema';
-export { createHeadCore } from 'unhead';
-export { r as resolveUnrefHeadInput } from './shared/vue.BF-HCrO8.mjs';
-import { ResolvableProperties, UseHeadOptions } from '@unhead/vue';
-import { ScriptInstance, UseScriptStatus, UseScriptOptions as UseScriptOptions$1, UseFunctionType } from 'unhead/legacy';
-export { UseFunctionType, resolveScriptKey } from 'unhead/legacy';
-import { Ref } from 'vue';
-import { VueHeadClient, UseHeadInput, UseHeadOptions as UseHeadOptions$1, UseHeadSafeInput, UseSeoMetaInput } from './types.mjs';
+import * as unhead_types from 'unhead/types';
+import { CreateClientHeadOptions, ActiveHeadEntry } from 'unhead/types';
+import { createUnhead } from 'unhead';
+import { V as VueHeadClient, U as UseHeadInput, a as UseHeadOptions, b as UseSeoMetaInput } from './shared/vue.C1egIkvG.mjs';
+import { U as UseHeadSafeInput } from './shared/vue.Ds_C3mXu.mjs';
+import 'vue';
 
-interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
-    status: Ref<UseScriptStatus>;
-}
-type UseScriptInput = string | (ResolvableProperties<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
-    src: string;
-});
-interface UseScriptOptions<T extends Record<symbol | string, any> = Record<string, any>> extends Omit<HeadEntryOptions, 'head'>, Pick<UseScriptOptions$1<T>, 'use' | '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>;
-    /**
-     * The Unhead instance to use.
-     */
-    head?: UseHeadOptions['head'];
-}
-type UseScriptContext<T extends Record<symbol | string, any>> = Promise<T> & VueScriptInstance<T>;
-type UseScriptReturn<T extends Record<symbol | string, any>> = UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
-declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptReturn<T>;
-
-declare const CapoPlugin: () => _unhead_schema.HeadPluginInput;
-declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): VueHeadClient<T>;
-declare function createServerHead<T extends MergeHead>(options?: CreateClientHeadOptions): VueHeadClient<T>;
+declare const createHeadCore: typeof createUnhead;
+declare function resolveUnrefHeadInput(input: any): any;
+declare function CapoPlugin(): unhead_types.HeadPluginInput;
+declare function createHead(options?: CreateClientHeadOptions): VueHeadClient;
+declare function createServerHead(options?: CreateClientHeadOptions): VueHeadClient;
 /**
  * @deprecated Please switch to non-legacy version
  */
 declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
 declare function injectHead(): VueHeadClient<any> | undefined;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions$1): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions$1): ActiveHeadEntry<UseHeadSafeInput> | void;
-declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
-declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
+declare function useHead(input: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput> | void;
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+/**
+ * @deprecated use `useHead` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHead(input: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+/**
+ * @deprecated use `useHeadSafe` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+/**
+ * @deprecated use `useSeoMeta` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
 
-export { CapoPlugin, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptReturn, type VueScriptInstance, createHead, createServerHead, injectHead, setHeadInjectionHandler, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { CapoPlugin, createHead, createHeadCore, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/legacy.d.ts

@@ -1,52 +1,34 @@
-import * as _unhead_schema from '@unhead/schema';
-import { ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, MergeHead, CreateClientHeadOptions, ActiveHeadEntry } from '@unhead/schema';
-export { createHeadCore } from 'unhead';
-export { r as resolveUnrefHeadInput } from './shared/vue.BF-HCrO8.js';
-import { ResolvableProperties, UseHeadOptions } from '@unhead/vue';
-import { ScriptInstance, UseScriptStatus, UseScriptOptions as UseScriptOptions$1, UseFunctionType } from 'unhead/legacy';
-export { UseFunctionType, resolveScriptKey } from 'unhead/legacy';
-import { Ref } from 'vue';
-import { VueHeadClient, UseHeadInput, UseHeadOptions as UseHeadOptions$1, UseHeadSafeInput, UseSeoMetaInput } from './types.js';
+import * as unhead_types from 'unhead/types';
+import { CreateClientHeadOptions, ActiveHeadEntry } from 'unhead/types';
+import { createUnhead } from 'unhead';
+import { V as VueHeadClient, U as UseHeadInput, a as UseHeadOptions, b as UseSeoMetaInput } from './shared/vue.C1egIkvG.js';
+import { U as UseHeadSafeInput } from './shared/vue.A6QPXQyg.js';
+import 'vue';
 
-interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
-    status: Ref<UseScriptStatus>;
-}
-type UseScriptInput = string | (ResolvableProperties<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
-    src: string;
-});
-interface UseScriptOptions<T extends Record<symbol | string, any> = Record<string, any>> extends Omit<HeadEntryOptions, 'head'>, Pick<UseScriptOptions$1<T>, 'use' | '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>;
-    /**
-     * The Unhead instance to use.
-     */
-    head?: UseHeadOptions['head'];
-}
-type UseScriptContext<T extends Record<symbol | string, any>> = Promise<T> & VueScriptInstance<T>;
-type UseScriptReturn<T extends Record<symbol | string, any>> = UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
-declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptReturn<T>;
-
-declare const CapoPlugin: () => _unhead_schema.HeadPluginInput;
-declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): VueHeadClient<T>;
-declare function createServerHead<T extends MergeHead>(options?: CreateClientHeadOptions): VueHeadClient<T>;
+declare const createHeadCore: typeof createUnhead;
+declare function resolveUnrefHeadInput(input: any): any;
+declare function CapoPlugin(): unhead_types.HeadPluginInput;
+declare function createHead(options?: CreateClientHeadOptions): VueHeadClient;
+declare function createServerHead(options?: CreateClientHeadOptions): VueHeadClient;
 /**
  * @deprecated Please switch to non-legacy version
  */
 declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
 declare function injectHead(): VueHeadClient<any> | undefined;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions$1): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions$1): ActiveHeadEntry<UseHeadSafeInput> | void;
-declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
-declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions$1): ActiveHeadEntry<any> | void;
+declare function useHead(input: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput> | void;
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+/**
+ * @deprecated use `useHead` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHead(input: UseHeadInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+/**
+ * @deprecated use `useHeadSafe` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+/**
+ * @deprecated use `useSeoMeta` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
 
-export { CapoPlugin, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptReturn, type VueScriptInstance, createHead, createServerHead, injectHead, setHeadInjectionHandler, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { CapoPlugin, createHead, createHeadCore, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/legacy.mjs

@@ -1,83 +1,24 @@
-import { defineHeadPlugin, whitelistSafeInput, unpackMeta } from '@unhead/shared';
-export { createHeadCore } from 'unhead';
-import { DeprecationsPlugin, PromisesPlugin } from 'unhead/plugins';
-import { getCurrentInstance, onMounted, isRef, watch, onScopeDispose, ref, inject, watchEffect, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
+import { createUnhead } from 'unhead';
+import { inject, ref, watchEffect, unref, watch, getCurrentInstance, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
 import { createHead as createHead$1 } from './client.mjs';
-import { h as headSymbol, r as resolveUnrefHeadInput } from './shared/vue.D2UzSD_b.mjs';
+import { h as headSymbol } from './shared/vue.BYLJNEcq.mjs';
+import { V as VueResolver } from './shared/vue.N9zWjxoK.mjs';
 import { createHead as createHead$2 } from './server.mjs';
-import { useScript as useScript$1 } from 'unhead/legacy';
-export { resolveScriptKey } from 'unhead/legacy';
+import { walkResolver } from 'unhead/utils';
+import { defineHeadPlugin, DeprecationsPlugin, PromisesPlugin, TemplateParamsPlugin, AliasSortingPlugin, SafeInputPlugin, FlatMetaPlugin } from 'unhead/plugins';
 import 'unhead/client';
-import './shared/vue.51u-UkLG.mjs';
-import './shared/vue.CNiRntV8.mjs';
+import './shared/vue.nvpYXC6D.mjs';
 import 'unhead/server';
 
-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();
-  });
+const createHeadCore = createUnhead;
+function resolveUnrefHeadInput(input) {
+  return walkResolver(input, VueResolver);
 }
-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 CapoPlugin() {
+  return defineHeadPlugin({
+    key: "capo"
   });
 }
-
-const CapoPlugin = () => defineHeadPlugin({});
 function createHead(options = {}) {
   return createHead$1({
     disableCapoSorting: true,
@@ -85,6 +26,8 @@ function createHead(options = {}) {
     plugins: [
       DeprecationsPlugin,
       PromisesPlugin,
+      TemplateParamsPlugin,
+      AliasSortingPlugin,
       ...options.plugins || []
     ]
   });
@@ -96,6 +39,8 @@ function createServerHead(options = {}) {
     plugins: [
       DeprecationsPlugin,
       PromisesPlugin,
+      TemplateParamsPlugin,
+      AliasSortingPlugin,
       ...options.plugins || []
     ]
   });
@@ -115,7 +60,7 @@ function clientUseHead(head, input, options = {}) {
   const deactivated = ref(false);
   const resolvedInput = ref({});
   watchEffect(() => {
-    resolvedInput.value = deactivated.value ? {} : resolveUnrefHeadInput(input);
+    resolvedInput.value = deactivated.value ? {} : walkResolver(input, (v) => unref(v));
   });
   const entry = head.push(resolvedInput.value, options);
   watch(resolvedInput, (e) => {
@@ -136,27 +81,25 @@ function clientUseHead(head, input, options = {}) {
   return entry;
 }
 function useHeadSafe(input, options = {}) {
-  return useHead(input, { ...options, transform: whitelistSafeInput });
+  const head = options.head || injectHead();
+  if (head) {
+    head.use(SafeInputPlugin);
+    options._safe = true;
+    return useHead(input, options);
+  }
 }
 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
-      };
-    }
-  });
+  const head = options?.head || injectHead();
+  if (head) {
+    head.use(FlatMetaPlugin);
+    const { title, titleTemplate, ...meta } = input;
+    return useHead({
+      title,
+      titleTemplate,
+      // @ts-expect-error runtime type
+      _flatMeta: meta
+    }, options);
+  }
 }
 function useServerHead(input, options = {}) {
   return useHead(input, { ...options, mode: "server" });
@@ -168,4 +111,4 @@ function useServerSeoMeta(input, options) {
   return useSeoMeta(input, { ...options, mode: "server" });
 }
 
-export { CapoPlugin, createHead, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { CapoPlugin, createHead, createHeadCore, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/plugins.d.mts

@@ -0,0 +1 @@
+export * from 'unhead/plugins';

package/dist/plugins.d.ts

@@ -0,0 +1 @@
+export * from 'unhead/plugins';

package/dist/plugins.mjs

@@ -0,0 +1 @@
+export * from 'unhead/plugins';

package/dist/scripts.d.mts

@@ -0,0 +1,32 @@
+import { UseScriptOptions as UseScriptOptions$1, ScriptInstance, UseScriptStatus, UseFunctionType } from 'unhead/scripts';
+import { ScriptWithoutEvents, DataKeys, SchemaAugmentations, HeadEntryOptions } from 'unhead/types';
+import { Ref } from 'vue';
+import { o as ResolvableProperties, V as VueHeadClient } from './shared/vue.C1egIkvG.mjs';
+
+interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
+    status: Ref<UseScriptStatus>;
+}
+type UseScriptInput = string | (ResolvableProperties<Omit<ScriptWithoutEvents & DataKeys & SchemaAugmentations['script'], 'src'>> & {
+    src: string;
+});
+interface UseScriptOptions<T extends Record<symbol | string, any> = Record<string, any>> extends Omit<HeadEntryOptions, 'head'>, Pick<UseScriptOptions$1<T>, 'use' | '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>;
+    /**
+     * Unhead instance.
+     */
+    head?: VueHeadClient<any>;
+}
+type UseScriptContext<T extends Record<symbol | string, any>> = VueScriptInstance<T>;
+type UseScriptReturn<T extends Record<symbol | string, any>> = UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
+declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptReturn<T>;
+
+export { type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptReturn, type VueScriptInstance, useScript };