@event4u/agent-config 16.4.0 → 17.0.0

package/dist/hooks/svg_rules.chunk.cjs

@@ -0,0 +1,1858 @@
+const __acChunkMetaUrl = require('node:url').pathToFileURL(__filename).href; const __acChunkMeta = { url: __acChunkMetaUrl, dirname: __dirname, filename: __filename };
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/_lib/svg_rules.ts
+var svg_rules_exports = {};
+__export(svg_rules_exports, {
+  DELIVERY_MODES: () => DELIVERY_MODES,
+  GENERIC_IDS: () => GENERIC_IDS,
+  VECTOR_GEOMETRY: () => VECTOR_GEOMETRY,
+  directChildrenOfRoot: () => directChildrenOfRoot,
+  elementExtent: () => elementExtent,
+  maskComments: () => maskComments,
+  parseElements: () => parseElements,
+  parseIgnores: () => parseIgnores,
+  pathDataError: () => pathDataError,
+  pathExtent: () => pathExtent,
+  pointsExtent: () => pointsExtent,
+  readViewBox: () => readViewBox,
+  referencedIds: () => referencedIds,
+  safetySeverity: () => safetySeverity,
+  scanHostHtml: () => scanHostHtml,
+  scanSvg: () => scanSvg,
+  staticBox: () => staticBox,
+  tokenisePath: () => tokenisePath,
+  vectorVerdict: () => vectorVerdict
+});
+module.exports = __toCommonJS(svg_rules_exports);
+
+// src/scripts/_lib/svg_dom.ts
+function positions(content) {
+  const starts = [0];
+  for (let i = 0; i < content.length; i += 1) {
+    if (content[i] === "\n") starts.push(i + 1);
+  }
+  return (offset) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return { line: lo + 1, column: offset - starts[lo] + 1 };
+  };
+}
+function tagEnd(content, from) {
+  let quote = null;
+  for (let i = from + 1; i < content.length; i += 1) {
+    const ch = content[i];
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">") return i;
+  }
+  return -1;
+}
+function attrsOf(raw) {
+  const attrs = {};
+  const re = /([A-Za-z_:][\w.:-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+  let m;
+  while ((m = re.exec(raw)) !== null) {
+    const key = (m[1] ?? "").toLowerCase();
+    const value = m[3] ?? m[4] ?? "";
+    attrs[key] = value.replace(/&amp;/g, "&");
+  }
+  return attrs;
+}
+function parseDocument(content) {
+  const at = positions(content);
+  const roots = [];
+  const elements = [];
+  const errors = [];
+  const stack = [];
+  const make = (kind, start, name = "", value = "", attrs = {}) => {
+    const { line, column } = at(start);
+    return { kind, name, attrs, line, column, start, value, children: [], parent: null };
+  };
+  const append = (node) => {
+    const parent = stack[stack.length - 1];
+    if (parent === void 0) {
+      roots.push(node);
+    } else {
+      node.parent = parent;
+      parent.children.push(node);
+    }
+  };
+  let i = 0;
+  while (i < content.length) {
+    const lt = content.indexOf("<", i);
+    if (lt === -1) {
+      const rest = content.slice(i);
+      if (rest.trim() !== "") append(make("text", i, "", rest));
+      break;
+    }
+    if (lt > i) {
+      const text = content.slice(i, lt);
+      if (text.trim() !== "") append(make("text", i, "", text));
+    }
+    if (content.startsWith("<!--", lt)) {
+      const end = content.indexOf("-->", lt + 4);
+      if (end === -1) {
+        const p = at(lt);
+        errors.push({ message: "unterminated comment", line: p.line, column: p.column });
+        append(make("comment", lt, "", content.slice(lt + 4)));
+        break;
+      }
+      append(make("comment", lt, "", content.slice(lt + 4, end)));
+      i = end + 3;
+      continue;
+    }
+    if (content.startsWith("<![CDATA[", lt)) {
+      const end = content.indexOf("]]>", lt + 9);
+      if (end === -1) {
+        const p = at(lt);
+        errors.push({ message: "unterminated CDATA section", line: p.line, column: p.column });
+        append(make("cdata", lt, "", content.slice(lt + 9)));
+        break;
+      }
+      append(make("cdata", lt, "", content.slice(lt + 9, end)));
+      i = end + 3;
+      continue;
+    }
+    if (content.startsWith("<?", lt)) {
+      const end = content.indexOf("?>", lt + 2);
+      if (end === -1) {
+        const p = at(lt);
+        errors.push({ message: "unterminated processing instruction", line: p.line, column: p.column });
+      }
+      const stop = end === -1 ? content.length : end + 2;
+      append(make("pi", lt, "", content.slice(lt + 2, end === -1 ? content.length : end)));
+      i = stop;
+      continue;
+    }
+    if (content.startsWith("<!", lt)) {
+      const bracket = content.indexOf("[", lt);
+      const close = content.indexOf(">", lt);
+      let stop;
+      if (bracket !== -1 && close !== -1 && bracket < close) {
+        const endBracket = content.indexOf("]", bracket);
+        const after = endBracket === -1 ? close : content.indexOf(">", endBracket);
+        stop = after === -1 ? content.length : after + 1;
+      } else {
+        stop = close === -1 ? content.length : close + 1;
+      }
+      if (close === -1) {
+        const p = at(lt);
+        errors.push({ message: "unterminated declaration", line: p.line, column: p.column });
+      }
+      append(make("doctype", lt, "", content.slice(lt + 2, Math.max(lt + 2, stop - 1))));
+      i = stop;
+      continue;
+    }
+    const gt = tagEnd(content, lt);
+    if (gt === -1) {
+      const p = at(lt);
+      errors.push({ message: "unterminated tag", line: p.line, column: p.column });
+      break;
+    }
+    const raw = content.slice(lt, gt + 1);
+    const nameMatch = /^<\/?\s*([A-Za-z_][\w.:-]*)/.exec(raw);
+    if (!nameMatch) {
+      const p = at(lt);
+      errors.push({ message: `"${raw.slice(0, 24)}" is not a tag`, line: p.line, column: p.column });
+      i = gt + 1;
+      continue;
+    }
+    const name = (nameMatch[1] ?? "").toLowerCase();
+    const closing = raw.startsWith("</");
+    const selfClosing = raw.endsWith("/>");
+    if (closing) {
+      const open = stack[stack.length - 1];
+      const p = at(lt);
+      if (open === void 0) {
+        errors.push({ message: `closing tag </${name}> with no open element`, line: p.line, column: p.column });
+      } else if (open.name !== name) {
+        errors.push({
+          message: `closing tag </${name}> does not match the open <${open.name}> (line ${String(open.line)})`,
+          line: p.line,
+          column: p.column
+        });
+        const idx = stack.map((n) => n.name).lastIndexOf(name);
+        if (idx !== -1) stack.length = idx;
+      } else {
+        stack.pop();
+      }
+      i = gt + 1;
+      continue;
+    }
+    const node = make("element", lt, name, "", attrsOf(raw));
+    append(node);
+    elements.push(node);
+    if (!selfClosing) stack.push(node);
+    i = gt + 1;
+  }
+  for (const unclosed of stack) {
+    errors.push({
+      message: `<${unclosed.name}> is never closed`,
+      line: unclosed.line,
+      column: unclosed.column
+    });
+  }
+  return { roots, elements, errors };
+}
+
+// src/scripts/_lib/svg_geometry.ts
+function staticBox(el) {
+  if (el.attrs["transform"] || el.attrs["style"]?.includes("transform")) return null;
+  const num = (k) => {
+    const v = el.attrs[k];
+    if (v === void 0) return null;
+    if (!/^-?\d+(\.\d+)?$/.test(v.trim())) return null;
+    return Number(v);
+  };
+  const originOr0 = (k) => el.attrs[k] === void 0 ? 0 : num(k);
+  switch (el.name) {
+    case "rect": {
+      const x = originOr0("x");
+      const y = originOr0("y");
+      const w = num("width");
+      const h = num("height");
+      if (x === null || y === null || w === null || h === null) return null;
+      return { minX: x, minY: y, maxX: x + w, maxY: y + h };
+    }
+    case "circle": {
+      const cx = originOr0("cx");
+      const cy = originOr0("cy");
+      const r = num("r");
+      if (cx === null || cy === null || r === null) return null;
+      return { minX: cx - r, minY: cy - r, maxX: cx + r, maxY: cy + r };
+    }
+    case "ellipse": {
+      const cx = originOr0("cx");
+      const cy = originOr0("cy");
+      const rx = num("rx");
+      const ry = num("ry");
+      if (cx === null || cy === null || rx === null || ry === null) return null;
+      return { minX: cx - rx, minY: cy - ry, maxX: cx + rx, maxY: cy + ry };
+    }
+    case "line": {
+      const x1 = num("x1");
+      const y1 = num("y1");
+      const x2 = num("x2");
+      const y2 = num("y2");
+      if (x1 === null || y1 === null || x2 === null || y2 === null) return null;
+      return {
+        minX: Math.min(x1, x2),
+        minY: Math.min(y1, y2),
+        maxX: Math.max(x1, x2),
+        maxY: Math.max(y1, y2)
+      };
+    }
+    default:
+      return null;
+  }
+}
+function pathExtent(d) {
+  const tokens = tokenisePath(d);
+  if (!tokens) return null;
+  const argCount = { m: 2, l: 2, t: 2, h: 1, v: 1, c: 6, s: 4, q: 4, a: 7, z: 0 };
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  const see = (x, y) => {
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+    minY = Math.min(minY, y);
+    maxY = Math.max(maxY, y);
+  };
+  let cx = 0;
+  let cy = 0;
+  let sx = 0;
+  let sy = 0;
+  let i = 0;
+  let cmd = "";
+  let rel = false;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (/^[a-zA-Z]$/.test(tok)) {
+      cmd = tok.toLowerCase();
+      rel = tok === tok.toLowerCase();
+      i += 1;
+      if (cmd === "z") {
+        cx = sx;
+        cy = sy;
+        continue;
+      }
+      if (!(cmd in argCount)) return null;
+    } else if (cmd === "" || cmd === "z") {
+      return null;
+    }
+    const need = argCount[cmd];
+    if (need === 0) continue;
+    const args = [];
+    while (args.length < need && i < tokens.length && !/^[a-zA-Z]$/.test(tokens[i])) {
+      args.push(Number(tokens[i]));
+      i += 1;
+    }
+    if (args.length < need) return null;
+    switch (cmd) {
+      case "h": {
+        cx = rel ? cx + args[0] : args[0];
+        break;
+      }
+      case "v": {
+        cy = rel ? cy + args[0] : args[0];
+        break;
+      }
+      case "a": {
+        const ex = rel ? cx + args[5] : args[5];
+        const ey = rel ? cy + args[6] : args[6];
+        for (const [px, py] of arcExtremes(
+          cx,
+          cy,
+          ex,
+          ey,
+          args[0],
+          args[1],
+          args[2],
+          args[3] !== 0,
+          args[4] !== 0
+        )) {
+          see(px, py);
+        }
+        cx = ex;
+        cy = ey;
+        break;
+      }
+      default: {
+        for (let k = 0; k + 1 < args.length; k += 2) {
+          const px = rel ? cx + args[k] : args[k];
+          const py = rel ? cy + args[k + 1] : args[k + 1];
+          see(px, py);
+          if (k + 2 >= args.length) {
+            cx = px;
+            cy = py;
+          }
+        }
+        break;
+      }
+    }
+    see(cx, cy);
+    if (cmd === "m") {
+      sx = cx;
+      sy = cy;
+      cmd = "l";
+    }
+  }
+  if (!Number.isFinite(minX)) return null;
+  return { minX, minY, maxX, maxY };
+}
+function tokenisePath(d) {
+  const NUM = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/y;
+  const FLAG = /[01]/y;
+  const SEP = /[\s,]*/y;
+  const out = [];
+  const text = d.trim();
+  let i = 0;
+  let cmd = "";
+  const eat = (re) => {
+    re.lastIndex = i;
+    const m = re.exec(text);
+    if (m === null) return null;
+    i = re.lastIndex;
+    return m[0];
+  };
+  const skip = () => {
+    void eat(SEP);
+  };
+  while (i < text.length) {
+    skip();
+    if (i >= text.length) break;
+    const ch = text[i];
+    if (/[a-zA-Z]/.test(ch)) {
+      cmd = ch;
+      out.push(ch);
+      i += 1;
+      continue;
+    }
+    if (cmd.toLowerCase() === "a") {
+      for (let k = 0; k < 3; k += 1) {
+        skip();
+        const n2 = eat(NUM);
+        if (n2 === null) return null;
+        out.push(n2);
+      }
+      for (let k = 0; k < 2; k += 1) {
+        skip();
+        const f = eat(FLAG);
+        if (f === null) return null;
+        out.push(f);
+      }
+      for (let k = 0; k < 2; k += 1) {
+        skip();
+        const n2 = eat(NUM);
+        if (n2 === null) return null;
+        out.push(n2);
+      }
+      continue;
+    }
+    const n = eat(NUM);
+    if (n === null) return null;
+    out.push(n);
+  }
+  return out.length > 0 ? out : null;
+}
+function arcExtremes(x1, y1, x2, y2, rxIn, ryIn, rotationDeg, largeArc, sweep) {
+  const ends = [
+    [x1, y1],
+    [x2, y2]
+  ];
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  if (rx === 0 || ry === 0 || x1 === x2 && y1 === y2) return ends;
+  const phi = rotationDeg * Math.PI / 180;
+  const cosP = Math.cos(phi);
+  const sinP = Math.sin(phi);
+  const dx2 = (x1 - x2) / 2;
+  const dy2 = (y1 - y2) / 2;
+  const x1p = cosP * dx2 + sinP * dy2;
+  const y1p = -sinP * dx2 + cosP * dy2;
+  const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+  if (lambda > 1) {
+    const k = Math.sqrt(lambda);
+    rx *= k;
+    ry *= k;
+  }
+  const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+  if (den === 0) return ends;
+  const coef = (largeArc === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num / den));
+  const cxp = coef * rx * y1p / ry;
+  const cyp = -coef * ry * x1p / rx;
+  const ccx = cosP * cxp - sinP * cyp + (x1 + x2) / 2;
+  const ccy = sinP * cxp + cosP * cyp + (y1 + y2) / 2;
+  const angleOf = (px, py) => {
+    const ux = (cosP * (px - ccx) + sinP * (py - ccy)) / rx;
+    const uy = (-sinP * (px - ccx) + cosP * (py - ccy)) / ry;
+    return Math.atan2(uy, ux);
+  };
+  const start = angleOf(x1, y1);
+  const end = angleOf(x2, y2);
+  const TAU = Math.PI * 2;
+  let delta = end - start;
+  if (sweep && delta < 0) delta += TAU;
+  if (!sweep && delta > 0) delta -= TAU;
+  const within = (theta) => {
+    let t = theta - start;
+    if (sweep) {
+      while (t < 0) t += TAU;
+      return t <= delta + 1e-9;
+    }
+    while (t > 0) t -= TAU;
+    return t >= delta - 1e-9;
+  };
+  const at = (theta) => [
+    ccx + rx * Math.cos(theta) * cosP - ry * Math.sin(theta) * sinP,
+    ccy + rx * Math.cos(theta) * sinP + ry * Math.sin(theta) * cosP
+  ];
+  const out = [...ends];
+  const tx = Math.atan2(-ry * sinP, rx * cosP);
+  const ty = Math.atan2(ry * cosP, rx * sinP);
+  for (const base of [tx, ty]) {
+    for (const theta of [base, base + Math.PI]) {
+      if (within(theta)) out.push(at(theta));
+    }
+  }
+  return out;
+}
+function pointsExtent(points) {
+  const nums = points.trim().match(/-?\d*\.?\d+(?:[eE][-+]?\d+)?/g);
+  if (!nums || nums.length < 2) return null;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i + 1 < nums.length; i += 2) {
+    const x = Number(nums[i]);
+    const y = Number(nums[i + 1]);
+    if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+    minY = Math.min(minY, y);
+    maxY = Math.max(maxY, y);
+  }
+  return Number.isFinite(minX) ? { minX, minY, maxX, maxY } : null;
+}
+function elementExtent(el) {
+  if (el.closing) return null;
+  if (el.attrs["transform"] || el.attrs["style"]?.includes("transform")) return null;
+  if (el.name === "path") return pathExtent(el.attrs["d"] ?? "");
+  if (el.name === "polygon" || el.name === "polyline") return pointsExtent(el.attrs["points"] ?? "");
+  return staticBox(el);
+}
+function pathDataError(d) {
+  const trimmed = d.trim();
+  if (!trimmed) return "empty d attribute";
+  if (!/^[mM]/.test(trimmed)) return "path data does not start with a moveto command";
+  const argCount = {
+    m: 2,
+    l: 2,
+    t: 2,
+    h: 1,
+    v: 1,
+    c: 6,
+    s: 4,
+    q: 4,
+    a: 7,
+    z: 0
+  };
+  const tokens = tokenisePath(trimmed);
+  if (!tokens) {
+    return "path data could not be read \u2014 a coordinate, an arc flag or a command letter is malformed";
+  }
+  let i = 0;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (!/^[a-zA-Z]$/.test(tok)) return `unexpected token "${tok}" where a command letter was required`;
+    const cmd = tok.toLowerCase();
+    if (!(cmd in argCount)) return `unknown path command "${tok}"`;
+    const need = argCount[cmd];
+    i += 1;
+    if (need === 0) continue;
+    let consumed = 0;
+    while (i < tokens.length && !/^[a-zA-Z]$/.test(tokens[i])) {
+      i += 1;
+      consumed += 1;
+    }
+    if (consumed === 0 || consumed % need !== 0) {
+      return `command "${tok}" takes ${need} coordinate(s) per repetition, got ${consumed}`;
+    }
+  }
+  return null;
+}
+
+// src/scripts/_lib/svg_filled_counter.ts
+var CURVE_STEPS = 12;
+var MAX_SUBPATHS = 400;
+function styleProp(el, prop) {
+  const direct = el.attrs[prop];
+  if (direct !== void 0) return direct.trim();
+  const m = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i").exec(el.attrs["style"] ?? "");
+  return m?.[1]?.trim();
+}
+function arcPoints(from, args) {
+  const [rxIn, ryIn, rotDeg, large, sweep, x, y] = args;
+  const [x1, y1] = from;
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  if (rx === 0 || ry === 0 || x1 === x && y1 === y) return [[x, y]];
+  const phi = rotDeg * Math.PI / 180;
+  const cos = Math.cos(phi);
+  const sin = Math.sin(phi);
+  const dx = (x1 - x) / 2;
+  const dy = (y1 - y) / 2;
+  const xp = cos * dx + sin * dy;
+  const yp = -sin * dx + cos * dy;
+  const lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+  const num = rx * rx * ry * ry - rx * rx * yp * yp - ry * ry * xp * xp;
+  const den = rx * rx * yp * yp + ry * ry * xp * xp;
+  const coef = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num / den));
+  const cxp = coef * rx * yp / ry;
+  const cyp = -coef * ry * xp / rx;
+  const cx = cos * cxp - sin * cyp + (x1 + x) / 2;
+  const cy = sin * cxp + cos * cyp + (y1 + y) / 2;
+  const angle = (ux, uy, vx, vy) => {
+    const a = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    return a;
+  };
+  const t1 = angle(1, 0, (xp - cxp) / rx, (yp - cyp) / ry);
+  let dt = angle((xp - cxp) / rx, (yp - cyp) / ry, (-xp - cxp) / rx, (-yp - cyp) / ry);
+  if (!sweep && dt > 0) dt -= 2 * Math.PI;
+  if (sweep && dt < 0) dt += 2 * Math.PI;
+  const out = [];
+  for (let k = 1; k <= CURVE_STEPS; k++) {
+    const t = t1 + dt * k / CURVE_STEPS;
+    const ex = rx * Math.cos(t);
+    const ey = ry * Math.sin(t);
+    out.push([cos * ex - sin * ey + cx, sin * ex + cos * ey + cy]);
+  }
+  return out;
+}
+function bezier(p0, p1, p2, p3) {
+  const out = [];
+  for (let k = 1; k <= CURVE_STEPS; k++) {
+    const t = k / CURVE_STEPS;
+    const u = 1 - t;
+    out.push([
+      u * u * u * p0[0] + 3 * u * u * t * p1[0] + 3 * u * t * t * p2[0] + t * t * t * p3[0],
+      u * u * u * p0[1] + 3 * u * u * t * p1[1] + 3 * u * t * t * p2[1] + t * t * t * p3[1]
+    ]);
+  }
+  return out;
+}
+function subpathPolygons(d) {
+  const tokens = tokenisePath(d);
+  if (tokens === null) return null;
+  const ARGS = { m: 2, l: 2, t: 2, h: 1, v: 1, c: 6, s: 4, q: 4, a: 7, z: 0 };
+  const polys = [];
+  let poly = [];
+  let cur = [0, 0];
+  let start = [0, 0];
+  let lastCtrl = null;
+  let lastQuad = null;
+  let i = 0;
+  let cmd = "";
+  const flush = () => {
+    if (poly.length >= 3) polys.push(poly);
+    poly = [];
+  };
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (/^[a-zA-Z]$/.test(tok)) {
+      cmd = tok;
+      i += 1;
+      if (cmd.toLowerCase() === "z") {
+        cur = start;
+        lastCtrl = lastQuad = null;
+        flush();
+        continue;
+      }
+      if (i >= tokens.length) break;
+      continue;
+    }
+    const lower = cmd.toLowerCase();
+    const n = ARGS[lower];
+    if (n === void 0 || n === 0) return null;
+    const a = tokens.slice(i, i + n).map(Number);
+    if (a.length < n || a.some((v) => !Number.isFinite(v))) return null;
+    i += n;
+    const rel = cmd !== cmd.toUpperCase();
+    const ox = rel ? cur[0] : 0;
+    const oy = rel ? cur[1] : 0;
+    const at = (k) => [a[k] + ox, a[k + 1] + oy];
+    let next = cur;
+    let pts = [];
+    let ctrl = null;
+    let quad = null;
+    switch (lower) {
+      case "m":
+        flush();
+        next = at(0);
+        start = next;
+        pts = [next];
+        cmd = rel ? "l" : "L";
+        break;
+      case "l":
+        next = at(0);
+        pts = [next];
+        break;
+      case "h":
+        next = [a[0] + ox, cur[1]];
+        pts = [next];
+        break;
+      case "v":
+        next = [cur[0], a[0] + oy];
+        pts = [next];
+        break;
+      case "c":
+        ctrl = at(2);
+        next = at(4);
+        pts = bezier(cur, at(0), ctrl, next);
+        break;
+      case "s": {
+        const c1 = lastCtrl ? [2 * cur[0] - lastCtrl[0], 2 * cur[1] - lastCtrl[1]] : cur;
+        ctrl = at(0);
+        next = at(2);
+        pts = bezier(cur, c1, ctrl, next);
+        break;
+      }
+      case "q":
+      case "t": {
+        const q = lower === "q" ? at(0) : lastQuad ? [2 * cur[0] - lastQuad[0], 2 * cur[1] - lastQuad[1]] : cur;
+        next = lower === "q" ? at(2) : at(0);
+        quad = q;
+        const c1 = [cur[0] + 2 / 3 * (q[0] - cur[0]), cur[1] + 2 / 3 * (q[1] - cur[1])];
+        const c2 = [next[0] + 2 / 3 * (q[0] - next[0]), next[1] + 2 / 3 * (q[1] - next[1])];
+        pts = bezier(cur, c1, c2, next);
+        break;
+      }
+      case "a":
+        next = [a[5] + ox, a[6] + oy];
+        pts = arcPoints(cur, [a[0], a[1], a[2], a[3], a[4], next[0], next[1]]);
+        break;
+    }
+    poly.push(...pts);
+    cur = next;
+    lastCtrl = ctrl;
+    lastQuad = quad;
+    if (polys.length > MAX_SUBPATHS) return polys;
+  }
+  flush();
+  return polys;
+}
+function signedArea(poly) {
+  let s = 0;
+  for (let k = 0; k < poly.length; k++) {
+    const [x1, y1] = poly[k];
+    const [x2, y2] = poly[(k + 1) % poly.length];
+    s += x1 * y2 - x2 * y1;
+  }
+  return s / 2;
+}
+function inside(pt, poly) {
+  let hit = false;
+  for (let k = 0, j = poly.length - 1; k < poly.length; j = k++) {
+    const [xi, yi] = poly[k];
+    const [xj, yj] = poly[j];
+    if (yi > pt[1] !== yj > pt[1] && pt[0] < (xj - xi) * (pt[1] - yi) / (yj - yi) + xi) hit = !hit;
+  }
+  return hit;
+}
+function filledCounters(elements) {
+  const out = [];
+  const stack = [];
+  for (const el of elements) {
+    if (el.closing) {
+      const at = stack.map((s) => s.name).lastIndexOf(el.name);
+      if (at >= 0) stack.length = at;
+      continue;
+    }
+    const parent = stack[stack.length - 1];
+    const rule = styleProp(el, "fill-rule") ?? parent?.rule;
+    const fill = styleProp(el, "fill") ?? parent?.fill;
+    if (!el.selfClosing) stack.push({ name: el.name, rule, fill });
+    if (el.name !== "path") continue;
+    if ((rule ?? "nonzero").toLowerCase() === "evenodd" || (fill ?? "").toLowerCase() === "none") continue;
+    const polys = subpathPolygons(el.attrs["d"] ?? "");
+    if (polys === null || polys.length < 2 || polys.length > MAX_SUBPATHS) continue;
+    const areas = polys.map(signedArea);
+    for (let inner = 0; inner < polys.length; inner++) {
+      const ia = areas[inner];
+      if (Math.abs(ia) < 1e-9) continue;
+      let around = 0;
+      let nearest = -1;
+      for (let outer = 0; outer < polys.length; outer++) {
+        if (outer === inner) continue;
+        const oa = areas[outer];
+        if (Math.abs(oa) <= Math.abs(ia)) continue;
+        const op = polys[outer];
+        if (!polys[inner].every((p) => inside(p, op))) continue;
+        around += Math.sign(oa);
+        if (nearest < 0 || Math.abs(oa) < Math.abs(areas[nearest])) nearest = outer;
+      }
+      if (around !== 0 && Math.sign(around) === Math.sign(ia)) {
+        out.push({ element: el, inner: inner + 1, outer: nearest + 1 });
+      }
+    }
+  }
+  return out;
+}
+function ruleFilledCounter(elements, file) {
+  return filledCounters(elements).map((c) => ({
+    rule: "svg-structure-filled-counter",
+    file,
+    line: c.element.line,
+    snippet: `<path> subpath ${c.inner} sits inside subpath ${c.outer} with the same winding under nonzero, so the counter paints \u2014 wind the inner contour the other way, or declare fill-rule="evenodd"`,
+    severity: "warning"
+  }));
+}
+
+// src/scripts/_lib/svg_urls.ts
+function svgPrefixes(content) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /xmlns:([\w.-]+)\s*=\s*["']http:\/\/www\.w3\.org\/2000\/svg["']/gi;
+  let m;
+  while ((m = re.exec(content)) !== null) out.add((m[1] ?? "").toLowerCase());
+  return out;
+}
+function localName(name, prefixes) {
+  const colon = name.indexOf(":");
+  return colon !== -1 && prefixes.has(name.slice(0, colon)) ? name.slice(colon + 1) : name;
+}
+function rawAttrs(raw) {
+  const out = {};
+  const re = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>"'`=]+))/g;
+  let m;
+  while ((m = re.exec(raw)) !== null) out[(m[1] ?? "").toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? "";
+  return out;
+}
+var URL_ATTRS = /* @__PURE__ */ new Set(["href", "xlink:href", "src"]);
+var isActiveUrl = (raw) => /^(javascript:|data:text\/html)/i.test(resolvedUrl(raw));
+var NAMED_URL_ENTITIES = {
+  colon: ":",
+  sol: "/",
+  tab: "	",
+  newline: "\n",
+  period: ".",
+  lpar: "(",
+  rpar: ")",
+  amp: "&"
+};
+function resolvedUrl(raw) {
+  const decoded = raw.replace(/&(?:#x([0-9a-f]+)|#(\d+)|([a-z]+));?/gi, (m, hex, dec, name) => {
+    const cp = hex ? parseInt(hex, 16) : dec ? parseInt(dec, 10) : NaN;
+    if (!Number.isNaN(cp)) return cp <= 1114111 ? String.fromCodePoint(cp) : m;
+    return NAMED_URL_ENTITIES[name.toLowerCase()] ?? m;
+  });
+  return decoded.replace(/^[\u0000- ]+|[\u0000- ]+$/g, "").replace(/[\t\n\r]/g, "");
+}
+function cssUnescape(raw) {
+  return raw.replace(/\\([0-9a-f]{1,6})\s?|\\(.)/gi, (m, hex, ch) => {
+    if (hex) {
+      const cp = parseInt(hex, 16);
+      return cp <= 1114111 ? String.fromCodePoint(cp) : m;
+    }
+    return ch;
+  });
+}
+
+// src/scripts/_lib/svg_motion.ts
+var SMIL_TAGS = /* @__PURE__ */ new Set([
+  "animate",
+  "animatetransform",
+  "animatemotion",
+  "animatecolor",
+  "set"
+]);
+var SMIL_MARKUP_RE = /<(animate|animateTransform|animateMotion|animateColor|set)\b/i;
+var REDUCED_MOTION_RE = /@media[^{]*prefers-reduced-motion/i;
+function hasSmilMarkup(content) {
+  return SMIL_MARKUP_RE.test(content);
+}
+function hasCssAnimation(content) {
+  return /@keyframes\s+[\w-]+/i.test(content) || /\banimation(?:-name)?\s*:/i.test(content);
+}
+function hasReducedMotionQuery(content) {
+  return REDUCED_MOTION_RE.test(content);
+}
+function lineIndexer(content) {
+  const starts = [0];
+  for (let i = 0; i < content.length; i++) if (content[i] === "\n") starts.push(i + 1);
+  return (offset) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  };
+}
+function matchBrace(css, open) {
+  let depth = 0;
+  for (let i = open; i < css.length; i++) {
+    if (css[i] === "{") depth += 1;
+    else if (css[i] === "}") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function collectRules(css, base, atRule, lineOf, out) {
+  let i = 0;
+  while (i < css.length) {
+    const brace = css.indexOf("{", i);
+    if (brace === -1) break;
+    const prelude = css.slice(i, brace).trim();
+    const end = matchBrace(css, brace);
+    if (end === -1) break;
+    const body = css.slice(brace + 1, end);
+    if (prelude.startsWith("@")) {
+      collectRules(body, base + brace + 1, prelude, lineOf, out);
+    } else if (prelude) {
+      out.push({ selector: prelude, body, line: lineOf(base + i), atRule });
+    }
+    i = end + 1;
+  }
+}
+function readCssRules(content) {
+  const rules = [];
+  const lineOf = lineIndexer(content);
+  const styleRe = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi;
+  let sm;
+  while ((sm = styleRe.exec(content)) !== null) {
+    const css = (sm[1] ?? "").replace(/\/\*[\s\S]*?\*\//g, (c) => c.replace(/[^\n]/g, " "));
+    const base = sm.index + (sm[0] ?? "").indexOf(sm[1] ?? "");
+    collectRules(css, base, "", lineOf, rules);
+  }
+  return rules;
+}
+function declarationsOf(body) {
+  const out = {};
+  for (const decl of body.split(";")) {
+    const idx = decl.indexOf(":");
+    if (idx === -1) continue;
+    const prop = decl.slice(0, idx).trim().toLowerCase();
+    if (!prop || prop.startsWith("@") || prop.includes("{")) continue;
+    out[prop] = decl.slice(idx + 1).trim();
+  }
+  return out;
+}
+function reducedMotionReachesSmil(content) {
+  const scoped = readCssRules(content).filter((r) => /prefers-reduced-motion/i.test(r.atRule));
+  for (const rule of scoped) {
+    for (const prop of Object.keys(declarationsOf(rule.body))) {
+      if (prop === "animation" || prop.startsWith("animation-")) continue;
+      if (prop === "transition" || prop.startsWith("transition-")) continue;
+      return true;
+    }
+  }
+  if (/begin\s*=\s*["']indefinite["']/i.test(content)) return true;
+  return false;
+}
+function smilVerdict(content) {
+  if (!hasSmilMarkup(content)) return "no-smil";
+  if (!hasReducedMotionQuery(content)) return "no-route";
+  return reducedMotionReachesSmil(content) ? "routed" : "css-only";
+}
+function firstSmilLine(content) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (SMIL_MARKUP_RE.test(lines[i] ?? "")) return i + 1;
+  }
+  return 1;
+}
+
+// src/scripts/_lib/svg_rules.ts
+var DELIVERY_MODES = ["inline", "document", "img", "css-bg"];
+function parseElements(content) {
+  const out = [];
+  const lineOf = lineIndexer2(content);
+  let i = 0;
+  while (i < content.length) {
+    const lt = content.indexOf("<", i);
+    if (lt === -1) break;
+    if (content.startsWith("<!--", lt)) {
+      const end = content.indexOf("-->", lt + 4);
+      i = end === -1 ? content.length : end + 3;
+      continue;
+    }
+    if (content.startsWith("<![CDATA[", lt)) {
+      const end = content.indexOf("]]>", lt + 9);
+      i = end === -1 ? content.length : end + 3;
+      continue;
+    }
+    if (content.startsWith("<?", lt)) {
+      const end = content.indexOf("?>", lt + 2);
+      i = end === -1 ? content.length : end + 2;
+      continue;
+    }
+    if (content.startsWith("<!", lt)) {
+      const bracket = content.indexOf("[", lt);
+      const close = content.indexOf(">", lt);
+      if (bracket !== -1 && close !== -1 && bracket < close) {
+        const endBracket = content.indexOf("]", bracket);
+        const after = endBracket === -1 ? close : content.indexOf(">", endBracket);
+        i = after === -1 ? content.length : after + 1;
+      } else {
+        i = close === -1 ? content.length : close + 1;
+      }
+      continue;
+    }
+    const gt = tagEnd(content, lt);
+    if (gt === -1) break;
+    const raw = content.slice(lt, gt + 1);
+    const closing = raw.startsWith("</");
+    const selfClosing = raw.endsWith("/>");
+    const nameMatch = /^<\/?\s*([A-Za-z_][\w.:-]*)/.exec(raw);
+    if (!nameMatch) {
+      i = gt + 1;
+      continue;
+    }
+    out.push({
+      name: (nameMatch[1] ?? "").toLowerCase(),
+      attrs: closing ? {} : attrsOf(raw),
+      line: lineOf(lt),
+      start: lt,
+      selfClosing,
+      closing,
+      raw
+    });
+    i = gt + 1;
+  }
+  return out;
+}
+function maskComments(content) {
+  if (!content.includes("<!--")) return content;
+  const out = content.split("");
+  let i = 0;
+  while (i < out.length) {
+    const start = content.indexOf("<!--", i);
+    if (start === -1) break;
+    const close = content.indexOf("-->", start + 4);
+    const end = close === -1 ? content.length : close + 3;
+    for (let j = start; j < end; j += 1) {
+      if (out[j] !== "\n" && out[j] !== "\r") out[j] = " ";
+    }
+    i = end;
+  }
+  return out.join("");
+}
+function lineIndexer2(content) {
+  const starts = [0];
+  for (let i = 0; i < content.length; i++) if (content[i] === "\n") starts.push(i + 1);
+  return (offset) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  };
+}
+function textOf(content, elements, index) {
+  const el = elements[index];
+  if (!el || el.selfClosing) return "";
+  const openEnd = content.indexOf(">", el.start);
+  const closeTag = `</${el.name}`;
+  const closeAt = content.toLowerCase().indexOf(closeTag, openEnd);
+  if (openEnd === -1 || closeAt === -1) return "";
+  return content.slice(openEnd + 1, closeAt);
+}
+function readViewBox(el) {
+  const raw = el?.attrs["viewbox"];
+  if (!raw) return null;
+  const parts = raw.trim().split(/[\s,]+/).map(Number);
+  if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n))) return null;
+  const [x, y, w, h] = parts;
+  if (w <= 0 || h <= 0) return null;
+  return { x, y, w, h };
+}
+function referencedIds(content, elements) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const el of elements) {
+    for (const key of ["href", "xlink:href"]) {
+      const v = el.attrs[key];
+      if (v && v.startsWith("#")) ids.add(v.slice(1));
+    }
+  }
+  const urlRe = /url\(\s*['"]?#([^)'"\s]+)/g;
+  let m;
+  while ((m = urlRe.exec(content)) !== null) ids.add(m[1]);
+  const beginRe = /\b(?:begin|end)\s*=\s*"([A-Za-z_][\w.:-]*)\./g;
+  while ((m = beginRe.exec(content)) !== null) ids.add(m[1]);
+  return ids;
+}
+function ruleMissingXmlns(elements, file) {
+  const root = elements.find((el) => el.name === "svg" && !el.closing);
+  if (!root) return [];
+  if (root.attrs["xmlns"]) return [];
+  return [
+    {
+      rule: "svg-structure-missing-xmlns",
+      file,
+      line: root.line,
+      snippet: "root <svg> has no xmlns \u2014 the file does not render as a standalone document or through <img>",
+      severity: "error"
+    }
+  ];
+}
+function buildContainerDepth(elements) {
+  const stack = [];
+  const out = /* @__PURE__ */ new Map();
+  elements.forEach((el, idx) => {
+    if (el.closing) {
+      if (stack[stack.length - 1] === el.name) stack.pop();
+      out.set(idx, [...stack]);
+      return;
+    }
+    out.set(idx, [...stack]);
+    if (!el.selfClosing) stack.push(el.name);
+  });
+  return out;
+}
+var NON_RENDERED_CONTAINERS = /* @__PURE__ */ new Set(["defs", "symbol", "clippath", "mask", "marker", "pattern"]);
+function ruleOutsideViewBox(elements, file) {
+  const root = elements.find((el) => el.name === "svg" && !el.closing);
+  const vb = readViewBox(root);
+  if (!vb) return [];
+  const ancestry = buildContainerDepth(elements);
+  const findings = [];
+  elements.forEach((el, idx) => {
+    if (el.closing) return;
+    const chain = ancestry.get(idx) ?? [];
+    if (chain.some((c) => NON_RENDERED_CONTAINERS.has(c))) return;
+    if (chain.length && hasTransformedAncestor(elements, idx)) return;
+    const box = staticBox(el);
+    if (!box) return;
+    const outside = box.maxX <= vb.x || box.minX >= vb.x + vb.w || box.maxY <= vb.y || box.minY >= vb.y + vb.h;
+    if (!outside) return;
+    findings.push({
+      rule: "svg-structure-outside-viewbox",
+      file,
+      line: el.line,
+      snippet: `<${el.name}> box (${box.minX},${box.minY})-(${box.maxX},${box.maxY}) lies entirely outside viewBox ${vb.x} ${vb.y} ${vb.w} ${vb.h} \u2014 it will never paint`,
+      severity: "error"
+    });
+  });
+  return findings;
+}
+function hasTransformedAncestor(elements, index) {
+  const stack = [];
+  for (let i = 0; i < index; i++) {
+    const el = elements[i];
+    if (el.closing) {
+      if (stack[stack.length - 1]?.name === el.name) stack.pop();
+      continue;
+    }
+    if (!el.selfClosing) stack.push(el);
+  }
+  return stack.some((el) => Boolean(el.attrs["transform"]));
+}
+function ruleUnparseablePath(elements, file) {
+  const findings = [];
+  for (const el of elements) {
+    if (el.closing) continue;
+    const d = el.attrs["d"];
+    if (d === void 0) continue;
+    const err = pathDataError(d);
+    if (err) {
+      findings.push({
+        rule: "svg-structure-unparseable-path",
+        file,
+        line: el.line,
+        snippet: `<${el.name} d="\u2026"> ${err}`,
+        severity: "error"
+      });
+    }
+  }
+  return findings;
+}
+function ruleUnusedDefs(content, elements, file) {
+  const used = referencedIds(content, elements);
+  const ancestry = buildContainerDepth(elements);
+  const findings = [];
+  elements.forEach((el, idx) => {
+    if (el.closing) return;
+    const id = el.attrs["id"];
+    if (!id) return;
+    const chain = ancestry.get(idx) ?? [];
+    if (!chain.includes("defs")) return;
+    if (el.name === "symbol") return;
+    if (used.has(id)) return;
+    findings.push({
+      rule: "svg-structure-unused-defs",
+      file,
+      line: el.line,
+      snippet: `<${el.name} id="${id}"> sits in <defs> and nothing in this file references it`,
+      severity: "warning"
+    });
+  });
+  return findings;
+}
+function ruleDanglingReference(content, elements, file) {
+  const defined = /* @__PURE__ */ new Set();
+  for (const el of elements) if (!el.closing && el.attrs["id"]) defined.add(el.attrs["id"]);
+  const findings = [];
+  const lineOf = lineIndexer2(content);
+  for (const el of elements) {
+    if (el.closing) continue;
+    for (const key of ["href", "xlink:href"]) {
+      const v = el.attrs[key];
+      if (!v || !v.startsWith("#")) continue;
+      const id = v.slice(1);
+      if (defined.has(id)) continue;
+      findings.push({
+        rule: "svg-structure-dangling-reference",
+        file,
+        line: el.line,
+        snippet: `<${el.name} ${key}="${v}"> points at an id this file does not define`,
+        severity: "error"
+      });
+    }
+  }
+  const urlRe = /url\(\s*['"]?#([^)'"\s]+)/g;
+  let m;
+  while ((m = urlRe.exec(content)) !== null) {
+    const id = m[1];
+    if (defined.has(id)) continue;
+    findings.push({
+      rule: "svg-structure-dangling-reference",
+      file,
+      line: lineOf(m.index),
+      snippet: `url(#${id}) points at an id this file does not define`,
+      severity: "error"
+    });
+  }
+  return dedupe(findings);
+}
+function safetySeverity(mode) {
+  return mode === "img" || mode === "css-bg" ? "inert" : "error";
+}
+var ACTIVE_ATTR_RE = /\son[a-z]+\s*=\s*(["']|[^\s>"'])/i;
+var ACTIVE_ELEMENTS = /* @__PURE__ */ new Set(["script", "foreignobject", "iframe", "embed", "object"]);
+function ruleActiveContent(content, elements, file, mode) {
+  const severity = safetySeverity(mode);
+  const findings = [];
+  const lineOf = lineIndexer2(content);
+  const prefixes = svgPrefixes(content);
+  for (const el of elements) {
+    if (el.closing) continue;
+    const local = localName(el.name, prefixes);
+    const smil = local === "set" || local === "animate" ? rawAttrs(el.raw) : null;
+    const animatesHref = smil !== null && /^(xlink:)?href$/i.test(resolvedUrl(smil["attributename"] ?? ""));
+    if (animatesHref && ["to", "from", "by", "values"].some((k) => (smil[k] ?? "").split(";").some(isActiveUrl))) {
+      findings.push({
+        rule: "svg-safety-active-content",
+        file,
+        line: el.line,
+        snippet: `<${el.name} attributeName="href"> animates in an active URL; delivery mode "${mode}" grades it ${severity}`,
+        severity
+      });
+    }
+    if (ACTIVE_ELEMENTS.has(local)) {
+      findings.push({
+        rule: "svg-safety-active-content",
+        file,
+        line: el.line,
+        snippet: `<${el.name}> is active content; delivery mode "${mode}" grades it ${severity}`,
+        severity
+      });
+    }
+    for (const [key, value] of Object.entries(el.attrs)) {
+      if (/^on[a-z]+$/.test(key)) {
+        findings.push({
+          rule: "svg-safety-active-content",
+          file,
+          line: el.line,
+          snippet: `<${el.name} ${key}="\u2026"> is an event handler; delivery mode "${mode}" grades it ${severity}`,
+          severity
+        });
+      }
+      if (/^javascript:/i.test(resolvedUrl(value)) || URL_ATTRS.has(key) && isActiveUrl(value)) {
+        findings.push({
+          rule: "svg-safety-active-content",
+          file,
+          line: el.line,
+          snippet: `<${el.name} ${key}="${resolvedUrl(value).slice(0, 16)}\u2026"> is an active URL; delivery mode "${mode}" grades it ${severity}`,
+          severity
+        });
+      }
+    }
+  }
+  if (!findings.length && ACTIVE_ATTR_RE.test(content)) {
+    const idx = content.search(ACTIVE_ATTR_RE);
+    findings.push({
+      rule: "svg-safety-active-content",
+      file,
+      line: lineOf(idx),
+      snippet: `an on* event handler attribute is present; delivery mode "${mode}" grades it ${severity}`,
+      severity
+    });
+  }
+  return dedupe(findings);
+}
+function ruleInternalSubset(content, file) {
+  const lineOf = lineIndexer2(content);
+  const findings = [];
+  const entity = /<!ENTITY\b/i.exec(content);
+  if (entity) {
+    findings.push({
+      rule: "svg-safety-internal-subset",
+      file,
+      line: lineOf(entity.index),
+      snippet: "<!ENTITY declaration \u2014 an entity-expansion surface; a bare public DOCTYPE is clean, this is not",
+      severity: "error"
+    });
+  }
+  const doctype = /<!DOCTYPE[^>[]*\[/i.exec(content);
+  if (doctype) {
+    findings.push({
+      rule: "svg-safety-internal-subset",
+      file,
+      line: lineOf(doctype.index),
+      snippet: 'DOCTYPE carries an internal subset "[\u2026]" \u2014 strip it; a bare public DOCTYPE is clean',
+      severity: "error"
+    });
+  }
+  return dedupe(findings);
+}
+var EXTERNAL_URL_RE = /^(?:https?:|ftp:|\/\/)/i;
+function ruleExternalReference(content, elements, file, mode) {
+  const severity = safetySeverity(mode);
+  const findings = [];
+  const lineOf = lineIndexer2(content);
+  for (const el of elements) {
+    if (el.closing) continue;
+    for (const key of ["href", "xlink:href", "src"]) {
+      const v = el.attrs[key];
+      if (v && EXTERNAL_URL_RE.test(resolvedUrl(v))) {
+        findings.push({
+          rule: "svg-safety-external-reference",
+          file,
+          line: el.line,
+          snippet: `<${el.name} ${key}="${v.slice(0, 60)}"> loads from outside the file; mode "${mode}" grades it ${severity}`,
+          severity
+        });
+      }
+    }
+  }
+  const urlRe = /url\(\s*['"]?((?:https?:|ftp:|\/\/)[^)'"\s]+)/gi;
+  let m;
+  while ((m = urlRe.exec(content)) !== null) {
+    findings.push({
+      rule: "svg-safety-external-reference",
+      file,
+      line: lineOf(m.index),
+      snippet: `url(${(m[1] ?? "").slice(0, 60)}) loads from outside the file; mode "${mode}" grades it ${severity}`,
+      severity
+    });
+  }
+  const importRe = /@import\s+(?:url\(\s*)?(['"])([^'"]*)\1/gi;
+  while ((m = importRe.exec(content)) !== null) {
+    const target = resolvedUrl(cssUnescape(resolvedUrl(m[2] ?? "")));
+    if (!EXTERNAL_URL_RE.test(target)) continue;
+    findings.push({
+      rule: "svg-safety-external-reference",
+      file,
+      line: lineOf(m.index),
+      snippet: `@import "${target.slice(0, 60)}" loads from outside the file; mode "${mode}" grades it ${severity}`,
+      severity
+    });
+  }
+  return dedupe(findings);
+}
+var VECTOR_GEOMETRY = /* @__PURE__ */ new Set([
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "textpath",
+  "use"
+]);
+function vectorVerdict(elements) {
+  let raster = 0;
+  let vector = 0;
+  for (const el of elements) {
+    if (el.closing) continue;
+    if (el.name === "image") {
+      raster += 1;
+      continue;
+    }
+    if (el.name === "foreignobject") {
+      raster += 1;
+      continue;
+    }
+    if (VECTOR_GEOMETRY.has(el.name)) vector += 1;
+  }
+  if (raster > 0) {
+    return {
+      trueVector: false,
+      rasterElements: raster,
+      vectorElements: vector,
+      reason: `carries ${raster} raster/foreignObject element(s) \u2014 not a true vector whatever else it contains`
+    };
+  }
+  return {
+    trueVector: vector > 0,
+    rasterElements: 0,
+    vectorElements: vector,
+    reason: vector > 0 ? `${vector} vector geometry element(s), no embedded raster` : "no painted geometry at all"
+  };
+}
+function ruleEmbeddedRaster(elements, file) {
+  const verdict = vectorVerdict(elements);
+  if (verdict.rasterElements === 0) return [];
+  const first = elements.find((el) => !el.closing && (el.name === "image" || el.name === "foreignobject"));
+  return [
+    {
+      rule: "svg-vector-embedded-raster",
+      file,
+      line: first?.line ?? 1,
+      snippet: `${verdict.reason}; ${verdict.vectorElements} vector element(s) beside it does not make it one`,
+      severity: "error"
+    }
+  ];
+}
+var GENERIC_IDS = /* @__PURE__ */ new Set([
+  "title",
+  "desc",
+  "a",
+  "b",
+  "c",
+  "g",
+  "gradient",
+  "grad",
+  "mask",
+  "clip",
+  "clippath",
+  "shadow",
+  "icon",
+  "path",
+  "path1",
+  "layer1",
+  "layer_1",
+  "svg",
+  "defs",
+  "filter",
+  "glow"
+]);
+function ruleGenericId(elements, file) {
+  const findings = [];
+  for (const el of elements) {
+    if (el.closing) continue;
+    const id = el.attrs["id"];
+    if (!id) continue;
+    if (!GENERIC_IDS.has(id.toLowerCase())) continue;
+    findings.push({
+      rule: "svg-a11y-generic-id",
+      file,
+      line: el.line,
+      snippet: `id="${id}" collides with any second graphic inlined on the same page \u2014 namespace it`,
+      severity: "warning"
+    });
+  }
+  return findings;
+}
+function isDirectChildOfRoot(elements, index) {
+  let depth = 0;
+  for (let i = 0; i < index; i++) {
+    const el = elements[i];
+    if (el.closing) depth -= 1;
+    else if (!el.selfClosing) depth += 1;
+  }
+  return depth === 1;
+}
+function directChildrenOfRoot(doc) {
+  const root = doc.elements.find((el) => el.name === "svg");
+  if (root === void 0) return [];
+  return root.children.filter((n) => n.kind === "element");
+}
+function ruleDegenerateGradient(elements, file) {
+  const findings = [];
+  const open = [];
+  for (const el of elements) {
+    if (el.name === "lineargradient" || el.name === "radialgradient") {
+      if (el.closing) {
+        const g = open.pop();
+        if (!g || g.stops.length < 2) continue;
+        const first = g.stops[0];
+        const same = g.stops.every((s) => s.color === first.color && s.opacity === first.opacity);
+        if (!same) continue;
+        findings.push({
+          rule: "svg-structure-degenerate-gradient",
+          file,
+          line: g.el.line,
+          snippet: `<${g.el.name} id="${g.el.attrs["id"] ?? ""}"> has ${String(g.stops.length)} stops, all ${first.color || "(inherited)"} at opacity ${first.opacity} \u2014 a flat fill in a gradient's clothes, which costs bytes and makes the file harder to edit`,
+          severity: "warning"
+        });
+      } else if (!el.selfClosing) {
+        open.push({ el, stops: [] });
+      }
+      continue;
+    }
+    if (el.name === "stop" && !el.closing) {
+      const host = open[open.length - 1];
+      if (!host) continue;
+      const style = el.attrs["style"] ?? "";
+      const fromStyle = /stop-color\s*:\s*([^;]+)/i.exec(style)?.[1];
+      const opacityFromStyle = /stop-opacity\s*:\s*([^;]+)/i.exec(style)?.[1];
+      host.stops.push({
+        color: (fromStyle ?? el.attrs["stop-color"] ?? "").trim().toLowerCase(),
+        opacity: (opacityFromStyle ?? el.attrs["stop-opacity"] ?? "1").trim()
+      });
+    }
+  }
+  return findings;
+}
+function ruleWellFormed(doc, file) {
+  if (doc.errors.length === 0) return [];
+  const shown = doc.errors.slice(0, 5);
+  const more = doc.errors.length - shown.length;
+  return shown.map((e, i) => ({
+    rule: "svg-structure-not-well-formed",
+    file,
+    line: e.line,
+    snippet: `${e.message} (column ${String(e.column)})` + (i === shown.length - 1 && more > 0 ? ` \u2014 and ${String(more)} further error(s)` : ""),
+    severity: "error"
+  }));
+}
+function rootNameState(content, doc, elements) {
+  const rootIdx = elements.findIndex((el) => el.name === "svg" && !el.closing);
+  const root = rootIdx === -1 ? void 0 : elements[rootIdx];
+  const titleIdx = elements.findIndex(
+    (el, i) => el.name === "title" && !el.closing && rootIdx !== -1 && isDirectChildOfRoot(elements, i)
+  );
+  const titleIsDirectChild = directChildrenOfRoot(doc).some((n) => n.name === "title");
+  const hasTitle = titleIsDirectChild && titleIdx !== -1 && textOf(content, elements, titleIdx).trim().length > 0;
+  const titleIds = new Set(
+    elements.filter((el) => el.name === "title" && !el.closing && el.attrs["id"]).map((el) => el.attrs["id"])
+  );
+  const labelledBy = (root?.attrs["aria-labelledby"] ?? "").trim();
+  const labelledByTargets = labelledBy.split(/\s+/).filter(Boolean);
+  const labelledByOwnTitle = labelledByTargets.length > 0 && labelledByTargets.every((id) => titleIds.has(id));
+  return {
+    root,
+    hidden: (root?.attrs["aria-hidden"] ?? "").toLowerCase() === "true",
+    hasTitle,
+    hasLabel: Boolean(root?.attrs["aria-label"]?.trim()),
+    hasLabelledBy: labelledBy.length > 0,
+    labelledByOwnTitle,
+    hasRoleImg: (root?.attrs["role"] ?? "").toLowerCase() === "img"
+  };
+}
+function ruleAccessibleName(s, file) {
+  if (!s.root) return [];
+  if (s.hidden) return [];
+  if (s.hasTitle || s.hasLabel || s.hasLabelledBy) return [];
+  return [
+    {
+      rule: "svg-a11y-no-accessible-name",
+      file,
+      line: s.root.line,
+      snippet: 'graphic has no accessible name and is not aria-hidden="true" \u2014 add role="img" with a <title>, or declare it decorative',
+      severity: "error"
+    }
+  ];
+}
+function ruleDoubleName(s, file) {
+  if (!s.root) return [];
+  const labelledByIsSeparate = s.hasLabelledBy && !s.labelledByOwnTitle;
+  const names = [s.hasLabel, labelledByIsSeparate, s.hasTitle].filter(Boolean).length;
+  if (names < 2) return [];
+  return [
+    {
+      rule: "svg-a11y-double-name",
+      file,
+      line: s.root.line,
+      snippet: "graphic declares more than one accessible name (aria-label / aria-labelledby / <title>) \u2014 only one wins and which one is renderer-dependent",
+      severity: "error"
+    }
+  ];
+}
+function ruleKeySplinesRange(elements, file) {
+  const findings = [];
+  for (const el of elements) {
+    if (el.closing) continue;
+    const raw = el.attrs["keysplines"];
+    if (!raw) continue;
+    const nums = raw.split(/[;\s,]+/).filter(Boolean).map(Number);
+    const bad = nums.filter((n) => Number.isFinite(n) && (n < 0 || n > 1));
+    if (!bad.length) continue;
+    findings.push({
+      rule: "svg-motion-keysplines-range",
+      file,
+      line: el.line,
+      snippet: `<${el.name} keySplines="${raw}"> holds ${bad.join(", ")} outside [0,1] \u2014 SMIL rejects the whole animation rather than clamping it, so the element never moves`,
+      severity: "error"
+    });
+  }
+  return findings;
+}
+function ruleTransformBox(content, elements, file) {
+  const findings = [];
+  for (const el of elements) {
+    if (el.closing) continue;
+    const style = el.attrs["style"] ?? "";
+    const decls = declarationsOf(style);
+    const origin = decls["transform-origin"] ?? el.attrs["transform-origin"];
+    if (!origin) continue;
+    if (isOriginDefault(origin)) continue;
+    const box = decls["transform-box"] ?? el.attrs["transform-box"];
+    if (box) continue;
+    findings.push({
+      rule: "svg-motion-transform-box",
+      file,
+      line: el.line,
+      snippet: `<${el.name}> sets transform-origin: ${origin} with no transform-box \u2014 in SVG the origin resolves against the view box, not the element, so the pivot lands somewhere else`,
+      severity: "error"
+    });
+  }
+  for (const rule of readCssRules(content)) {
+    const decls = declarationsOf(rule.body);
+    const origin = decls["transform-origin"];
+    if (!origin || isOriginDefault(origin)) continue;
+    if (decls["transform-box"]) continue;
+    findings.push({
+      rule: "svg-motion-transform-box",
+      file,
+      line: rule.line,
+      snippet: `selector "${rule.selector}" sets transform-origin: ${origin} with no transform-box \u2014 the pivot resolves against the view box`,
+      severity: "error"
+    });
+  }
+  return dedupe(findings);
+}
+function isOriginDefault(value) {
+  const v = value.trim().toLowerCase();
+  return v === "0 0" || v === "0px 0px" || v === "0" || v === "left top" || v === "0% 0%";
+}
+function ruleNoReducedMotion(content, elements, file) {
+  if (!hasSmilMarkup(content) && !hasCssAnimation(content)) return [];
+  if (hasReducedMotionQuery(content)) return [];
+  const line = hasSmilMarkup(content) ? firstSmilLine(content) : elements.find((el) => !el.closing)?.line ?? 1;
+  return [
+    {
+      rule: "svg-motion-no-reduced-motion",
+      file,
+      line,
+      snippet: "the file animates and carries no prefers-reduced-motion route at all \u2014 a viewer who asked the OS to stop motion still gets it",
+      severity: "error"
+    }
+  ];
+}
+function ruleSmilCssOnlyBranch(content, file) {
+  if (smilVerdict(content) !== "css-only") return [];
+  return [
+    {
+      rule: "svg-motion-smil-css-only",
+      file,
+      line: firstSmilLine(content),
+      snippet: "this file animates with SMIL and its only reduced-motion route is a CSS declaration \u2014 CSS animation/transition properties do not reach SMIL, so the animation keeps running",
+      severity: "error"
+    }
+  ];
+}
+var PATH_COMMAND_RE = /[a-zA-Z]/g;
+function ruleDMorphMismatch(elements, file) {
+  const findings = [];
+  for (const el of elements) {
+    if (el.closing) continue;
+    if (!SMIL_TAGS.has(el.name)) continue;
+    if ((el.attrs["attributename"] ?? "").toLowerCase() !== "d") continue;
+    const raw = el.attrs["values"];
+    if (!raw) continue;
+    const entries = raw.split(";").map((s) => s.trim()).filter(Boolean);
+    if (entries.length < 2) continue;
+    const shapes = entries.map((e) => (e.match(PATH_COMMAND_RE) ?? []).join("").toUpperCase());
+    const first = shapes[0];
+    const differing = shapes.findIndex((s) => s !== first);
+    if (differing === -1) continue;
+    findings.push({
+      rule: "svg-motion-d-morph-mismatch",
+      file,
+      line: el.line,
+      snippet: `<${el.name} attributeName="d"> value ${differing + 1} has command sequence "${shapes[differing]}" against "${first}" in value 1 \u2014 a path morph interpolates coordinates, not commands`,
+      severity: "error"
+    });
+  }
+  return findings;
+}
+function dedupe(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const f of findings) {
+    const key = `${f.rule}::${f.file}::${f.line}::${f.snippet}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(f);
+  }
+  return out;
+}
+function scanSvg(content, relPath, opts = {}) {
+  const mode = opts.delivery ?? "inline";
+  const elements = parseElements(content);
+  const doc = parseDocument(content);
+  const nameState = rootNameState(content, doc, elements);
+  const text = maskComments(content);
+  const raw = [
+    ...ruleWellFormed(doc, relPath),
+    // No `text` argument: the rule reads elements only, and comment
+    // skipping already happened inside `parseElements`. Passing the masked
+    // text told a reader the parameter was load-bearing (finding 12);
+    // `no-unused-vars` could not catch it because two later parameters were
+    // used.
+    ...ruleDegenerateGradient(elements, relPath),
+    ...ruleMissingXmlns(elements, relPath),
+    ...ruleOutsideViewBox(elements, relPath),
+    ...ruleUnparseablePath(elements, relPath),
+    ...ruleFilledCounter(elements, relPath),
+    ...ruleUnusedDefs(text, elements, relPath),
+    ...ruleDanglingReference(text, elements, relPath),
+    ...ruleActiveContent(text, elements, relPath, mode),
+    ...ruleInternalSubset(text, relPath),
+    ...ruleExternalReference(text, elements, relPath, mode),
+    ...ruleEmbeddedRaster(elements, relPath),
+    ...ruleGenericId(elements, relPath),
+    ...ruleAccessibleName(nameState, relPath),
+    ...ruleDoubleName(nameState, relPath),
+    ...ruleKeySplinesRange(elements, relPath),
+    ...ruleTransformBox(text, elements, relPath),
+    ...ruleNoReducedMotion(text, elements, relPath),
+    ...ruleSmilCssOnlyBranch(text, relPath),
+    ...ruleDMorphMismatch(elements, relPath)
+  ];
+  const ignores = parseIgnores(content.split("\n"));
+  return dedupe(raw).filter((f) => !isIgnored(ignores, f));
+}
+function maskScriptBodies(content) {
+  const out = content.split("");
+  const re = /<(script|style)\b[^>]*>/gi;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const bodyStart = m.index + m[0].length;
+    const close = content.toLowerCase().indexOf(`</${m[1].toLowerCase()}`, bodyStart);
+    const bodyEnd = close === -1 ? content.length : close;
+    for (let i = bodyStart; i < bodyEnd; i += 1) {
+      if (out[i] !== "\n" && out[i] !== "\r") out[i] = " ";
+    }
+    re.lastIndex = bodyEnd;
+  }
+  return out.join("");
+}
+function topLevelGraphics(text) {
+  const out = [];
+  const tagRe = /<(\/?)svg\b[^>]*?(\/?)>/gi;
+  let depth = 0;
+  let start = -1;
+  let t;
+  while ((t = tagRe.exec(text)) !== null) {
+    const closing = t[1] === "/";
+    const selfClosing = t[2] === "/";
+    if (closing) {
+      if (depth === 0) continue;
+      depth -= 1;
+      if (depth === 0 && start !== -1) {
+        out.push({ start, end: t.index + t[0].length });
+        start = -1;
+      }
+      continue;
+    }
+    if (selfClosing) {
+      if (depth === 0) out.push({ start: t.index, end: t.index + t[0].length });
+      continue;
+    }
+    if (depth === 0) start = t.index;
+    depth += 1;
+  }
+  if (depth > 0 && start !== -1) out.push({ start, end: text.length });
+  return out;
+}
+function scanHostHtml(content, relPath, opts = {}) {
+  const mode = opts.delivery ?? "inline";
+  const findings = [];
+  const lineOf = lineIndexer2(content);
+  const graphics = [];
+  const hostText = maskScriptBodies(maskComments(content));
+  for (const m of topLevelGraphics(hostText)) {
+    graphics.push({ body: content.slice(m.start, m.end), offset: m.start });
+  }
+  for (const g of graphics) {
+    const baseLine = lineOf(g.offset) - 1;
+    for (const f of scanSvg(g.body, relPath, { delivery: mode })) {
+      if (f.rule === "svg-structure-missing-xmlns") continue;
+      if (f.rule === "svg-motion-no-reduced-motion") continue;
+      if (f.rule === "svg-motion-smil-css-only") continue;
+      findings.push({ ...f, line: f.line + baseLine });
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const g of graphics) {
+    const baseLine = lineOf(g.offset) - 1;
+    for (const el of parseElements(g.body)) {
+      if (el.closing) continue;
+      const id = el.attrs["id"];
+      if (!id) continue;
+      const key = id.toLowerCase();
+      if (seen.has(key)) {
+        findings.push({
+          // ITS OWN RULE ID. Finding 4 of the fifth completion
+          // review: this error shared `svg-a11y-generic-id` with the
+          // single-graphic WARNING about a generic name, so one
+          // `svg-asset-disable svg-a11y-generic-id` — a reasonable
+          // thing to write when you have deliberately named
+          // something `icon` — silenced a real collision between two
+          // graphics as well. Two findings, two severities, two
+          // remedies; one id was one too few.
+          rule: "svg-a11y-duplicate-id",
+          file: relPath,
+          line: el.line + baseLine,
+          snippet: `id="${id}" is already used by another inline graphic on this page (line ${seen.get(key)}) \u2014 the accessibility tree names both after the first`,
+          severity: "error"
+        });
+      } else {
+        seen.set(key, el.line + baseLine);
+      }
+    }
+  }
+  const ignores = parseIgnores(content.split("\n"));
+  return dedupe(findings).filter((f) => !isIgnored(ignores, f));
+}
+function parseIgnores(lines) {
+  const ignores = /* @__PURE__ */ new Map();
+  const slot = (rule) => {
+    const found = ignores.get(rule) ?? { lines: /* @__PURE__ */ new Set(), wholeFile: false };
+    ignores.set(rule, found);
+    return found;
+  };
+  const add = (rule, line) => {
+    slot(rule).lines.add(line);
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const next = /svg-asset-disable-next-line\s+([\w-]+)/i.exec(line);
+    if (next?.[1]) add(next[1].toLowerCase(), i + 2);
+    const same = /svg-asset-disable-line\s+([\w-]+)/i.exec(line);
+    if (same?.[1]) add(same[1].toLowerCase(), i + 1);
+    const whole = /svg-asset-disable\s+([\w-]+)/i.exec(line);
+    if (whole?.[1] && !/-next-line|-line\s/.test(line)) {
+      slot(whole[1].toLowerCase()).wholeFile = true;
+    }
+  }
+  return ignores;
+}
+function isIgnored(ignores, finding) {
+  if (finding.rule.startsWith("svg-safety-")) return false;
+  const hit = ignores.get(finding.rule.toLowerCase());
+  if (hit === void 0) return false;
+  return hit.wholeFile || hit.lines.has(finding.line);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DELIVERY_MODES,
+  GENERIC_IDS,
+  VECTOR_GEOMETRY,
+  directChildrenOfRoot,
+  elementExtent,
+  maskComments,
+  parseElements,
+  parseIgnores,
+  pathDataError,
+  pathExtent,
+  pointsExtent,
+  readViewBox,
+  referencedIds,
+  safetySeverity,
+  scanHostHtml,
+  scanSvg,
+  staticBox,
+  tokenisePath,
+  vectorVerdict
+});