sibujs 4.7.0 → 4.8.0

package/dist/ui.cjs

@@ -834,7 +834,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.7.0" : "dev";
+var _runtimeVersion = true ? "4.8.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -2179,33 +2179,402 @@ function createDialogAria(element, options = {}) {
   return { titleId, descriptionId };
 }
 
-// src/ui/scopedStyle.ts
-var _scope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.scopedStyle.v1"), () => ({ n: 0 }));
-function decodeCssEscapes(css) {
-  return css.replace(/\\([0-9a-f]{1,6})[ \t\n\r\f]?|\\([^\n])/gi, (_match, hex, ch) => {
-    if (hex) {
-      const code = Number.parseInt(hex, 16);
-      if (Number.isFinite(code) && code > 0 && code <= 1114111) {
-        try {
-          return String.fromCodePoint(code);
-        } catch {
-          return "";
+// src/utils/sanitize.ts
+function stripControlChars(value) {
+  return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
+}
+var ASCII_UPPER = /[A-Z]/;
+var ASCII_UPPER_G = /[A-Z]/g;
+function canonicalAttrName(name) {
+  return ASCII_UPPER.test(name) ? name.replace(ASCII_UPPER_G, (ch) => String.fromCharCode(ch.charCodeAt(0) + 32)) : name;
+}
+function isEventHandlerAttr(name) {
+  if (name.length < 3) return false;
+  const lower = name.toLowerCase();
+  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
+}
+var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
+var OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
+function sanitizeUrl(url) {
+  const probe = stripControlChars(url).trim();
+  if (!probe) return "";
+  const output = url.replace(OUTER_TRIM, "");
+  if (probe.length >= 2 && (probe[0] === "\\" || probe[0] === "/") && (probe[1] === "\\" || probe[1] === "/") && (probe[0] === "\\" || probe[1] === "\\")) {
+    return "";
+  }
+  const lower = probe.toLowerCase();
+  let schemeEnd = -1;
+  for (let i = 0; i < lower.length; i++) {
+    const ch = lower.charCodeAt(i);
+    if (ch === 58) {
+      schemeEnd = i;
+      break;
+    }
+    if (ch === 47 || ch === 63 || ch === 35) break;
+  }
+  if (schemeEnd === -1) return output;
+  const scheme = lower.slice(0, schemeEnd + 1);
+  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return output;
+  if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
+  return output;
+}
+var SRCSET_DESCRIPTOR = /^\d+(\.\d+)?[wx]$/;
+function isSrcsetWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function sanitizeSrcset(value) {
+  const input = String(value);
+  const out = [];
+  let i = 0;
+  const n = input.length;
+  while (i < n) {
+    while (i < n && (isSrcsetWhitespace(input[i]) || input[i] === ",")) i++;
+    if (i >= n) break;
+    const urlStart = i;
+    while (i < n && !isSrcsetWhitespace(input[i])) i++;
+    let url = input.slice(urlStart, i);
+    const descriptors = [];
+    if (url.endsWith(",")) {
+      url = url.replace(/,+$/, "");
+    } else {
+      let current = "";
+      let inParens = false;
+      while (i < n) {
+        const ch = input[i];
+        if (inParens) {
+          current += ch;
+          if (ch === ")") inParens = false;
+          i++;
+          continue;
+        }
+        if (isSrcsetWhitespace(ch)) {
+          if (current) descriptors.push(current);
+          current = "";
+          i++;
+          continue;
+        }
+        if (ch === ",") {
+          i++;
+          break;
         }
+        if (ch === "(") inParens = true;
+        current += ch;
+        i++;
       }
-      return "";
+      if (current) descriptors.push(current);
     }
-    return ch || "";
+    if (url === "") continue;
+    if (descriptors.length > 1) continue;
+    if (descriptors.length === 1 && !SRCSET_DESCRIPTOR.test(descriptors[0])) continue;
+    const safe = sanitizeUrl(url);
+    if (!safe) continue;
+    if (safe.startsWith(",") || safe.endsWith(",")) continue;
+    out.push(descriptors.length === 1 ? `${safe} ${descriptors[0]}` : safe);
+  }
+  return out.join(", ");
+}
+var CSS_DANGER_GATE = /[(:@\\]/;
+function isCssWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function isHexDigit(ch) {
+  return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
+}
+function decodeCssEscapes(value) {
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    if (i + 1 >= value.length) break;
+    const next = value[i + 1];
+    if (next === "\n" || next === "\f") {
+      i += 1;
+      continue;
+    }
+    if (next === "\r") {
+      i += value[i + 2] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (isHexDigit(next)) {
+      let hex = "";
+      let j = i + 1;
+      while (j < value.length && hex.length < 6 && isHexDigit(value[j])) {
+        hex += value[j];
+        j++;
+      }
+      if (j < value.length && isCssWhitespace(value[j])) {
+        j += value[j] === "\r" && value[j + 1] === "\n" ? 2 : 1;
+      }
+      const code = Number.parseInt(hex, 16);
+      const invalid = code === 0 || code > 1114111 || code >= 55296 && code <= 57343;
+      out += invalid ? "\uFFFD" : String.fromCodePoint(code);
+      i = j - 1;
+      continue;
+    }
+    out += next;
+    i += 1;
+  }
+  return out;
+}
+var BLOCKED_CSS_NEEDLES = [
+  "url(",
+  "expression(",
+  "javascript:",
+  "vbscript:",
+  "-moz-binding",
+  "behavior:",
+  "@import",
+  "image-set(",
+  "filter:progid",
+  // CSS Images 4 `image("…")` and CSS Values 5 `src("…")` take a URL as a
+  // plain STRING, so they fetch without ever spelling `url(`. Support is thin
+  // today, which is exactly when a blocklist should get ahead of it.
+  "image(",
+  "src("
+];
+var CSS_REASON_MOZ_BINDING = 4;
+var CSS_REASON_BEHAVIOR = 5;
+var CSS_REASON_PROGID = 8;
+function describeElement(el) {
+  if (!el) return "an element";
+  let out = el.tagName.toLowerCase();
+  const id = el.getAttribute("id");
+  if (id) out += `#${id}`;
+  const cls = el.getAttribute("class");
+  if (cls) out += `.${cls.trim().split(/\s+/).slice(0, 3).join(".")}`;
+  return `<${out}>`;
+}
+var warnedDeclarations = /* @__PURE__ */ new Set();
+var MAX_WARNED_DECLARATIONS = 100;
+var declarationCapAnnounced = false;
+function warnDroppedDeclaration(value, reason, ctx) {
+  devWarnLazy(() => {
+    const reasons = [
+      "url() in an inline style is an exfiltration channel: the browser fetches it immediately and the URL's path or query can carry page data off-origin",
+      "expression() executes arbitrary script in legacy engines",
+      "the javascript: scheme executes script",
+      "the vbscript: scheme executes script",
+      "-moz-binding loads and runs remote XBL",
+      "behavior: loads and runs a remote HTC script",
+      "@import pulls in a remote stylesheet",
+      "image-set() fetches remote images, the same exfiltration channel as url()",
+      "filter:progid activates legacy scriptable filters",
+      "image() fetches its string argument as a URL, the same exfiltration channel as url()",
+      "src() fetches its string argument as a URL, the same exfiltration channel as url()"
+    ];
+    const declaration = ctx?.property ? `${ctx.property}: ${value}` : value;
+    const where = describeElement(ctx?.element);
+    const key = `${where}|${declaration}`;
+    if (warnedDeclarations.has(key)) return "";
+    if (warnedDeclarations.size >= MAX_WARNED_DECLARATIONS) {
+      if (declarationCapAnnounced) return "";
+      declarationCapAnnounced = true;
+      return `${MAX_WARNED_DECLARATIONS} distinct dropped style declarations have been reported; suppressing further ones for the rest of this session so they cannot flood the console. The declarations are still dropped \u2014 only the reporting stops. Fix the reported ones and reload to see any that remain.`;
+    }
+    warnedDeclarations.add(key);
+    return `style declaration "${declaration}" was dropped by the style sanitizer on ${where} \u2014 ${reasons[reason]}. The element renders without it, which usually looks like a missing image rather than an error. Sanctioned alternatives: for a content image use an <img> element (or a <picture>); for decoration, put the rule in a stylesheet and set a class instead \u2014 stylesheet CSS is not sanitized, only inline style attributes are. If this declaration is not yours, it came from untrusted data and the drop just prevented an exfiltration.`;
   });
 }
-function sanitizeCSS(css) {
-  let sanitized = decodeCssEscapes(css);
-  sanitized = sanitized.replace(/@import\s+[^;]+;/gi, "/* @import removed */");
-  sanitized = sanitized.replace(/url\s*\(\s*(?:"[^"]*"|'[^']*'|[^)]*)\s*\)/gi, "/* url() removed */");
-  sanitized = sanitized.replace(/expression\s*\(\s*(?:"[^"]*"|'[^']*'|[^)]*)\s*\)/gi, "/* expression() removed */");
-  sanitized = sanitized.replace(/-moz-binding\s*:[^;]+;/gi, "/* -moz-binding removed */");
-  sanitized = sanitized.replace(/behavior\s*:[^;]+;/gi, "/* behavior removed */");
-  return sanitized;
+function normalizeCssForScan(value) {
+  const normalized = value.includes("\\") ? decodeCssEscapes(value) : value;
+  return normalized.toLowerCase().replace(/\s+/g, "");
+}
+function blockedCssReason(value) {
+  if (!CSS_DANGER_GATE.test(value)) return -1;
+  const lower = normalizeCssForScan(value);
+  for (let i = 0; i < BLOCKED_CSS_NEEDLES.length; i++) {
+    if (lower.includes(BLOCKED_CSS_NEEDLES[i])) return i;
+  }
+  return -1;
+}
+var STYLESHEET_BLOCKED_FUNCTIONS = ["url", "image-set", "image", "src", "expression"];
+function stripCssFunctions(css) {
+  const pattern = new RegExp(`(?:-webkit-)?(${STYLESHEET_BLOCKED_FUNCTIONS.join("|")})\\s*\\(`, "gi");
+  let out = "";
+  let last = 0;
+  for (let match = pattern.exec(css); match !== null; match = pattern.exec(css)) {
+    const before = match.index > 0 ? css[match.index - 1] : "";
+    if (/[\w-]/.test(before)) continue;
+    let depth = 1;
+    let i = pattern.lastIndex;
+    let quote = "";
+    for (; i < css.length && depth > 0; i++) {
+      const ch = css[i];
+      if (quote) {
+        if (ch === "\\") i++;
+        else if (ch === quote) quote = "";
+      } else if (ch === '"' || ch === "'") quote = ch;
+      else if (ch === "(") depth++;
+      else if (ch === ")") depth--;
+    }
+    out += `${css.slice(last, match.index)}/* ${match[1].toLowerCase()}() removed */`;
+    last = i;
+    pattern.lastIndex = i;
+  }
+  return out + css.slice(last);
+}
+function sanitizeStylesheetText(css) {
+  let text = css.includes("\\") ? decodeCssEscapes(css) : css;
+  text = text.replace(/@import\b[^;{}]*;?/gi, "/* @import removed */");
+  text = stripCssFunctions(text);
+  text = text.replace(/(^|[;{\s])behavior\s*:[^;}]*;?/gi, "$1/* behavior removed */");
+  text = text.replace(/(^|[;{\s])-moz-binding\s*:[^;}]*;?/gi, "$1/* -moz-binding removed */");
+  text = text.replace(/(^|[;{\s])(-ms-)?filter\s*:[^;}]*progid[^;}]*;?/gi, "$1/* filter:progid removed */");
+  return text;
+}
+function blockedDeclarationReason(property, value) {
+  const reason = blockedCssReason(value);
+  if (reason !== -1) return reason;
+  const name = canonicalAttrName(property);
+  if (name === "behavior") return CSS_REASON_BEHAVIOR;
+  if (name === "-moz-binding") return CSS_REASON_MOZ_BINDING;
+  if ((name === "filter" || name === "-ms-filter") && normalizeCssForScan(value).includes("progid:")) {
+    return CSS_REASON_PROGID;
+  }
+  return -1;
+}
+function parseStyleDeclarations(css) {
+  const chunks = [];
+  let buf = "";
+  let depth = 0;
+  let quote = "";
+  for (let i = 0; i < css.length; i++) {
+    const ch = css[i];
+    if (quote) {
+      buf += ch;
+      if (ch === "\\" && i + 1 < css.length) buf += css[++i];
+      else if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === "\\") {
+      buf += ch;
+      if (i + 1 < css.length) buf += css[++i];
+      continue;
+    }
+    if (ch === "/" && css[i + 1] === "*") {
+      const end = css.indexOf("*/", i + 2);
+      if (end === -1) return null;
+      i = end + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") {
+      if (--depth < 0) return null;
+    } else if (ch === "{" || ch === "}") return null;
+    else if (ch === ";" && depth === 0) {
+      chunks.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (quote || depth !== 0) return null;
+  chunks.push(buf);
+  const out = [];
+  for (const chunk of chunks) {
+    const colon = chunk.indexOf(":");
+    if (colon === -1) continue;
+    const rawName = chunk.slice(0, colon).trim();
+    if (!/^(--[\w-]+|-?[a-zA-Z_][\w-]*)$/.test(rawName)) continue;
+    let value = chunk.slice(colon + 1).trim();
+    const bang = /!\s*important\s*$/i.exec(value);
+    if (bang) value = value.slice(0, bang.index).trim();
+    if (value === "") continue;
+    const property = rawName.startsWith("--") ? rawName : canonicalAttrName(rawName);
+    out.push([property, value, bang !== null]);
+  }
+  return out;
+}
+function sanitizeStyleDeclarationList(cssText, context) {
+  const input = String(cssText);
+  const declarations = parseStyleDeclarations(input);
+  if (declarations === null) {
+    if (blockedCssReason(input) !== -1) warnDroppedDeclaration(input, blockedCssReason(input), context);
+    return "";
+  }
+  const kept = [];
+  for (const [property, value, important] of declarations) {
+    const reason = blockedDeclarationReason(property, value);
+    if (reason !== -1) {
+      warnDroppedDeclaration(value, reason, { property, element: context?.element });
+      continue;
+    }
+    kept.push(`${property}: ${value}${important ? " !important" : ""}`);
+  }
+  return kept.join("; ");
+}
+function sanitizeStyleAttribute(cssText, context) {
+  const input = String(cssText);
+  if (input.trim() === "") return "";
+  if (typeof document === "undefined") return sanitizeStyleDeclarationList(input, context);
+  const probe = document.createElement("div");
+  try {
+    probe.style.cssText = input;
+  } catch {
+    return "";
+  }
+  const declarations = [];
+  for (let i = 0; i < probe.style.length; i++) {
+    const property = probe.style[i];
+    const value = probe.style.getPropertyValue(property);
+    const reason = blockedDeclarationReason(property, value);
+    if (reason !== -1) {
+      warnDroppedDeclaration(value, reason, { property, element: context?.element });
+      continue;
+    }
+    const priority = probe.style.getPropertyPriority(property);
+    declarations.push(`${property}: ${value}${priority ? ` !${priority}` : ""}`);
+  }
+  return declarations.join("; ");
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "href",
+  "xlink:href",
+  "src",
+  "action",
+  "formaction",
+  "formtarget",
+  "cite",
+  "poster",
+  "background",
+  "srcset",
+  "ping",
+  "data",
+  // `<html manifest>` is a URL sink too. It was carried only by the SSR
+  // serializers' private copy of this set; folding that copy into this one would
+  // otherwise have silently dropped its coverage.
+  "manifest"
+]);
+var HTML_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set(["srcdoc"]);
+function isHtmlContentAttribute(name) {
+  return HTML_CONTENT_ATTRIBUTES.has(name.toLowerCase());
+}
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr.toLowerCase());
 }
+function isPolicyAttribute(name) {
+  const lower = name.toLowerCase();
+  return lower === "style" || URL_ATTRIBUTES.has(lower);
+}
+function sanitizeAttributeString(attr, value, context) {
+  const lower = attr.toLowerCase();
+  if (lower === "srcset") return sanitizeSrcset(value);
+  if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
+  if (lower === "style") return sanitizeStyleAttribute(value, context);
+  return value;
+}
+function resolveAttributeValue(attr, value, context) {
+  if (!isPolicyAttribute(attr)) return value;
+  const safe = sanitizeAttributeString(attr, value, context);
+  return safe === "" ? null : safe;
+}
+
+// src/ui/scopedStyle.ts
+var _scope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.scopedStyle.v1"), () => ({ n: 0 }));
 function firstCompoundEnd(selector) {
   let parens = 0;
   let brackets = 0;
@@ -2367,7 +2736,7 @@ function scopeStylesheet(css, attr) {
 function scopedStyle(css) {
   const id = `sibu-s${_scope.n++}`;
   const attr = `data-${id}`;
-  const safeCss = sanitizeCSS(css);
+  const safeCss = sanitizeStylesheetText(css);
   const scopedCSS = scopeStylesheet(safeCss, attr);
   if (typeof document !== "undefined") {
     const styleEl = document.createElement("style");
@@ -2393,240 +2762,223 @@ function removeScopedStyle(scopeId) {
   if (el) el.remove();
 }
 
-// src/utils/sanitize.ts
-function stripControlChars(value) {
-  return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
-}
-function isEventHandlerAttr(name) {
-  if (name.length < 3) return false;
-  const lower = name.toLowerCase();
-  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
-}
-var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
-var OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
-function sanitizeUrl(url) {
-  const probe = stripControlChars(url).trim();
-  if (!probe) return "";
-  const output = url.replace(OUTER_TRIM, "");
-  const lower = probe.toLowerCase();
-  let schemeEnd = -1;
-  for (let i = 0; i < lower.length; i++) {
-    const ch = lower.charCodeAt(i);
-    if (ch === 58) {
-      schemeEnd = i;
-      break;
-    }
-    if (ch === 47 || ch === 63 || ch === 35) break;
-  }
-  if (schemeEnd === -1) return output;
-  const scheme = lower.slice(0, schemeEnd + 1);
-  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return output;
-  if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
-  return output;
-}
-var SRCSET_DESCRIPTOR = /^\s+\d+(\.\d+)?[wx]$/;
-function sanitizeSrcset(value) {
-  const parts = value.split(",");
-  const out = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i].trim();
-    if (!part) continue;
-    const m = part.match(/^(\S+)(\s+.+)?$/);
-    if (!m) continue;
-    if (m[2] !== void 0 && !SRCSET_DESCRIPTOR.test(m[2])) continue;
-    const safe = sanitizeUrl(m[1]);
-    if (!safe) continue;
-    out.push(m[2] ? `${safe}${m[2]}` : safe);
-  }
-  return out.join(", ");
-}
-var CSS_DANGER_GATE = /[(:@\\]/;
-function isCssWhitespace(ch) {
+// src/utils/metaRefresh.ts
+function isAsciiWhitespace(ch) {
   return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
 }
-function isHexDigit(ch) {
-  return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
-}
-function decodeCssEscapes2(value) {
-  let out = "";
-  for (let i = 0; i < value.length; i++) {
-    const ch = value[i];
-    if (ch !== "\\") {
-      out += ch;
-      continue;
-    }
-    if (i + 1 >= value.length) break;
-    const next = value[i + 1];
-    if (next === "\n" || next === "\f") {
-      i += 1;
-      continue;
-    }
-    if (next === "\r") {
-      i += value[i + 2] === "\n" ? 2 : 1;
-      continue;
-    }
-    if (isHexDigit(next)) {
-      let hex = "";
-      let j = i + 1;
-      while (j < value.length && hex.length < 6 && isHexDigit(value[j])) {
-        hex += value[j];
-        j++;
-      }
-      if (j < value.length && isCssWhitespace(value[j])) {
-        j += value[j] === "\r" && value[j + 1] === "\n" ? 2 : 1;
-      }
-      const code = Number.parseInt(hex, 16);
-      const invalid = code === 0 || code > 1114111 || code >= 55296 && code <= 57343;
-      out += invalid ? "\uFFFD" : String.fromCodePoint(code);
-      i = j - 1;
-      continue;
-    }
-    out += next;
-    i += 1;
-  }
-  return out;
-}
-var BLOCKED_CSS_NEEDLES = [
-  "url(",
-  "expression(",
-  "javascript:",
-  "vbscript:",
-  "-moz-binding",
-  "behavior:",
-  "@import",
-  "image-set(",
-  "filter:progid"
-];
-function describeElement(el) {
-  if (!el) return "an element";
-  let out = el.tagName.toLowerCase();
-  const id = el.getAttribute("id");
-  if (id) out += `#${id}`;
-  const cls = el.getAttribute("class");
-  if (cls) out += `.${cls.trim().split(/\s+/).slice(0, 3).join(".")}`;
-  return `<${out}>`;
-}
-var warnedDeclarations = /* @__PURE__ */ new Set();
-var MAX_WARNED_DECLARATIONS = 100;
-var declarationCapAnnounced = false;
-function warnDroppedDeclaration(value, reason, ctx) {
-  devWarnLazy(() => {
-    const reasons = [
-      "url() in an inline style is an exfiltration channel: the browser fetches it immediately and the URL's path or query can carry page data off-origin",
-      "expression() executes arbitrary script in legacy engines",
-      "the javascript: scheme executes script",
-      "the vbscript: scheme executes script",
-      "-moz-binding loads and runs remote XBL",
-      "behavior: loads and runs a remote HTC script",
-      "@import pulls in a remote stylesheet",
-      "image-set() fetches remote images, the same exfiltration channel as url()",
-      "filter:progid activates legacy scriptable filters"
-    ];
-    const declaration = ctx?.property ? `${ctx.property}: ${value}` : value;
-    const where = describeElement(ctx?.element);
-    const key = `${where}|${declaration}`;
-    if (warnedDeclarations.has(key)) return "";
-    if (warnedDeclarations.size >= MAX_WARNED_DECLARATIONS) {
-      if (declarationCapAnnounced) return "";
-      declarationCapAnnounced = true;
-      return `${MAX_WARNED_DECLARATIONS} distinct dropped style declarations have been reported; suppressing further ones for the rest of this session so they cannot flood the console. The declarations are still dropped \u2014 only the reporting stops. Fix the reported ones and reload to see any that remain.`;
-    }
-    warnedDeclarations.add(key);
-    return `style declaration "${declaration}" was dropped by the style sanitizer on ${where} \u2014 ${reasons[reason]}. The element renders without it, which usually looks like a missing image rather than an error. Sanctioned alternatives: for a content image use an <img> element (or a <picture>); for decoration, put the rule in a stylesheet and set a class instead \u2014 stylesheet CSS is not sanitized, only inline style attributes are. If this declaration is not yours, it came from untrusted data and the drop just prevented an exfiltration.`;
-  });
-}
-function blockedCssReason(value) {
-  if (!CSS_DANGER_GATE.test(value)) return -1;
-  const normalized = value.includes("\\") ? decodeCssEscapes2(value) : value;
-  const lower = normalized.toLowerCase().replace(/\s+/g, "");
-  for (let i = 0; i < BLOCKED_CSS_NEEDLES.length; i++) {
-    if (lower.includes(BLOCKED_CSS_NEEDLES[i])) return i;
-  }
-  return -1;
-}
-function sanitizeCSSValue(value, context) {
-  const reason = blockedCssReason(value);
-  if (reason === -1) return value;
-  warnDroppedDeclaration(value, reason, context);
-  return "";
-}
-function sanitizeStyleAttribute(cssText, context) {
-  const input = String(cssText);
-  if (input.trim() === "") return "";
-  if (typeof document === "undefined") {
-    return sanitizeCSSValue(input, context) === "" ? "" : input;
-  }
-  const probe = document.createElement("div");
-  try {
-    probe.style.cssText = input;
-  } catch {
-    return "";
-  }
-  const declarations = [];
-  for (let i = 0; i < probe.style.length; i++) {
-    const property = probe.style[i];
-    const value = probe.style.getPropertyValue(property);
-    let reason = blockedCssReason(value);
-    if (reason === -1) reason = blockedCssReason(`${property}:${value}`);
-    if (reason !== -1) {
-      warnDroppedDeclaration(value, reason, { property, element: context?.element });
-      continue;
-    }
-    const priority = probe.style.getPropertyPriority(property);
-    declarations.push(`${property}: ${value}${priority ? ` !${priority}` : ""}`);
-  }
-  return declarations.join("; ");
+function trimAsciiWhitespace(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && isAsciiWhitespace(value[start])) start++;
+  while (end > start && isAsciiWhitespace(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+var forbidden = (reason) => ({ kind: "forbidden", reason });
+function parseMetaRefreshContent(content) {
+  const raw = trimAsciiWhitespace(stripControlChars(content));
+  if (raw === "") return forbidden(DEV ? "empty content" : "");
+  let i = 0;
+  while (i < raw.length && raw[i] >= "0" && raw[i] <= "9") i++;
+  if (i === 0) return forbidden(DEV ? "missing or non-numeric delay" : "");
+  const delay = Number.parseInt(raw.slice(0, i), 10);
+  if (!Number.isFinite(delay)) return forbidden(DEV ? "unparseable delay" : "");
+  while (i < raw.length && isAsciiWhitespace(raw[i])) i++;
+  if (i === raw.length) return { kind: "delay-only", delay };
+  if (raw[i] !== ";" && raw[i] !== ",") return forbidden(DEV ? "unexpected text after delay" : "");
+  i++;
+  while (i < raw.length && isAsciiWhitespace(raw[i])) i++;
+  const keyStart = i;
+  while (i < raw.length && !isAsciiWhitespace(raw[i]) && raw[i] !== "=") i++;
+  const key = raw.slice(keyStart, i).toLowerCase();
+  if (key !== "url") return forbidden(DEV ? `unsupported refresh key ${JSON.stringify(key)}` : "");
+  while (i < raw.length && isAsciiWhitespace(raw[i])) i++;
+  if (raw[i] !== "=") return forbidden(DEV ? "missing '=' after url" : "");
+  i++;
+  while (i < raw.length && isAsciiWhitespace(raw[i])) i++;
+  let destination;
+  const quote = raw[i];
+  if (quote === '"' || quote === "'") {
+    const close = raw.indexOf(quote, i + 1);
+    if (close === -1) return forbidden(DEV ? "unterminated quoted destination" : "");
+    destination = raw.slice(i + 1, close);
+    const rest = trimAsciiWhitespace(raw.slice(close + 1));
+    if (rest !== "") return forbidden(DEV ? "trailing text after quoted destination" : "");
+  } else {
+    destination = trimAsciiWhitespace(raw.slice(i));
+    if (/[;,]/.test(destination)) return forbidden(DEV ? "multiple refresh assignments" : "");
+  }
+  if (destination === "") return forbidden(DEV ? "empty destination" : "");
+  const sanitizedDestination = sanitizeUrl(destination);
+  if (sanitizedDestination === "") return forbidden(DEV ? "destination uses a disallowed protocol" : "");
+  return { kind: "allowed", delay, destination, sanitizedDestination };
+}
+function resolveMetaRefreshPolicy(attributes) {
+  let httpEquiv;
+  let content;
+  let duplicateName;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, value] of attributes) {
+    const canonical = canonicalAttrName(key);
+    if (seen.has(canonical)) duplicateName = canonical;
+    seen.add(canonical);
+    if (canonical === "http-equiv") httpEquiv = value;
+    else if (canonical === "content") content = value;
+  }
+  if (duplicateName !== void 0) {
+    return forbidden(DEV ? `duplicate case-insensitive attribute ${JSON.stringify(duplicateName)}` : "");
+  }
+  if (typeof httpEquiv !== "string") return { kind: "not-refresh" };
+  if (trimAsciiWhitespace(stripControlChars(httpEquiv)).toLowerCase() !== "refresh") {
+    return { kind: "not-refresh" };
+  }
+  if (typeof content !== "string") return { kind: "not-refresh" };
+  return parseMetaRefreshContent(content);
 }
-var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "href",
-  "xlink:href",
-  "src",
-  "action",
-  "formaction",
-  "formtarget",
-  "cite",
-  "poster",
-  "background",
-  "srcset",
-  "ping",
-  "data",
-  // `<html manifest>` is a URL sink too. It was carried only by the SSR
-  // serializers' private copy of this set; folding that copy into this one would
-  // otherwise have silently dropped its coverage.
-  "manifest"
-]);
-var HTML_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set(["srcdoc"]);
-function isHtmlContentAttribute(name) {
-  return HTML_CONTENT_ATTRIBUTES.has(name.toLowerCase());
+
+// src/utils/elementPolicy.ts
+var HTML_NS = "http://www.w3.org/1999/xhtml";
+var SVG_NS = "http://www.w3.org/2000/svg";
+var BLOCKED_ELEMENTS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
+function canonicalTagName(tag) {
+  return canonicalAttrName(tag);
+}
+function isBlockedElement(tag) {
+  return BLOCKED_ELEMENTS.has(canonicalTagName(tag));
+}
+var ContextualRefusal = {
+  None: 0,
+  /** The element would carry a refresh directive the shared policy forbids. */
+  MetaRefreshForbidden: 1,
+  /** A `<meta>` with a reactive binding may not carry any refresh directive. */
+  MetaRefreshReactive: 2,
+  /** A runtime value may not choose which program a `<script>` runs. */
+  ScriptSource: 3,
+  /** An SVG animation may not target a URL, handler or document attribute. */
+  AnimationTarget: 4,
+  /** A runtime-written `href` may not become an applied stylesheet. */
+  StylesheetSource: 5
+};
+var SCRIPT_SOURCE_ATTRIBUTES = /* @__PURE__ */ new Set(["src", "href", "xlink:href", "type", "language"]);
+var SVG_ANIMATION_ELEMENTS = /* @__PURE__ */ new Set(["animate", "set", "animateMotion", "animateTransform", "animateColor"]);
+var reactiveMetaElements = /* @__PURE__ */ new WeakSet();
+function isHtmlNamespace(el) {
+  return el.namespaceURI === HTML_NS || el.namespaceURI === null;
+}
+function metaSnapshot(el, canonical, value) {
+  const snapshot = /* @__PURE__ */ new Map();
+  const attrs = el.attributes;
+  for (let i = 0; i < attrs.length; i++) {
+    const attr = attrs[i];
+    if (attr.name === canonical) continue;
+    snapshot.set(attr.name, attr.value);
+  }
+  if (canonical !== null && value !== null) snapshot.set(canonical, value);
+  return snapshot;
+}
+function claimReactiveMeta(el) {
+  if (reactiveMetaElements.has(el)) return;
+  reactiveMetaElements.add(el);
+  if (el.getAttribute("content") === null) return;
+  if (resolveMetaRefreshPolicy(metaSnapshot(el, null, null)).kind !== "not-refresh") {
+    el.removeAttribute("content");
+  }
+}
+function metaRefusal(el, name, value, origin) {
+  if (!isHtmlNamespace(el)) return ContextualRefusal.None;
+  const canonical = canonicalAttrName(name);
+  if (canonical !== "http-equiv" && canonical !== "content") return ContextualRefusal.None;
+  if (origin === "reactive") claimReactiveMeta(el);
+  if (value === null) return ContextualRefusal.None;
+  if (canonical === "content" && !el.hasAttribute("http-equiv")) return ContextualRefusal.None;
+  const decision = resolveMetaRefreshPolicy(metaSnapshot(el, canonical, value));
+  if (decision.kind === "forbidden") return ContextualRefusal.MetaRefreshForbidden;
+  if (decision.kind !== "not-refresh" && reactiveMetaElements.has(el)) return ContextualRefusal.MetaRefreshReactive;
+  return ContextualRefusal.None;
+}
+function animationRefusal(name, value) {
+  if (value === null || canonicalAttrName(name) !== "attributename") return ContextualRefusal.None;
+  const target = stripControlChars(value);
+  return isUrlAttribute(target) || isEventHandlerAttr(target) || isHtmlContentAttribute(target) ? ContextualRefusal.AnimationTarget : ContextualRefusal.None;
+}
+var runtimeHrefLinks = /* @__PURE__ */ new WeakSet();
+function relHasStylesheet(rel) {
+  if (rel === null) return false;
+  const lower = canonicalAttrName(rel);
+  if (!lower.includes("stylesheet")) return false;
+  const tokens = lower.split(/[\t\n\f\r ]+/);
+  for (let i = 0; i < tokens.length; i++) if (tokens[i] === "stylesheet") return true;
+  return false;
 }
-function sanitizeAttributeString(attr, value, context) {
-  const lower = attr.toLowerCase();
-  if (lower === "srcset") return sanitizeSrcset(value);
-  if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
-  if (lower === "style") return sanitizeStyleAttribute(value, context);
-  return value;
+function stylesheetRefusal(el, name, value, origin) {
+  if (!isHtmlNamespace(el)) return ContextualRefusal.None;
+  const canonical = canonicalAttrName(name);
+  if (canonical === "href") {
+    if (origin === "static" || value === null) return ContextualRefusal.None;
+    if (relHasStylesheet(el.getAttribute("rel"))) return ContextualRefusal.StylesheetSource;
+    runtimeHrefLinks.add(el);
+    return ContextualRefusal.None;
+  }
+  if (canonical === "rel") {
+    if (!relHasStylesheet(value)) return ContextualRefusal.None;
+    return runtimeHrefLinks.has(el) && el.hasAttribute("href") ? ContextualRefusal.StylesheetSource : ContextualRefusal.None;
+  }
+  return ContextualRefusal.None;
+}
+function contextualAttributeRefusal(el, name, value, origin) {
+  const local = el.localName;
+  if (local === "meta") return metaRefusal(el, name, value, origin);
+  if (local === "link") return stylesheetRefusal(el, name, value, origin);
+  if (local === "script") {
+    if (origin === "static" || value === null) return ContextualRefusal.None;
+    return SCRIPT_SOURCE_ATTRIBUTES.has(canonicalAttrName(name)) ? ContextualRefusal.ScriptSource : ContextualRefusal.None;
+  }
+  if (SVG_ANIMATION_ELEMENTS.has(local) && el.namespaceURI === SVG_NS) return animationRefusal(name, value);
+  return ContextualRefusal.None;
+}
+function settleAttributeProvenance(el, name, origin) {
+  if (el.localName !== "link" || canonicalAttrName(name) !== "href") return;
+  if (origin !== "static" && el.hasAttribute("href")) runtimeHrefLinks.add(el);
+  else runtimeHrefLinks.delete(el);
 }
 
 // src/utils/setSafeAttribute.ts
-var HTML_NS = "http://www.w3.org/1999/xhtml";
-var SVG_NS = "http://www.w3.org/2000/svg";
+var HTML_NS2 = "http://www.w3.org/1999/xhtml";
+var SVG_NS2 = "http://www.w3.org/2000/svg";
 var XLINK_NS = "http://www.w3.org/1999/xlink";
 var XML_NS = "http://www.w3.org/XML/1998/namespace";
 var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
 function isHtmlElement(el) {
-  return el.namespaceURI === null || el.namespaceURI === HTML_NS;
+  return el.namespaceURI === null || el.namespaceURI === HTML_NS2;
+}
+function warnContextualRefusal(label, name, refusal) {
+  devWarnLazy(() => {
+    const reasons = [
+      "",
+      'the element would become a <meta http-equiv="refresh"> directive the shared refresh policy forbids (a destination outside the URL allowlist, or a directive too malformed to read unambiguously)',
+      "a <meta> whose http-equiv or content is reactive may never carry a refresh directive: a browser schedules the navigation as soon as the directive is valid, and nothing can withdraw it when the state changes back",
+      "a runtime value may not choose the program a <script> runs; name the script in static template source, or load it through Head({ script }) as an explicit trust decision",
+      "an SVG animation may not target a URL, event-handler or nested-document attribute; its to / values would be written into that attribute without passing the URL policy",
+      'a runtime-chosen href may not become an applied <link rel="stylesheet">: a well-formed URL is not a trusted stylesheet. Name the stylesheet in static template source, or load a runtime-chosen one through Head({ link }) as an explicit trust decision'
+    ];
+    return `${label}: refusing "${name}" in this element's context \u2014 ${reasons[refusal]}. The write was not performed.`;
+  });
 }
 function setProp(el, key, val) {
   el[key] = val;
 }
 function namespaceFor(el, name) {
-  if (el.namespaceURI !== SVG_NS) return null;
+  if (el.namespaceURI !== SVG_NS2) return null;
   const lower = name.toLowerCase();
   if (lower.startsWith("xlink:")) return XLINK_NS;
   if (lower.startsWith("xml:")) return XML_NS;
   return null;
 }
 function setSafeAttribute(el, name, value, options = {}) {
+  const written = commitSafeAttribute(el, name, value, options);
+  if (el.localName === "link") settleAttributeProvenance(el, name, options.reactive ? "reactive" : "runtime");
+  return written;
+}
+function commitSafeAttribute(el, name, value, options) {
   const ns = namespaceFor(el, name);
   const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
   if (isEventHandlerAttr(name)) {
@@ -2639,6 +2991,14 @@ function setSafeAttribute(el, name, value, options = {}) {
     else el.removeAttribute(name);
     return false;
   }
+  const pending = value == null || value === false ? null : value === true ? "" : String(value);
+  const refusal = contextualAttributeRefusal(el, name, pending, options.reactive ? "reactive" : "runtime");
+  if (refusal !== ContextualRefusal.None) {
+    warnContextualRefusal(options.label ?? "setSafeAttribute", name, refusal);
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
   if (value == null) {
     if (ns) el.removeAttributeNS(ns, localName);
     else el.removeAttribute(name);
@@ -2682,7 +3042,12 @@ function setSafeAttribute(el, name, value, options = {}) {
     setProp(el, idlName, idlName === "checked" ? Boolean(value) : str);
     return true;
   }
-  const safe = sanitizeAttributeString(name, str, { element: el });
+  const safe = str === "" ? "" : resolveAttributeValue(name, str, { element: el });
+  if (safe === null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
   const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
   if (current === safe) return true;
   if (ns) el.setAttributeNS(ns, name, safe);
@@ -2705,7 +3070,7 @@ function bindAttribute(el, attr, getter) {
       reportError(err, { phase: "binding", name: `bindAttribute("${attr}")`, node: el });
       return;
     }
-    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")` });
+    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")`, reactive: true });
   }
   return reactiveBinding2(commit, el);
 }
@@ -2742,7 +3107,7 @@ function bindBoolAttr(el, attr, getter) {
       reportError(err, { phase: "binding", name: "bindBoolAttr", node: el });
       return;
     }
-    setSafeAttribute(el, attr, Boolean(value), { label: "bindBoolAttr" });
+    setSafeAttribute(el, attr, Boolean(value), { label: "bindBoolAttr", reactive: true });
   }
   return reactiveBinding2(commit, el);
 }
@@ -3388,7 +3753,7 @@ function scrollLock() {
 }
 
 // src/platform/customElement.ts
-var SVG_NS2 = "http://www.w3.org/2000/svg";
+var SVG_NS3 = "http://www.w3.org/2000/svg";
 var MAX_RENDER_PASSES = 10;
 var ABANDONED_RENDER = /* @__PURE__ */ Symbol("sibujs.defineElement.abandonedRender");
 function defineElement(name, component, options = {}) {
@@ -3537,7 +3902,10 @@ function defineElement(name, component, options = {}) {
   customElements.define(name, SibuElement);
 }
 function svgElement(tag, props = {}, ...nodes) {
-  const el = document.createElementNS(SVG_NS2, tag);
+  if (isBlockedElement(tag)) {
+    throw new Error(`svgElement: refusing to create <${tag}> \u2014 tag is blocked for security reasons.`);
+  }
+  const el = document.createElementNS(SVG_NS3, tag);
   for (const [key, value] of Object.entries(props)) {
     if (key === "nodes") continue;
     if (typeof value === "function" && isEventHandlerAttr(key)) {