@tinycloud/share-sdk 1.2.0-beta.5 → 1.2.0-beta.7

package/dist/html-bundle.cjs

@@ -0,0 +1,975 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/html-bundle/index.ts
+var html_bundle_exports = {};
+__export(html_bundle_exports, {
+  ARTIFACT_ENTRY: () => ARTIFACT_ENTRY,
+  ArtifactBundleError: () => ArtifactBundleError,
+  MAX_ARTIFACT_ATTRIBUTES_PER_ELEMENT: () => MAX_ARTIFACT_ATTRIBUTES_PER_ELEMENT,
+  MAX_ARTIFACT_COMMENTS: () => MAX_ARTIFACT_COMMENTS,
+  MAX_ARTIFACT_CSS_IMPORT_DEPTH: () => MAX_ARTIFACT_CSS_IMPORT_DEPTH,
+  MAX_ARTIFACT_FILES: () => MAX_ARTIFACT_FILES,
+  MAX_ARTIFACT_REFERENCES: () => MAX_ARTIFACT_REFERENCES,
+  MAX_ARTIFACT_RENDER_BYTES: () => MAX_ARTIFACT_RENDER_BYTES,
+  MAX_ARTIFACT_SOURCE_BYTES: () => MAX_ARTIFACT_SOURCE_BYTES,
+  MAX_ARTIFACT_TEXT_BYTES: () => MAX_ARTIFACT_TEXT_BYTES,
+  artifactMediaType: () => artifactMediaType,
+  assertSelfContainedPage: () => assertSelfContainedPage,
+  canonicalArtifactPath: () => canonicalArtifactPath,
+  detectHtmlArtifact: () => detectHtmlArtifact,
+  inlineHtmlFolder: () => inlineHtmlFolder,
+  isPassiveArtifactPath: () => isPassiveArtifactPath,
+  normalizeCssEscapes: () => normalizeCssEscapes,
+  prepareHtmlArtifact: () => prepareHtmlArtifact,
+  resolveArtifactReference: () => resolveArtifactReference
+});
+module.exports = __toCommonJS(html_bundle_exports);
+
+// src/filename-policy.ts
+var UNSAFE_FILENAME_CODE_POINT = /[\p{Cc}\p{Cf}\p{Cs}\u2028\u2029]/u;
+function hasUnsafeFilenameCodePoint(value) {
+  return UNSAFE_FILENAME_CODE_POINT.test(value);
+}
+
+// src/html-bundle/bundle.ts
+var ARTIFACT_ENTRY = "index.html";
+var MAX_ARTIFACT_FILES = 1e3;
+var MAX_ARTIFACT_SOURCE_BYTES = 100 * 1024 * 1024;
+var MAX_ARTIFACT_RENDER_BYTES = 10 * 1024 * 1024;
+var MAX_ARTIFACT_TEXT_BYTES = 5 * 1024 * 1024;
+var MAX_ARTIFACT_REFERENCES = 2e3;
+var MAX_ARTIFACT_CSS_IMPORT_DEPTH = 16;
+var MAX_ARTIFACT_COMMENTS = 2e4;
+var MAX_ARTIFACT_ATTRIBUTES_PER_ELEMENT = 5e3;
+var ArtifactBundleError = class extends Error {
+  /**
+   * `path` is the bundle file being processed when the refusal happened; `reference` is the reference text inside it
+   * that was refused, when there is one. Both are the folder's own text: print them through a terminal-safe printer.
+   */
+  constructor(kind, message, path, reference) {
+    super(message);
+    this.kind = kind;
+    this.path = path;
+    this.reference = reference;
+    this.name = "ArtifactBundleError";
+  }
+};
+var MIME_BY_EXTENSION = Object.freeze({
+  html: "text/html;charset=utf-8",
+  htm: "text/html;charset=utf-8",
+  css: "text/css;charset=utf-8",
+  js: "text/javascript;charset=utf-8",
+  json: "application/json;charset=utf-8",
+  txt: "text/plain;charset=utf-8",
+  md: "text/markdown;charset=utf-8",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  pdf: "application/pdf"
+});
+var SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+var ENCODED_PATH_ALIAS = /%2f|%5c|%2e/i;
+var SAFE_MEDIA_QUERY = /^[a-z0-9\s,().:%\-+/]+$/i;
+var UNSAFE_CLASSIC_SCRIPT = /\b(?:fetch|XMLHttpRequest|WebSocket|EventSource|Worker|SharedWorker|importScripts|sendBeacon)\s*\(|\b(?:window|self|globalThis|top|parent|opener)\s*\.\s*open\s*\(|\b(?:window|document|globalThis|self|top|parent|opener)\s*(?:\.\s*location|\[\s*["']location["']\s*\])|\blocation\s*(?:=|(?:\.\s*|\[\s*["'])href(?:["']\s*\])?|\.assign\s*\(|\.replace\s*\(|\.reload\s*\()|\bimport\s*\(|\beval\s*\(|\bWebAssembly\b/;
+function fail(kind, detail) {
+  throw new ArtifactBundleError(kind, detail);
+}
+function defaultParseHtml(html) {
+  if (typeof DOMParser === "undefined") {
+    throw new TypeError("html-bundle needs a DOM parser: pass parseHtml outside a browser");
+  }
+  return new DOMParser().parseFromString(html, "text/html");
+}
+function canonicalArtifactPath(input) {
+  const value = input.normalize("NFC");
+  const encodedLength = new TextEncoder().encode(value).byteLength;
+  if (value.length === 0 || encodedLength > 4096 || value.startsWith("/") || value.endsWith("/") || value.includes("\\") || hasUnsafeFilenameCodePoint(value) || ENCODED_PATH_ALIAS.test(value)) {
+    fail("malformed", "artifact path is not canonical");
+  }
+  const segments = value.split("/");
+  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === ".." || new TextEncoder().encode(segment).byteLength > 255)) {
+    fail("malformed", "artifact path is not canonical");
+  }
+  return segments.join("/");
+}
+function artifactMediaType(path, supplied) {
+  const normalized = supplied?.split(";")[0]?.trim().toLowerCase();
+  if (normalized !== void 0 && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(normalized)) {
+    return supplied.trim();
+  }
+  const extension = path.split(".").at(-1)?.toLowerCase() ?? "";
+  return MIME_BY_EXTENSION[extension] ?? "application/octet-stream";
+}
+function resolveArtifactReference(basePath, reference) {
+  const raw = trimUrl(reference);
+  if (raw.length === 0) return { path: canonicalArtifactPath(basePath), fragment: "", fragmentOnly: true };
+  if (raw.startsWith("#")) {
+    return { path: canonicalArtifactPath(basePath), fragment: raw, fragmentOnly: true };
+  }
+  if (raw.startsWith("//") || raw.startsWith("/") || SCHEME.test(raw)) {
+    fail("unsupported", "external artifact reference");
+  }
+  const hashAt = raw.indexOf("#");
+  const queryAt = raw.indexOf("?");
+  const end = [hashAt, queryAt].filter((value) => value >= 0).reduce((min, value) => Math.min(min, value), raw.length);
+  const pathname = raw.slice(0, end);
+  const fragment = hashAt >= 0 ? raw.slice(hashAt) : "";
+  if (pathname.length === 0) return { path: canonicalArtifactPath(basePath), fragment, fragmentOnly: true };
+  if (pathname.includes("\\") || hasUnsafeFilenameCodePoint(pathname) || ENCODED_PATH_ALIAS.test(pathname)) {
+    fail("malformed", "artifact reference is not canonical");
+  }
+  const output = basePath.split("/").slice(0, -1);
+  for (const segment of pathname.normalize("NFC").split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      if (output.length === 0) fail("malformed", "artifact reference escapes its bundle");
+      output.pop();
+      continue;
+    }
+    output.push(segment);
+  }
+  return { path: canonicalArtifactPath(output.join("/")), fragment, fragmentOnly: false };
+}
+function detectHtmlArtifact(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  let rootCount = 0;
+  for (const rawPath of paths) {
+    const path = canonicalArtifactPath(rawPath);
+    const key = path.toLowerCase();
+    if (seen.has(key)) fail("malformed", "artifact paths collide after canonicalization");
+    seen.add(key);
+    if (path === ARTIFACT_ENTRY) rootCount += 1;
+  }
+  if (rootCount === 1) return { kind: "html", entry: ARTIFACT_ENTRY };
+  return { kind: "folder", reason: "missing-root-index" };
+}
+function toBase64(bytes) {
+  let binary = "";
+  const chunk = 32768;
+  for (let offset = 0; offset < bytes.length; offset += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + chunk));
+  }
+  return btoa(binary);
+}
+function chargeInlinedBytes(context, bytes) {
+  context.counter.inlinedBytes += bytes;
+  if (context.counter.inlinedBytes > MAX_ARTIFACT_RENDER_BYTES) fail("limit", "artifact inlined resources exceed the render limit");
+}
+function asDataUrl(file, context) {
+  if (file.bytes.byteLength > MAX_ARTIFACT_RENDER_BYTES) fail("limit", "artifact resource exceeds render limit");
+  const prefix = `data:${artifactMediaType(file.path, file.mediaType)};base64,`;
+  chargeInlinedBytes(context, prefix.length + 4 * Math.ceil(file.bytes.byteLength / 3));
+  return `${prefix}${toBase64(file.bytes)}`;
+}
+function decodeText(file, context) {
+  if (file.bytes.byteLength > MAX_ARTIFACT_TEXT_BYTES) fail("limit", "artifact text file exceeds render limit");
+  if (context !== void 0) chargeInlinedBytes(context, file.bytes.byteLength);
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(file.bytes);
+  } catch {
+    return fail("malformed", "artifact text is not utf-8");
+  }
+}
+function assertClassicScript(source) {
+  if (UNSAFE_CLASSIC_SCRIPT.test(source)) fail("unsupported", "artifact script uses a blocked browser capability");
+}
+function normalizeMediaQuery(media, detail = "artifact uses an unsupported stylesheet media query") {
+  const value = media?.trim() ?? "";
+  if (value.length === 0 || value.toLowerCase() === "all") return null;
+  if (/[\u0000-\u001f\u007f<>{};"'`\\]/.test(value) || !SAFE_MEDIA_QUERY.test(value)) fail("unsupported", detail);
+  return value;
+}
+function wrapMediaCss(source, media, detail) {
+  const value = normalizeMediaQuery(media, detail);
+  if (value === null) return source;
+  return `@media ${value} {
+${source}
+}`;
+}
+function classifyLinkRelation(rel) {
+  const tokens = rel?.trim().toLowerCase().split(/\s+/).filter(Boolean) ?? [];
+  if (tokens.length === 0) return null;
+  const tokenSet = new Set(tokens);
+  if (tokenSet.has("stylesheet") && [...tokenSet].every((token) => token === "stylesheet" || token === "alternate")) return "stylesheet";
+  if ((tokenSet.has("icon") || tokenSet.has("apple-touch-icon")) && [...tokenSet].every((token) => token === "icon" || token === "apple-touch-icon" || token === "shortcut")) return "icon";
+  return null;
+}
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function documentRoots(doc) {
+  const roots = [doc];
+  for (let index = 0; index < roots.length; index += 1) {
+    for (const template of roots[index].querySelectorAll("template")) roots.push(template.content);
+  }
+  return roots;
+}
+function queryAll(roots, selector) {
+  return roots.flatMap((root) => [...root.querySelectorAll(selector)]);
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "href",
+  "src",
+  "srcset",
+  "imagesrcset",
+  "poster",
+  "action",
+  "formaction",
+  "cite",
+  "data",
+  "codebase",
+  "longdesc",
+  "usemap",
+  "ping",
+  "background",
+  "manifest",
+  "icon",
+  "archive",
+  "classid",
+  "profile",
+  "lowsrc",
+  "dynsrc",
+  "attributionsrc",
+  "itemtype",
+  "itemid"
+]);
+function trimUrl(value) {
+  return value.replace(/^[\u0000-\u0020]+|[\u0000-\u0020]+$/g, "");
+}
+function urlText(value) {
+  return trimUrl(value).replace(/[\t\n\r]/g, "");
+}
+function isFragmentOnly(trimmed) {
+  return /^#[^\u0000-\u0020\u007f-\u009f\\]*$/.test(trimmed);
+}
+var INLINE_DATA_URL = /^data:;base64(?:,[A-Za-z0-9+/=]*)?(?:#[^\u0000-\u0020\\]*)?$/;
+function isInlineReference(value) {
+  const text = urlText(value);
+  return isFragmentOnly(text) || INLINE_DATA_URL.test(text);
+}
+function assertInlineSrcset(value) {
+  for (const raw of value.split(/[\t\n\f\r ]+/)) {
+    const token = raw.replace(/,+$/, "");
+    if (token === "" || /^\d+(?:\.\d+)?[wx]$/i.test(token)) continue;
+    if (!isInlineReference(token)) throw new ArtifactBundleError("unsupported", "artifact page still references a resource", void 0, token);
+  }
+}
+var JAVASCRIPT_TYPES = /* @__PURE__ */ new Set([
+  "application/ecmascript",
+  "application/javascript",
+  "application/x-ecmascript",
+  "application/x-javascript",
+  "text/ecmascript",
+  "text/javascript",
+  "text/javascript1.0",
+  "text/javascript1.1",
+  "text/javascript1.2",
+  "text/javascript1.3",
+  "text/javascript1.4",
+  "text/javascript1.5",
+  "text/jscript",
+  "text/livescript",
+  "text/x-ecmascript",
+  "text/x-javascript"
+]);
+function isJavaScriptType(value) {
+  const type = (value ?? "").replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "").toLowerCase();
+  if (type === "") return true;
+  return JAVASCRIPT_TYPES.has(type.split(";")[0].replace(/[\t\n\f\r ]+$/g, ""));
+}
+var BLOCKED_ELEMENTS = "base, form, iframe, frame, frameset, object, embed, portal, noscript, plaintext, xmp, noembed, noframes, applet, area[href], link:not([href]), [ping]";
+var DATA_URI = /data:[a-z0-9!#$&^_.+/-]*(?:;[a-z0-9!#$&^_.+=-]+)*;base64,[A-Za-z0-9+/=]*/gi;
+function withoutDataUris(html) {
+  return html.replace(DATA_URI, "data:;base64,");
+}
+var TEXT_ATTRIBUTES = /^(?:alt|title|placeholder|value|label|content|name|id|class|lang|summary|abbr|datetime|pattern|xmlns(?::[\w.-]+)?|aria-[\w.:-]*|data-[\w.:-]*)$/;
+function looksLikeUrl(raw) {
+  const value = raw.replace(/\\/g, "/");
+  return /(?:^|[^a-z0-9+.-])(?:https?|ftps?|wss?|file|javascript|vbscript|blob|about|view-source|filesystem):/i.test(value) || /(?:^|[\s,;(="'])\/\/\S/.test(value) || /:\/\//.test(value) || /^\s*\.{0,2}\/[^\s]/.test(value);
+}
+var NAMED_CHARACTERS = {
+  amp: "&",
+  quot: '"',
+  apos: "'",
+  lt: "<",
+  gt: ">",
+  nbsp: "\xA0",
+  colon: ":",
+  sol: "/",
+  bsol: "\\",
+  period: ".",
+  comma: ",",
+  semi: ";",
+  equals: "=",
+  num: "#",
+  quest: "?",
+  lpar: "(",
+  rpar: ")",
+  tab: "	",
+  newline: "\n"
+};
+function decodeAttributeValue(value) {
+  return value.replace(/&(?:#[xX]([0-9a-fA-F]{1,6})|#([0-9]{1,7})|([A-Za-z]{2,8}));?/g, (whole, hex, decimal, name) => {
+    if (name !== void 0) return NAMED_CHARACTERS[name.toLowerCase()] ?? whole;
+    const point = Number.parseInt(hex ?? decimal ?? "", hex === void 0 ? 10 : 16);
+    return point > 0 && point <= 1114111 && !(point >= 55296 && point <= 57343) ? String.fromCodePoint(point) : "\uFFFD";
+  });
+}
+var MARKUP_BLOCKED_NAMES = /* @__PURE__ */ new Set(["base", "form", "iframe", "frame", "frameset", "object", "embed", "portal", "noscript", "plaintext", "xmp", "noembed", "noframes", "applet"]);
+function unsupportedOutput(detail, reference) {
+  throw new ArtifactBundleError("unsupported", detail, void 0, reference);
+}
+function isHrefAnimation(tag, attributeName, value) {
+  return /^(?:animate|set|animatetransform|animatemotion)$/i.test(tag) && attributeName.toLowerCase() === "attributename" && /^(?:xlink:)?href$/i.test(trimUrl(value));
+}
+function checkAttribute(name, decoded) {
+  const local = name.slice(name.lastIndexOf(":") + 1);
+  if (/^on/.test(name)) unsupportedOutput("artifact output contains a blocked html feature");
+  if (name === "style") {
+    assertOnlyInlineCssReferences(decoded);
+    return;
+  }
+  if (local === "srcset" || local === "imagesrcset") {
+    assertInlineSrcset(decoded);
+    return;
+  }
+  if (URL_ATTRIBUTES.has(local)) {
+    if (!isInlineReference(decoded)) unsupportedOutput("artifact page still references a resource", decoded);
+    return;
+  }
+  if (TEXT_ATTRIBUTES.test(name)) return;
+  if (looksLikeUrl(urlText(decoded))) unsupportedOutput("artifact page still references a resource", decoded);
+  if (/url\s*\(|image-set|@import|\\/i.test(decoded) || /(?:^|[^\w-])src\s*\(/i.test(decoded)) assertOnlyInlineCssReferences(decoded);
+}
+function isOwnPolicyMeta(httpEquiv, content) {
+  return httpEquiv.trim().toLowerCase() === "content-security-policy" && content === INNER_CSP;
+}
+var HTML_SPACE = "\\t\\n\\f\\r ";
+var TAG_NAME = new RegExp(`[^${HTML_SPACE}/>]*`, "y");
+var ATTRIBUTE_NAME = new RegExp(`=?[^${HTML_SPACE}/>=]*`, "y");
+var UNQUOTED_VALUE = new RegExp(`[^${HTML_SPACE}>]*`, "y");
+var SKIPPED = new RegExp(`[${HTML_SPACE}/]`);
+var SPACE = new RegExp(`[${HTML_SPACE}]`);
+var ODD_TAG_NAME = /[\u00a0\u1680\u180e\u2000-\u200f\u2028-\u202f\u205f-\u2064\u3000\ufeff]/;
+var COMMENT_END = /--!?>/g;
+var SCRIPT_END = /<\/script/gi;
+var STYLE_END = /<\/style/gi;
+function scanMarkup(html, options) {
+  const checkReferences = options.references;
+  const length = html.length;
+  let index = 0;
+  let comments = 0;
+  const malformed = (detail) => {
+    if (checkReferences) unsupportedOutput(detail);
+    return true;
+  };
+  const countComment = () => {
+    comments += 1;
+    if (comments > MAX_ARTIFACT_COMMENTS) fail("limit", "artifact page has too many comments");
+  };
+  while (index < length) {
+    const open = html.indexOf("<", index);
+    if (open === -1) return;
+    index = open + 1;
+    const next = html[index] ?? "";
+    if (html.startsWith("!--", index)) {
+      countComment();
+      let end;
+      if (html[index + 3] === ">") end = index + 4;
+      else if (html.startsWith("->", index + 3)) end = index + 5;
+      else {
+        COMMENT_END.lastIndex = index + 3;
+        const close = COMMENT_END.exec(html);
+        if (close === null) {
+          if (malformed("artifact output has an unterminated comment")) return;
+          return;
+        }
+        end = close.index + close[0].length;
+      }
+      index = end;
+      continue;
+    }
+    if (next === "!" || next === "?" || next === "/") {
+      if (next === "?" || next === "!" && !/^!doctype/i.test(html.slice(index, index + 8))) countComment();
+      const close = html.indexOf(">", index);
+      if (close === -1) {
+        if (malformed("artifact output has an unterminated tag")) return;
+        return;
+      }
+      index = close + 1;
+      continue;
+    }
+    if (!/[A-Za-z]/.test(next)) continue;
+    TAG_NAME.lastIndex = index;
+    const rawTag = TAG_NAME.exec(html)[0];
+    const tag = rawTag.toLowerCase();
+    index = TAG_NAME.lastIndex;
+    if (checkReferences) {
+      if (ODD_TAG_NAME.test(rawTag)) unsupportedOutput("artifact output has a tag name with an unexpected character");
+      if (MARKUP_BLOCKED_NAMES.has(tag)) unsupportedOutput("artifact output contains a blocked html feature");
+    }
+    const attributes = /* @__PURE__ */ new Map();
+    let attributeCount = 0;
+    for (; ; ) {
+      while (index < length && SKIPPED.test(html[index])) index += 1;
+      if (index >= length) {
+        if (malformed("artifact output has an unterminated tag")) return;
+        return;
+      }
+      if (html[index] === ">") {
+        index += 1;
+        break;
+      }
+      ATTRIBUTE_NAME.lastIndex = index;
+      const rawName = ATTRIBUTE_NAME.exec(html)[0];
+      index = ATTRIBUTE_NAME.lastIndex;
+      while (index < length && SPACE.test(html[index])) index += 1;
+      let rawValue = "";
+      if (html[index] === "=") {
+        index += 1;
+        while (index < length && SPACE.test(html[index])) index += 1;
+        const quote = html[index];
+        if (quote === '"' || quote === "'") {
+          const close = html.indexOf(quote, index + 1);
+          if (close === -1) {
+            if (malformed("artifact output has an unterminated attribute")) return;
+            return;
+          }
+          rawValue = html.slice(index + 1, close);
+          index = close + 1;
+        } else {
+          UNQUOTED_VALUE.lastIndex = index;
+          rawValue = UNQUOTED_VALUE.exec(html)[0];
+          index = UNQUOTED_VALUE.lastIndex;
+        }
+      }
+      if (rawName.length > 0) {
+        attributeCount += 1;
+        if (attributeCount > MAX_ARTIFACT_ATTRIBUTES_PER_ELEMENT) fail("limit", "artifact element has too many attributes");
+        if (!checkReferences) continue;
+        const name = rawName.toLowerCase();
+        const decoded = decodeAttributeValue(rawValue);
+        checkAttribute(name, decoded);
+        if (isHrefAnimation(tag, name, decoded)) unsupportedOutput("artifact svg animates a resource reference");
+        if (!attributes.has(name)) attributes.set(name, decoded);
+      } else if (index < length && html[index] !== ">" && !SKIPPED.test(html[index])) {
+        index += 1;
+      }
+    }
+    if (checkReferences) {
+      if (tag === "area" && attributes.has("href") || attributes.has("ping") || tag === "link" && !attributes.has("href")) {
+        unsupportedOutput("artifact output contains a blocked html feature");
+      }
+      if (tag === "meta" && attributes.has("http-equiv") && !isOwnPolicyMeta(attributes.get("http-equiv"), attributes.get("content") ?? null)) {
+        unsupportedOutput("artifact output contains a meta http-equiv", attributes.get("http-equiv"));
+      }
+      if (tag === "script" && !isJavaScriptType(attributes.get("type"))) {
+        unsupportedOutput("artifact output holds a script type that is not JavaScript", attributes.get("type"));
+      }
+    }
+    if (tag === "script") {
+      SCRIPT_END.lastIndex = index;
+      const close = SCRIPT_END.exec(html);
+      if (close === null) return;
+      index = close.index;
+    } else if (tag === "style" && checkReferences) {
+      STYLE_END.lastIndex = index;
+      const close = STYLE_END.exec(html);
+      assertOnlyInlineCssReferences(html.slice(index, close === null ? length : close.index));
+    }
+  }
+}
+function assertSelfContainedPage(output, options = {}) {
+  const page = withoutDataUris(output);
+  if (options.only !== "dom") scanMarkup(page, { references: true });
+  if (options.only === "bytes") return;
+  const doc = (options.parseHtml ?? defaultParseHtml)(page);
+  const roots = documentRoots(doc);
+  if (queryAll(roots, BLOCKED_ELEMENTS).length > 0) fail("unsupported", "artifact output contains a blocked html feature");
+  for (const meta of queryAll(roots, "meta[http-equiv]")) {
+    if (!isOwnPolicyMeta(meta.getAttribute("http-equiv") ?? "", meta.getAttribute("content"))) fail("unsupported", "artifact output contains a meta http-equiv");
+  }
+  if (queryAll(roots, "script[src]").length > 0) fail("unsupported", "artifact output still loads a script");
+  for (const script of queryAll(roots, "script")) {
+    if (!isJavaScriptType(script.getAttribute("type"))) fail("unsupported", "artifact output holds a script type that is not JavaScript");
+  }
+  for (const style of queryAll(roots, "style")) assertOnlyInlineCssReferences(style.textContent ?? "");
+  for (const element of queryAll(roots, "*")) {
+    const inSvg = element.namespaceURI === SVG_NAMESPACE;
+    if (inSvg && element.localName === "script") fail("unsupported", "artifact svg contains a script");
+    for (const name of element.getAttributeNames()) {
+      const lower = name.toLowerCase();
+      const local = lower.slice(lower.lastIndexOf(":") + 1);
+      const value = element.getAttribute(name) ?? "";
+      if (/^on/.test(lower)) fail("unsupported", "artifact output contains a blocked html feature");
+      if (URL_ATTRIBUTES.has(local)) {
+        if (local === "srcset" || local === "imagesrcset") assertInlineSrcset(value);
+        else if (!isInlineReference(value)) throw new ArtifactBundleError("unsupported", "artifact page still references a resource", void 0, value);
+      } else if (lower !== "style" && !TEXT_ATTRIBUTES.test(lower) && looksLikeUrl(urlText(value))) {
+        throw new ArtifactBundleError("unsupported", "artifact page still references a resource", void 0, value);
+      }
+      if (lower === "style" || inSvg) assertOnlyInlineCssReferences(value);
+      if (isHrefAnimation(element.localName, lower, value)) fail("unsupported", "artifact svg animates a resource reference");
+    }
+  }
+}
+function verifySelfContained(output, context) {
+  assertSelfContainedPage(output, { parseHtml: context.parseHtml });
+}
+function rejectSvgResourceReferences(roots) {
+  for (const element of queryAll(roots, "*")) {
+    if (element.namespaceURI !== SVG_NAMESPACE) continue;
+    const animatesHref = /^(?:animate|set|animatetransform|animatemotion)$/i.test(element.localName) && element.getAttributeNames().some((name) => name.toLowerCase() === "attributename" && /^(?:xlink:)?href$/i.test(trimUrl(element.getAttribute(name) ?? "")));
+    if (animatesHref) fail("unsupported", "artifact svg animates a resource reference");
+    if (element.localName === "script") fail("unsupported", "artifact svg contains a script");
+    for (const attributeName of element.getAttributeNames()) {
+      if (attributeName !== "href" && !attributeName.endsWith(":href")) continue;
+      if (element.localName === "a" && attributeName === "href") continue;
+      if (!isFragmentOnly(urlText(element.getAttribute(attributeName) ?? ""))) fail("unsupported", "artifact svg references a resource");
+    }
+  }
+}
+function rejectEventHandlerAttributes(roots) {
+  for (const element of queryAll(roots, "*")) {
+    for (const attributeName of element.getAttributeNames()) {
+      if (/^on/i.test(attributeName)) fail("unsupported", "artifact contains a blocked html feature");
+    }
+  }
+}
+function replaceAsync(input, expression, replacer) {
+  const matches = [...input.matchAll(expression)];
+  return matches.reduceRight(
+    async (next, match) => {
+      const value = await next;
+      const replacement = await replacer(...match.map((entry) => entry ?? ""));
+      return `${value.slice(0, match.index)}${replacement}${value.slice((match.index ?? 0) + match[0].length)}`;
+    },
+    Promise.resolve(input)
+  );
+}
+function newDeferred() {
+  const bytes = new Uint8Array(8);
+  if (globalThis.crypto?.getRandomValues !== void 0) globalThis.crypto.getRandomValues(bytes);
+  else for (let index = 0; index < bytes.length; index += 1) bytes[index] = Math.floor(Math.random() * 256);
+  return { token: Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(""), urls: [] };
+}
+function parkUrl(deferred, url) {
+  deferred.urls.push(url);
+  return `data:;base64,TCPH${deferred.token}x${deferred.urls.length - 1}x`;
+}
+function restoreParkedUrls(page, deferred) {
+  if (deferred.urls.length === 0) return page;
+  const pattern = new RegExp(`data:;base64,TCPH${deferred.token}x(\\d+)x`, "g");
+  return page.replace(pattern, (_whole, index) => deferred.urls[Number(index)]);
+}
+function resolveReferenceFrom(basePath, reference) {
+  try {
+    return resolveArtifactReference(basePath, reference);
+  } catch (error) {
+    if (error instanceof ArtifactBundleError) throw new ArtifactBundleError(error.kind, error.message, basePath, reference);
+    throw error;
+  }
+}
+function requiredFile(context, basePath, reference) {
+  context.counter.references += 1;
+  if (context.counter.references > MAX_ARTIFACT_REFERENCES) fail("limit", "artifact has too many resource references");
+  const resolved = resolveReferenceFrom(basePath, reference);
+  const file = context.files.get(resolved.path);
+  if (file === void 0) throw new ArtifactBundleError("missing", "artifact resource is missing", basePath, reference);
+  return { file, resolved };
+}
+var CSS_REFERENCE_NAMES = /* @__PURE__ */ new Set(["url", "image-set", "-webkit-image-set", "src", "import"]);
+function isCssIdentifierCode(code) {
+  return code >= 128 || code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 45;
+}
+function normalizeCssEscapes(source) {
+  let output = "";
+  let index = 0;
+  const length = source.length;
+  while (index < length) {
+    const char = source[index];
+    if (char === "/" && source[index + 1] === "*") {
+      const end = source.indexOf("*/", index + 2);
+      const stop = end === -1 ? length : end + 2;
+      output += source.slice(index, stop);
+      index = stop;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      let cursor = index + 1;
+      while (cursor < length && source[cursor] !== char && source[cursor] !== "\n") cursor += source[cursor] === "\\" ? 2 : 1;
+      const stop = Math.min(source[cursor] === char ? cursor + 1 : cursor, length);
+      output += source.slice(index, stop);
+      index = stop;
+      continue;
+    }
+    if (char === "\\" || isCssIdentifierCode(source.charCodeAt(index))) {
+      let cursor = index;
+      let decoded = "";
+      let escaped = false;
+      while (cursor < length) {
+        if (source[cursor] === "\\") {
+          const next = source[cursor + 1];
+          if (next === void 0) {
+            decoded += "\uFFFD";
+            escaped = true;
+            cursor += 1;
+            break;
+          }
+          if (next === "\n" || next === "\r" || next === "\f") break;
+          escaped = true;
+          const hex = /^[0-9a-fA-F]{1,6}/.exec(source.slice(cursor + 1, cursor + 7));
+          if (hex !== null) {
+            const point = Number.parseInt(hex[0], 16);
+            cursor += 1 + hex[0].length;
+            if (source[cursor] === "\r" && source[cursor + 1] === "\n") cursor += 2;
+            else if (/[ \t\n\r\f]/.test(source[cursor] ?? "")) cursor += 1;
+            decoded += point === 0 || point > 1114111 || point >= 55296 && point <= 57343 ? "\uFFFD" : String.fromCodePoint(point);
+          } else {
+            const point = source.codePointAt(cursor + 1);
+            decoded += String.fromCodePoint(point);
+            cursor += 1 + (point > 65535 ? 2 : 1);
+          }
+        } else if (isCssIdentifierCode(source.charCodeAt(cursor))) {
+          decoded += source[cursor];
+          cursor += 1;
+        } else break;
+      }
+      const raw = source.slice(index, cursor);
+      const startsReference = escaped && (source[cursor] === "(" || output.endsWith("@")) && CSS_REFERENCE_NAMES.has(decoded.toLowerCase());
+      output += startsReference ? decoded : raw;
+      index = cursor;
+      continue;
+    }
+    output += char;
+    index += 1;
+  }
+  return output;
+}
+function assertOnlyInlineCssReferences(css) {
+  const text = normalizeCssEscapes(css);
+  if (/@import/i.test(text)) fail("unsupported", "artifact css still imports a stylesheet");
+  if (/(?:^|[^\w-])(?:-webkit-)?image-set\s*\(/i.test(text) || /(?:^|[^\w-])src\s*\(/i.test(text)) fail("unsupported", "artifact css uses an unsupported resource function");
+  const opened = text.match(/url\(/gi)?.length ?? 0;
+  let read = 0;
+  for (const match of text.matchAll(/url\([ \t\n\r\f]*(?:"([^"]*)"|'([^']*)'|([^)"' \t\n\r\f]*))[ \t\n\r\f]*\)/gi)) {
+    read += 1;
+    const value = match[1] ?? match[2] ?? match[3] ?? "";
+    if (!isInlineReference(value) || value.includes("\\")) {
+      throw new ArtifactBundleError("unsupported", "artifact css references a resource", void 0, value);
+    }
+  }
+  if (read !== opened) fail("unsupported", "artifact css has a url() that cannot be read");
+}
+async function transformCss(sourceText, basePath, context) {
+  if (context.cssStack.length > MAX_ARTIFACT_CSS_IMPORT_DEPTH) fail("limit", "artifact stylesheet import depth exceeded");
+  const source = normalizeCssEscapes(sourceText);
+  const imported = await replaceAsync(
+    source,
+    /@import\s+(?:url\(\s*(?:(["'])([^"']+)\1|([^"')\s]+))\s*\)|(["'])([^"']+)\4)\s*([^;]*);/gi,
+    async (_whole, _urlQuote, quotedUrl, unquotedUrl, _quote, quotedReference, media) => {
+      const reference = quotedUrl || unquotedUrl || quotedReference;
+      if (/^(?:layer|supports)\b/i.test(media.trim()) || /\b(?:layer|supports)\b/i.test(media)) fail("unsupported", "artifact uses an unsupported stylesheet import condition");
+      const { file, resolved } = requiredFile(context, basePath, reference);
+      if (context.cssStack.includes(resolved.path)) fail("unsupported", "artifact stylesheet import cycle");
+      const css = await transformCss(decodeText(file, context), resolved.path, { ...context, cssStack: [...context.cssStack, resolved.path] });
+      return wrapMediaCss(css, media, "artifact uses an unsupported stylesheet import condition");
+    }
+  );
+  return replaceAsync(
+    imported,
+    /url\(\s*(["']?)([^"')]+)\1\s*\)/gi,
+    async (_whole, _quote, reference) => {
+      if (trimUrl(reference).startsWith("#")) return `url("${trimUrl(reference)}")`;
+      const { file, resolved } = requiredFile(context, basePath, reference);
+      const dataUrl = asDataUrl(file, context);
+      return `url("${context.deferred === void 0 ? dataUrl : parkUrl(context.deferred, dataUrl)}${resolved.fragment}")`;
+    }
+  );
+}
+function serializeSrcset(value, basePath, context) {
+  return value.split(",").map((candidate) => {
+    const trimmed = candidate.trim();
+    const separator = trimmed.search(/\s/);
+    const reference = separator === -1 ? trimmed : trimmed.slice(0, separator);
+    const descriptor = separator === -1 ? "" : trimmed.slice(separator).trim();
+    const { file, resolved } = requiredFile(context, basePath, reference);
+    return `${asDataUrl(file, context)}${resolved.fragment}${descriptor.length === 0 ? "" : ` ${descriptor}`}`;
+  }).join(", ");
+}
+var CHILD_BOOTSTRAP = `(function(){
+  "use strict";
+  document.addEventListener("click",function(event){
+    var target=event.target instanceof Element?event.target.closest("a[data-tc-artifact-path]"):null;
+    if(!target)return;
+    event.preventDefault();
+    window.parent.postMessage({type:"navigate",path:target.getAttribute("data-tc-artifact-path"),fragment:target.getAttribute("data-tc-artifact-fragment")||""},"*");
+  },true);
+  window.addEventListener("message",function(event){
+    if(event.source!==window.parent||event.origin!=="null"||!event.data||event.data.type!=="artifact-fragment"||typeof event.data.fragment!=="string")return;
+    var fragment=event.data.fragment;
+    if(!/^#[^\\u0000-\\u001f\\u007f]{1,1024}$/.test(fragment))return;
+    try{var target=document.getElementById(decodeURIComponent(fragment.slice(1)));if(target)target.scrollIntoView();}catch(_){}
+  });
+  window.parent.postMessage({type:"artifact-ready"},"*");
+})();`;
+var INNER_CSP = [
+  "default-src 'none'",
+  "script-src 'unsafe-inline'",
+  "style-src 'unsafe-inline'",
+  "img-src data: blob:",
+  "font-src data: blob:",
+  "media-src data: blob:",
+  "connect-src 'none'",
+  "frame-src 'none'",
+  "child-src 'none'",
+  "object-src 'none'",
+  "base-uri 'none'",
+  "form-action 'none'"
+].join("; ");
+async function transformHtml(path, file, context) {
+  const text = decodeText(file);
+  scanMarkup(text, { references: false });
+  const doc = context.parseHtml(text);
+  const roots = documentRoots(doc);
+  const deferred = newDeferred();
+  if (doc.querySelector("parsererror") !== null) fail("malformed", "artifact html is malformed");
+  if (queryAll(roots, BLOCKED_ELEMENTS).length > 0) {
+    fail("unsupported", "artifact contains a blocked html feature");
+  }
+  rejectEventHandlerAttributes(roots);
+  rejectSvgResourceReferences(roots);
+  const inlineStyles = queryAll(roots, "style");
+  for (const meta of queryAll(roots, "meta[http-equiv]")) meta.remove();
+  for (const link of queryAll(roots, "link[href]")) {
+    const relation = classifyLinkRelation(link.getAttribute("rel"));
+    if (relation === "stylesheet") {
+      const { file: stylesheet, resolved } = requiredFile(context, path, link.getAttribute("href") ?? "");
+      const style = doc.createElement("style");
+      style.textContent = wrapMediaCss(await transformCss(decodeText(stylesheet, context), resolved.path, { ...context, cssStack: [resolved.path] }), link.getAttribute("media"));
+      link.replaceWith(style);
+      continue;
+    }
+    if (relation === "icon") {
+      const { file: icon, resolved } = requiredFile(context, path, link.getAttribute("href") ?? "");
+      link.href = `${asDataUrl(icon, context)}${resolved.fragment}`;
+      continue;
+    }
+    fail("unsupported", "artifact contains an unsupported link relation");
+  }
+  for (const style of inlineStyles) {
+    style.textContent = wrapMediaCss(await transformCss(style.textContent ?? "", path, { ...context, cssStack: [] }), style.getAttribute("media"));
+  }
+  for (const element of queryAll(roots, "[style]")) {
+    const value = element.getAttribute("style");
+    if (value !== null) element.setAttribute("style", await transformCss(value, path, { ...context, cssStack: [], deferred }));
+  }
+  for (const script of queryAll(roots, "script")) {
+    if ((script.getAttribute("type") ?? "").trim().toLowerCase() === "module" || script.hasAttribute("async") || script.hasAttribute("defer")) {
+      fail("unsupported", "artifact uses an unsupported script mode");
+    }
+    if (!isJavaScriptType(script.getAttribute("type"))) fail("unsupported", "artifact uses a script type that is not JavaScript");
+    let source = script.textContent ?? "";
+    const reference = script.getAttribute("src");
+    if (reference !== null) {
+      const { file: scriptFile } = requiredFile(context, path, reference);
+      source = decodeText(scriptFile, context);
+      script.removeAttribute("src");
+    }
+    assertClassicScript(source);
+    script.textContent = source.replace(/<\/script/gi, "<\\/script");
+  }
+  const resourceAttributes = [
+    ["img[src]", "src"],
+    ["source[src]", "src"],
+    ["video[src]", "src"],
+    ["video[poster]", "poster"],
+    ["audio[src]", "src"],
+    ["track[src]", "src"],
+    ["input[type=image][src]", "src"]
+  ];
+  for (const [selector, attribute] of resourceAttributes) {
+    for (const element of queryAll(roots, selector)) {
+      const reference = element.getAttribute(attribute);
+      if (reference === null) continue;
+      const { file: resource, resolved } = requiredFile(context, path, reference);
+      element.setAttribute(attribute, `${asDataUrl(resource, context)}${resolved.fragment}`);
+    }
+  }
+  for (const element of queryAll(roots, "[srcset]")) {
+    const value = element.getAttribute("srcset");
+    if (value !== null) element.setAttribute("srcset", serializeSrcset(value, path, context));
+  }
+  for (const anchor of queryAll(roots, "a[href]")) {
+    anchor.removeAttribute("target");
+    anchor.removeAttribute("download");
+    const reference = anchor.getAttribute("href") ?? "";
+    if (reference.startsWith("#")) continue;
+    const resolved = resolveReferenceFrom(path, reference);
+    if (context.singlePage) throw new ArtifactBundleError("unsupported", "artifact links to another page", path, reference);
+    if (!context.files.has(resolved.path) || !/\.html?$/i.test(resolved.path)) fail("unsupported", "artifact link leaves its html bundle");
+    anchor.href = "#";
+    anchor.dataset.tcArtifactPath = resolved.path;
+    if (resolved.fragment.length > 0) anchor.dataset.tcArtifactFragment = resolved.fragment;
+  }
+  const head = doc.head ?? doc.documentElement.insertBefore(doc.createElement("head"), doc.body);
+  const csp = doc.createElement("meta");
+  csp.httpEquiv = "Content-Security-Policy";
+  csp.content = INNER_CSP;
+  const bootstrap = doc.createElement("script");
+  bootstrap.textContent = CHILD_BOOTSTRAP;
+  head.prepend(bootstrap);
+  head.prepend(csp);
+  const output = restoreParkedUrls(`<!DOCTYPE html>
+${doc.documentElement.outerHTML}`, deferred);
+  verifySelfContained(output, context);
+  return output;
+}
+async function prepareHtmlArtifact(input, options = {}) {
+  if (input.length === 0) fail("malformed", "artifact bundle is empty");
+  if (input.length > MAX_ARTIFACT_FILES) fail("limit", "artifact has too many files");
+  const files = /* @__PURE__ */ new Map();
+  const aliases = /* @__PURE__ */ new Set();
+  let sourceBytes = 0;
+  for (const candidate of input) {
+    let path;
+    try {
+      path = canonicalArtifactPath(candidate.path);
+    } catch (error) {
+      if (error instanceof ArtifactBundleError) throw new ArtifactBundleError(error.kind, error.message, candidate.path);
+      throw error;
+    }
+    const alias = path.toLowerCase();
+    if (aliases.has(alias)) throw new ArtifactBundleError("malformed", "artifact paths collide after canonicalization", path);
+    aliases.add(alias);
+    sourceBytes += candidate.bytes.byteLength;
+    if (!Number.isSafeInteger(sourceBytes) || sourceBytes > MAX_ARTIFACT_SOURCE_BYTES) throw new ArtifactBundleError("limit", "artifact source exceeds limit", path);
+    files.set(path, { ...candidate, path });
+  }
+  const detection = detectHtmlArtifact([...files.keys()]);
+  if (detection.kind !== "html") fail("malformed", "artifact root index is missing");
+  const renderBytes = [...files.values()].filter((file) => /^(?:text\/|application\/(?:javascript|json)|image\/svg\+xml)/i.test(artifactMediaType(file.path, file.mediaType))).reduce((total, file) => total + file.bytes.byteLength, 0);
+  if (renderBytes > MAX_ARTIFACT_RENDER_BYTES) fail("limit", "artifact render aggregate exceeds limit");
+  const context = {
+    files,
+    cssStack: [],
+    counter: { references: 0, inlinedBytes: 0 },
+    parseHtml: options.parseHtml ?? defaultParseHtml,
+    singlePage: options.singlePage === true
+  };
+  const pages = {};
+  let renderedBytes = 0;
+  for (const [path, file] of files) {
+    if (!/\.html?$/i.test(path)) continue;
+    if (context.singlePage && path !== ARTIFACT_ENTRY) continue;
+    let page;
+    try {
+      page = await transformHtml(path, file, context);
+    } catch (error) {
+      if (error instanceof ArtifactBundleError && error.path === void 0) throw new ArtifactBundleError(error.kind, error.message, path, error.reference);
+      throw error;
+    }
+    renderedBytes += new TextEncoder().encode(page).byteLength;
+    if (!Number.isSafeInteger(renderedBytes) || renderedBytes > MAX_ARTIFACT_RENDER_BYTES) {
+      fail("limit", "artifact rendered output exceeds limit");
+    }
+    pages[path] = page;
+  }
+  return { entry: ARTIFACT_ENTRY, pages: Object.freeze(pages), fileCount: files.size, sourceBytes };
+}
+
+// src/html-bundle/folder.ts
+function isPassiveArtifactPath(canonicalPath) {
+  const lower = canonicalPath.toLowerCase();
+  return lower === "manifest.json" || lower.startsWith("knowledge/");
+}
+function canonicalWithPath(path) {
+  try {
+    return canonicalArtifactPath(path);
+  } catch (error) {
+    if (error instanceof ArtifactBundleError) throw new ArtifactBundleError(error.kind, error.message, path);
+    throw error;
+  }
+}
+async function inlineHtmlFolder(files, options = {}) {
+  if (files.length === 0) throw new ArtifactBundleError("malformed", "artifact bundle is empty");
+  if (files.length > MAX_ARTIFACT_FILES) throw new ArtifactBundleError("limit", "artifact has too many files");
+  const canonical = /* @__PURE__ */ new Map();
+  const aliases = /* @__PURE__ */ new Map();
+  let sourceBytes = 0;
+  for (const candidate of files) {
+    const path = canonicalWithPath(candidate.path);
+    const alias = path.toLowerCase();
+    if (aliases.has(alias)) throw new ArtifactBundleError("malformed", "artifact paths collide after canonicalization", path);
+    aliases.set(alias, path);
+    sourceBytes += candidate.bytes.byteLength;
+    if (!Number.isSafeInteger(sourceBytes) || sourceBytes > MAX_ARTIFACT_SOURCE_BYTES) {
+      throw new ArtifactBundleError("limit", "artifact source exceeds limit", path);
+    }
+    canonical.set(path, { ...candidate, path });
+  }
+  if (!canonical.has(ARTIFACT_ENTRY)) throw new ArtifactBundleError("missing", "artifact root index is missing", ARTIFACT_ENTRY);
+  const active = [];
+  const passive = [];
+  for (const file of canonical.values()) (isPassiveArtifactPath(file.path) ? passive : active).push(file);
+  const prepared = await prepareHtmlArtifact(active, { ...options, singlePage: true });
+  passive.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+  return {
+    entry: ARTIFACT_ENTRY,
+    html: new TextEncoder().encode(prepared.pages[ARTIFACT_ENTRY]),
+    passive,
+    fileCount: canonical.size,
+    sourceBytes
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARTIFACT_ENTRY,
+  ArtifactBundleError,
+  MAX_ARTIFACT_ATTRIBUTES_PER_ELEMENT,
+  MAX_ARTIFACT_COMMENTS,
+  MAX_ARTIFACT_CSS_IMPORT_DEPTH,
+  MAX_ARTIFACT_FILES,
+  MAX_ARTIFACT_REFERENCES,
+  MAX_ARTIFACT_RENDER_BYTES,
+  MAX_ARTIFACT_SOURCE_BYTES,
+  MAX_ARTIFACT_TEXT_BYTES,
+  artifactMediaType,
+  assertSelfContainedPage,
+  canonicalArtifactPath,
+  detectHtmlArtifact,
+  inlineHtmlFolder,
+  isPassiveArtifactPath,
+  normalizeCssEscapes,
+  prepareHtmlArtifact,
+  resolveArtifactReference
+});
+//# sourceMappingURL=html-bundle.cjs.map