renovate-log-parser 0.1.0 → 0.1.2

package/web/.output/server/node_modules/unhead/dist/server.mjs

@@ -1,180 +0,0 @@
-import { a as createUnhead } from './shared/unhead.CaI5ZD4O.mjs';
-import { T as TagsWithInnerContent, S as SelfClosingTags } from './shared/unhead.yem5I2v_.mjs';
-import { parseHtmlForUnheadExtraction, applyHeadToHtml, parseHtmlForIndexes } from './parser.mjs';
-import 'hookable';
-import './shared/unhead.B3VbJo7Y.mjs';
-import './shared/unhead.CbpEuj3y.mjs';
-
-// @__NO_SIDE_EFFECTS__
-function createHead(options = {}) {
-  const unhead = createUnhead({
-    ...options,
-    // @ts-expect-error untyped
-    document: false,
-    propResolvers: [
-      ...options.propResolvers || [],
-      (k, v) => {
-        if (k && k.startsWith("on") && typeof v === "function") {
-          return `this.dataset.${k}fired = true`;
-        }
-        return v;
-      }
-    ],
-    init: [
-      options.disableDefaults ? void 0 : {
-        htmlAttrs: {
-          lang: "en"
-        },
-        meta: [
-          {
-            charset: "utf-8"
-          },
-          {
-            name: "viewport",
-            content: "width=device-width, initial-scale=1"
-          }
-        ]
-      },
-      ...options.init || []
-    ]
-  });
-  unhead._ssrPayload = {};
-  unhead.use({
-    key: "server",
-    hooks: {
-      "tags:resolve": function(ctx) {
-        const title = ctx.tagMap.get("title");
-        const titleTemplate = ctx.tagMap.get("titleTemplate");
-        let payload = {
-          title: title?.mode === "server" ? unhead._title : void 0,
-          titleTemplate: titleTemplate?.mode === "server" ? unhead._titleTemplate : void 0
-        };
-        if (Object.keys(unhead._ssrPayload || {}).length > 0) {
-          payload = {
-            ...unhead._ssrPayload,
-            ...payload
-          };
-        }
-        if (Object.values(payload).some(Boolean)) {
-          ctx.tags.push({
-            tag: "script",
-            innerHTML: JSON.stringify(payload),
-            props: { id: "unhead:payload", type: "application/json" }
-          });
-        }
-      }
-    }
-  });
-  return unhead;
-}
-
-function extractUnheadInputFromHtml(html) {
-  return parseHtmlForUnheadExtraction(html);
-}
-
-function encodeAttribute(value) {
-  return String(value).replace(/"/g, """);
-}
-function propsToString(props) {
-  let attrs = "";
-  for (const key in props) {
-    if (!Object.hasOwn(props, key))
-      continue;
-    let value = props[key];
-    if ((key === "class" || key === "style") && typeof value !== "string") {
-      value = key === "class" ? Array.from(value).join(" ") : Array.from(value).map(([k, v]) => `${k}:${v}`).join(";");
-    }
-    if (value !== false && value !== null) {
-      attrs += value === true ? ` ${key}` : ` ${key}="${encodeAttribute(value)}"`;
-    }
-  }
-  return attrs;
-}
-
-function escapeHtml(str) {
-  return str.replace(/[&<>"'/]/g, (char) => {
-    switch (char) {
-      case "&":
-        return "&amp;";
-      case "<":
-        return "&lt;";
-      case ">":
-        return "&gt;";
-      case '"':
-        return "&quot;";
-      case "'":
-        return "&#x27;";
-      case "/":
-        return "&#x2F;";
-      default:
-        return char;
-    }
-  });
-}
-function tagToString(tag) {
-  const attrs = propsToString(tag.props);
-  const openTag = `<${tag.tag}${attrs}>`;
-  if (!TagsWithInnerContent.has(tag.tag))
-    return SelfClosingTags.has(tag.tag) ? openTag : `${openTag}</${tag.tag}>`;
-  let content = String(tag.textContent || tag.innerHTML || "");
-  content = tag.tag === "title" ? escapeHtml(content) : content.replace(new RegExp(`</${tag.tag}`, "gi"), `<\\/${tag.tag}`);
-  return SelfClosingTags.has(tag.tag) ? openTag : `${openTag}${content}</${tag.tag}>`;
-}
-
-function ssrRenderTags(tags, options) {
-  const schema = { htmlAttrs: {}, bodyAttrs: {}, tags: { head: "", bodyClose: "", bodyOpen: "" } };
-  const lineBreaks = !options?.omitLineBreaks ? "\n" : "";
-  for (const tag of tags) {
-    if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
-      Object.assign(schema[tag.tag], tag.props);
-      continue;
-    }
-    const s = tagToString(tag);
-    const tagPosition = tag.tagPosition || "head";
-    schema.tags[tagPosition] += schema.tags[tagPosition] ? `${lineBreaks}${s}` : s;
-  }
-  return {
-    headTags: schema.tags.head,
-    bodyTags: schema.tags.bodyClose,
-    bodyTagsOpen: schema.tags.bodyOpen,
-    htmlAttrs: propsToString(schema.htmlAttrs),
-    bodyAttrs: propsToString(schema.bodyAttrs)
-  };
-}
-
-// @__NO_SIDE_EFFECTS__
-async function renderSSRHead(head, options) {
-  const beforeRenderCtx = { shouldRender: true };
-  await head.hooks.callHook("ssr:beforeRender", beforeRenderCtx);
-  if (!beforeRenderCtx.shouldRender) {
-    return {
-      headTags: "",
-      bodyTags: "",
-      bodyTagsOpen: "",
-      htmlAttrs: "",
-      bodyAttrs: ""
-    };
-  }
-  const ctx = { tags: options?.resolvedTags || await head.resolveTags() };
-  await head.hooks.callHook("ssr:render", ctx);
-  const html = ssrRenderTags(ctx.tags, options);
-  const renderCtx = { tags: ctx.tags, html };
-  await head.hooks.callHook("ssr:rendered", renderCtx);
-  return renderCtx.html;
-}
-
-// @__NO_SIDE_EFFECTS__
-async function transformHtmlTemplate(head, html, options) {
-  const template = parseHtmlForUnheadExtraction(html);
-  head.push(template.input, { _index: 0 });
-  const headHtml = await renderSSRHead(head, options);
-  return applyHeadToHtml(template, headHtml);
-}
-// @__NO_SIDE_EFFECTS__
-async function transformHtmlTemplateRaw(head, html, options) {
-  const headHtml = await renderSSRHead(head, options);
-  const template = parseHtmlForIndexes(html);
-  return applyHeadToHtml(template, headHtml);
-}
-
-export { createHead, escapeHtml, extractUnheadInputFromHtml, propsToString, renderSSRHead, ssrRenderTags, tagToString, transformHtmlTemplate, transformHtmlTemplateRaw };

