sibujs 4.7.0 → 4.9.0

package/dist/plugins.cjs

@@ -152,7 +152,7 @@ function stripControlChars(value) {
   return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
 }
 function canonicalAttrName(name) {
-  return name.replace(/[A-Z]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) + 32));
+  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;
@@ -163,6 +163,9 @@ function sanitizeUrl(url) {
   const probe = stripControlChars(url).trim();
   if (!probe) return "";
   const output2 = 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 i2 = 0; i2 < lower.length; i2++) {
@@ -179,18 +182,57 @@ function sanitizeUrl(url) {
   if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
   return output2;
 }
+function isSrcsetWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
 function sanitizeSrcset(value) {
-  const parts = value.split(",");
+  const input2 = String(value);
   const out = [];
-  for (let i2 = 0; i2 < parts.length; i2++) {
-    const part = parts[i2].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]);
+  let i2 = 0;
+  const n = input2.length;
+  while (i2 < n) {
+    while (i2 < n && (isSrcsetWhitespace(input2[i2]) || input2[i2] === ",")) i2++;
+    if (i2 >= n) break;
+    const urlStart = i2;
+    while (i2 < n && !isSrcsetWhitespace(input2[i2])) i2++;
+    let url = input2.slice(urlStart, i2);
+    const descriptors = [];
+    if (url.endsWith(",")) {
+      url = url.replace(/,+$/, "");
+    } else {
+      let current = "";
+      let inParens = false;
+      while (i2 < n) {
+        const ch = input2[i2];
+        if (inParens) {
+          current += ch;
+          if (ch === ")") inParens = false;
+          i2++;
+          continue;
+        }
+        if (isSrcsetWhitespace(ch)) {
+          if (current) descriptors.push(current);
+          current = "";
+          i2++;
+          continue;
+        }
+        if (ch === ",") {
+          i2++;
+          break;
+        }
+        if (ch === "(") inParens = true;
+        current += ch;
+        i2++;
+      }
+      if (current) descriptors.push(current);
+    }
+    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;
-    out.push(m[2] ? `${safe}${m[2]}` : safe);
+    if (safe.startsWith(",") || safe.endsWith(",")) continue;
+    out.push(descriptors.length === 1 ? `${safe} ${descriptors[0]}` : safe);
   }
   return out.join(", ");
 }
