unhead 2.0.0-alpha.9 → 2.0.0-beta.0

package/dist/client.d.mts

@@ -1,16 +1,7 @@
-import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateClientHeadOptions, DomPluginOptions, Unhead, RenderDomHeadOptions } from '@unhead/schema';
+import { R as ResolvableHead, q as CreateClientHeadOptions, U as Unhead, G as RenderDomHeadOptions } from './shared/unhead.DVcP39oW.mjs';
+import 'hookable';
 
-declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): _unhead_schema.Unhead<T>;
-
-declare function DomPlugin(options: DomPluginOptions): _unhead_schema.HeadPluginInput;
-
-/**
- * Supports DOM event handlers (i.e `onload`) as functions.
- *
- * When SSR we need to strip out these values. On CSR we
- */
-declare const ClientEventHandlerPlugin: _unhead_schema.HeadPluginInput;
+declare function createHead<T = ResolvableHead>(options?: CreateClientHeadOptions): Unhead<T>;
 
 /**
  * Render the head tags to the DOM.
@@ -19,4 +10,4 @@ declare function renderDOMHead<T extends Unhead<any>>(head: T, options?: RenderD
 
 declare function createDebouncedFn(callee: () => void, delayer: (fn: () => void) => void): () => void;
 
-export { ClientEventHandlerPlugin, DomPlugin, createDebouncedFn, createHead, renderDOMHead };
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/client.d.ts

@@ -1,16 +1,7 @@
-import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateClientHeadOptions, DomPluginOptions, Unhead, RenderDomHeadOptions } from '@unhead/schema';
+import { R as ResolvableHead, q as CreateClientHeadOptions, U as Unhead, G as RenderDomHeadOptions } from './shared/unhead.DVcP39oW.js';
+import 'hookable';
 
-declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): _unhead_schema.Unhead<T>;
-
-declare function DomPlugin(options: DomPluginOptions): _unhead_schema.HeadPluginInput;
-
-/**
- * Supports DOM event handlers (i.e `onload`) as functions.
- *
- * When SSR we need to strip out these values. On CSR we
- */
-declare const ClientEventHandlerPlugin: _unhead_schema.HeadPluginInput;
+declare function createHead<T = ResolvableHead>(options?: CreateClientHeadOptions): Unhead<T>;
 
 /**
  * Render the head tags to the DOM.
@@ -19,4 +10,4 @@ declare function renderDOMHead<T extends Unhead<any>>(head: T, options?: RenderD
 
 declare function createDebouncedFn(callee: () => void, delayer: (fn: () => void) => void): () => void;
 
-export { ClientEventHandlerPlugin, DomPlugin, createDebouncedFn, createHead, renderDOMHead };
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/client.mjs

@@ -1,8 +1,8 @@
-import { HasElementTags, hashTag, normaliseProps, tagDedupeKey, IsBrowser } from '@unhead/shared';
-import { c as createHeadCore } from './shared/unhead.aU5fNi04.mjs';
-import { D as DomPlugin, C as ClientEventHandlerPlugin } from './shared/unhead.Bxnr6E-l.mjs';
+import { a as createUnhead } from './shared/unhead.CydFxwlU.mjs';
+import { H as HasElementTags } from './shared/unhead.yem5I2v_.mjs';
+import { h as hashTag, i as isMetaArrayDupeKey, a as normalizeProps, d as dedupeKey } from './shared/unhead.xsi8MZXD.mjs';
 import 'hookable';
-import './shared/unhead.9459P6Us.mjs';
+import './shared/unhead.DZbvapt-.mjs';
 
 async function renderDOMHead(head, options = {}) {
   const dom = options.document || head.resolvedOptions.document;
@@ -16,17 +16,30 @@ async function renderDOMHead(head, options = {}) {
     return head._domUpdatePromise;
   }
   head._domUpdatePromise = new Promise(async (resolve) => {
-    const tags = (await head.resolveTags()).map((tag) => ({
-      tag,
-      id: HasElementTags.has(tag.tag) ? hashTag(tag) : tag.tag,
-      shouldRender: true
-    }));
+    const dupeKeyCounter = /* @__PURE__ */ new Map();
+    const resolveTagPromise = new Promise((resolve2) => {
+      head.resolveTags().then((tags2) => {
+        resolve2(
+          tags2.map((tag) => {
+            const count = dupeKeyCounter.get(tag._d) || 0;
+            const res = {
+              tag,
+              id: (count ? `${tag._d}:${count}` : tag._d) || hashTag(tag),
+              shouldRender: true
+            };
+            if (tag._d && isMetaArrayDupeKey(tag._d)) {
+              dupeKeyCounter.set(tag._d, count + 1);
+            }
+            return res;
+          })
+        );
+      });
+    });
     let state = head._dom;
     if (!state) {
       state = {
-        elMap: { htmlAttrs: dom.documentElement, bodyAttrs: dom.body }
+        elMap: (/* @__PURE__ */ new Map()).set("htmlAttrs", dom.documentElement).set("bodyAttrs", dom.body)
       };
-      const takenDedupeKeys = /* @__PURE__ */ new Set();
       for (const key of ["body", "head"]) {
         const children = dom[key]?.children;
         for (const c of children) {
@@ -34,23 +47,25 @@ async function renderDOMHead(head, options = {}) {
           if (!HasElementTags.has(tag)) {
             continue;
           }
-          const t = {
-            tag,
-            props: await normaliseProps(
-              c.getAttributeNames().reduce((props, name) => ({ ...props, [name]: c.getAttribute(name) }), {})
-            ),
-            innerHTML: c.innerHTML
-          };
-          const dedupeKey = tagDedupeKey(t);
-          let d = dedupeKey;
-          let i = 1;
-          while (d && takenDedupeKeys.has(d))
-            d = `${dedupeKey}:${i++}`;
-          if (d) {
-            t._d = d;
-            takenDedupeKeys.add(d);
+          const next = normalizeProps({ tag, props: {} }, {
+            innerHTML: c.innerHTML,
+            ...c.getAttributeNames().reduce((props, name) => {
+              props[name] = c.getAttribute(name);
+              return props;
+            }, {}) || {}
+          });
+          next.key = c.getAttribute("data-hid") || void 0;
+          next._d = dedupeKey(next) || hashTag(next);
+          if (state.elMap.has(next._d)) {
+            let count = 1;
+            let k = next._d;
+            while (state.elMap.has(k)) {
+              k = `${next._d}:${count++}`;
+            }
+            state.elMap.set(k, c);
+          } else {
+            state.elMap.set(next._d, c);
           }
-          state.elMap[c.getAttribute("data-hid") || hashTag(t)] = c;
         }
       }
     }
@@ -63,7 +78,7 @@ async function renderDOMHead(head, options = {}) {
     }
     function trackCtx({ id, $el, tag }) {
       const isAttrTag = tag.tag.endsWith("Attrs");
-      state.elMap[id] = $el;
+      state.elMap.set(id, $el);
       if (!isAttrTag) {
         if (tag.textContent && tag.textContent !== $el.textContent) {
           $el.textContent = tag.textContent;
@@ -72,36 +87,36 @@ async function renderDOMHead(head, options = {}) {
           $el.innerHTML = tag.innerHTML;
         }
         track(id, "el", () => {
-          state.elMap[id]?.remove();
-          delete state.elMap[id];
+          $el?.remove();
+          state.elMap.delete(id);
         });
       }
-      if (tag._eventHandlers) {
-        for (const k in tag._eventHandlers) {
-          if (!Object.prototype.hasOwnProperty.call(tag._eventHandlers, k)) {
-            continue;
+      for (const k in tag.props) {
+        if (!Object.hasOwn(tag.props, k))
+          continue;
+        const value = tag.props[k];
+        if (k.startsWith("on") && typeof value === "function") {
+          const dataset = $el?.dataset;
+          if (dataset && dataset[`${k}fired`]) {
+            const ek = k.slice(0, -5);
+            value.call($el, new Event(ek.substring(2)));
           }
           if ($el.getAttribute(`data-${k}`) !== "") {
             (tag.tag === "bodyAttrs" ? dom.defaultView : $el).addEventListener(
               // onload -> load
               k.substring(2),
-              tag._eventHandlers[k].bind($el)
+              value.bind($el)
             );
             $el.setAttribute(`data-${k}`, "");
           }
-        }
-      }
-      for (const k in tag.props) {
-        if (!Object.prototype.hasOwnProperty.call(tag.props, k)) {
           continue;
         }
-        const value = tag.props[k];
         const ck = `attr:${k}`;
         if (k === "class") {
           if (!value) {
             continue;
           }
-          for (const c of value.split(" ")) {
+          for (const c of value) {
             isAttrTag && track(id, `${ck}:${c}`, () => $el.classList.remove(c));
             !$el.classList.contains(c) && $el.classList.add(c);
           }
@@ -109,16 +124,13 @@ async function renderDOMHead(head, options = {}) {
           if (!value) {
             continue;
           }
-          for (const c of value.split(";")) {
-            const propIndex = c.indexOf(":");
-            const k2 = c.substring(0, propIndex).trim();
-            const v = c.substring(propIndex + 1).trim();
+          for (const [k2, v] of value) {
             track(id, `${ck}:${k2}`, () => {
               $el.style.removeProperty(k2);
             });
             $el.style.setProperty(k2, v);
           }
-        } else {
+        } else if (value !== false && value !== null) {
           $el.getAttribute(k) !== value && $el.setAttribute(k, value === true ? "" : String(value));
           isAttrTag && track(id, ck, () => $el.removeAttribute(k));
         }
@@ -126,10 +138,11 @@ async function renderDOMHead(head, options = {}) {
     }
     const pending = [];
     const frag = {
-      bodyClose: undefined,
-      bodyOpen: undefined,
-      head: undefined
+      bodyClose: void 0,
+      bodyOpen: void 0,
+      head: void 0
     };
+    const tags = await resolveTagPromise;
     for (const ctx of tags) {
       const { tag, shouldRender, id } = ctx;
       if (!shouldRender)
@@ -138,7 +151,7 @@ async function renderDOMHead(head, options = {}) {
         dom.title = tag.textContent;
         continue;
       }
-      ctx.$el = ctx.$el || state.elMap[id];
+      ctx.$el = ctx.$el || state.elMap.get(id);
       if (ctx.$el) {
         trackCtx(ctx);
       } else if (HasElementTags.has(tag.tag)) {
@@ -164,25 +177,29 @@ async function renderDOMHead(head, options = {}) {
     await head.hooks.callHook("dom:rendered", { renders: tags });
     resolve();
   }).finally(() => {
-    head._domUpdatePromise = undefined;
+    head._domUpdatePromise = void 0;
     head.dirty = false;
   });
   return head._domUpdatePromise;
 }
 
 function createHead(options = {}) {
-  return createHeadCore({
-    document: IsBrowser ? document : undefined,
-    ...options,
-    plugins: [
-      ...options.plugins || [],
-      DomPlugin({
-        render: renderDOMHead,
-        ...options.domOptions
-      }),
-      ClientEventHandlerPlugin
-    ]
+  const head = createUnhead({
+    document: typeof window !== "undefined" ? document : void 0,
+    ...options
+  });
+  const initialPayload = head.resolvedOptions.document?.head.querySelector('script[id="unhead:payload"]')?.innerHTML || false;
+  if (initialPayload) {
+    head.push(JSON.parse(initialPayload));
+  }
+  const render = options.domOptions?.render || renderDOMHead;
+  head.use({
+    key: "client",
+    hooks: {
+      "entries:updated": render
+    }
   });
+  return head;
 }
 
 function createDebouncedFn(callee, delayer) {
@@ -197,4 +214,4 @@ function createDebouncedFn(callee, delayer) {
   };
 }
 
-export { ClientEventHandlerPlugin, DomPlugin, createDebouncedFn, createHead, renderDOMHead };
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/index.d.mts

@@ -1,9 +1,32 @@
-import { MergeHead, Head, Unhead, HeadEntryOptions, HeadSafe, ActiveHeadEntry, UseSeoMetaInput } from '@unhead/schema';
-export { c as createHeadCore } from './shared/unhead.D--bHScR.mjs';
+import { H as HeadSafe } from './shared/unhead.DLPWlHGE.mjs';
+import { U as Unhead, R as ResolvableHead, r as HeadEntryOptions, o as ActiveHeadEntry, a8 as UseSeoMetaInput, C as CreateHeadOptions } from './shared/unhead.DVcP39oW.mjs';
+export { u as useScript } from './shared/unhead.UCwgwV97.mjs';
+import 'hookable';
 
-type UseHeadInput<T extends MergeHead> = Head<T>;
-declare function useHead<T extends Unhead<any>>(unhead: T, input: Parameters<T['push']>[0], options?: HeadEntryOptions): ReturnType<T['push']>;
-declare function useHeadSafe<T extends Unhead<any>>(unhead: T, input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
-declare function useSeoMeta<T extends Unhead<any>>(unhead: T, input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
+declare function useHead<T extends Unhead<any>, I = ResolvableHead>(unhead: T, input?: ResolvableHead, options?: HeadEntryOptions): ActiveHeadEntry<I>;
+declare function useHeadSafe<T extends Unhead<any>>(unhead: T, input?: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
+declare function useSeoMeta<T extends Unhead<any>>(unhead: T, input?: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<UseSeoMetaInput>;
+/**
+ * @deprecated use `useHead` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHead<T extends Unhead<any>>(unhead: T, input?: Parameters<T['push']>[0], options?: Omit<HeadEntryOptions, 'mode'>): ReturnType<T['push']>;
+/**
+ * @deprecated use `useHeadSafe` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHeadSafe<T extends Unhead<any>>(unhead: T, input?: HeadSafe, options?: Omit<HeadEntryOptions, 'mode'>): ActiveHeadEntry<HeadSafe>;
+/**
+ * @deprecated use `useSeoMeta` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerSeoMeta<T extends Unhead<any>>(unhead: T, input?: UseSeoMetaInput, options?: Omit<HeadEntryOptions, 'mode'>): ActiveHeadEntry<UseSeoMetaInput>;
 
-export { type UseHeadInput, useHead, useHeadSafe, useSeoMeta };
+/**
+ * @deprecated use `createUnhead` instead
+ */
+declare function createHeadCore<T = ResolvableHead>(resolvedOptions?: CreateHeadOptions): Unhead<T>;
+/**
+ * Creates a core instance of unhead. Does not provide a global ctx for composables to work
+ * and does not register DOM plugins.
+ */
+declare function createUnhead<T = ResolvableHead>(resolvedOptions?: CreateHeadOptions): Unhead<T>;
+
+export { createHeadCore, createUnhead, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.d.ts

@@ -1,9 +1,32 @@
-import { MergeHead, Head, Unhead, HeadEntryOptions, HeadSafe, ActiveHeadEntry, UseSeoMetaInput } from '@unhead/schema';
-export { c as createHeadCore } from './shared/unhead.D--bHScR.js';
+import { H as HeadSafe } from './shared/unhead.Bj0vvOrH.js';
+import { U as Unhead, R as ResolvableHead, r as HeadEntryOptions, o as ActiveHeadEntry, a8 as UseSeoMetaInput, C as CreateHeadOptions } from './shared/unhead.DVcP39oW.js';
+export { u as useScript } from './shared/unhead.Bc1vIJ23.js';
+import 'hookable';
 
-type UseHeadInput<T extends MergeHead> = Head<T>;
-declare function useHead<T extends Unhead<any>>(unhead: T, input: Parameters<T['push']>[0], options?: HeadEntryOptions): ReturnType<T['push']>;
-declare function useHeadSafe<T extends Unhead<any>>(unhead: T, input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
-declare function useSeoMeta<T extends Unhead<any>>(unhead: T, input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
+declare function useHead<T extends Unhead<any>, I = ResolvableHead>(unhead: T, input?: ResolvableHead, options?: HeadEntryOptions): ActiveHeadEntry<I>;
+declare function useHeadSafe<T extends Unhead<any>>(unhead: T, input?: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
+declare function useSeoMeta<T extends Unhead<any>>(unhead: T, input?: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<UseSeoMetaInput>;
+/**
+ * @deprecated use `useHead` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHead<T extends Unhead<any>>(unhead: T, input?: Parameters<T['push']>[0], options?: Omit<HeadEntryOptions, 'mode'>): ReturnType<T['push']>;
+/**
+ * @deprecated use `useHeadSafe` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerHeadSafe<T extends Unhead<any>>(unhead: T, input?: HeadSafe, options?: Omit<HeadEntryOptions, 'mode'>): ActiveHeadEntry<HeadSafe>;
+/**
+ * @deprecated use `useSeoMeta` instead. Advanced use cases should tree shake using import.meta.* if statements.
+ */
+declare function useServerSeoMeta<T extends Unhead<any>>(unhead: T, input?: UseSeoMetaInput, options?: Omit<HeadEntryOptions, 'mode'>): ActiveHeadEntry<UseSeoMetaInput>;
 
-export { type UseHeadInput, useHead, useHeadSafe, useSeoMeta };
+/**
+ * @deprecated use `createUnhead` instead
+ */
+declare function createHeadCore<T = ResolvableHead>(resolvedOptions?: CreateHeadOptions): Unhead<T>;
+/**
+ * Creates a core instance of unhead. Does not provide a global ctx for composables to work
+ * and does not register DOM plugins.
+ */
+declare function createUnhead<T = ResolvableHead>(resolvedOptions?: CreateHeadOptions): Unhead<T>;
+
+export { createHeadCore, createUnhead, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.mjs

@@ -1,37 +1,9 @@
-import { whitelistSafeInput, unpackMeta } from '@unhead/shared';
-export { c as createHeadCore } from './shared/unhead.aU5fNi04.mjs';
+export { u as useHead, a as useHeadSafe, b as useSeoMeta, c as useServerHead, d as useServerHeadSafe, e as useServerSeoMeta } from './shared/unhead.BPM0-cfG.mjs';
+export { c as createHeadCore, a as createUnhead } from './shared/unhead.CydFxwlU.mjs';
+export { u as useScript } from './shared/unhead.BHfOzKG2.mjs';
+import './shared/unhead.CApf5sj3.mjs';
+import './shared/unhead.DQc16pHI.mjs';
+import './shared/unhead.yem5I2v_.mjs';
 import 'hookable';
-import './shared/unhead.9459P6Us.mjs';
-
-function useHead(unhead, input, options = {}) {
-  return unhead.push(input, options);
-}
-function useHeadSafe(unhead, input, options) {
-  return useHead(unhead, input, {
-    ...options,
-    // @ts-expect-error untyped
-    transform: whitelistSafeInput
-  });
-}
-function useSeoMeta(unhead, input, options) {
-  const { title, titleTemplate, ...meta } = input;
-  return useHead(unhead, {
-    title,
-    titleTemplate,
-    // we need to input the meta so the reactivity will be resolved
-    _flatMeta: meta
-  }, {
-    ...options,
-    transform(t) {
-      const meta2 = unpackMeta({ ...t._flatMeta });
-      delete t._flatMeta;
-      return {
-        // @ts-expect-error runtime type
-        ...t,
-        meta: meta2
-      };
-    }
-  });
-}
-
-export { useHead, useHeadSafe, useSeoMeta };
+import './shared/unhead.xsi8MZXD.mjs';
+import './shared/unhead.DZbvapt-.mjs';

package/dist/legacy.d.mts

@@ -1,115 +1,16 @@
-import { Script, ActiveHeadEntry, HeadEntryOptions, Unhead, Head, CreateHeadOptions, MergeHead, HeadSafe, UseSeoMetaInput } from '@unhead/schema';
-export { composableNames } from '@unhead/shared';
-export { c as createHeadCore } from './shared/unhead.D--bHScR.mjs';
-
-type UseScriptInput = string | (Omit<Script, 'src'> & {
-    src: string;
-});
-type UseScriptResolvedInput = Omit<Script, 'src'> & {
-    src: string;
-};
-declare function resolveScriptKey(input: UseScriptResolvedInput): any;
-type UseScriptStatus = 'awaitingLoad' | 'loading' | 'loaded' | 'error' | 'removed';
-interface ScriptInstance<T extends BaseScriptApi> {
-    proxy: AsAsyncFunctionValues<T>;
-    instance?: T;
-    id: string;
-    status: UseScriptStatus;
-    entry?: ActiveHeadEntry<any>;
-    load: () => Promise<T>;
-    remove: () => boolean;
-    setupTriggerHandler: (trigger: UseScriptOptions['trigger']) => void;
-    onLoaded: (fn: (instance: T) => void | Promise<void>) => void;
-    onError: (fn: (err?: Error) => void | Promise<void>) => void;
-    /**
-     * @internal
-     */
-    _triggerAbortController?: AbortController | null;
-    /**
-     * @internal
-     */
-    _triggerAbortPromise?: Promise<void>;
-    /**
-     * @internal
-     */
-    _triggerPromises?: Promise<void>[];
-    /**
-     * @internal
-     */
-    _cbs: {
-        loaded: null | ((instance: T) => void | Promise<void>)[];
-        error: null | ((err?: Error) => void | Promise<void>)[];
-    };
-}
-interface UseScriptOptions<T extends BaseScriptApi = Record<string, any>> extends HeadEntryOptions {
-    /**
-     * Resolve the script instance from the window.
-     */
-    use?: () => T | undefined | null;
-    /**
-     * Stub the script instance. Useful for SSR or testing.
-     */
-    stub?: ((ctx: {
-        script: ScriptInstance<T>;
-        fn: string | symbol;
-    }) => any);
-    /**
-     * 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.
-     */
-    trigger?: 'client' | 'server' | 'manual' | Promise<boolean | void> | ((fn: any) => any) | null;
-    /**
-     * Context to run events with. This is useful in Vue to attach the current instance context before
-     * calling the event, allowing the event to be reactive.
-     */
-    eventContext?: any;
-    /**
-     * Called before the script is initialized. Will not be triggered when the script is already loaded. This means
-     * this is guaranteed to be called only once, unless the script is removed and re-added.
-     */
-    beforeInit?: () => void;
-}
-type BaseScriptApi = Record<symbol | string, any>;
-type AsAsyncFunctionValues<T extends BaseScriptApi> = {
-    [key in keyof T]: T[key] extends any[] ? T[key] : T[key] extends (...args: infer A) => infer R ? (...args: A) => R extends Promise<any> ? R : Promise<R> : T[key] extends Record<any, any> ? AsAsyncFunctionValues<T[key]> : never;
-};
-type UseScriptContext<T extends Record<symbol | string, any>> = (Promise<T> & ScriptInstance<T>) & AsAsyncFunctionValues<T> & {
-    /**
-     * @deprecated Use top-level functions instead.
-     */
-    $script: Promise<T> & ScriptInstance<T>;
-};
-type UseFunctionType<T, U> = T extends {
-    use: infer V;
-} ? V extends (...args: any) => any ? ReturnType<V> : U : U;
-/**
- * Load third-party scripts with SSR support and a proxied API.
- *
- * @see https://unhead.unjs.io/usage/composables/use-script
- */
-declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
+import { createUnhead } from './index.mjs';
+export { useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta } from './index.mjs';
+import { U as Unhead, R as ResolvableHead, C as CreateHeadOptions } from './shared/unhead.DVcP39oW.mjs';
+export { u as useScript } from './shared/unhead.UCwgwV97.mjs';
+import './shared/unhead.DLPWlHGE.mjs';
+import 'hookable';
 
 declare const activeHead: {
     value: Unhead<any> | null;
 };
 declare function getActiveHead(): Unhead<any> | null;
-declare const unheadComposablesImports: {
-    from: string;
-    imports: string[];
-}[];
-
-declare function createServerHead<T extends Record<string, any> = Head>(options?: CreateHeadOptions): Unhead<T>;
-declare function createHead<T extends Record<string, any> = Head>(options?: CreateHeadOptions): Unhead<T>;
-type UseHeadInput<T extends MergeHead> = Head<T>;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe> | void;
-declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useServerHeadSafe<T extends HeadSafe>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
+declare function createServerHead<T extends Record<string, any> = ResolvableHead>(options?: CreateHeadOptions): Unhead<T>;
+declare function createHead<T extends Record<string, any> = ResolvableHead>(options?: CreateHeadOptions): Unhead<T>;
+declare const createHeadCore: typeof createUnhead;
 
-export { type AsAsyncFunctionValues, type ScriptInstance, type UseFunctionType, type UseHeadInput, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptResolvedInput, type UseScriptStatus, activeHead, createHead, createServerHead, getActiveHead, resolveScriptKey, unheadComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { activeHead, createHead, createHeadCore, createServerHead, createUnhead, getActiveHead };