package/web/.output/server/node_modules/unhead/dist/shared/unhead.B3VbJo7Y.mjs

@@ -1,207 +0,0 @@
-import { U as UniqueTags, T as TagsWithInnerContent, M as MetaTagsArrayable, H as HasElementTags, a as TagConfigKeys, D as DupeableTags } from './unhead.yem5I2v_.mjs';
-
-const allowedMetaProperties = ["name", "property", "http-equiv"];
-const StandardSingleMetaTags = /* @__PURE__ */ new Set([
-  "viewport",
-  "description",
-  "keywords",
-  "robots"
-]);
-function isMetaArrayDupeKey(v) {
-  const parts = v.split(":");
-  if (!parts.length)
-    return false;
-  return MetaTagsArrayable.has(parts[1]);
-}
-function dedupeKey(tag) {
-  const { props, tag: name } = tag;
-  if (UniqueTags.has(name))
-    return name;
-  if (name === "link" && props.rel === "canonical")
-    return "canonical";
-  if (name === "link" && props.rel === "alternate") {
-    if (props.hreflang)
-      return `alternate:${props.hreflang}`;
-    if (props.type)
-      return `alternate:${props.type}:${props.href || ""}`;
-  }
-  if (props.charset)
-    return "charset";
-  if (tag.tag === "meta") {
-    for (const n of allowedMetaProperties) {
-      if (props[n] !== void 0) {
-        const propValue = props[n];
-        const isStructured = propValue && typeof propValue === "string" && propValue.includes(":");
-        const isStandardSingle = propValue && StandardSingleMetaTags.has(propValue);
-        const shouldAlwaysDedupe = isStructured || isStandardSingle;
-        const keyPart = !shouldAlwaysDedupe && tag.key ? `:key:${tag.key}` : "";
-        return `${name}:${propValue}${keyPart}`;
-      }
-    }
-  }
-  if (tag.key) {
-    return `${name}:key:${tag.key}`;
-  }
-  if (props.id) {
-    return `${name}:id:${props.id}`;
-  }
-  if (name === "link" && props.rel === "alternate") {
-    return `alternate:${props.href || ""}`;
-  }
-  if (TagsWithInnerContent.has(name)) {
-    const v = tag.textContent || tag.innerHTML;
-    if (v) {
-      return `${name}:content:${v}`;
-    }
-  }
-}
-function hashTag(tag) {
-  const dedupe = tag._h || tag._d;
-  if (dedupe)
-    return dedupe;
-  const inner = tag.textContent || tag.innerHTML;
-  if (inner)
-    return inner;
-  return `${tag.tag}:${Object.entries(tag.props).map(([k, v]) => `${k}:${String(v)}`).join(",")}`;
-}
-
-function walkResolver(val, resolve, key) {
-  const type = typeof val;
-  if (type === "function") {
-    if (!key || key !== "titleTemplate" && !(key[0] === "o" && key[1] === "n")) {
-      val = val();
-    }
-  }
-  const v = resolve ? resolve(key, val) : val;
-  if (Array.isArray(v)) {
-    return v.map((r) => walkResolver(r, resolve));
-  }
-  if (v?.constructor === Object) {
-    const next = {};
-    for (const k of Object.keys(v)) {
-      next[k] = walkResolver(v[k], resolve, k);
-    }
-    return next;
-  }
-  return v;
-}
-
-function normalizeStyleClassProps(key, value) {
-  const store = key === "style" ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
-  function processValue(rawValue) {
-    if (rawValue == null || rawValue === void 0)
-      return;
-    const value2 = String(rawValue).trim();
-    if (!value2)
-      return;
-    if (key === "style") {
-      const [k, ...v] = value2.split(":").map((s) => s ? s.trim() : "");
-      if (k && v.length)
-        store.set(k, v.join(":"));
-    } else {
-      value2.split(" ").filter(Boolean).forEach((c) => store.add(c));
-    }
-  }
-  if (typeof value === "string") {
-    key === "style" ? value.split(";").forEach(processValue) : processValue(value);
-  } else if (Array.isArray(value)) {
-    value.forEach((item) => processValue(item));
-  } else if (value && typeof value === "object") {
-    Object.entries(value).forEach(([k, v]) => {
-      if (v && v !== "false") {
-        key === "style" ? store.set(String(k).trim(), String(v)) : processValue(k);
-      }
-    });
-  }
-  return store;
-}
-function normalizeProps(tag, input) {
-  tag.props = tag.props || {};
-  if (!input) {
-    return tag;
-  }
-  if (tag.tag === "templateParams") {
-    tag.props = input;
-    return tag;
-  }
-  const isHtmlTag = HasElementTags.has(tag.tag) || tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs";
-  Object.entries(input).forEach(([prop, value]) => {
-    if (prop === "__proto__" || prop === "constructor" || prop === "prototype")
-      return;
-    if (value === null) {
-      tag.props[prop] = null;
-      return;
-    }
-    if (prop === "class" || prop === "style") {
-      tag.props[prop] = normalizeStyleClassProps(prop, value);
-      return;
-    }
-    if (TagConfigKeys.has(prop)) {
-      if ((prop === "textContent" || prop === "innerHTML") && typeof value === "object") {
-        let type = input.type;
-        if (!input.type) {
-          type = "application/json";
-        }
-        if (!type?.endsWith("json") && type !== "speculationrules") {
-          return;
-        }
-        input.type = type;
-        tag.props.type = type;
-        tag[prop] = JSON.stringify(value);
-      } else {
-        tag[prop] = value;
-      }
-      return;
-    }
-    const isDataKey = prop.startsWith("data-");
-    const key = isHtmlTag && !isDataKey ? prop.toLowerCase() : prop;
-    const strValue = String(value);
-    const isMetaContentKey = tag.tag === "meta" && key === "content";
-    if (strValue === "true" || strValue === "") {
-      tag.props[key] = isDataKey || isMetaContentKey ? strValue : true;
-    } else if (!value && isDataKey && strValue === "false") {
-      tag.props[key] = "false";
-    } else if (value !== void 0) {
-      tag.props[key] = value;
-    }
-  });
-  return tag;
-}
-function normalizeTag(tagName, _input) {
-  const input = typeof _input === "object" && typeof _input !== "function" ? _input : { [tagName === "script" || tagName === "noscript" || tagName === "style" ? "innerHTML" : "textContent"]: _input };
-  const tag = normalizeProps({ tag: tagName, props: {} }, input);
-  if (tag.key && DupeableTags.has(tag.tag)) {
-    tag.props["data-hid"] = tag._h = tag.key;
-  }
-  if (tag.tag === "script" && typeof tag.innerHTML === "object") {
-    tag.innerHTML = JSON.stringify(tag.innerHTML);
-    tag.props.type = tag.props.type || "application/json";
-  }
-  return Array.isArray(tag.props.content) ? tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } })) : tag;
-}
-function normalizeEntryToTags(input, propResolvers) {
-  if (!input) {
-    return [];
-  }
-  if (typeof input === "function") {
-    input = input();
-  }
-  const resolvers = (key, val) => {
-    for (let i = 0; i < propResolvers.length; i++) {
-      val = propResolvers[i](key, val);
-    }
-    return val;
-  };
-  input = resolvers(void 0, input);
-  const tags = [];
-  input = walkResolver(input, resolvers);
-  Object.entries(input || {}).forEach(([key, value]) => {
-    if (value === void 0)
-      return;
-    for (const v of Array.isArray(value) ? value : [value])
-      tags.push(normalizeTag(key, v));
-  });
-  return tags.flat();
-}
-
-export { normalizeProps as a, dedupeKey as d, hashTag as h, isMetaArrayDupeKey as i, normalizeEntryToTags as n, walkResolver as w };

