html-preview-sandbox 0.1.0

package/dist/index.browser.js

@@ -0,0 +1,988 @@
+// src/errors.ts
+var PreviewError = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "PreviewError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+var ERROR_CODES = {
+  OVERSIZED: "OVERSIZED",
+  DECODE_FAILED: "DECODE_FAILED",
+  EMPTY_AFTER_SANITIZE: "EMPTY_AFTER_SANITIZE",
+  RENDER_FAILED: "RENDER_FAILED"
+};
+
+// src/decode.ts
+var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
+var BOM_UTF8 = [239, 187, 191];
+var BOM_UTF16_LE = [255, 254];
+var BOM_UTF16_BE = [254, 255];
+function startsWithBytes(bytes, prefix) {
+  if (bytes.length < prefix.length) return false;
+  return prefix.every((byte, index) => bytes[index] === byte);
+}
+function decodeWith(bytes, encoding, fatal = false) {
+  try {
+    return new TextDecoder(encoding, { fatal }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function findDeclaredCharset(head) {
+  const metaCharset = head.match(/<meta[^>]+charset\s*=\s*["']?([\w-]+)/i);
+  if (metaCharset?.[1]) return metaCharset[1].toLowerCase();
+  const contentType = head.match(/charset\s*=\s*["']?([\w-]+)/i);
+  if (contentType?.[1]) return contentType[1].toLowerCase();
+  return null;
+}
+async function normalizeInput(input, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  if (typeof input === "string") {
+    const size = new TextEncoder().encode(input).byteLength;
+    if (size > maxBytes) {
+      throw new PreviewError(ERROR_CODES.OVERSIZED, `HTML input exceeds ${maxBytes} bytes`);
+    }
+    return { html: input, encoding: "utf-8", usedBom: false, size };
+  }
+  let bytes;
+  if (input instanceof Uint8Array) {
+    bytes = input;
+  } else if (input instanceof ArrayBuffer) {
+    bytes = new Uint8Array(input);
+  } else if (typeof Blob !== "undefined" && input instanceof Blob) {
+    if (input.size > maxBytes) {
+      throw new PreviewError(ERROR_CODES.OVERSIZED, `HTML input exceeds ${maxBytes} bytes`);
+    }
+    bytes = new Uint8Array(await input.arrayBuffer());
+  } else {
+    throw new PreviewError(ERROR_CODES.DECODE_FAILED, "Unsupported preview input");
+  }
+  if (bytes.byteLength > maxBytes) {
+    throw new PreviewError(ERROR_CODES.OVERSIZED, `HTML input exceeds ${maxBytes} bytes`);
+  }
+  return decodeHtmlBytes(bytes);
+}
+function decodeHtmlBytes(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (startsWithBytes(bytes, BOM_UTF8)) {
+    return {
+      html: decodeWith(bytes.subarray(BOM_UTF8.length), "utf-8") ?? "",
+      encoding: "utf-8",
+      usedBom: true,
+      size: bytes.byteLength
+    };
+  }
+  if (startsWithBytes(bytes, BOM_UTF16_LE)) {
+    return {
+      html: decodeWith(bytes.subarray(BOM_UTF16_LE.length), "utf-16le") ?? "",
+      encoding: "utf-16le",
+      usedBom: true,
+      size: bytes.byteLength
+    };
+  }
+  if (startsWithBytes(bytes, BOM_UTF16_BE)) {
+    return {
+      html: decodeWith(bytes.subarray(BOM_UTF16_BE.length), "utf-16be") ?? "",
+      encoding: "utf-16be",
+      usedBom: true,
+      size: bytes.byteLength
+    };
+  }
+  const strictUtf8 = decodeWith(bytes, "utf-8", true);
+  if (strictUtf8 !== null) {
+    return { html: strictUtf8, encoding: "utf-8", usedBom: false, size: bytes.byteLength };
+  }
+  const head = decodeWith(bytes.subarray(0, 4096), "iso-8859-1") ?? "";
+  const declared = findDeclaredCharset(head);
+  if (declared && declared !== "utf-8" && declared !== "utf8") {
+    const decoded = decodeWith(bytes, declared);
+    if (decoded !== null) {
+      return { html: decoded, encoding: declared, usedBom: false, size: bytes.byteLength };
+    }
+  }
+  return {
+    html: decodeWith(bytes, "utf-8") ?? "",
+    encoding: "utf-8",
+    usedBom: false,
+    size: bytes.byteLength
+  };
+}
+
+// src/sanitize.browser.ts
+import createDOMPurify from "dompurify";
+
+// src/sanitize-core.ts
+var DEFAULT_ALLOWED_TAGS = [
+  "html",
+  "head",
+  "body",
+  "title",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "main",
+  "section",
+  "article",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "div",
+  "span",
+  "p",
+  "br",
+  "hr",
+  "pre",
+  "code",
+  "blockquote",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "dl",
+  "dt",
+  "dd",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  "a",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "small",
+  "mark",
+  "sub",
+  "sup",
+  "img",
+  "picture",
+  "source",
+  "audio",
+  "video",
+  "canvas",
+  "form",
+  "label",
+  "input",
+  "button",
+  "select",
+  "option",
+  "optgroup",
+  "textarea",
+  "fieldset",
+  "legend",
+  "details",
+  "summary",
+  "svg",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "desc",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "path",
+  "text",
+  "tspan",
+  "textPath",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "pattern",
+  "mask",
+  "clipPath",
+  "filter",
+  "feGaussianBlur",
+  "feColorMatrix",
+  "feOffset",
+  "feMerge",
+  "feMergeNode",
+  "feBlend",
+  "feFlood",
+  "feComposite",
+  "feTurbulence",
+  "feDisplacementMap",
+  "feDropShadow",
+  "marker",
+  "animate",
+  "animateTransform",
+  "animateMotion",
+  "set",
+  "foreignObject"
+];
+var DISALLOWED_TAGS = ["base", "object", "embed", "applet"];
+var GLOBAL_ATTRS = [
+  "class",
+  "id",
+  "style",
+  "title",
+  "lang",
+  "dir",
+  "role",
+  "tabindex",
+  "hidden",
+  "aria-*",
+  "data-*"
+];
+var SAFE_INLINE_EVENTS = [
+  "onclick",
+  "onauxclick",
+  "ondblclick",
+  "oninput",
+  "onchange",
+  "onsubmit",
+  "onreset",
+  "onkeydown",
+  "onkeyup",
+  "onkeypress",
+  "onfocusin",
+  "onfocusout"
+];
+var SVG_ATTRS = [
+  "x",
+  "y",
+  "cx",
+  "cy",
+  "r",
+  "rx",
+  "ry",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "width",
+  "height",
+  "d",
+  "points",
+  "transform",
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "stroke-opacity",
+  "stroke-miterlimit",
+  "opacity",
+  "color",
+  "visibility",
+  "display",
+  "vector-effect",
+  "viewBox",
+  "preserveAspectRatio",
+  "xmlns",
+  "xmlns:xlink",
+  "href",
+  "xlink:href",
+  "offset",
+  "gradientUnits",
+  "gradientTransform",
+  "spreadMethod",
+  "stop-color",
+  "stop-opacity",
+  "text-anchor",
+  "dominant-baseline",
+  "alignment-baseline",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "font-style",
+  "letter-spacing",
+  "word-spacing",
+  "text-decoration",
+  "dx",
+  "dy",
+  "rotate",
+  "startOffset",
+  "textLength",
+  "lengthAdjust",
+  "clip-path",
+  "clip-rule",
+  "mask",
+  "filter",
+  "stdDeviation",
+  "in",
+  "in2",
+  "result",
+  "mode",
+  "flood-color",
+  "flood-opacity",
+  "edgeMode",
+  "patternUnits",
+  "patternTransform",
+  "patternContentUnits",
+  "markerWidth",
+  "markerHeight",
+  "refX",
+  "refY",
+  "orient",
+  "markerUnits",
+  "marker-start",
+  "marker-mid",
+  "marker-end",
+  "attributeName",
+  "attributeType",
+  "from",
+  "to",
+  "by",
+  "values",
+  "dur",
+  "repeatCount",
+  "repeatDur",
+  "begin",
+  "end",
+  "calcMode",
+  "keyTimes",
+  "keySplines",
+  "additive",
+  "accumulate",
+  "fill-mode",
+  "restart"
+];
+var ATTRS_BY_TAG = {
+  a: ["href", "name", "target", "rel", "download"],
+  link: ["rel", "href", "as", "crossorigin", "integrity", "referrerpolicy", "type", "media", "sizes"],
+  meta: ["charset", "name", "content", "http-equiv", "property"],
+  img: ["src", "alt", "width", "height", "loading", "decoding", "srcset", "sizes"],
+  source: ["src", "srcset", "type", "media"],
+  input: ["type", "name", "value", "placeholder", "min", "max", "step", "required", "checked", "disabled", "readonly", "pattern", "maxlength"],
+  button: ["type", "name", "value", "disabled"],
+  select: ["name", "value", "multiple", "disabled", "required"],
+  option: ["value", "selected", "disabled"],
+  textarea: ["name", "value", "placeholder", "rows", "cols", "maxlength", "required", "disabled", "readonly"],
+  form: ["method", "enctype", "novalidate"],
+  label: ["for"],
+  audio: ["src", "controls", "autoplay", "loop", "muted", "preload"],
+  video: ["src", "controls", "autoplay", "loop", "muted", "preload", "poster", "width", "height"],
+  script: ["src", "type", "async", "defer", "crossorigin", "integrity", "referrerpolicy", "nomodule", "nonce"]
+};
+var URL_ATTRS = /* @__PURE__ */ new Set(["href", "src", "srcset", "cite", "xlink:href", "action"]);
+var DEFAULT_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+var MEDIA_TAGS = /* @__PURE__ */ new Set(["img", "audio", "video", "source", "picture"]);
+function emptyReport() {
+  return {
+    removedTags: [],
+    removedAttributes: [],
+    removedSchemes: [],
+    strippedAll: false
+  };
+}
+function increment(list, predicate, create) {
+  const existing = list.find(predicate);
+  if (existing) {
+    existing.count += 1;
+    return;
+  }
+  list.push({ ...create(), count: 1 });
+}
+function reportTag(report, tag) {
+  increment(report.removedTags, (item) => item.tag === tag, () => ({ tag }));
+}
+function reportAttr(report, tag, attr) {
+  increment(report.removedAttributes, (item) => item.tag === tag && item.attr === attr, () => ({ tag, attr }));
+}
+function reportScheme(report, scheme) {
+  increment(report.removedSchemes, (item) => item.scheme === scheme, () => ({ scheme }));
+}
+function normalizeName(name) {
+  return String(name || "").toLowerCase();
+}
+function matchesPattern(attr, pattern) {
+  const normalizedPattern = normalizeName(pattern);
+  return normalizedPattern.endsWith("*") ? attr.startsWith(normalizedPattern.slice(0, -1)) : attr === normalizedPattern;
+}
+function getAllowedTags(options = {}) {
+  const tags = new Set(DEFAULT_ALLOWED_TAGS.map(normalizeName));
+  if (options.allowScripts === false) tags.delete("script");
+  for (const tag of options.extraTags ?? []) tags.add(normalizeName(tag));
+  for (const tag of options.dropTags ?? []) tags.delete(normalizeName(tag));
+  return tags;
+}
+function getAllowedAttrs(options = {}) {
+  return [
+    ...GLOBAL_ATTRS,
+    ...options.allowInlineEvents === false ? [] : SAFE_INLINE_EVENTS,
+    ...SVG_ATTRS,
+    ...Object.values(ATTRS_BY_TAG).flat(),
+    ...options.extraAttributes?.["*"] ?? [],
+    ...Object.values(options.extraAttributes ?? {}).flat()
+  ];
+}
+function isAllowedAttr(tag, attr, options = {}) {
+  if (GLOBAL_ATTRS.some((pattern) => matchesPattern(attr, pattern))) return true;
+  if (options.allowInlineEvents !== false && SAFE_INLINE_EVENTS.map(normalizeName).includes(attr)) return true;
+  if (SVG_ATTRS.map(normalizeName).includes(attr)) return true;
+  if ((ATTRS_BY_TAG[tag] ?? []).map(normalizeName).includes(attr)) return true;
+  if ((options.extraAttributes?.["*"] ?? []).map(normalizeName).includes(attr)) return true;
+  if ((options.extraAttributes?.[tag] ?? []).map(normalizeName).includes(attr)) return true;
+  return false;
+}
+function getScheme(raw) {
+  const trimmed = String(raw || "").trim();
+  const match = trimmed.match(/^([a-zA-Z][\w+.-]*):/);
+  return match ? `${match[1].toLowerCase()}:` : "";
+}
+function isAllowedUrl(raw, tag, options = {}) {
+  const scheme = getScheme(raw);
+  if (!scheme) return true;
+  if (DEFAULT_SCHEMES.has(scheme)) return true;
+  if (MEDIA_TAGS.has(tag) && (scheme === "data:" || scheme === "blob:")) return true;
+  return (options.extraSchemes ?? []).map((item) => item.endsWith(":") ? item.toLowerCase() : `${item.toLowerCase()}:`).includes(scheme);
+}
+function splitSrcsetCandidates(raw) {
+  return String(raw || "").split(",").map((candidate) => candidate.trim()).filter(Boolean).map((candidate) => candidate.split(/\s+/)[0]).filter(Boolean);
+}
+function disallowedSrcsetSchemes(raw, tag, options = {}) {
+  const schemes = /* @__PURE__ */ new Set();
+  for (const url of splitSrcsetCandidates(raw)) {
+    if (!isAllowedUrl(url, tag, options)) {
+      schemes.add(getScheme(url) || "invalid");
+    }
+  }
+  return [...schemes];
+}
+function isDangerousMeta(node) {
+  if (normalizeName(node.nodeName) !== "meta") return false;
+  const equiv = normalizeName(node.getAttribute("http-equiv"));
+  return equiv === "refresh" || equiv === "content-security-policy";
+}
+var ANIMATION_TAGS = /* @__PURE__ */ new Set(["animate", "set", "animatemotion", "animatetransform"]);
+var URL_TARGET_ATTRS = /* @__PURE__ */ new Set(["href", "xlink:href", "src"]);
+function isUrlTargetingAnimation(node) {
+  if (!ANIMATION_TAGS.has(normalizeName(node.nodeName))) return false;
+  const target = normalizeName(node.getAttribute?.("attributeName"));
+  return URL_TARGET_ATTRS.has(target);
+}
+var BLOCKED_LINK_RELS = /* @__PURE__ */ new Set(["dns-prefetch", "preconnect", "prefetch", "prerender"]);
+function isBlockedResourceHintLink(node) {
+  if (normalizeName(node.nodeName) !== "link") return false;
+  const rel = normalizeName(node.getAttribute?.("rel"));
+  if (!rel) return false;
+  return rel.split(/\s+/).some((token) => BLOCKED_LINK_RELS.has(token));
+}
+function applyProjectHooks(purifier, report, options) {
+  const pendingRemoval = /* @__PURE__ */ new WeakSet();
+  purifier.addHook("uponSanitizeElement", (node, data) => {
+    const tag = normalizeName(data.tagName || node.nodeName);
+    if (DISALLOWED_TAGS.includes(tag)) reportTag(report, tag);
+    if (isDangerousMeta(node)) reportAttr(report, "meta", "http-equiv");
+    if (isUrlTargetingAnimation(node)) {
+      reportTag(report, tag);
+      pendingRemoval.add(node);
+    }
+    if (isBlockedResourceHintLink(node)) {
+      reportTag(report, tag);
+      pendingRemoval.add(node);
+    }
+  });
+  purifier.addHook("afterSanitizeElements", (node) => {
+    if (isDangerousMeta(node) || pendingRemoval.has(node)) {
+      node.remove();
+    }
+  });
+  purifier.addHook("afterSanitizeAttributes", (node) => {
+    const tag = normalizeName(node.nodeName);
+    if (!node.attributes) return;
+    for (const attrNode of [...node.attributes]) {
+      const attr = normalizeName(attrNode.name);
+      if (!isAllowedAttr(tag, attr, options)) {
+        reportAttr(report, tag, attr);
+        node.removeAttribute(attrNode.name);
+        continue;
+      }
+      if (URL_ATTRS.has(attr) && !isAllowedUrl(attrNode.value, tag, options)) {
+        reportAttr(report, tag, attr);
+        reportScheme(report, getScheme(attrNode.value) || "invalid");
+        node.removeAttribute(attrNode.name);
+        continue;
+      }
+      if (attr === "srcset") {
+        const blockedSchemes = disallowedSrcsetSchemes(attrNode.value, tag, options);
+        if (blockedSchemes.length) {
+          reportAttr(report, tag, attr);
+          for (const scheme of blockedSchemes) reportScheme(report, scheme);
+          node.removeAttribute(attrNode.name);
+        }
+      }
+    }
+  });
+}
+function collectDomPurifyRemoved(purifier, report) {
+  for (const item of purifier.removed ?? []) {
+    if (item.element) {
+      reportTag(report, normalizeName(item.element.nodeName));
+    }
+    if (item.attribute) {
+      reportAttr(report, normalizeName(item.from?.nodeName || "*"), normalizeName(item.attribute.name));
+      if (URL_ATTRS.has(normalizeName(item.attribute.name))) {
+        reportScheme(report, getScheme(item.attribute.value) || "invalid");
+      }
+    }
+  }
+}
+function createSanitizer(runtimeWindow, createDOMPurify2) {
+  return function sanitizeHtml2(rawHtml, options = {}) {
+    const purifier = createDOMPurify2(runtimeWindow);
+    const report = emptyReport();
+    const allowedTags = [...getAllowedTags(options)];
+    applyProjectHooks(purifier, report, options);
+    const html = purifier.sanitize(rawHtml, {
+      WHOLE_DOCUMENT: true,
+      // ALLOWED_TAGS/ALLOWED_ATTR are authoritative (they replace DOMPurify's
+      // defaults). Per-tag attribute tightening happens in the afterSanitizeAttributes
+      // hook; DISALLOWED_TAGS is the hard deny-list.
+      ALLOWED_TAGS: allowedTags,
+      ALLOWED_ATTR: getAllowedAttrs(options),
+      FORBID_TAGS: DISALLOWED_TAGS,
+      KEEP_CONTENT: true,
+      ALLOW_DATA_ATTR: true,
+      ALLOW_ARIA_ATTR: true
+    });
+    collectDomPurifyRemoved(purifier, report);
+    const parser = new runtimeWindow.DOMParser();
+    const doc = parser.parseFromString(html, "text/html");
+    report.strippedAll = !doc.body.textContent?.trim() && !doc.body.querySelector("script,style,img,svg,canvas,video,audio");
+    return { html, report };
+  };
+}
+
+// src/sanitize.browser.ts
+var sanitizeHtml = createSanitizer(window, createDOMPurify);
+
+// src/policy.ts
+var DEFAULT_SCRIPT_HOSTS = [
+  "https://cdnjs.cloudflare.com",
+  "https://cdn.jsdelivr.net",
+  "https://cdn.tailwindcss.com",
+  "https://code.jquery.com"
+];
+var DEFAULT_STYLE_HOSTS = [
+  "https://cdnjs.cloudflare.com",
+  "https://cdn.jsdelivr.net",
+  "https://cdn.tailwindcss.com",
+  "https://fonts.googleapis.com"
+];
+var DEFAULT_FONT_HOSTS = ["https://fonts.gstatic.com"];
+var DEFAULT_SANDBOX_TOKENS = [
+  "allow-scripts",
+  "allow-forms",
+  "allow-popups",
+  "allow-popups-to-escape-sandbox",
+  "allow-modals"
+];
+var UNSAFE_SANDBOX_TOKENS = [
+  "allow-same-origin",
+  "allow-top-navigation",
+  "allow-top-navigation-by-user-activation",
+  "allow-downloads"
+];
+var DEFAULT_ALLOWED_EXTERNAL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:"];
+function normalizePolicy(policy) {
+  if (!policy) return { preset: "strict" };
+  if (typeof policy === "string") return { preset: policy };
+  return { preset: "strict", ...policy };
+}
+function join(values) {
+  return [...new Set(values.filter(Boolean))].join(" ");
+}
+function buildCsp(policy) {
+  const normalized = normalizePolicy(policy);
+  const preset = normalized.preset ?? "strict";
+  const scriptHosts = [...DEFAULT_SCRIPT_HOSTS, ...normalized.scriptHosts ?? []];
+  const styleHosts = [...DEFAULT_STYLE_HOSTS, ...normalized.styleHosts ?? []];
+  const fontHosts = [...DEFAULT_FONT_HOSTS, ...normalized.fontHosts ?? []];
+  const imgHosts = normalized.imgHosts ?? [];
+  const connectHosts = normalized.connectHosts ?? [];
+  const directives = {
+    "default-src": "'none'",
+    "script-src": join(["'unsafe-inline'", "'unsafe-eval'", ...scriptHosts]),
+    "style-src": join(["'unsafe-inline'", ...styleHosts]),
+    "img-src": join(["blob:", "data:", ...imgHosts]),
+    "media-src": "blob: data:",
+    "font-src": join(["data:", ...fontHosts]),
+    "connect-src": "'none'",
+    "worker-src": "'none'",
+    "frame-src": "blob:",
+    "object-src": "'none'",
+    "base-uri": "'none'",
+    "form-action": "'none'",
+    "upgrade-insecure-requests": "",
+    "block-all-mixed-content": ""
+  };
+  if (preset === "balanced") {
+    directives["script-src"] = join(["'unsafe-inline'", "'unsafe-eval'", ...scriptHosts, "https://unpkg.com"]);
+    directives["style-src"] = join(["'unsafe-inline'", ...styleHosts, "https://unpkg.com"]);
+    directives["img-src"] = join(["https:", "blob:", "data:", ...imgHosts]);
+    directives["media-src"] = join(["https:", "blob:", "data:"]);
+    directives["connect-src"] = connectHosts.length ? join(["https:", ...connectHosts]) : "https:";
+  }
+  if (preset === "offline") {
+    directives["script-src"] = "'unsafe-inline'";
+    directives["style-src"] = "'unsafe-inline'";
+    directives["img-src"] = "blob: data:";
+    directives["media-src"] = "blob: data:";
+    directives["font-src"] = "data:";
+    directives["connect-src"] = "'none'";
+  }
+  Object.assign(directives, normalized.directives ?? {});
+  return Object.entries(directives).map(([name, value]) => value ? `${name} ${value}` : name).join("; ");
+}
+function injectCspMeta(html, csp) {
+  const escaped = csp.replace(/"/g, "&quot;");
+  const meta = `<meta http-equiv="Content-Security-Policy" content="${escaped}">`;
+  if (/<head[^>]*>/i.test(html)) {
+    return html.replace(/<head[^>]*>/i, (match) => `${match}${meta}`);
+  }
+  if (/<html[^>]*>/i.test(html)) {
+    return html.replace(/<html[^>]*>/i, (match) => `${match}<head>${meta}</head>`);
+  }
+  return `<!doctype html><html><head>${meta}</head><body>${html}</body></html>`;
+}
+function getSandboxAttribute(tokens = DEFAULT_SANDBOX_TOKENS, options = {}) {
+  const allowUnsafeTokens = options.allowUnsafeTokens === true;
+  return [...new Set(tokens)].filter((token) => allowUnsafeTokens || !UNSAFE_SANDBOX_TOKENS.includes(token)).join(" ");
+}
+function isAllowedExternalUrl(url, protocols = DEFAULT_ALLOWED_EXTERNAL_PROTOCOLS) {
+  try {
+    const parsed = new URL(url);
+    const allowedProtocols = protocols.map((protocol) => {
+      const normalized = String(protocol || "").toLowerCase();
+      return normalized.endsWith(":") ? normalized : `${normalized}:`;
+    });
+    return allowedProtocols.includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+
+// src/bridge.ts
+var BRIDGE_OPEN_EXTERNAL = "html-preview-sandbox:openExternal";
+var BRIDGE_CSP_VIOLATION = "html-preview-sandbox:cspViolation";
+var CSP_VIOLATION_LIMIT = 30;
+function bridgeScript() {
+  return `<script>
+(() => {
+  const OPEN_EXTERNAL = ${JSON.stringify(BRIDGE_OPEN_EXTERNAL)};
+  const CSP_VIOLATION = ${JSON.stringify(BRIDGE_CSP_VIOLATION)};
+  const LIMIT = ${CSP_VIOLATION_LIMIT};
+
+  function post(type, payload) {
+    try {
+      window.parent.postMessage(Object.assign({ type }, payload), '*');
+    } catch (_) {}
+  }
+
+  function postExternal(href, source) {
+    post(OPEN_EXTERNAL, { href: String(href || ''), source });
+  }
+
+  document.addEventListener('click', (event) => {
+    let element = event.target;
+    while (element && element.nodeName !== 'A') element = element.parentElement;
+    if (!element) return;
+
+    const href = element.getAttribute('href');
+    const resolved = element.href || '';
+
+    if (href == null || href === '' || href.charAt(0) === '#') {
+      event.preventDefault();
+      event.stopPropagation();
+      const fragment = href && href.length > 1 ? href.slice(1) : '';
+      if (fragment) {
+        let target = null;
+        try {
+          target = document.getElementById(fragment) || document.querySelector('a[name="' + CSS.escape(fragment) + '"]');
+        } catch (_) {}
+        if (target && target.scrollIntoView) target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+      } else if (href === '#') {
+        try { window.scrollTo({ top: 0, behavior: 'smooth' }); } catch (_) {}
+      }
+      return;
+    }
+
+    // Defense in depth: even if a relaxed custom sanitizer let a javascript: URL
+    // through, the bridge must not allow the default click to run it.
+    if (/^javascript:/i.test(resolved)) {
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+
+    try {
+      const url = new URL(resolved);
+      if (url.protocol === 'about:') return;
+    } catch (_) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+    postExternal(resolved, 'link');
+  }, true);
+
+  window.open = (url) => {
+    if (url) postExternal(url, 'window.open');
+    return null;
+  };
+
+  const seen = new Set();
+  let sent = 0;
+  document.addEventListener('securitypolicyviolation', (event) => {
+    if (sent >= LIMIT) return;
+    const key = (event.effectiveDirective || event.violatedDirective || '') + '|' + (event.blockedURI || '');
+    if (seen.has(key)) return;
+    seen.add(key);
+    sent += 1;
+    post(CSP_VIOLATION, {
+      blockedURI: String(event.blockedURI || ''),
+      violatedDirective: String(event.violatedDirective || ''),
+      effectiveDirective: String(event.effectiveDirective || ''),
+      sourceFile: String(event.sourceFile || ''),
+      lineNumber: Number(event.lineNumber || 0),
+      columnNumber: Number(event.columnNumber || 0),
+      disposition: String(event.disposition || ''),
+      sample: String(event.sample || '').slice(0, 120),
+    });
+  });
+})();
+<\/script>`;
+}
+function injectBridgeScript(html) {
+  const script = bridgeScript();
+  const cspMeta = /<meta[^>]*http-equiv\s*=\s*["']Content-Security-Policy["'][^>]*>/i;
+  if (cspMeta.test(html)) {
+    return html.replace(cspMeta, (match) => `${match}${script}`);
+  }
+  if (/<\/head>/i.test(html)) {
+    return html.replace(/<\/head>/i, `${script}</head>`);
+  }
+  if (/<body[^>]*>/i.test(html)) {
+    return html.replace(/<body[^>]*>/i, (match) => `${match}${script}`);
+  }
+  return `${html}${script}`;
+}
+
+// src/scrollbar.ts
+var AUTHOR_SCROLLBAR_RE = /::-webkit-scrollbar|scrollbar-width|scrollbar-color/i;
+var SCROLLBAR_STYLE = `<style data-html-preview-sandbox-scrollbar>
+:root {
+  color-scheme: light;
+}
+html, body {
+  min-height: 100%;
+}
+* {
+  scrollbar-width: thin;
+  scrollbar-color: rgba(96, 112, 128, 0.45) transparent;
+}
+*::-webkit-scrollbar {
+  width: 10px;
+  height: 10px;
+}
+*::-webkit-scrollbar-thumb {
+  background: rgba(96, 112, 128, 0.38);
+  border-radius: 999px;
+  border: 2px solid transparent;
+  background-clip: content-box;
+}
+</style>`;
+function hasAuthorScrollbarStyle(html) {
+  return AUTHOR_SCROLLBAR_RE.test(html || "");
+}
+function injectScrollbarStyle(html) {
+  if (hasAuthorScrollbarStyle(html)) return html;
+  if (/<\/head>/i.test(html)) {
+    return html.replace(/<\/head>/i, `${SCROLLBAR_STYLE}</head>`);
+  }
+  if (/<body[^>]*>/i.test(html)) {
+    return html.replace(/<body[^>]*>/i, (match) => `${match}${SCROLLBAR_STYLE}`);
+  }
+  return `${html}${SCROLLBAR_STYLE}`;
+}
+
+// src/document.browser.ts
+async function createHtmlDocument(input, options = {}) {
+  const decoded = await normalizeInput(input, { maxBytes: options.maxBytes });
+  const sanitized = sanitizeHtml(decoded.html, options.sanitize);
+  if (!sanitized.html.trim()) {
+    sanitized.report.strippedAll = true;
+    throw new PreviewError(ERROR_CODES.EMPTY_AFTER_SANITIZE, "HTML is empty after sanitization");
+  }
+  const csp = buildCsp(options.csp);
+  const withCsp = injectCspMeta(sanitized.html, csp);
+  const withBridge = injectBridgeScript(withCsp);
+  const html = options.injectScrollbarStyle === false ? withBridge : injectScrollbarStyle(withBridge);
+  return {
+    html,
+    encoding: decoded.encoding,
+    sanitizeReport: sanitized.report
+  };
+}
+
+// src/renderer-core.ts
+function toMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function toPreviewError(error) {
+  return error instanceof PreviewError ? error : new PreviewError(ERROR_CODES.RENDER_FAILED, toMessage(error), error);
+}
+function createPreviewFactory(createHtmlDocument2) {
+  return function createPreview2(container, options = {}) {
+    if (!container || typeof container.appendChild !== "function") {
+      throw new TypeError("createPreview requires a container HTMLElement");
+    }
+    let currentOptions = { ...options };
+    let iframe = null;
+    let destroyed = false;
+    let lastHtml = "";
+    function removeIframe() {
+      if (iframe?.parentNode) iframe.parentNode.removeChild(iframe);
+      iframe = null;
+    }
+    function ensureIframe() {
+      removeIframe();
+      iframe = document.createElement("iframe");
+      iframe.setAttribute("sandbox", getSandboxAttribute(currentOptions.sandboxTokens ?? DEFAULT_SANDBOX_TOKENS, {
+        allowUnsafeTokens: currentOptions.allowUnsafeSandboxTokens
+      }));
+      iframe.setAttribute("referrerpolicy", "no-referrer");
+      iframe.setAttribute("title", "HTML preview sandbox");
+      iframe.style.width = "100%";
+      iframe.style.height = "100%";
+      iframe.style.border = "0";
+      iframe.style.display = "block";
+      iframe.style.background = "#fff";
+      container.appendChild(iframe);
+      return iframe;
+    }
+    function handleMessage(event) {
+      const data = event?.data;
+      if (!data || typeof data !== "object") return;
+      if (!iframe || event.source !== iframe.contentWindow) return;
+      if ("type" in data && data.type === BRIDGE_CSP_VIOLATION) {
+        currentOptions.onCspViolation?.({
+          effectiveDirective: String(data.effectiveDirective || data.violatedDirective || ""),
+          blockedURI: String(data.blockedURI || ""),
+          sourceFile: String(data.sourceFile || ""),
+          lineNumber: Number(data.lineNumber || 0),
+          sample: String(data.sample || "")
+        });
+        return;
+      }
+      if ("type" in data && data.type === BRIDGE_OPEN_EXTERNAL) {
+        const href = String(data.href || "");
+        const source = data.source === "window.open" ? "window.open" : "link";
+        const context = { source };
+        if (!isAllowedExternal(href, context)) {
+          currentOptions.logger?.warn?.(`Blocked external URL: ${href}`);
+          return;
+        }
+        currentOptions.onOpenExternal?.(href, context);
+      }
+    }
+    function isAllowedExternal(url, context) {
+      if (!isAllowedExternalUrl(url, currentOptions.externalProtocols)) return false;
+      if (!currentOptions.allowExternalUrl) return true;
+      try {
+        return currentOptions.allowExternalUrl(url, context) === true;
+      } catch (error) {
+        currentOptions.logger?.warn?.(`External URL policy threw: ${toMessage(error)}`);
+        return false;
+      }
+    }
+    function remountLastHtml() {
+      if (!lastHtml) return;
+      const target = ensureIframe();
+      target.srcdoc = lastHtml;
+    }
+    window.addEventListener("message", handleMessage);
+    return {
+      async render(input) {
+        if (destroyed) throw new Error("Preview has been destroyed");
+        try {
+          const result = await createHtmlDocument2(input, currentOptions);
+          currentOptions.onSanitize?.(result.sanitizeReport);
+          lastHtml = result.html;
+          const target = ensureIframe();
+          target.srcdoc = result.html;
+          return result;
+        } catch (error) {
+          currentOptions.onError?.(toPreviewError(error));
+          throw error;
+        }
+      },
+      updateOptions(patch) {
+        currentOptions = { ...currentOptions, ...patch };
+      },
+      notifyNavigationAttempt(url, context = { source: "navigation" }) {
+        const href = String(url || "");
+        if (!href) return;
+        currentOptions.onNavigationAttempt?.(href, context);
+        remountLastHtml();
+        if (isAllowedExternal(href, context)) {
+          currentOptions.onOpenExternal?.(href, context);
+        } else {
+          currentOptions.logger?.warn?.(`Blocked navigation URL: ${href}`);
+        }
+      },
+      destroy() {
+        destroyed = true;
+        window.removeEventListener("message", handleMessage);
+        removeIframe();
+        lastHtml = "";
+      },
+      get iframe() {
+        return iframe;
+      }
+    };
+  };
+}
+
+// src/renderer.browser.ts
+var createPreview = createPreviewFactory(createHtmlDocument);
+export {
+  BRIDGE_CSP_VIOLATION,
+  BRIDGE_OPEN_EXTERNAL,
+  DEFAULT_ALLOWED_EXTERNAL_PROTOCOLS,
+  DEFAULT_MAX_BYTES,
+  DEFAULT_SANDBOX_TOKENS,
+  ERROR_CODES,
+  PreviewError,
+  UNSAFE_SANDBOX_TOKENS,
+  buildCsp,
+  createHtmlDocument,
+  createPreview,
+  decodeHtmlBytes,
+  getSandboxAttribute,
+  hasAuthorScrollbarStyle,
+  injectBridgeScript,
+  injectCspMeta,
+  injectScrollbarStyle,
+  isAllowedExternalUrl,
+  normalizeInput,
+  sanitizeHtml
+};
+//# sourceMappingURL=index.browser.js.map