unhead 1.9.16 → 1.10.0-beta.3

package/dist/index.cjs

@@ -4,72 +4,80 @@ const hookable = require('hookable');
 const dom = require('@unhead/dom');
 const shared = require('@unhead/shared');
 
-const UsesMergeStrategy = ["templateParams", "htmlAttrs", "bodyAttrs"];
+const UsesMergeStrategy = /* @__PURE__ */ new Set(["templateParams", "htmlAttrs", "bodyAttrs"]);
 const DedupePlugin = shared.defineHeadPlugin({
   hooks: {
-    "tag:normalise": function({ tag }) {
-      ["hid", "vmid", "key"].forEach((key) => {
-        if (tag.props[key]) {
-          tag.key = tag.props[key];
-          delete tag.props[key];
-        }
-      });
+    "tag:normalise": ({ tag }) => {
+      if (tag.props.hid) {
+        tag.key = tag.props.hid;
+        delete tag.props.hid;
+      }
+      if (tag.props.vmid) {
+        tag.key = tag.props.vmid;
+        delete tag.props.vmid;
+      }
+      if (tag.props.key) {
+        tag.key = tag.props.key;
+        delete tag.props.key;
+      }
       const generatedKey = shared.tagDedupeKey(tag);
       const dedupe = generatedKey || (tag.key ? `${tag.tag}:${tag.key}` : false);
       if (dedupe)
         tag._d = dedupe;
     },
-    "tags:resolve": function(ctx) {
-      const deduping = {};
-      ctx.tags.forEach((tag) => {
+    "tags:resolve": (ctx) => {
+      const deduping = /* @__PURE__ */ Object.create(null);
+      for (const tag of ctx.tags) {
         const dedupeKey = (tag.key ? `${tag.tag}:${tag.key}` : tag._d) || tag._p;
         const dupedTag = deduping[dedupeKey];
         if (dupedTag) {
           let strategy = tag?.tagDuplicateStrategy;
-          if (!strategy && UsesMergeStrategy.includes(tag.tag))
+          if (!strategy && UsesMergeStrategy.has(tag.tag))
             strategy = "merge";
           if (strategy === "merge") {
             const oldProps = dupedTag.props;
-            ["class", "style"].forEach((key) => {
-              if (oldProps[key]) {
-                if (tag.props[key]) {
-                  if (key === "style" && !oldProps[key].endsWith(";"))
-                    oldProps[key] += ";";
-                  tag.props[key] = `${oldProps[key]} ${tag.props[key]}`;
-                } else {
-                  tag.props[key] = oldProps[key];
-                }
+            if (oldProps.style && tag.props.style) {
+              if (oldProps.style[oldProps.style.length - 1] !== ";") {
+                oldProps.style += ";";
               }
-            });
+              tag.props.style = `${oldProps.style} ${tag.props.style}`;
+            }
+            if (oldProps.class && tag.props.class) {
+              tag.props.class = `${oldProps.class} ${tag.props.class}`;
+            } else if (oldProps.class) {
+              tag.props.class = oldProps.class;
+            }
             deduping[dedupeKey].props = {
               ...oldProps,
               ...tag.props
             };
-            return;
+            continue;
           } else if (tag._e === dupedTag._e) {
             dupedTag._duped = dupedTag._duped || [];
             tag._d = `${dupedTag._d}:${dupedTag._duped.length + 1}`;
             dupedTag._duped.push(tag);
-            return;
+            continue;
           } else if (shared.tagWeight(tag) > shared.tagWeight(dupedTag)) {
-            return;
+            continue;
           }
         }
-        const propCount = Object.keys(tag.props).length + (tag.innerHTML ? 1 : 0) + (tag.textContent ? 1 : 0);
-        if (shared.HasElementTags.includes(tag.tag) && propCount === 0) {
+        const hasProps = tag.innerHTML || tag.textContent || Object.keys(tag.props).length !== 0;
+        if (!hasProps && shared.HasElementTags.has(tag.tag)) {
           delete deduping[dedupeKey];
-          return;
+          continue;
         }
         deduping[dedupeKey] = tag;
-      });
+      }
       const newTags = [];
-      Object.values(deduping).forEach((tag) => {
+      for (const key in deduping) {
+        const tag = deduping[key];
         const dupes = tag._duped;
-        delete tag._duped;
         newTags.push(tag);
-        if (dupes)
+        if (dupes) {
+          delete tag._duped;
           newTags.push(...dupes);
-      });
+        }
+      }
       ctx.tags = newTags;
       ctx.tags = ctx.tags.filter((t) => !(t.tag === "meta" && (t.props.name || t.props.property) && !t.props.content));
     }
@@ -79,53 +87,84 @@ const DedupePlugin = shared.defineHeadPlugin({
 const PayloadPlugin = shared.defineHeadPlugin({
   mode: "server",
   hooks: {
-    "tags:resolve": function(ctx) {
+    "tags:resolve": (ctx) => {
       const payload = {};
-      ctx.tags.filter((tag) => ["titleTemplate", "templateParams", "title"].includes(tag.tag) && tag._m === "server").forEach((tag) => {
-        payload[tag.tag] = tag.tag.startsWith("title") ? tag.textContent : tag.props;
-      });
-      Object.keys(payload).length && ctx.tags.push({
-        tag: "script",
-        innerHTML: JSON.stringify(payload),
-        props: { id: "unhead:payload", type: "application/json" }
-      });
+      let hasPayload = false;
+      for (const tag of ctx.tags) {
+        if (tag._m !== "server" || tag.tag !== "titleTemplate" && tag.tag !== "templateParams" && tag.tag !== "title") {
+          continue;
+        }
+        payload[tag.tag] = tag.tag === "title" || tag.tag === "titleTemplate" ? tag.textContent : tag.props;
+        hasPayload = true;
+      }
+      if (hasPayload) {
+        ctx.tags.push({
+          tag: "script",
+          innerHTML: JSON.stringify(payload),
+          props: { id: "unhead:payload", type: "application/json" }
+        });
+      }
     }
   }
 });
 
-const ValidEventTags = ["script", "link", "bodyAttrs"];
+const ValidEventTags = /* @__PURE__ */ new Set(["script", "link", "bodyAttrs"]);
 const EventHandlersPlugin = shared.defineHeadPlugin((head) => ({
   hooks: {
-    "tags:resolve": function(ctx) {
-      for (const tag of ctx.tags.filter((t) => ValidEventTags.includes(t.tag))) {
-        Object.entries(tag.props).forEach(([key, value]) => {
-          if (key.startsWith("on") && typeof value === "function") {
-            if (head.ssr && shared.NetworkEvents.includes(key))
-              tag.props[key] = `this.dataset.${key}fired = true`;
-            else
-              delete tag.props[key];
-            tag._eventHandlers = tag._eventHandlers || {};
-            tag._eventHandlers[key] = value;
+    "tags:resolve": (ctx) => {
+      for (const tag of ctx.tags) {
+        if (!ValidEventTags.has(tag.tag)) {
+          continue;
+        }
+        const props = tag.props;
+        for (const key in props) {
+          if (key[0] !== "o" || key[1] !== "n") {
+            continue;
           }
-        });
-        if (head.ssr && tag._eventHandlers && (tag.props.src || tag.props.href))
+          if (!Object.prototype.hasOwnProperty.call(props, key)) {
+            continue;
+          }
+          const value = props[key];
+          if (typeof value !== "function") {
+            continue;
+          }
+          if (head.ssr && shared.NetworkEvents.has(key)) {
+            props[key] = `this.dataset.${key}fired = true`;
+          } else {
+            delete props[key];
+          }
+          tag._eventHandlers = tag._eventHandlers || {};
+          tag._eventHandlers[key] = value;
+        }
+        if (head.ssr && tag._eventHandlers && (tag.props.src || tag.props.href)) {
           tag.key = tag.key || shared.hashCode(tag.props.src || tag.props.href);
+        }
       }
     },
-    "dom:renderTag": function({ $el, tag }) {
-      for (const k of Object.keys($el?.dataset || {}).filter((k2) => shared.NetworkEvents.some((e) => `${e}fired` === k2))) {
-        const ek = k.replace("fired", "");
-        tag._eventHandlers?.[ek]?.call($el, new Event(ek.replace("on", "")));
+    "dom:renderTag": ({ $el, tag }) => {
+      const dataset = $el?.dataset;
+      if (!dataset) {
+        return;
+      }
+      for (const k in dataset) {
+        if (!k.endsWith("fired")) {
+          continue;
+        }
+        const ek = k.slice(0, -5);
+        if (!shared.NetworkEvents.has(ek)) {
+          continue;
+        }
+        tag._eventHandlers?.[ek]?.call($el, new Event(ek.substring(2)));
       }
     }
   }
 }));
 
-const DupeableTags = ["link", "style", "script", "noscript"];
+const DupeableTags = /* @__PURE__ */ new Set(["link", "style", "script", "noscript"]);
 const HashKeyedPlugin = shared.defineHeadPlugin({
   hooks: {
     "tag:normalise": ({ tag }) => {
-      if (tag.key && DupeableTags.includes(tag.tag)) {
+      if (tag.key && DupeableTags.has(tag.tag)) {
         tag.props["data-hid"] = tag._h = shared.hashCode(tag.key);
       }
     }
@@ -135,17 +174,32 @@ const HashKeyedPlugin = shared.defineHeadPlugin({
 const SortPlugin = shared.defineHeadPlugin({
   hooks: {
     "tags:resolve": (ctx) => {
-      const tagPositionForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
-      for (const { prefix, offset } of shared.SortModifiers) {
-        for (const tag of ctx.tags.filter((tag2) => typeof tag2.tagPriority === "string" && tag2.tagPriority.startsWith(prefix))) {
-          const position = tagPositionForKey(
-            tag.tagPriority.replace(prefix, "")
-          );
-          if (typeof position !== "undefined")
+      for (const tag of ctx.tags) {
+        if (typeof tag.tagPriority !== "string") {
+          continue;
+        }
+        for (const { prefix, offset } of shared.SortModifiers) {
+          if (!tag.tagPriority.startsWith(prefix)) {
+            continue;
+          }
+          const key = tag.tagPriority.substring(prefix.length);
+          const position = ctx.tags.find((tag2) => tag2._d === key)?._p;
+          if (position !== void 0) {
             tag._p = position + offset;
+            break;
+          }
         }
       }
-      ctx.tags.sort((a, b) => a._p - b._p).sort((a, b) => shared.tagWeight(a) - shared.tagWeight(b));
+      ctx.tags.sort((a, b) => {
+        const aWeight = shared.tagWeight(a);
+        const bWeight = shared.tagWeight(b);
+        if (aWeight < bWeight) {
+          return -1;
+        } else if (aWeight > bWeight) {
+          return 1;
+        }
+        return a._p - b._p;
+      });
     }
   }
 });
@@ -155,30 +209,45 @@ const SupportedAttrs = {
   link: "href",
   htmlAttrs: "lang"
 };
+const contentAttrs = ["innerHTML", "textContent"];
 const TemplateParamsPlugin = shared.defineHeadPlugin((head) => ({
   hooks: {
     "tags:resolve": (ctx) => {
       const { tags } = ctx;
-      const title = tags.find((tag) => tag.tag === "title")?.textContent;
-      const idx = tags.findIndex((tag) => tag.tag === "templateParams");
-      const params = idx !== -1 ? tags[idx].props : {};
+      let templateParams;
+      for (let i = 0; i < tags.length; i += 1) {
+        const tag = tags[i];
+        if (tag.tag !== "templateParams") {
+          continue;
+        }
+        templateParams = ctx.tags.splice(i, 1)[0].props;
+        i -= 1;
+      }
+      const params = templateParams || {};
       const sep = params.separator || "|";
       delete params.separator;
-      params.pageTitle = shared.processTemplateParams(params.pageTitle || title || "", params, sep);
-      for (const tag of tags.filter((t) => t.processTemplateParams !== false)) {
+      params.pageTitle = shared.processTemplateParams(
+        // find templateParams
+        params.pageTitle || tags.find((tag) => tag.tag === "title")?.textContent || "",
+        params,
+        sep
+      );
+      for (const tag of tags) {
+        if (tag.processTemplateParams === false) {
+          continue;
+        }
         const v = SupportedAttrs[tag.tag];
         if (v && typeof tag.props[v] === "string") {
           tag.props[v] = shared.processTemplateParams(tag.props[v], params, sep);
-        } else if (tag.processTemplateParams === true || ["titleTemplate", "title"].includes(tag.tag)) {
-          ["innerHTML", "textContent"].forEach((p) => {
+        } else if (tag.processTemplateParams || tag.tag === "titleTemplate" || tag.tag === "title") {
+          for (const p of contentAttrs) {
             if (typeof tag[p] === "string")
               tag[p] = shared.processTemplateParams(tag[p], params, sep);
-          });
+          }
         }
       }
       head._templateParams = params;
       head._separator = sep;
-      ctx.tags = tags.filter((tag) => tag.tag !== "templateParams");
     }
   }
 }));
@@ -187,42 +256,49 @@ const TitleTemplatePlugin = shared.defineHeadPlugin({
   hooks: {
     "tags:resolve": (ctx) => {
       const { tags } = ctx;
-      let titleTemplateIdx = tags.findIndex((i) => i.tag === "titleTemplate");
-      const titleIdx = tags.findIndex((i) => i.tag === "title");
-      if (titleIdx !== -1 && titleTemplateIdx !== -1) {
+      let titleTag;
+      let titleTemplateTag;
+      for (let i = 0; i < tags.length; i += 1) {
+        const tag = tags[i];
+        if (tag.tag === "title") {
+          titleTag = tag;
+        } else if (tag.tag === "titleTemplate") {
+          titleTemplateTag = tag;
+        }
+      }
+      if (titleTemplateTag && titleTag) {
         const newTitle = shared.resolveTitleTemplate(
-          tags[titleTemplateIdx].textContent,
-          tags[titleIdx].textContent
+          titleTemplateTag.textContent,
+          titleTag.textContent
         );
         if (newTitle !== null) {
-          tags[titleIdx].textContent = newTitle || tags[titleIdx].textContent;
+          titleTag.textContent = newTitle || titleTag.textContent;
         } else {
-          delete tags[titleIdx];
+          ctx.tags.splice(ctx.tags.indexOf(titleTag), 1);
         }
-      } else if (titleTemplateIdx !== -1) {
+      } else if (titleTemplateTag) {
         const newTitle = shared.resolveTitleTemplate(
-          tags[titleTemplateIdx].textContent
+          titleTemplateTag.textContent
         );
         if (newTitle !== null) {
-          tags[titleTemplateIdx].textContent = newTitle;
-          tags[titleTemplateIdx].tag = "title";
-          titleTemplateIdx = -1;
+          titleTemplateTag.textContent = newTitle;
+          titleTemplateTag.tag = "title";
+          titleTemplateTag = void 0;
         }
       }
-      if (titleTemplateIdx !== -1) {
-        delete tags[titleTemplateIdx];
+      if (titleTemplateTag) {
+        ctx.tags.splice(ctx.tags.indexOf(titleTemplateTag), 1);
       }
-      ctx.tags = tags.filter(Boolean);
     }
   }
 });
 
 const XSSPlugin = shared.defineHeadPlugin({
   hooks: {
-    "tags:afterResolve": function(ctx) {
+    "tags:afterResolve": (ctx) => {
       for (const tag of ctx.tags) {
         if (typeof tag.innerHTML === "string") {
-          if (tag.innerHTML && ["application/ld+json", "application/json"].includes(tag.props.type)) {
+          if (tag.innerHTML && (tag.props.type === "application/ld+json" || tag.props.type === "application/json")) {
             tag.innerHTML = tag.innerHTML.replace(/</g, "\\u003C");
           } else {
             tag.innerHTML = tag.innerHTML.replace(new RegExp(`</${tag.tag}`, "g"), `<\\/${tag.tag}`);
@@ -293,12 +369,11 @@ function createHeadCore(options = {}) {
         },
         // a patch is the same as creating a new entry, just a nice DX
         patch(input2) {
-          entries = entries.map((e) => {
+          for (const e of entries) {
             if (e._i === entry._i) {
               e.input = entry.input = input2;
             }
-            return e;
-          });
+          }
           updated();
         }
       };
@@ -349,7 +424,7 @@ const importRe = /@import/;
 function CapoPlugin(options) {
   return shared.defineHeadPlugin({
     hooks: {
-      "tags:beforeResolve": function({ tags }) {
+      "tags:beforeResolve": ({ tags }) => {
         for (const tag of tags) {
           if (tag.tagPosition && tag.tagPosition !== "head")
             continue;
@@ -367,11 +442,11 @@ function CapoPlugin(options) {
             tag.tagPriority = 50;
           } else if (isLink && tag.props.rel === "stylesheet" || tag.tag === "style") {
             tag.tagPriority = 60;
-          } else if (isLink && ["preload", "modulepreload"].includes(tag.props.rel)) {
+          } else if (isLink && (tag.props.rel === "preload" || tag.props.rel === "modulepreload")) {
             tag.tagPriority = 70;
           } else if (isScript && isTruthy(tag.props.defer) && tag.props.src && !isTruthy(tag.props.async)) {
             tag.tagPriority = 80;
-          } else if (isLink && ["prefetch", "dns-prefetch", "prerender"].includes(tag.props.rel)) {
+          } else if (isLink && (tag.props.rel === "prefetch" || tag.props.rel === "dns-prefetch" || tag.props.rel === "prerender")) {
             tag.tagPriority = 90;
           }
         }
@@ -402,9 +477,9 @@ function useHead(input, options = {}) {
   return head?.push(input, options);
 }
 
-function useHeadSafe(input, options = {}) {
+function useHeadSafe(input, options) {
   return useHead(input, {
-    ...options || {},
+    ...options,
     transform: shared.whitelistSafeInput
   });
 }
@@ -441,18 +516,25 @@ function useSeoMeta(input, options) {
 
 function useServerSeoMeta(input, options) {
   return useSeoMeta(input, {
-    ...options || {},
+    ...options,
     mode: "server"
   });
 }
 
+const ScriptProxyTarget = Symbol("ScriptProxyTarget");
+function sharedTarget() {
+}
+sharedTarget[ScriptProxyTarget] = true;
+function resolveScriptKey(input) {
+  return input.key || shared.hashCode(input.src || (typeof input.innerHTML === "string" ? input.innerHTML : ""));
+}
 function useScript(_input, _options) {
   const input = typeof _input === "string" ? { src: _input } : _input;
   const options = _options || {};
   const head = options.head || getActiveHead();
   if (!head)
     throw new Error("Missing Unhead context.");
-  const id = input.key || shared.hashCode(input.src || (typeof input.innerHTML === "string" ? input.innerHTML : ""));
+  const id = resolveScriptKey(input);
   if (head._scripts?.[id])
     return head._scripts[id];
   options.beforeInit?.();
@@ -460,7 +542,7 @@ function useScript(_input, _options) {
     script.status = s;
     head.hooks.callHook(`script:updated`, hookCtx);
   };
-  const trigger = typeof options.trigger !== "undefined" ? options.trigger : "client";
+  const trigger = options.trigger !== void 0 ? options.trigger : "client";
   shared.ScriptNetworkEvents.forEach((fn) => {
     const _fn = typeof input[fn] === "function" ? input[fn].bind(options.eventContext) : null;
     input[fn] = (e) => {
@@ -468,15 +550,23 @@ function useScript(_input, _options) {
       _fn?.(e);
     };
   });
-  const proxy = { instance: !head.ssr && options?.use?.() || {} };
+  const _cbs = { loaded: [], error: [] };
+  const _registerCb = (key, cb) => {
+    const i = _cbs[key].push(cb);
+    return () => _cbs[key].splice(i - 1, 1);
+  };
   const loadPromise = new Promise((resolve, reject) => {
+    if (head.ssr)
+      return;
     const emit = (api) => requestAnimationFrame(() => resolve(api));
     const _ = head.hooks.hook("script:updated", ({ script: script2 }) => {
       if (script2.id === id && (script2.status === "loaded" || script2.status === "error")) {
         if (script2.status === "loaded") {
           if (typeof options.use === "function") {
             const api = options.use();
-            api && emit(api);
+            if (api) {
+              emit(api);
+            }
           } else {
             emit({});
           }
@@ -486,8 +576,10 @@ function useScript(_input, _options) {
         _();
       }
     });
-  }).then((api) => proxy.instance = api);
-  const script = {
+  });
+  const script = Object.assign(loadPromise, {
+    instance: !head.ssr && options?.use?.() || null,
+    proxy: null,
     id,
     status: "awaitingLoad",
     remove() {
@@ -499,7 +591,7 @@ function useScript(_input, _options) {
       }
       return false;
     },
-    load() {
+    load(cb) {
       if (!script.entry) {
         syncStatus("loading");
         const defaults = {
@@ -514,9 +606,26 @@ function useScript(_input, _options) {
           script: [{ ...defaults, ...input, key: `script.${id}` }]
         }, options);
       }
+      if (cb)
+        _registerCb("loaded", cb);
       return loadPromise;
-    }
-  };
+    },
+    onLoaded(cb) {
+      return _registerCb("loaded", cb);
+    },
+    onError(cb) {
+      return _registerCb("error", cb);
+    },
+    _cbs
+  });
+  loadPromise.then((api) => {
+    script.instance = api;
+    _cbs.loaded.forEach((cb) => cb(api));
+    _cbs.loaded = [];
+  }).catch((err) => {
+    _cbs.error.forEach((cb) => cb(err));
+    _cbs.error = [];
+  });
   const hookCtx = { script };
   if (trigger === "client" && !head.ssr || trigger === "server" && head.ssr)
     script.load();
@@ -524,27 +633,53 @@ function useScript(_input, _options) {
     trigger.then(script.load);
   else if (typeof trigger === "function")
     trigger(async () => script.load());
-  proxy.$script = Object.assign(loadPromise, script);
-  const instance = new Proxy(proxy, {
-    get({ instance: _ }, k) {
-      const stub = options.stub?.({ script: proxy.$script, fn: k });
-      if (stub)
-        return stub;
-      if (k === "$script")
-        return proxy.$script;
-      const exists = _ && k in _ && typeof _[k] !== "undefined";
-      head.hooks.callHook("script:instance-fn", { script, fn: k, exists });
-      return exists ? Reflect.get(_, k) : (...args) => loadPromise.then((api) => {
-        const _k = Reflect.get(api, k);
-        return typeof _k === "function" ? Reflect.apply(api[k], api, args) : _k;
-      });
+  script.$script = script;
+  const proxyChain = (instance, accessor, accessors) => {
+    return new Proxy((!accessor ? instance : instance?.[accessor]) || sharedTarget, {
+      get(_, k, r) {
+        head.hooks.callHook("script:instance-fn", { script, fn: k, exists: k in _ });
+        if (!accessor) {
+          const stub = options.stub?.({ script, fn: k });
+          if (stub)
+            return stub;
+        }
+        if (_ && k in _) {
+          return Reflect.get(_, k, r);
+        }
+        if (k === Symbol.iterator) {
+          return [][Symbol.iterator];
+        }
+        return proxyChain(accessor ? instance?.[accessor] : instance, k, accessors || [k]);
+      },
+      async apply(_, _this, args) {
+        if (head.ssr && _[ScriptProxyTarget])
+          return;
+        let instance2;
+        const access = (fn2) => {
+          instance2 = fn2 || instance2;
+          for (let i = 0; i < (accessors || []).length; i++) {
+            const k = (accessors || [])[i];
+            fn2 = fn2?.[k];
+          }
+          return fn2;
+        };
+        const fn = access(script.instance) || access(await loadPromise);
+        return typeof fn === "function" ? Reflect.apply(fn, instance2, args) : fn;
+      }
+    });
+  };
+  script.proxy = proxyChain(script.instance);
+  const res = new Proxy(script, {
+    get(_, k) {
+      const target = k in script ? script : script.proxy;
+      if (k === "then" || k === "catch") {
+        return script[k].bind(script);
+      }
+      return Reflect.get(target, k, target);
     }
   });
-  head._scripts = Object.assign(
-    head._scripts || {},
-    { [id]: instance }
-  );
-  return instance;
+  head._scripts = Object.assign(head._scripts || {}, { [id]: res });
+  return res;
 }
 
 exports.composableNames = shared.composableNames;
@@ -554,6 +689,7 @@ exports.createHead = createHead;
 exports.createHeadCore = createHeadCore;
 exports.createServerHead = createServerHead;
 exports.getActiveHead = getActiveHead;
+exports.resolveScriptKey = resolveScriptKey;
 exports.unheadComposablesImports = unheadComposablesImports;
 exports.useHead = useHead;
 exports.useHeadSafe = useHeadSafe;

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateHeadOptions, Unhead, MergeHead, HeadEntryOptions, ActiveHeadEntry, HeadSafe, UseSeoMetaInput, UseScriptInput, UseScriptOptions, ScriptInstance } from '@unhead/schema';
+import { Head, CreateHeadOptions, Unhead, MergeHead, HeadEntryOptions, ActiveHeadEntry, HeadSafe, UseSeoMetaInput, ScriptInstance, AsAsyncFunctionValues, UseScriptResolvedInput, UseScriptInput, UseScriptOptions, UseFunctionType } from '@unhead/schema';
 export { composableNames } from '@unhead/shared';
 
 declare function createHead<T extends {} = Head>(options?: CreateHeadOptions): Unhead<T>;
@@ -41,14 +41,18 @@ declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions):
 
 declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
+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>;
+};
+declare function resolveScriptKey(input: UseScriptResolvedInput): any;
 /**
  * Load third-party scripts with SSR support and a proxied API.
  *
- * @experimental
  * @see https://unhead.unjs.io/usage/composables/use-script
  */
-declare function useScript<T extends Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): T & {
-    $script: Promise<T> & ScriptInstance<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>>;
 
-export { CapoPlugin, HashHydrationPlugin, type UseHeadInput, createHead, createHeadCore, createServerHead, getActiveHead, unheadComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { CapoPlugin, HashHydrationPlugin, type UseHeadInput, type UseScriptContext, createHead, createHeadCore, createServerHead, getActiveHead, resolveScriptKey, unheadComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };