unhead 2.0.0-alpha.3 → 2.0.0-alpha.31

package/dist/client.d.mts

@@ -1,25 +1,13 @@
-import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateClientHeadOptions, Unhead, DomPluginOptions, RenderDomHeadOptions } from '@unhead/schema';
+import { R as ResolvableHead, q as CreateClientHeadOptions, U as Unhead, G as RenderDomHeadOptions } from './shared/unhead.BlCDUtBx.mjs';
+import 'hookable';
 
-declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): _unhead_schema.Unhead<T>;
-
-/**
- * Queue a debounced update of the DOM head.
- */
-declare function debouncedRenderDOMHead<T extends Unhead<any>>(head: T, options?: DomPluginOptions): Promise<void>;
-
-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.
  */
 declare function renderDOMHead<T extends Unhead<any>>(head: T, options?: RenderDomHeadOptions): Promise<void>;
 
-export { ClientEventHandlerPlugin, DomPlugin, createHead, debouncedRenderDOMHead, renderDOMHead };
+declare function createDebouncedFn(callee: () => void, delayer: (fn: () => void) => void): () => void;
+
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/client.d.ts

@@ -1,25 +1,13 @@
-import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateClientHeadOptions, Unhead, DomPluginOptions, RenderDomHeadOptions } from '@unhead/schema';
+import { R as ResolvableHead, q as CreateClientHeadOptions, U as Unhead, G as RenderDomHeadOptions } from './shared/unhead.BlCDUtBx.js';
+import 'hookable';
 
-declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): _unhead_schema.Unhead<T>;
-
-/**
- * Queue a debounced update of the DOM head.
- */
-declare function debouncedRenderDOMHead<T extends Unhead<any>>(head: T, options?: DomPluginOptions): Promise<void>;
-
-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.
  */
 declare function renderDOMHead<T extends Unhead<any>>(head: T, options?: RenderDomHeadOptions): Promise<void>;
 
-export { ClientEventHandlerPlugin, DomPlugin, createHead, debouncedRenderDOMHead, renderDOMHead };
+declare function createDebouncedFn(callee: () => void, delayer: (fn: () => void) => void): () => void;
+
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/client.mjs