package/web/.output/server/node_modules/unhead/dist/shared/unhead.BYvz9V1x.mjs

@@ -1,43 +0,0 @@
-const SepSub = "%separator";
-function sub(p, token, isJson = false) {
-  let val;
-  if (token === "s" || token === "pageTitle") {
-    val = p.pageTitle;
-  } else if (token.includes(".")) {
-    const dotIndex = token.indexOf(".");
-    val = p[token.substring(0, dotIndex)]?.[token.substring(dotIndex + 1)];
-  } else {
-    val = p[token];
-  }
-  if (val !== void 0) {
-    return isJson ? (val || "").replace(/\\/g, "\\\\").replace(/</g, "\\u003C").replace(/"/g, '\\"') : val || "";
-  }
-  return void 0;
-}
-function processTemplateParams(s, p, sep, isJson = false) {
-  if (typeof s !== "string" || !s.includes("%"))
-    return s;
-  let decoded = s;
-  try {
-    decoded = decodeURI(s);
-  } catch {
-  }
-  const tokens = decoded.match(/%\w+(?:\.\w+)?/g);
-  if (!tokens) {
-    return s;
-  }
-  const hasSepSub = s.includes(SepSub);
-  s = s.replace(/%\w+(?:\.\w+)?/g, (token) => {
-    if (token === SepSub || !tokens.includes(token)) {
-      return token;
-    }
-    const re = sub(p, token.slice(1), isJson);
-    return re !== void 0 ? re : token;
-  }).trim();
-  if (hasSepSub) {
-    s = s.split(SepSub).map((part) => part.trim()).filter((part) => part !== "").join(sep ? ` ${sep} ` : " ");
-  }
-  return s;
-}
-
-export { processTemplateParams as p };

package/web/.output/server/node_modules/unhead/dist/shared/unhead.BnoAbrHA.mjs

@@ -1,269 +0,0 @@
-import { b as ScriptNetworkEvents } from './unhead.yem5I2v_.mjs';
-
-function createNoopedRecordingProxy(instance = {}) {
-  const stack = [];
-  let stackIdx = -1;
-  const handler = (reuseStack = false) => ({
-    get(_, prop, receiver) {
-      if (!reuseStack) {
-        const v = Reflect.get(_, prop, receiver);
-        if (typeof v !== "undefined") {
-          return v;
-        }
-        stackIdx++;
-        stack[stackIdx] = [];
-      }
-      stack[stackIdx].push({ type: "get", key: prop });
-      return new Proxy(() => {
-      }, handler(true));
-    },
-    apply(_, __, args) {
-      stack[stackIdx].push({ type: "apply", key: "", args });
-      return void 0;
-    }
-  });
-  return {
-    proxy: new Proxy(instance || {}, handler()),
-    stack
-  };
-}
-function createForwardingProxy(target) {
-  const handler = {
-    get(_, prop, receiver) {
-      const v = Reflect.get(_, prop, receiver);
-      if (typeof v === "object") {
-        return new Proxy(v, handler);
-      }
-      return v;
-    },
-    apply(_, __, args) {
-      Reflect.apply(_, __, args);
-      return void 0;
-    }
-  };
-  return new Proxy(target, handler);
-}
-function replayProxyRecordings(target, stack) {
-  stack.forEach((recordings) => {
-    let context = target;
-    let prevContext = target;
-    recordings.forEach(({ type, key, args }) => {
-      if (type === "get") {
-        prevContext = context;
-        context = context[key];
-      } else if (type === "apply") {
-        context = context.call(prevContext, ...args);
-      }
-    });
-  });
-}
-
-function resolveScriptKey(input) {
-  return input.key || input.src || (typeof input.innerHTML === "string" ? input.innerHTML : "");
-}
-const PreconnectServerModes = ["preconnect", "dns-prefetch"];
-function useScript(head, _input, _options) {
-  const input = typeof _input === "string" ? { src: _input } : _input;
-  const options = _options || {};
-  const id = resolveScriptKey(input);
-  const prevScript = head._scripts?.[id];
-  if (prevScript) {
-    prevScript.setupTriggerHandler(options.trigger);
-    return prevScript;
-  }
-  options.beforeInit?.();
-  const syncStatus = (s) => {
-    script.status = s;
-    head.hooks.callHook(`script:updated`, hookCtx);
-  };
-  ScriptNetworkEvents.forEach((fn) => {
-    const k = fn;
-    const _fn = typeof input[k] === "function" ? input[k].bind(options.eventContext) : null;
-    input[k] = (e) => {
-      syncStatus(fn === "onload" ? "loaded" : fn === "onerror" ? "error" : "loading");
-      _fn?.(e);
-    };
-  });
-  const _cbs = { loaded: [], error: [] };
-  const _uniqueCbs = /* @__PURE__ */ new Set();
-  const _registerCb = (key, cb, options2) => {
-    if (head.ssr) {
-      return;
-    }
-    if (options2?.key) {
-      const key2 = `${options2?.key}:${options2.key}`;
-      if (_uniqueCbs.has(key2)) {
-        return;
-      }
-      _uniqueCbs.add(key2);
-    }
-    if (_cbs[key]) {
-      const i = _cbs[key].push(cb);
-      return () => _cbs[key]?.splice(i - 1, 1);
-    }
-    cb(script.instance);
-    return () => {
-    };
-  };
-  const loadPromise = new Promise((resolve) => {
-    if (head.ssr)
-      return;
-    const emit = (api) => requestAnimationFrame(() => resolve(api));
-    const _ = head.hooks.hook("script:updated", ({ script: script2 }) => {
-      const status = script2.status;
-      if (script2.id === id && (status === "loaded" || status === "error")) {
-        if (status === "loaded") {
-          if (typeof options.use === "function") {
-            const api = options.use();
-            if (api) {
-              emit(api);
-            }
-          } else {
-            emit({});
-          }
-        } else if (status === "error") {
-          resolve(false);
-        }
-        _();
-      }
-    });
-  });
-  const script = {
-    _loadPromise: loadPromise,
-    instance: !head.ssr && options?.use?.() || null,
-    proxy: null,
-    id,
-    status: "awaitingLoad",
-    remove() {
-      script._triggerAbortControllers?.forEach((ac) => ac.abort());
-      script._triggerAbortControllers?.clear();
-      script._triggerPromises = [];
-      script._warmupEl?.dispose();
-      if (script.entry) {
-        script.entry.dispose();
-        script.entry = void 0;
-        syncStatus("removed");
-        delete head._scripts?.[id];
-        return true;
-      }
-      return false;
-    },
-    warmup(rel) {
-      const { src } = input;
-      const isCrossOrigin = !src.startsWith("/") || src.startsWith("//");
-      const isPreconnect = rel && PreconnectServerModes.includes(rel);
-      let href = src;
-      if (!rel || isPreconnect && !isCrossOrigin) {
-        return;
-      }
-      if (isPreconnect) {
-        const $url = new URL(src);
-        href = `${$url.protocol}//${$url.host}`;
-      }
-      const link = {
-        href,
-        rel,
-        crossorigin: typeof input.crossorigin !== "undefined" ? input.crossorigin : isCrossOrigin ? "anonymous" : void 0,
-        referrerpolicy: typeof input.referrerpolicy !== "undefined" ? input.referrerpolicy : isCrossOrigin ? "no-referrer" : void 0,
-        fetchpriority: typeof input.fetchpriority !== "undefined" ? input.fetchpriority : "low",
-        integrity: input.integrity,
-        as: rel === "preload" ? "script" : void 0
-      };
-      script._warmupEl = head.push({ link: [link] }, { head, tagPriority: "high" });
-      return script._warmupEl;
-    },
-    load(cb) {
-      script._triggerAbortControllers?.forEach((ac) => ac.abort());
-      script._triggerAbortControllers?.clear();
-      script._triggerPromises = [];
-      if (!script.entry) {
-        syncStatus("loading");
-        const defaults = {
-          defer: true,
-          fetchpriority: "low"
-        };
-        if (input.src && (input.src.startsWith("http") || input.src.startsWith("//"))) {
-          defaults.crossorigin = "anonymous";
-          defaults.referrerpolicy = "no-referrer";
-        }
-        script.entry = head.push({
-          script: [{ ...defaults, ...input }]
-        }, options);
-      }
-      if (cb)
-        _registerCb("loaded", cb);
-      return loadPromise;
-    },
-    onLoaded(cb, options2) {
-      return _registerCb("loaded", cb, options2);
-    },
-    onError(cb, options2) {
-      return _registerCb("error", cb, options2);
-    },
-    setupTriggerHandler(trigger) {
-      if (script.status !== "awaitingLoad") {
-        return;
-      }
-      if ((typeof trigger === "undefined" || trigger === "client") && !head.ssr || trigger === "server") {
-        script.load();
-      } else if (trigger instanceof Promise) {
-        if (head.ssr) {
-          return;
-        }
-        const abortController = new AbortController();
-        script._triggerAbortControllers = script._triggerAbortControllers || /* @__PURE__ */ new Set();
-        script._triggerAbortControllers.add(abortController);
-        const abortPromise = new Promise((resolve) => {
-          abortController.signal.addEventListener("abort", () => {
-            script._triggerAbortControllers?.delete(abortController);
-            resolve();
-          });
-        });
-        script._triggerAbortController = abortController;
-        script._triggerPromises = script._triggerPromises || [];
-        const idx = script._triggerPromises.push(Promise.race([
-          trigger.then((v) => typeof v === "undefined" || v ? script.load : void 0),
-          abortPromise
-        ]).catch(() => {
-        }).then((res) => {
-          res?.();
-        }).finally(() => {
-          script._triggerPromises?.splice(idx, 1);
-        }));
-      } else if (typeof trigger === "function") {
-        trigger(script.load);
-      }
-    },
-    _cbs
-  };
-  loadPromise.then((api) => {
-    if (api !== false) {
-      script.instance = api;
-      _cbs.loaded?.forEach((cb) => cb(api));
-      _cbs.loaded = null;
-    } else {
-      _cbs.error?.forEach((cb) => cb());
-      _cbs.error = null;
-    }
-  });
-  const hookCtx = { script };
-  script.setupTriggerHandler(options.trigger);
-  if (options.use) {
-    const { proxy, stack } = createNoopedRecordingProxy(head.ssr ? {} : options.use() || {});
-    script.proxy = proxy;
-    script.onLoaded((instance) => {
-      replayProxyRecordings(instance, stack);
-      script.proxy = createForwardingProxy(instance);
-    });
-  }
-  if (!options.warmupStrategy && (typeof options.trigger === "undefined" || options.trigger === "client")) {
-    options.warmupStrategy = "preload";
-  }
-  if (options.warmupStrategy) {
-    script.warmup(options.warmupStrategy);
-  }
-  head._scripts = Object.assign(head._scripts || {}, { [id]: script });
-  return script;
-}
-
-export { resolveScriptKey as r, useScript as u };