@@ -259,7 +301,9 @@ function warnDroppedDeclaration(value, reason, ctx) {
       "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"
+      "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);
@@ -274,27 +318,110 @@ function warnDroppedDeclaration(value, reason, ctx) {
     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 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 normalized = value.includes("\\") ? decodeCssEscapes(value) : value;
-  const lower = normalized.toLowerCase().replace(/\s+/g, "");
+  const lower = normalizeCssForScan(value);
   for (let i2 = 0; i2 < BLOCKED_CSS_NEEDLES.length; i2++) {
     if (lower.includes(BLOCKED_CSS_NEEDLES[i2])) return i2;
   }
   return -1;
 }
-function sanitizeCSSValue(value, context) {
-  const reason = blockedCssReason(value);
+function sanitizeCSSDeclaration(property, value, context) {
+  const reason = blockedDeclarationReason(property, value);
   if (reason === -1) return value;
-  warnDroppedDeclaration(value, reason, context);
+  warnDroppedDeclaration(value, reason, { property, element: context?.element });
   return "";
 }
+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 quote2 = "";
+  for (let i2 = 0; i2 < css.length; i2++) {
+    const ch = css[i2];
+    if (quote2) {
+      buf += ch;
+      if (ch === "\\" && i2 + 1 < css.length) buf += css[++i2];
+      else if (ch === quote2) quote2 = "";
+      continue;
+    }
+    if (ch === "\\") {
+      buf += ch;
+      if (i2 + 1 < css.length) buf += css[++i2];
+      continue;
+    }
+    if (ch === "/" && css[i2 + 1] === "*") {
+      const end = css.indexOf("*/", i2 + 2);
+      if (end === -1) return null;
+      i2 = end + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") quote2 = 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 (quote2 || 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 input2 = String(cssText);
+  const declarations = parseStyleDeclarations(input2);
+  if (declarations === null) {
+    if (blockedCssReason(input2) !== -1) warnDroppedDeclaration(input2, blockedCssReason(input2), 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 input2 = String(cssText);
   if (input2.trim() === "") return "";
-  if (typeof document === "undefined") {
-    return sanitizeCSSValue(input2, context) === "" ? "" : input2;
-  }
+  if (typeof document === "undefined") return sanitizeStyleDeclarationList(input2, context);
   const probe = document.createElement("div");
   try {
     probe.style.cssText = input2;
@@ -305,8 +432,7 @@ function sanitizeStyleAttribute(cssText, context) {
   for (let i2 = 0; i2 < probe.style.length; i2++) {
     const property = probe.style[i2];
     const value = probe.style.getPropertyValue(property);
-    let reason = blockedCssReason(value);
-    if (reason === -1) reason = blockedCssReason(`${property}:${value}`);
+    const reason = blockedDeclarationReason(property, value);
     if (reason !== -1) {
       warnDroppedDeclaration(value, reason, { property, element: context?.element });
       continue;
@@ -333,14 +459,21 @@ function sanitizeAttributeString(attr, value, context) {
   if (lower === "style") return sanitizeStyleAttribute(value, context);
   return value;
 }
-var SAFE_URL_PROTOCOLS, OUTER_TRIM, SRCSET_DESCRIPTOR, CSS_DANGER_GATE, BLOCKED_CSS_NEEDLES, warnedDeclarations, MAX_WARNED_DECLARATIONS, declarationCapAnnounced, URL_ATTRIBUTES, HTML_CONTENT_ATTRIBUTES;
+function resolveAttributeValue(attr, value, context) {
+  if (!isPolicyAttribute(attr)) return value;
+  const safe = sanitizeAttributeString(attr, value, context);
+  return safe === "" ? null : safe;
+}
+var ASCII_UPPER, ASCII_UPPER_G, SAFE_URL_PROTOCOLS, OUTER_TRIM, SRCSET_DESCRIPTOR, CSS_DANGER_GATE, BLOCKED_CSS_NEEDLES, CSS_REASON_MOZ_BINDING, CSS_REASON_BEHAVIOR, CSS_REASON_PROGID, warnedDeclarations, MAX_WARNED_DECLARATIONS, declarationCapAnnounced, URL_ATTRIBUTES, HTML_CONTENT_ATTRIBUTES;
 var init_sanitize = __esm({
   "src/utils/sanitize.ts"() {
     "use strict";
     init_dev();
+    ASCII_UPPER = /[A-Z]/;
+    ASCII_UPPER_G = /[A-Z]/g;
     SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
     OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
-    SRCSET_DESCRIPTOR = /^\s+\d+(\.\d+)?[wx]$/;
+    SRCSET_DESCRIPTOR = /^\d+(\.\d+)?[wx]$/;
     CSS_DANGER_GATE = /[(:@\\]/;
     BLOCKED_CSS_NEEDLES = [
       "url(",
@@ -351,8 +484,16 @@ var init_sanitize = __esm({
       "behavior:",
       "@import",
       "image-set(",
-      "filter:progid"
+      "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("
     ];
+    CSS_REASON_MOZ_BINDING = 4;
+    CSS_REASON_BEHAVIOR = 5;
+    CSS_REASON_PROGID = 8;
     warnedDeclarations = /* @__PURE__ */ new Set();
     MAX_WARNED_DECLARATIONS = 100;
     declarationCapAnnounced = false;
@@ -378,6 +519,224 @@ var init_sanitize = __esm({
   }
 });
 
+// src/utils/metaRefresh.ts
+function isAsciiWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+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);
+}
+function parseMetaRefreshContent(content) {
+  const raw = trimAsciiWhitespace(stripControlChars(content));
+  if (raw === "") return forbidden(DEV ? "empty content" : "");
+  let i2 = 0;
+  while (i2 < raw.length && raw[i2] >= "0" && raw[i2] <= "9") i2++;
+  if (i2 === 0) return forbidden(DEV ? "missing or non-numeric delay" : "");
+  const delay = Number.parseInt(raw.slice(0, i2), 10);
+  if (!Number.isFinite(delay)) return forbidden(DEV ? "unparseable delay" : "");
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (i2 === raw.length) return { kind: "delay-only", delay };
+  if (raw[i2] !== ";" && raw[i2] !== ",") return forbidden(DEV ? "unexpected text after delay" : "");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  const keyStart = i2;
+  while (i2 < raw.length && !isAsciiWhitespace(raw[i2]) && raw[i2] !== "=") i2++;
+  const key = raw.slice(keyStart, i2).toLowerCase();
+  if (key !== "url") return forbidden(DEV ? `unsupported refresh key ${JSON.stringify(key)}` : "");
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (raw[i2] !== "=") return forbidden(DEV ? "missing '=' after url" : "");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  let destination;
+  const quote2 = raw[i2];
+  if (quote2 === '"' || quote2 === "'") {
+    const close = raw.indexOf(quote2, i2 + 1);
+    if (close === -1) return forbidden(DEV ? "unterminated quoted destination" : "");
+    destination = raw.slice(i2 + 1, close);
+    const rest = trimAsciiWhitespace(raw.slice(close + 1));
+    if (rest !== "") return forbidden(DEV ? "trailing text after quoted destination" : "");
+  } else {
+    destination = trimAsciiWhitespace(raw.slice(i2));
+    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);
+}
+function normalizeMetaAttributes(props) {
+  const out = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(props)) {
+    const canonical = canonicalAttrName(key);
+    if (seen.has(canonical)) return null;
+    seen.add(canonical);
+    out.set(key, props[key]);
+  }
+  return out;
+}
+function isForbiddenMetaEntry(props) {
+  const normalized = normalizeMetaAttributes(props);
+  if (normalized === null) return true;
+  return resolveMetaRefreshPolicy(normalized).kind === "forbidden";
+}
+var forbidden;
+var init_metaRefresh = __esm({
+  "src/utils/metaRefresh.ts"() {
+    "use strict";
+    init_dev();
+    init_sanitize();
+    forbidden = (reason) => ({ kind: "forbidden", reason });
+  }
+});
+
+// src/utils/elementPolicy.ts
+function canonicalTagName(tag) {
+  return canonicalAttrName(tag);
+}
+function isBlockedElement(tag) {
+  return BLOCKED_ELEMENTS.has(canonicalTagName(tag));
+}
+function isCodeTextElement(tag) {
+  return CODE_TEXT_ELEMENTS.has(canonicalTagName(tag));
+}
+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 i2 = 0; i2 < attrs.length; i2++) {
+    const attr = attrs[i2];
+    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;
+}
+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 i2 = 0; i2 < tokens.length; i2++) if (tokens[i2] === "stylesheet") return true;
+  return false;
+}
+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);
+}
+function isForbiddenMetaSnapshot(attributes) {
+  return resolveMetaRefreshPolicy(attributes).kind === "forbidden";
+}
+var HTML_NS, SVG_NS, BLOCKED_ELEMENTS, CODE_TEXT_ELEMENTS, ContextualRefusal, SCRIPT_SOURCE_ATTRIBUTES, SVG_ANIMATION_ELEMENTS, reactiveMetaElements, runtimeHrefLinks;
+var init_elementPolicy = __esm({
+  "src/utils/elementPolicy.ts"() {
+    "use strict";
+    init_metaRefresh();
+    init_sanitize();
+    HTML_NS = "http://www.w3.org/1999/xhtml";
+    SVG_NS = "http://www.w3.org/2000/svg";
+    BLOCKED_ELEMENTS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
+    CODE_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style"]);
+    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
+    };
+    SCRIPT_SOURCE_ATTRIBUTES = /* @__PURE__ */ new Set(["src", "href", "xlink:href", "type", "language"]);
+    SVG_ANIMATION_ELEMENTS = /* @__PURE__ */ new Set(["animate", "set", "animateMotion", "animateTransform", "animateColor"]);
+    reactiveMetaElements = /* @__PURE__ */ new WeakSet();
+    runtimeHrefLinks = /* @__PURE__ */ new WeakSet();
+  }
+});
+
 // src/core/rendering/dispose.ts
 var dispose_exports = {};
 __export(dispose_exports, {
@@ -607,99 +966,22 @@ var init_ssr_context = __esm({
   }
 });
 
-// src/utils/metaRefresh.ts
-function isAsciiWhitespace(ch) {
-  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
-}
-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);
-}
-function parseMetaRefreshContent(content) {
-  const raw = trimAsciiWhitespace(stripControlChars(content));
-  if (raw === "") return forbidden("empty content");
-  let i2 = 0;
-  while (i2 < raw.length && raw[i2] >= "0" && raw[i2] <= "9") i2++;
-  if (i2 === 0) return forbidden("missing or non-numeric delay");
-  const delay = Number.parseInt(raw.slice(0, i2), 10);
-  if (!Number.isFinite(delay)) return forbidden("unparseable delay");
-  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
-  if (i2 === raw.length) return { kind: "delay-only", delay };
-  if (raw[i2] !== ";" && raw[i2] !== ",") return forbidden("unexpected text after delay");
-  i2++;
-  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
-  const keyStart = i2;
-  while (i2 < raw.length && !isAsciiWhitespace(raw[i2]) && raw[i2] !== "=") i2++;
-  const key = raw.slice(keyStart, i2).toLowerCase();
-  if (key !== "url") return forbidden(`unsupported refresh key ${JSON.stringify(key)}`);
-  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
-  if (raw[i2] !== "=") return forbidden("missing '=' after url");
-  i2++;
-  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
-  let destination;
-  const quote2 = raw[i2];
-  if (quote2 === '"' || quote2 === "'") {
-    const close = raw.indexOf(quote2, i2 + 1);
-    if (close === -1) return forbidden("unterminated quoted destination");
-    destination = raw.slice(i2 + 1, close);
-    const rest = trimAsciiWhitespace(raw.slice(close + 1));
-    if (rest !== "") return forbidden("trailing text after quoted destination");
-  } else {
-    destination = trimAsciiWhitespace(raw.slice(i2));
-    if (/[;,]/.test(destination)) return forbidden("multiple refresh assignments");
-  }
-  if (destination === "") return forbidden("empty destination");
-  const sanitizedDestination = sanitizeUrl(destination);
-  if (sanitizedDestination === "") return forbidden("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(`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);
-}
-function normalizeMetaAttributes(props) {
-  const out = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(props)) {
-    const canonical = canonicalAttrName(key);
-    if (seen.has(canonical)) return null;
-    seen.add(canonical);
-    out.set(key, props[key]);
-  }
-  return out;
+// src/utils/guards.ts
+function isUnsafeKey(key) {
+  return UNSAFE_KEYS.has(key);
 }
-function isForbiddenMetaEntry(props) {
-  const normalized = normalizeMetaAttributes(props);
-  if (normalized === null) return true;
-  return resolveMetaRefreshPolicy(normalized).kind === "forbidden";
+function readOwnGlobal(key) {
+  if (typeof window === "undefined") return void 0;
+  if (!Object.hasOwn(window, key)) return void 0;
+  const value = window[key];
+  if (typeof Node !== "undefined" && value instanceof Node) return void 0;
+  return value;
 }
-var forbidden;
-var init_metaRefresh = __esm({
-  "src/utils/metaRefresh.ts"() {
+var UNSAFE_KEYS;
+var init_guards = __esm({
+  "src/utils/guards.ts"() {
     "use strict";
-    init_sanitize();
-    forbidden = (reason) => ({ kind: "forbidden", reason });
+    UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
   }
 });
 
@@ -712,9 +994,7 @@ function isEmittableHeadAttrName(name) {
   return true;
 }
 function sanitizeHeadAttrValue(canonical, value) {
-  if (!isPolicyAttribute(canonical)) return value;
-  const safe = sanitizeAttributeString(canonical, value);
-  return safe === "" ? null : safe;
+  return resolveAttributeValue(canonical, value);
 }
 function findDuplicateAttributeName(names) {
   const seen = /* @__PURE__ */ new Set();
@@ -801,15 +1081,9 @@ __export(ssr_exports, {
   suspenseSwapScript: () => suspenseSwapScript,
   trustHTML: () => trustHTML
 });
-function isPolicyAttr(lowerName) {
-  return isPolicyAttribute(lowerName);
-}
 function isForbiddenSsrAttr(lowerName) {
   return isHtmlContentAttribute(lowerName);
 }
-function sanitizeSsrAttributeValue(lowerName, value) {
-  return sanitizeAttributeString(lowerName, value);
-}
 function isSafeAttrName(name) {
   return SAFE_ATTR_NAME.test(name);
 }
@@ -823,6 +1097,63 @@ function ssrErrorComment(err) {
 function safeCommentText(text2) {
   return text2.replace(/-->/g, "--&gt;").replace(/--!>/g, "--!&gt;").replace(/<!--/g, "&lt;!--").replace(/--$/g, "--&#45;");
 }
+function findNativeGetter(proto, name) {
+  for (let p2 = proto; p2; p2 = Object.getPrototypeOf(p2)) {
+    const get = Object.getOwnPropertyDescriptor(p2, name)?.get;
+    if (get) return get;
+  }
+  return null;
+}
+function nativeAccessors() {
+  const realm = Element;
+  let accessors = nativeAccessorsByRealm.get(realm);
+  if (!accessors) {
+    accessors = {
+      attributes: findNativeGetter(Element.prototype, "attributes"),
+      tagName: findNativeGetter(Element.prototype, "tagName"),
+      childNodes: findNativeGetter(Node.prototype, "childNodes"),
+      getAttribute: Element.prototype.getAttribute
+    };
+    nativeAccessorsByRealm.set(realm, accessors);
+  }
+  return accessors;
+}
+function attributesOf(el) {
+  const get = nativeAccessors().attributes;
+  return get ? get.call(el) : el.attributes;
+}
+function tagNameOf(el) {
+  const get = nativeAccessors().tagName;
+  return get ? get.call(el) : el.tagName;
+}
+function childNodesOf(node) {
+  const get = nativeAccessors().childNodes;
+  return get ? get.call(node) : node.childNodes;
+}
+function getAttributeOf(el, name) {
+  return nativeAccessors().getAttribute.call(el, name);
+}
+function serializeOpenTag(element, tag) {
+  let html2 = `<${tag}`;
+  const meta2 = tag === "meta" ? /* @__PURE__ */ new Map() : null;
+  const attrs = attributesOf(element);
+  for (let i2 = 0; i2 < attrs.length; i2++) {
+    const attr = attrs[i2];
+    const rawName = attr.name;
+    if (!isSafeAttrName(rawName)) continue;
+    if (isEventHandlerAttr(rawName)) continue;
+    if (isForbiddenSsrAttr(rawName)) continue;
+    const value = resolveAttributeValue(rawName.toLowerCase(), attr.value);
+    if (value === null) continue;
+    meta2?.set(rawName, value);
+    html2 += ` ${rawName}="${escapeAttr(value)}"`;
+  }
+  if (meta2 && isForbiddenMetaSnapshot(meta2)) return null;
+  if (!getAttributeOf(element, "data-sibu-hydrate")) {
+    html2 += ` data-sibu-ssr="true"`;
+  }
+  return html2;
+}
 function renderToString(element) {
   if (element instanceof DocumentFragment) {
     return Array.from(element.childNodes).map((child) => {
@@ -842,35 +1173,21 @@ function renderToString(element) {
   if (!(element instanceof HTMLElement)) {
     return escapeHtml(element.textContent || "");
   }
-  const tag = element.tagName.toLowerCase();
-  if (tag === "script" || tag === "style") {
+  const tag = tagNameOf(element).toLowerCase();
+  if (isCodeTextElement(tag)) {
     return DEV ? `<!--ssr:${tag}-stripped-->` : "";
   }
   if (!/^[a-z][a-z0-9-]*$/i.test(tag)) {
     return DEV ? "<!--ssr:invalid-tag-->" : "";
   }
-  let html2 = `<${tag}`;
-  for (const attr of Array.from(element.attributes)) {
-    const rawName = attr.name;
-    if (!isSafeAttrName(rawName)) continue;
-    if (isEventHandlerAttr(rawName)) continue;
-    if (isForbiddenSsrAttr(rawName)) continue;
-    const lowerName = rawName.toLowerCase();
-    let value = attr.value;
-    if (isPolicyAttr(lowerName)) {
-      value = sanitizeSsrAttributeValue(lowerName, value);
-      if (!value) continue;
-    }
-    html2 += ` ${rawName}="${escapeAttr(value)}"`;
-  }
-  if (element.dataset && !element.dataset.sibuHydrate) {
-    html2 += ` data-sibu-ssr="true"`;
-  }
+  const openTag = serializeOpenTag(element, tag);
+  if (openTag === null) return DEV ? `<!--ssr:${tag}-stripped-->` : "";
+  let html2 = openTag;
   if (VOID_ELEMENTS.has(tag)) {
     return `${html2} />`;
   }
   html2 += ">";
-  for (const child of Array.from(element.childNodes)) {
+  for (const child of Array.from(childNodesOf(element))) {
     try {
       html2 += renderToString(child);
     } catch (err) {
@@ -1020,12 +1337,8 @@ function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
     if (!isSafeAttrName(rawKey)) continue;
     if (!allowEventHandlers && isEventHandlerAttr(rawKey)) continue;
     if (isForbiddenSsrAttr(rawKey)) continue;
-    const lowerKey = rawKey.toLowerCase();
-    let value = String(attrs[rawKey]);
-    if (isPolicyAttr(lowerKey)) {
-      value = sanitizeSsrAttributeValue(lowerKey, value);
-      if (!value) continue;
-    }
+    const value = resolveAttributeValue(rawKey.toLowerCase(), String(attrs[rawKey]));
+    if (value === null) continue;
     out.push(`${rawKey}="${escapeAttr(value)}"`);
   }
   return out.join(" ");
@@ -1088,8 +1401,8 @@ async function* renderToStream(element) {
     yield escapeHtml(element.textContent || "");
     return;
   }
-  const tag = element.tagName.toLowerCase();
-  if (tag === "script" || tag === "style") {
+  const tag = tagNameOf(element).toLowerCase();
+  if (isCodeTextElement(tag)) {
     if (DEV) yield `<!--ssr:${tag}-stripped-->`;
     return;
   }
@@ -1097,29 +1410,17 @@ async function* renderToStream(element) {
     if (DEV) yield "<!--ssr:invalid-tag-->";
     return;
   }
-  let openTag = `<${tag}`;
-  for (const attr of Array.from(element.attributes)) {
-    const rawName = attr.name;
-    if (!isSafeAttrName(rawName)) continue;
-    if (isEventHandlerAttr(rawName)) continue;
-    if (isForbiddenSsrAttr(rawName)) continue;
-    const lowerName = rawName.toLowerCase();
-    let value = attr.value;
-    if (isPolicyAttr(lowerName)) {
-      value = sanitizeSsrAttributeValue(lowerName, value);
-      if (!value) continue;
-    }
-    openTag += ` ${rawName}="${escapeAttr(value)}"`;
-  }
-  if (element.dataset && !element.dataset.sibuHydrate) {
-    openTag += ` data-sibu-ssr="true"`;
+  const openTag = serializeOpenTag(element, tag);
+  if (openTag === null) {
+    if (DEV) yield `<!--ssr:${tag}-stripped-->`;
+    return;
   }
   if (VOID_ELEMENTS.has(tag)) {
     yield `${openTag} />`;
     return;
   }
   yield `${openTag}>`;
-  for (const child of Array.from(element.childNodes)) {
+  for (const child of Array.from(childNodesOf(element))) {
     try {
       yield* renderToStream(child);
     } catch (err) {
@@ -1300,8 +1601,7 @@ function deserializeState(validate) {
       "[SibuJS SSR] deserializeState() called without a validate guard \u2014 tampered SSR payloads will not be detected."
     );
   }
-  const w = window;
-  const raw = w[SSR_DATA_ATTR];
+  const raw = readOwnGlobal(SSR_DATA_ATTR);
   if (raw === void 0) return void 0;
   if (validate && !validate(raw)) return void 0;
   return raw;
@@ -1312,13 +1612,15 @@ function escapeHtml(str) {
 function escapeAttr(str) {
   return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-var SAFE_ATTR_NAME, VOID_ELEMENTS, SAFE_ID, SAFE_SUSPENSE_ID, SSR_DATA_ATTR, DEFAULT_MAX_SSR_BYTES;
+var SAFE_ATTR_NAME, VOID_ELEMENTS, nativeAccessorsByRealm, SAFE_ID, SAFE_SUSPENSE_ID, SSR_DATA_ATTR, DEFAULT_MAX_SSR_BYTES;
 var init_ssr = __esm({
   "src/platform/ssr.ts"() {
     "use strict";
     init_dev();
     init_dispose();
     init_ssr_context();
+    init_elementPolicy();
+    init_guards();
     init_headEntry();
     init_metaRefresh();
     init_sanitize();
@@ -1339,6 +1641,7 @@ var init_ssr = __esm({
       "track",
       "wbr"
     ]);
+    nativeAccessorsByRealm = /* @__PURE__ */ new WeakMap();
     SAFE_ID = /^[A-Za-z0-9_-]+$/;
     SAFE_SUSPENSE_ID = /^[A-Za-z0-9_-]+$/;
     SSR_DATA_ATTR = "__SIBU_SSR_DATA__";
@@ -1441,26 +1744,45 @@ init_sanitize();
 
 // src/utils/setSafeAttribute.ts
 init_dev();
+init_elementPolicy();
 init_sanitize();
-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(label2, 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 `${label2}: 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)) {
@@ -1473,6 +1795,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);
@@ -1516,7 +1846,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);
@@ -2020,7 +2355,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.7.0" : "dev";
+var _runtimeVersion = true ? "4.9.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -2091,7 +2426,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);
 }
@@ -2271,13 +2606,10 @@ function bindChildNode(placeholder, getter) {
 }
 
 // src/core/rendering/tagFactory.ts
+init_elementPolicy();
 init_sanitize();
 init_dispose();
-var SVG_NS2 = "http://www.w3.org/2000/svg";
-var BLOCKED_TAGS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
-function isBlockedTag(tag) {
-  return BLOCKED_TAGS.has(tag.toLowerCase());
-}
+var SVG_NS3 = "http://www.w3.org/2000/svg";
 var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
   "config",
   "location",
@@ -2322,11 +2654,12 @@ function applyStyle(el, style2) {
       }
       const next = [];
       for (const prop in value) {
+        if (!Object.hasOwn(value, prop)) continue;
         const val = value[prop];
         if (val == null) continue;
         const name = toKebab(prop);
         next.push(name);
-        decl.setProperty(name, sanitizeCSSValue(String(val), { property: name, element: el }));
+        decl.setProperty(name, sanitizeCSSDeclaration(name, String(val), { element: el }));
       }
       for (let i2 = 0; i2 < written.length; i2++) {
         if (next.indexOf(written[i2]) === -1) decl.removeProperty(written[i2]);
@@ -2342,16 +2675,17 @@ function applyStyle(el, style2) {
   }
   const htmlEl = el;
   for (const prop in style2) {
+    if (!Object.hasOwn(style2, prop)) continue;
     const val = style2[prop];
     const name = toKebab(prop);
     if (typeof val === "function") {
       const getter = val;
       const teardown = reactiveBinding2(() => {
-        htmlEl.style.setProperty(name, sanitizeCSSValue(String(getter()), { property: name, element: el }));
+        htmlEl.style.setProperty(name, sanitizeCSSDeclaration(name, String(getter()), { element: el }));
       }, el);
       registerDisposer(el, teardown);
     } else {
-      htmlEl.style.setProperty(name, sanitizeCSSValue(String(val), { property: name, element: el }));
+      htmlEl.style.setProperty(name, sanitizeCSSDeclaration(name, String(val), { element: el }));
     }
   }
 }
@@ -2361,6 +2695,7 @@ function resolveClassValue(cls) {
   if (!cls) return "";
   let out = "";
   for (const name in cls) {
+    if (!Object.hasOwn(cls, name)) continue;
     const val = cls[name];
     const active = typeof val === "function" ? val() : val;
     if (active) out = out ? `${out} ${name}` : name;
@@ -2385,6 +2720,7 @@ function applyClass(el, cls) {
   let hasReactive = false;
   let result = "";
   for (const name in obj) {
+    if (!Object.hasOwn(obj, name)) continue;
     const val = obj[name];
     if (typeof val === "function") {
       hasReactive = true;
@@ -2396,6 +2732,7 @@ function applyClass(el, cls) {
     const update = () => {
       let r = "";
       for (const name in obj) {
+        if (!Object.hasOwn(obj, name)) continue;
         const val = obj[name];
         const active = typeof val === "function" ? val() : val;
         if (active) r = r ? `${r} ${name}` : name;
@@ -2459,7 +2796,7 @@ function appendChildren(el, nodes) {
   }
 }
 function tagFactory(tag, ns) {
-  const blocked = isBlockedTag(tag);
+  const blocked = isBlockedElement(tag);
   return (first, second) => {
     if (blocked) {
       throw new Error(`tagFactory: refusing to create <${tag}> \u2014 tag is blocked for security reasons.`);
@@ -2522,6 +2859,7 @@ function tagFactory(tag, ns) {
     const pOn = props.on;
     if (pOn) {
       for (const ev in pOn) {
+        if (!Object.hasOwn(pOn, ev)) continue;
         const handler = pOn[ev];
         if (typeof handler === "function") {
           el.addEventListener(ev, handler);
@@ -2548,6 +2886,7 @@ function tagFactory(tag, ns) {
           continue;
         // already handled above / below
         default: {
+          if (!Object.hasOwn(props, key)) continue;
           const value = props[key];
           if (value == null) continue;
           if (isEventHandlerAttr(key)) continue;
@@ -2637,7 +2976,7 @@ var param = tagFactory("param");
 var picture = tagFactory("picture");
 var portal = tagFactory("portal");
 var source = tagFactory("source");
-var svg = tagFactory("svg", SVG_NS2);
+var svg = tagFactory("svg", SVG_NS3);
 var math = tagFactory("math");
 var canvas = tagFactory("canvas");
 var noscript = tagFactory("noscript");
@@ -2678,26 +3017,26 @@ var base = tagFactory("base");
 var link = tagFactory("link");
 var meta = tagFactory("meta");
 var style = tagFactory("style");
-var circle = tagFactory("circle", SVG_NS2);
-var ellipse = tagFactory("ellipse", SVG_NS2);
-var g = tagFactory("g", SVG_NS2);
-var line = tagFactory("line", SVG_NS2);
-var path = tagFactory("path", SVG_NS2);
-var polygon = tagFactory("polygon", SVG_NS2);
-var polyline = tagFactory("polyline", SVG_NS2);
-var rect = tagFactory("rect", SVG_NS2);
-var text = tagFactory("text", SVG_NS2);
-var tspan = tagFactory("tspan", SVG_NS2);
-var defs = tagFactory("defs", SVG_NS2);
-var clipPath = tagFactory("clipPath", SVG_NS2);
-var mask = tagFactory("mask", SVG_NS2);
-var pattern = tagFactory("pattern", SVG_NS2);
-var linearGradient = tagFactory("linearGradient", SVG_NS2);
-var radialGradient = tagFactory("radialGradient", SVG_NS2);
-var stop = tagFactory("stop", SVG_NS2);
-var use = tagFactory("use", SVG_NS2);
-var symbol = tagFactory("symbol", SVG_NS2);
-var marker = tagFactory("marker", SVG_NS2);
+var circle = tagFactory("circle", SVG_NS3);
+var ellipse = tagFactory("ellipse", SVG_NS3);
+var g = tagFactory("g", SVG_NS3);
+var line = tagFactory("line", SVG_NS3);
+var path = tagFactory("path", SVG_NS3);
+var polygon = tagFactory("polygon", SVG_NS3);
+var polyline = tagFactory("polyline", SVG_NS3);
+var rect = tagFactory("rect", SVG_NS3);
+var text = tagFactory("text", SVG_NS3);
+var tspan = tagFactory("tspan", SVG_NS3);
+var defs = tagFactory("defs", SVG_NS3);
+var clipPath = tagFactory("clipPath", SVG_NS3);
+var mask = tagFactory("mask", SVG_NS3);
+var pattern = tagFactory("pattern", SVG_NS3);
+var linearGradient = tagFactory("linearGradient", SVG_NS3);
+var radialGradient = tagFactory("radialGradient", SVG_NS3);
+var stop = tagFactory("stop", SVG_NS3);
+var use = tagFactory("use", SVG_NS3);
+var symbol = tagFactory("symbol", SVG_NS3);
+var marker = tagFactory("marker", SVG_NS3);
 var center = tagFactory("center");
 var font = tagFactory("font");
 var marquee = tagFactory("marquee");
@@ -2880,6 +3219,7 @@ function getLocale() {
   }
   return clientLocale();
 }
+_i18n.getLocale ?? (_i18n.getLocale = getLocale);
 function registerTranslations(locale, messages) {
   const prepared = { ...messages };
   const merged = Object.assign(/* @__PURE__ */ Object.create(null), dictionaryFor(locale), prepared);
@@ -3078,9 +3418,14 @@ function normalizePathname(path2) {
   const trimmed = path2.length > 1 ? path2.replace(/\/+$/, "") : path2;
   return trimmed || "/";
 }
-function normalizeQuery(query) {
-  const params = new URLSearchParams(query);
-  return [...params.entries()].sort(([a2], [b2]) => a2 < b2 ? -1 : a2 > b2 ? 1 : 0).map(([k, v]) => `${k}=${v}`).join("&");
+function parseQuery(query) {
+  return Object.fromEntries(new URLSearchParams(query));
+}
+function paramsIdentity(params) {
+  return JSON.stringify(Object.entries(params).sort(([a2], [b2]) => a2 < b2 ? -1 : a2 > b2 ? 1 : 0));
+}
+function queryIdentity(query) {
+  return paramsIdentity(typeof query === "string" ? parseQuery(query) : query);
 }
 function isPathnameAncestor(target, current) {
   if (target === current) return true;
@@ -3781,7 +4126,7 @@ var _SibuRouter = class _SibuRouter {
   }
   createRouteContext(fullPath) {
     const { path: path2, query: queryString, hash } = splitRouteUrl(fullPath);
-    const query = Object.fromEntries(new URLSearchParams(queryString));
+    const query = parseQuery(queryString);
     const match = this.matcher.match(path2 || "/");
     const params = match?.params || {};
     const meta2 = match?.route.meta || {};
@@ -3945,7 +4290,7 @@ var _SibuRouter = class _SibuRouter {
   }
   isSameRoute(from, to) {
     if (from.matched.length === 0 && to.matched.length > 0) return false;
-    return from.path === to.path && JSON.stringify(from.params) === JSON.stringify(to.params) && JSON.stringify(from.query) === JSON.stringify(to.query) && from.hash === to.hash;
+    return from.path === to.path && paramsIdentity(from.params) === paramsIdentity(to.params) && queryIdentity(from.query) === queryIdentity(to.query) && from.hash === to.hash;
   }
   updateHistory(to, options) {
     const fullPath = this.options.base + to.path + (Object.keys(to.query).length ? `?${new URLSearchParams(to.query).toString()}` : "") + (to.hash ? `#${to.hash}` : "");
@@ -4455,8 +4800,7 @@ function KeepAliveRoute(options) {
       return;
     }
     if (!("component" in routeDef)) return;
-    const queryStr = Object.keys(route2.query).length > 0 ? `?${new URLSearchParams(route2.query).toString()}` : "";
-    const cacheKey = `${route2.path}${queryStr}${route2.hash ? `#${route2.hash}` : ""}`;
+    const cacheKey = JSON.stringify([route2.path, queryIdentity(route2.query), route2.hash]);
     const shouldCache = !includeNames || routeDef.name != null && includeNames.includes(routeDef.name);
     if (cacheKey === currentKey && currentNode) return;
     if (!anchor.parentNode) return;
@@ -4558,7 +4902,7 @@ function RouterLink(props, children) {
   const href = kind === "unsafe" ? "#" : rawHref;
   const { path: hrefPathRaw, query: hrefQueryRaw, hash: hrefHash } = splitRouteUrl(href);
   const targetPath = normalizePathname(hrefPathRaw);
-  const targetQuery = normalizeQuery(hrefQueryRaw);
+  const targetQuery = queryIdentity(hrefQueryRaw);
   const link2 = document.createElement("a");
   link2.href = href;
   if (target) {
@@ -4576,7 +4920,7 @@ function RouterLink(props, children) {
     const route2 = routeGetter();
     const currentPath = normalizePathname(route2.path);
     const isActive = kind === "internal" && isPathnameAncestor(targetPath, currentPath);
-    const isExactActive = kind === "internal" && currentPath === targetPath && normalizeQuery(route2.query) === targetQuery && route2.hash === hrefHash;
+    const isExactActive = kind === "internal" && currentPath === targetPath && queryIdentity(route2.query) === targetQuery && route2.hash === hrefHash;
     const classes = [];
     if (isActive) {
       if (activeClass) classes.push(activeClass);
@@ -4593,15 +4937,7 @@ function RouterLink(props, children) {
     const lkey = key.toLowerCase();
     if (lkey === "href" || lkey[0] === "o" && lkey[1] === "n") return;
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      const str = String(value);
-      if (isUrlAttribute(lkey)) {
-        const safe = sanitizeUrl(str);
-        if (safe) link2.setAttribute(key, safe);
-      } else if (lkey === "style") {
-        link2.setAttribute(key, sanitizeStyleAttribute(str, { element: link2 }));
-      } else {
-        link2.setAttribute(key, str);
-      }
+      setSafeAttribute(link2, key, String(value), { syncValueProperty: false, label: "RouterLink" });
     }
   });
   if (content !== void 0) appendChildren(link2, content);
@@ -4900,14 +5236,7 @@ function createMemoryRouter(routes, _initialPath = "/") {
 
 // src/plugins/routerSSR.ts
 init_ssr();
-
-// src/utils/guards.ts
-var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function isUnsafeKey(key) {
-  return UNSAFE_KEYS.has(key);
-}
-
-// src/plugins/routerSSR.ts
+init_guards();
 init_headEntry();
 init_sanitize();
 function safeDecode(raw) {
@@ -5140,8 +5469,7 @@ function serializeRouteState(state2, nonce) {
   return `<script${nonceAttr}>window.${SSR_ROUTE_STATE_KEY}=${json}</script>`;
 }
 function deserializeRouteState() {
-  if (typeof window === "undefined") return void 0;
-  return window[SSR_ROUTE_STATE_KEY];
+  return readOwnGlobal(SSR_ROUTE_STATE_KEY);
 }
 function hydrateRouter(routes, options) {
   const serverState = deserializeRouteState();
@@ -5581,7 +5909,7 @@ var CDN_ENTRY_POINTS = {
 };
 var packageInfo = {
   name: "sibujs",
-  version: true ? "4.7.0" : "dev",
+  version: true ? "4.9.0" : "dev",
   entryPoints: MODULE_ENTRY_POINTS,
   /**
    * Generate the package.json `exports` map. Module entries resolve to the
@@ -5726,7 +6054,7 @@ var env = {
 };
 
 // src/plugins/versioning.ts
-var VERSION = true ? "4.7.0" : "dev";
+var VERSION = true ? "4.9.0" : "dev";
 var NUM = "(?:0|[1-9]\\d*)";
 var PRE_ID = `(?:${NUM}|\\d*[a-zA-Z-][0-9a-zA-Z-]*)`;
 var BUILD_ID = "[0-9a-zA-Z-]+";
@@ -6008,15 +6336,18 @@ function extractRangeTarget(range) {
 // src/plugins/startup.ts
 init_errors();
 init_ssr();
+init_sanitize();
 function preloadCritical(resources) {
   if (typeof document === "undefined") return;
   for (const resource of resources) {
-    const safeHref = typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(resource.href) : resource.href.replace(/["\\]/g, "\\$&");
+    const href = sanitizeUrl(resource.href);
+    if (!href) continue;
+    const safeHref = typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(href) : href.replace(/["\\]/g, "\\$&");
     const existing = document.querySelector(`link[rel="preload"][href="${safeHref}"]`);
     if (existing) continue;
     const link2 = document.createElement("link");
     link2.rel = "preload";
-    link2.href = resource.href;
+    link2.href = href;
     link2.setAttribute("as", resource.as);
     if (resource.type) {
       link2.type = resource.type;