@@ -1,20 +1,217 @@
-import { IsBrowser } from '@unhead/shared';
-import { c as createHeadCore } from './shared/unhead.q1gkl3A9.mjs';
-import { D as DomPlugin, C as ClientEventHandlerPlugin } from './shared/unhead.ovi5lkPs.mjs';
-export { d as debouncedRenderDOMHead, r as renderDOMHead } from './shared/unhead.ovi5lkPs.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;
+  if (!dom || !head.dirty)
+    return;
+  const beforeRenderCtx = { shouldRender: true, tags: [] };
+  await head.hooks.callHook("dom:beforeRender", beforeRenderCtx);
+  if (!beforeRenderCtx.shouldRender)
+    return;
+  if (head._domUpdatePromise) {
+    return head._domUpdatePromise;
+  }
+  head._domUpdatePromise = new Promise(async (resolve) => {
+    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: (/* @__PURE__ */ new Map()).set("htmlAttrs", dom.documentElement).set("bodyAttrs", dom.body)
+      };
+      for (const key of ["body", "head"]) {
+        const children = dom[key]?.children;
+        for (const c of children) {
+          const tag = c.tagName.toLowerCase();
+          if (!HasElementTags.has(tag)) {
+            continue;
+          }
+          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.pendingSideEffects = { ...state.sideEffects };
+    state.sideEffects = {};
+    function track(id, scope, fn) {
+      const k = `${id}:${scope}`;
+      state.sideEffects[k] = fn;
+      delete state.pendingSideEffects[k];
+    }
+    function trackCtx({ id, $el, tag }) {
+      const isAttrTag = tag.tag.endsWith("Attrs");
+      state.elMap.set(id, $el);
+      if (!isAttrTag) {
+        if (tag.textContent && tag.textContent !== $el.textContent) {
+          $el.textContent = tag.textContent;
+        }
+        if (tag.innerHTML && tag.innerHTML !== $el.innerHTML) {
+          $el.innerHTML = tag.innerHTML;
+        }
+        track(id, "el", () => {
+          $el?.remove();
+          state.elMap.delete(id);
+        });
+      }
+      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),
+              value.bind($el)
+            );
+            $el.setAttribute(`data-${k}`, "");
+          }
+          continue;
+        }
+        const ck = `attr:${k}`;
+        if (k === "class") {
+          if (!value) {
+            continue;
+          }
+          for (const c of value) {
+            isAttrTag && track(id, `${ck}:${c}`, () => $el.classList.remove(c));
+            !$el.classList.contains(c) && $el.classList.add(c);
+          }
+        } else if (k === "style") {
+          if (!value) {
+            continue;
+          }
+          for (const [k2, v] of value) {
+            track(id, `${ck}:${k2}`, () => {
+              $el.style.removeProperty(k2);
+            });
+            $el.style.setProperty(k2, v);
+          }
+        } else if (value !== false && value !== null) {
+          $el.getAttribute(k) !== value && $el.setAttribute(k, value === true ? "" : String(value));
+          isAttrTag && track(id, ck, () => $el.removeAttribute(k));
+        }
+      }
+    }
+    const pending = [];
+    const frag = {
+      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)
+        continue;
+      if (tag.tag === "title") {
+        dom.title = tag.textContent;
+        continue;
+      }
+      ctx.$el = ctx.$el || state.elMap.get(id);
+      if (ctx.$el) {
+        trackCtx(ctx);
+      } else if (HasElementTags.has(tag.tag)) {
+        pending.push(ctx);
+      }
+    }
+    for (const ctx of pending) {
+      const pos = ctx.tag.tagPosition || "head";
+      ctx.$el = dom.createElement(ctx.tag.tag);
+      trackCtx(ctx);
+      frag[pos] = frag[pos] || dom.createDocumentFragment();
+      frag[pos].appendChild(ctx.$el);
+    }
+    for (const ctx of tags)
+      await head.hooks.callHook("dom:renderTag", ctx, dom, track);
+    frag.head && dom.head.appendChild(frag.head);
+    frag.bodyOpen && dom.body.insertBefore(frag.bodyOpen, dom.body.firstChild);
+    frag.bodyClose && dom.body.appendChild(frag.bodyClose);
+    for (const k in state.pendingSideEffects) {
+      state.pendingSideEffects[k]();
+    }
+    head._dom = state;
+    await head.hooks.callHook("dom:rendered", { renders: tags });
+    resolve();
+  }).finally(() => {
+    head._domUpdatePromise = void 0;
+    head.dirty = false;
+  });
+  return head._domUpdatePromise;
+}
 
 function createHead(options = {}) {
-  return createHeadCore({
-    document: IsBrowser ? document : undefined,
-    ...options,
-    plugins: [
-      ...options.plugins || [],
-      DomPlugin(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) {
+  let ctxId = 0;
+  return () => {
+    const delayFnCtxId = ++ctxId;
+    delayer(() => {
+      if (ctxId === delayFnCtxId) {
+        callee();
+      }
+    });
+  };
 }
 
-export { ClientEventHandlerPlugin, DomPlugin, createHead };
+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.BCRd_6gC.mjs';
+import { U as Unhead, R as ResolvableHead, r as HeadEntryOptions, o as ActiveHeadEntry, a8 as UseSeoMetaInput, C as CreateHeadOptions } from './shared/unhead.BlCDUtBx.mjs';
+export { u as useScript } from './shared/unhead.CGomMdtP.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.dVLMTonB.js';
+import { U as Unhead, R as ResolvableHead, r as HeadEntryOptions, o as ActiveHeadEntry, a8 as UseSeoMetaInput, C as CreateHeadOptions } from './shared/unhead.BlCDUtBx.js';
+export { u as useScript } from './shared/unhead.QmkIVPAq.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.q1gkl3A9.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.BlCDUtBx.mjs';
+export { u as useScript } from './shared/unhead.CGomMdtP.mjs';
+import './shared/unhead.BCRd_6gC.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 };