shelfware 0.0.1 → 0.1.0

package/.output/server/node_modules/unhead/dist/shared/unhead.Dssd7L5I.mjs

@@ -0,0 +1,196 @@
+import { c as createUnhead } from './unhead.D7HkBzZn.mjs';
+import { I as INVALID_ATTR_NAME_RE, r as resolveTags, n as normalizeEntryToTags, d as dedupeKey, h as hashTag } from './unhead.-hZVKou0.mjs';
+import { a as callHook, c as createHooks } from './unhead.Bm4Y6XQI.mjs';
+import { b as TagPriorityAliases, a as SelfClosingTags, c as TagsWithInnerContent } from './unhead.CGPOfp5O.mjs';
+
+const isTruthy = (v) => v === "" || v === true;
+function capoTagWeight(tag) {
+  if (typeof tag.tagPriority === "number")
+    return tag.tagPriority;
+  let weight = 100;
+  const offset = TagPriorityAliases[tag.tagPriority] || 0;
+  if (tag.tag === "base") {
+    weight = -10;
+  } else if (tag.tag === "title") {
+    weight = 10;
+  } else if (tag.tag === "meta") {
+    weight = tag.props["http-equiv"] === "content-security-policy" ? -30 : tag.props.charset ? -20 : tag.props.name === "viewport" ? -15 : weight;
+  } else if (tag.tag === "link" && tag.props.rel) {
+    const rel = tag.props.rel;
+    weight = rel === "preconnect" ? 20 : rel === "stylesheet" ? 60 : rel === "preload" || rel === "modulepreload" ? 70 : rel === "prefetch" || rel === "dns-prefetch" || rel === "prerender" ? 90 : weight;
+  } else if (tag.tag === "script") {
+    const type = typeof tag.props.type === "string" ? tag.props.type : "";
+    const json = type.endsWith("json");
+    if (type === "importmap")
+      weight = 25;
+    else if (type === "speculationrules")
+      weight = 90;
+    else if (isTruthy(tag.props.async))
+      weight = 30;
+    else if (tag.props.src && !isTruthy(tag.props.defer) && type !== "module" && !json || (tag.innerHTML || tag.textContent) && !json)
+      weight = 50;
+    else if (isTruthy(tag.props.defer) && tag.props.src || type === "module")
+      weight = 80;
+  } else if (tag.tag === "style") {
+    weight = tag.innerHTML && /@import/.test(tag.innerHTML) ? 40 : 60;
+  }
+  return (weight || 100) + offset;
+}
+
+const DOUBLE_QUOTE_RE = /"/g;
+function encodeAttribute(value) {
+  const s = typeof value === "string" ? value : String(value);
+  return s.includes('"') ? s.replace(DOUBLE_QUOTE_RE, """) : s;
+}
+function propsToString(props) {
+  let attrs = "";
+  for (const key in props) {
+    if (!Object.hasOwn(props, key) || !key || INVALID_ATTR_NAME_RE.test(key))
+      continue;
+    let value = props[key];
+    if (typeof value !== "string") {
+      if (key === "class") {
+        let out = "";
+        for (const c of value) out += out ? ` ${c}` : c;
+        value = out;
+      } else if (key === "style") {
+        let out = "";
+        for (const [k, v] of value) out += out ? `;${k}:${v}` : `${k}:${v}`;
+        value = out;
+      }
+    }
+    if (value !== false && value !== null) {
+      attrs += value === true ? ` ${key}` : ` ${key}="${encodeAttribute(value)}"`;
+    }
+  }
+  return attrs;
+}
+
+const ESCAPE_HTML_RE = /[&<>"'/]/g;
+const CLOSE_TAG_RE = {};
+const ESCAPE_HTML_MAP = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#x27;", "/": "&#x2F;" };
+function escapeHtml(str) {
+  return str.replace(ESCAPE_HTML_RE, (c) => ESCAPE_HTML_MAP[c]);
+}
+function tagToString(tag) {
+  const attrs = propsToString(tag.props);
+  const openTag = `<${tag.tag}${attrs}>`;
+  if (SelfClosingTags.has(tag.tag))
+    return openTag;
+  if (!TagsWithInnerContent.has(tag.tag))
+    return `${openTag}</${tag.tag}>`;
+  let content = String(tag.textContent ?? tag.innerHTML ?? "");
+  content = tag.tag === "title" ? escapeHtml(content) : content.replace(CLOSE_TAG_RE[tag.tag] ||= new RegExp(`</${tag.tag}`, "gi"), `<\\/${tag.tag}`);
+  return `${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__
+function createServerRenderer(options = {}) {
+  return (head) => {
+    const beforeRenderCtx = { shouldRender: true };
+    callHook(head, "ssr:beforeRender", beforeRenderCtx);
+    if (!beforeRenderCtx.shouldRender)
+      return ssrRenderTags([]);
+    const ctx = {
+      tags: options.resolvedTags || resolveTags(head, { tagWeight: options.tagWeight ?? capoTagWeight }),
+      options: { ...options }
+    };
+    callHook(head, "ssr:render", ctx);
+    const html = ssrRenderTags(ctx.tags, ctx.options);
+    const renderCtx = { tags: ctx.tags, html };
+    callHook(head, "ssr:rendered", renderCtx);
+    return renderCtx.html;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function renderSSRHead(head, options) {
+  return (/* @__PURE__ */ createServerRenderer(options))(head);
+}
+
+const DEFAULT_INIT = {
+  htmlAttrs: {
+    lang: "en"
+  },
+  meta: [
+    {
+      charset: "utf-8"
+    },
+    {
+      name: "viewport",
+      content: "width=device-width, initial-scale=1"
+    }
+  ]
+};
+const serverPropResolver = /* @__PURE__ */ Object.assign(
+  (k, v) => {
+    if (k && k.startsWith("on") && typeof v === "function") {
+      return `this.dataset.${k}fired = true`;
+    }
+    return v;
+  },
+  { _static: true }
+);
+let defaultInitTags;
+function getDefaultInitTags() {
+  if (!defaultInitTags) {
+    defaultInitTags = normalizeEntryToTags(DEFAULT_INIT, []);
+    for (let i = 0; i < defaultInitTags.length; i++) {
+      const t = defaultInitTags[i];
+      t._w = capoTagWeight(t);
+      t._p = (1 << 10) + i;
+      t._d = dedupeKey(t);
+      if (!t._d)
+        t._h = hashTag(t);
+    }
+  }
+  return defaultInitTags;
+}
+// @__NO_SIDE_EFFECTS__
+function createHead(options = {}) {
+  const tagWeight = options.tagWeight || capoTagWeight;
+  const core = createUnhead(createServerRenderer({ tagWeight, omitLineBreaks: options.omitLineBreaks }), {
+    _tagWeight: tagWeight,
+    // @ts-expect-error untyped
+    document: false,
+    experimentalStreamKey: options.experimentalStreamKey,
+    propResolvers: [
+      ...options.propResolvers || [],
+      serverPropResolver
+    ],
+    init: [
+      options.disableDefaults ? void 0 : DEFAULT_INIT,
+      ...options.init || []
+    ]
+  });
+  if (!options.disableDefaults && !options.tagWeight && !options.propResolvers?.some((r) => !r._static)) {
+    const defaultEntry = core.entries.get(1);
+    if (defaultEntry)
+      defaultEntry._precomputedTags = getDefaultInitTags();
+  }
+  core.hooks = createHooks(options.hooks);
+  options.plugins?.forEach((p) => core.use(p));
+  return core;
+}
+
+export { capoTagWeight as a, createServerRenderer as b, createHead as c, escapeHtml as e, propsToString as p, renderSSRHead as r, ssrRenderTags as s, tagToString as t };

package/.output/server/node_modules/unhead/dist/shared/unhead.jEy9BmRq.mjs

@@ -0,0 +1,264 @@
+import { u as unpackMeta } from './unhead.BQWSw36o.mjs';
+import { d as defineHeadPlugin } from './unhead.CHEy9ana.mjs';
+import { h as hasContent, i as isUnsafeKey } from './unhead.CGPOfp5O.mjs';
+
+const FlatMetaPlugin = /* @__PURE__ */ defineHeadPlugin({
+  key: "flatMeta",
+  hooks: {
+    "entries:normalize": (ctx) => {
+      let hasFlatMeta = false;
+      const tags = [];
+      const tagsToAdd = [];
+      for (const t of ctx.tags) {
+        if (t.tag !== "_flatMeta") {
+          tags.push(t);
+          continue;
+        }
+        hasFlatMeta = true;
+        for (const props of unpackMeta(t.props))
+          tagsToAdd.push({ ...t, tag: "meta", props });
+      }
+      if (!hasFlatMeta)
+        return;
+      for (const tag of tagsToAdd) tags.push(tag);
+      ctx.tags = tags;
+    }
+  }
+});
+
+const WhitelistAttributes = {
+  htmlAttrs: /* @__PURE__ */ new Set(["class", "style", "lang", "dir"]),
+  bodyAttrs: /* @__PURE__ */ new Set(["class", "style"]),
+  meta: /* @__PURE__ */ new Set(["name", "property", "charset", "content", "media"]),
+  noscript: /* @__PURE__ */ new Set([]),
+  style: /* @__PURE__ */ new Set(["media", "nonce", "title", "blocking"]),
+  script: /* @__PURE__ */ new Set(["type", "textContent", "nonce", "blocking"]),
+  link: /* @__PURE__ */ new Set(["color", "crossorigin", "fetchpriority", "href", "hreflang", "imagesrcset", "imagesizes", "integrity", "media", "referrerpolicy", "rel", "sizes", "type"])
+};
+const BlockedLinkRels = /* @__PURE__ */ new Set(["canonical", "modulepreload", "prerender", "preload", "prefetch", "dns-prefetch", "preconnect", "manifest", "pingback"]);
+const SafeDataAttrName = /^[a-z][a-z0-9-]*[a-z0-9]$/i;
+const AsciiWhitespace = /[\t\n\f\r ]+/;
+const HtmlEntityHex = /&#x([0-9a-f]+);?/gi;
+const HtmlEntityDec = /&#(\d+);?/g;
+const HtmlEntityNamed = /&(tab|newline|colon|semi|lpar|rpar|sol|bsol|comma|period|excl|num|dollar|percnt|amp|apos|ast|plus|lt|gt|equals|quest|at|lsqb|rsqb|lcub|rcub|vert|hat|grave|tilde|nbsp);?/gi;
+const ControlChars = /[\x00-\x20]+/g;
+const NamedEntityMap = {
+  tab: "	",
+  newline: "\n",
+  colon: ":",
+  semi: ";",
+  lpar: "(",
+  rpar: ")",
+  sol: "/",
+  bsol: "\\",
+  comma: ",",
+  period: ".",
+  excl: "!",
+  num: "#",
+  dollar: "$",
+  percnt: "%",
+  amp: "&",
+  apos: "'",
+  ast: "*",
+  plus: "+",
+  lt: "<",
+  gt: ">",
+  equals: "=",
+  quest: "?",
+  at: "@",
+  lsqb: "[",
+  rsqb: "]",
+  lcub: "{",
+  rcub: "}",
+  vert: "|",
+  hat: "^",
+  grave: "`",
+  tilde: "~",
+  nbsp: "\xA0"
+};
+function safeFromCodePoint(codePoint) {
+  if (codePoint > 1114111 || codePoint < 0 || Number.isNaN(codePoint))
+    return "";
+  return String.fromCodePoint(codePoint);
+}
+function decodeHtmlEntities(str) {
+  return str.replace(HtmlEntityHex, (_, hex) => safeFromCodePoint(Number.parseInt(hex, 16))).replace(HtmlEntityDec, (_, dec) => safeFromCodePoint(Number(dec))).replace(HtmlEntityNamed, (_, name) => NamedEntityMap[name.toLowerCase()] || "");
+}
+function hasDangerousProtocol(url) {
+  const entityDecoded = decodeHtmlEntities(url);
+  const cleaned = entityDecoded.replace(ControlChars, "");
+  let decoded;
+  try {
+    decoded = decodeURIComponent(cleaned);
+  } catch {
+    decoded = cleaned;
+  }
+  const sanitized = decoded.replace(ControlChars, "");
+  const lower = sanitized.toLowerCase();
+  return lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:");
+}
+function stripProtoKeys(obj) {
+  if (Array.isArray(obj))
+    return obj.map(stripProtoKeys);
+  if (obj && typeof obj === "object") {
+    const clean = {};
+    for (const key of Object.keys(obj)) {
+      if (isUnsafeKey(key))
+        continue;
+      clean[key] = stripProtoKeys(obj[key]);
+    }
+    return clean;
+  }
+  return obj;
+}
+function acceptDataAttrs(value, allowId = true) {
+  const next = {};
+  if (!value)
+    return next;
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const isData = key.startsWith("data-");
+    if ((isData || allowId && key === "id") && SafeDataAttrName.test(key))
+      next[key] = value[key];
+  }
+  return next;
+}
+function hasBlockedRel(rel) {
+  const tokens = rel.split(AsciiWhitespace);
+  return !tokens.some(Boolean) || tokens.some((token) => BlockedLinkRels.has(token.toLowerCase()));
+}
+function makeTagSafe(tag) {
+  let next = {};
+  const { tag: type, props: prev } = tag;
+  switch (type) {
+    // title: textContent is escaped in rendering (tagToString), no props needed
+    case "title":
+      break;
+    // virtual tags, not rendered to HTML — but sanitize to prevent injection if rendered
+    case "titleTemplate":
+    case "templateParams":
+      next = prev;
+      break;
+    case "htmlAttrs":
+    case "bodyAttrs":
+      WhitelistAttributes[type].forEach((attr) => {
+        if (prev[attr]) {
+          next[attr] = prev[attr];
+        }
+      });
+      delete tag.innerHTML;
+      delete tag.textContent;
+      tag.props = { ...acceptDataAttrs(prev, false), ...next };
+      return !Object.keys(tag.props).length ? false : tag;
+    case "style":
+      next = acceptDataAttrs(prev);
+      WhitelistAttributes.style.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // meta is safe, except for http-equiv
+    case "meta":
+      WhitelistAttributes.meta.forEach((key) => {
+        if (hasContent(prev[key])) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // link tags we block preloading, prerendering, prefetching, dns-prefetch, preconnect, manifest, etc
+    case "link":
+      WhitelistAttributes.link.forEach((key) => {
+        const val = prev[key];
+        if (!val) {
+          return;
+        }
+        if (key === "rel" && (typeof val !== "string" || hasBlockedRel(val))) {
+          return;
+        }
+        if (key === "href" || key === "imagesrcset") {
+          if (typeof val !== "string") {
+            return;
+          }
+          const urls = key === "imagesrcset" ? val.split(",").map((s) => s.trim()) : [val];
+          if (urls.some((u) => hasDangerousProtocol(u))) {
+            return;
+          }
+          next[key] = val;
+        } else if (val) {
+          next[key] = val;
+        }
+      });
+      if (!next.href && !next.imagesrcset || !next.rel) {
+        return false;
+      }
+      break;
+    case "noscript":
+      WhitelistAttributes.noscript.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // we only allow JSON in scripts
+    case "script":
+      if (!tag.textContent || typeof prev.type !== "string" || !prev.type.endsWith("json")) {
+        return false;
+      }
+      try {
+        const jsonVal = typeof tag.textContent === "string" ? JSON.parse(tag.textContent) : tag.textContent;
+        tag.textContent = JSON.stringify(stripProtoKeys(jsonVal), null, 0);
+      } catch {
+        return false;
+      }
+      WhitelistAttributes.script.forEach((s) => {
+        if (s !== "textContent" && prev[s]) {
+          next[s] = prev[s];
+        }
+      });
+      break;
+  }
+  delete tag.innerHTML;
+  if (type !== "title" && type !== "script") {
+    delete tag.textContent;
+  }
+  tag.props = { ...acceptDataAttrs(prev), ...next };
+  if (!Object.keys(tag.props).length && !tag.tag.endsWith("Attrs") && !tag.textContent) {
+    return false;
+  }
+  return tag;
+}
+const SafeInputPlugin = /* @__PURE__ */ defineHeadPlugin({
+  key: "safe",
+  hooks: {
+    "entries:normalize": (ctx) => {
+      if (ctx.entry.options?._safe) {
+        ctx.tags = ctx.tags.reduce((acc, tag) => {
+          const safeTag = makeTagSafe(tag);
+          if (safeTag)
+            acc.push(safeTag);
+          return acc;
+        }, []);
+      }
+    },
+    "tags:afterResolve": (ctx) => {
+      ctx.tags = ctx.tags.reduce((acc, tag) => {
+        if (!tag._safe) {
+          acc.push(tag);
+          return acc;
+        }
+        if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
+          acc.push(tag);
+          return acc;
+        }
+        const safeTag = makeTagSafe(tag);
+        if (safeTag)
+          acc.push(safeTag);
+        return acc;
+      }, []);
+    }
+  }
+});
+
+export { FlatMetaPlugin as F, SafeInputPlugin as S };

package/.output/server/node_modules/unhead/dist/shared/unhead.oZ7pkTV1.mjs

@@ -0,0 +1,19 @@
+import { c as createUnhead } from './unhead.D7HkBzZn.mjs';
+import { b as TagPriorityAliases } from './unhead.CGPOfp5O.mjs';
+import { c as createHooks } from './unhead.Bm4Y6XQI.mjs';
+import { c as createClientHeadAdapter } from './unhead.C5Bksi2B.mjs';
+import { c as createDomRenderer } from './unhead.Bjbp1C8D.mjs';
+
+const tagWeight = (tag) => typeof tag.tagPriority === "number" ? tag.tagPriority : 100 + (TagPriorityAliases[tag.tagPriority] || 0);
+function createHead(options = {}) {
+  options.document = options.document || (typeof window !== "undefined" ? document : void 0);
+  const renderer = options.render || createDomRenderer({ document: options.document });
+  const core = createUnhead(renderer, { document: options.document, propResolvers: options.propResolvers, _tagWeight: tagWeight, init: [] });
+  const hooks = createHooks(options.hooks);
+  const head = createClientHeadAdapter(core, hooks, renderer);
+  options.plugins?.forEach((p) => head.use(p));
+  options.init?.forEach((e) => e && head.push(e));
+  return head;
+}
+
+export { createHead as c };