// THE SOCIAL ICON'S SVG: what one may contain, and its normalized form.
//
// Pure, no imports: settingsSchema.ts (every save of a social link — Settings,
// a site's form, the homepage config) and socialLinks.ts (every render) both run
// it, so a stored icon is checked again each time it is inlined into a page.
//
// AN ALLOWLIST, TOKENIZED. An icon is inlined into every header and footer, and
// an operator pastes it from anywhere, so a text denylist is not enough: `/`
// separates attributes as well as whitespace does, a character reference spells
// `javascript:`, and a transform can join two fragments into a handler. The
// input is read once, tag by tag, and refused unless:
//   - it is ONE well-formed <svg> element: every tag either self-closes or is
//     closed in order, attributes are separated by HTML whitespace and quoted,
//     and there is no other markup (no <!…> declaration, CDATA or processing
//     instruction; an XML declaration and a DOCTYPE with no internal subset at
//     the very start, and every comment, are removed first);
//   - every element is on ELEMENTS (shapes, groups, gradients, clips, masks,
//     filters, text, and the three animation elements) — so no script,
//     foreignObject, style, a, image, iframe, object, embed, audio or video,
//     none of the HTML elements that break out of SVG, and no title or desc:
//     those two are HTML integration points, where the HTML parser reads a
//     child as HTML and can leave the icon unclosed around the rest of the
//     page. A title or desc holding text only is removed before the check
//     (the link's aria-label names the icon; the root is aria-hidden); one
//     with a child element is refused;
//   - every attribute is on ATTRIBUTES (the SVG presentation, geometry, filter
//     and animation set, plus aria-*, data-* and xmlns:*), and none is an event
//     handler (a name starting with "on");
//   - after decoding character references (numeric and named, with or without
//     the `;`) and dropping the whitespace a browser ignores in a URL, no value
//     holds `javascript:` or `vbscript:`, a backslash (a CSS escape), a CSS
//     comment, `@import`, `expression(`, or a function that can load
//     something (`image-set(`, `-webkit-image-set(`, `image(`, `cross-fade(`,
//     `-webkit-cross-fade(`, `element(`, `-moz-element(`, `src(`, `paint(`);
//     every `url(…)` points at a fragment of this icon, spelled plainly (a
//     quote may be a character reference); an `href` / `xlink:href` is a
//     plain fragment (`#id`, no reference, no space) — so every reference is
//     one scopeSvgIds rewrites; a `style` holds only presentation properties
//     (STYLE_PROPERTIES); an animation never targets anything named `href` or
//     a handler. The same rules cover an animation's to/from/values/by;
//   - every id is a plain name (`^[A-Za-z_][\w.:-]*$`), so a rendered copy can
//     prefix it safely (socialLinks.ts scopeSvgIds).
// The OUTPUT of the normalization below is checked again the same way, so no
// transform can assemble what the input check refused.

const ELEMENTS = new Set(
  [
    "svg", "g", "defs", "symbol", "use",
    "path", "rect", "circle", "ellipse", "line", "polyline", "polygon",
    "text", "tspan",
    "linearGradient", "radialGradient", "stop", "pattern", "clipPath", "mask",
    "filter", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite",
    "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR",
    "feGaussianBlur", "feMerge", "feMergeNode", "feMorphology", "feOffset",
    "animate", "animateTransform", "set",
  ].map((e) => e.toLowerCase()),
);

const ANIMATION = new Set(["animate", "animatetransform", "set"]);

const ATTRIBUTES = new Set(
  [
    // core
    "id", "class", "style", "lang", "xml:lang", "xml:space", "xmlns", "version",
    "baseProfile", "role", "focusable",
    // geometry
    "viewBox", "preserveAspectRatio", "width", "height", "x", "y", "x1", "y1",
    "x2", "y2", "cx", "cy", "r", "rx", "ry", "fx", "fy", "fr", "d", "points",
    "pathLength", "transform", "transform-origin",
    // paint and presentation
    "fill", "fill-opacity", "fill-rule", "clip-rule", "clip-path", "clipPathUnits",
    "mask", "maskUnits", "maskContentUnits", "filter", "filterUnits",
    "primitiveUnits", "stroke", "stroke-width", "stroke-linecap",
    "stroke-linejoin", "stroke-miterlimit", "stroke-dasharray",
    "stroke-dashoffset", "stroke-opacity", "opacity", "color", "display",
    "visibility", "overflow", "shape-rendering", "text-rendering",
    "image-rendering", "color-interpolation", "color-interpolation-filters",
    "color-rendering", "vector-effect", "paint-order", "mix-blend-mode",
    "isolation", "enable-background",
    // gradients and patterns
    "stop-color", "stop-opacity", "offset", "gradientUnits", "gradientTransform",
    "spreadMethod", "patternUnits", "patternContentUnits", "patternTransform",
    // text
    "font-family", "font-size", "font-weight", "font-style", "font-variant",
    "font-stretch", "text-anchor", "dominant-baseline", "alignment-baseline",
    "baseline-shift", "letter-spacing", "word-spacing", "text-decoration",
    "writing-mode", "dx", "dy", "rotate", "textLength", "lengthAdjust",
    // filter primitives
    "in", "in2", "result", "stdDeviation", "flood-color", "flood-opacity",
    "lighting-color", "operator", "k1", "k2", "k3", "k4", "mode", "values",
    "type", "tableValues", "slope", "intercept", "amplitude", "exponent",
    "radius", "edgeMode",
    // animation
    "attributeName", "attributeType", "from", "to", "by", "dur", "begin", "end",
    "repeatCount", "repeatDur", "calcMode", "keyTimes", "keySplines",
    "additive", "accumulate", "restart", "min", "max",
    // references — a fragment of this icon only (checked below)
    "href", "xlink:href",
  ].map((a) => a.toLowerCase()),
);

const ATTRIBUTE_PATTERNS = [/^aria-[a-z-]+$/, /^data-[a-z0-9_.-]+$/, /^xmlns:[a-z][a-z0-9_.-]*$/];

// An id a rendered copy can prefix (socialLinks.ts): a plain name.
export const SVG_ID_RE = /^[A-Za-z_][\w.:-]*$/;
const FRAGMENT_RE = /^#[A-Za-z_][\w.:-]*$/;

// The reasons a pasted icon is refused, by class. The editor shows them after
// the link's label, as text (React escapes it). None echoes the markup: a tag
// or attribute NAME is reduced to letters, digits and `_.:-` and cut to 40
// characters before it is named. Only the refusals a drawing program's export
// causes say how to export an acceptable file: a style (a `<style>` block or a
// `style` attribute), `<metadata>`, and an element or attribute in the
// program's own namespace (`inkscape:`, `sodipodi:`, …); an old DOCTYPE has a
// sentence of its own. An `<a>`, an `<image>`, a `<title>` with markup or a
// `src` is not something an export setting removes, so it gets no hint.
const nameOf = (name: string) => name.replace(/[^A-Za-z0-9_.:-]/g, "").slice(0, 40) || "?";
const EXPORT_HINT =
  "export it with presentation attributes rather than a style block (in Inkscape, save as Plain SVG)";
const fromDrawingProgram = (name: string) => /^(style|metadata)$/i.test(name) || name.includes(":");
const withHint = (name: string) => (fromDrawingProgram(name) ? `; ${EXPORT_HINT}` : "");
export const SVG_PROBLEM = {
  markup: "it is not one well-formed <svg> element",
  doctype: "it has a DOCTYPE with an internal subset; export it again without one, or delete the DOCTYPE",
  handler: "it has an event handler attribute",
  script: "it has a script, or a link that runs one",
  external: "it links to something outside the icon",
  style: `it has a style an icon cannot use; ${EXPORT_HINT}`,
  id: "it has an id an icon cannot use",
  viewBox: "it has no viewBox, and no numeric width and height to make one from",
  element: (name: string) => `it has an element an icon has no use for (${nameOf(name)})${withHint(name)}`,
  attribute: (name: string) => `it has an attribute an icon has no use for (${nameOf(name)})${withHint(name)}`,
} as const;

// The only properties a `style` attribute may set: presentation, never layout
// or position (an icon that paints outside its key, or over the page, is
// refused).
const STYLE_PROPERTIES = new Set([
  "fill", "stroke", "stop-color", "stop-opacity", "opacity", "fill-opacity",
  "stroke-opacity", "stroke-width", "stroke-linecap", "stroke-linejoin",
  "fill-rule", "clip-rule", "display", "visibility", "paint-order",
]);

// CSS functions that can load something, whatever attribute or style holds them.
const LOADING_FUNCTIONS =
  /(?:-webkit-)?image-set\(|(?:^|[^a-z-])image\(|(?:-webkit-)?cross-fade\(|(?:-moz-)?element\(|(?:^|[^a-z-])src\(|paint\(|@import|expression\(/i;

// A url(…) as scopeSvgIds rewrites it: a plain fragment, its quote literal or a
// character reference.
const RAW_URL_FRAGMENT = /url\(\s*(["']|&quot;|&apos;|&#34;|&#39;|&#x22;|&#x27;)?#[A-Za-z_][\w.:-]*\1\s*\)/gi;

// HTML whitespace, the only attribute separator this reads (a `/` between
// attributes, which HTML also takes, is refused as markup).
const WS = "[\\t\\n\\f\\r ]";
const TAG_RE = new RegExp(
  `<(\\/?)([A-Za-z][A-Za-z0-9_.:-]*)((?:${WS}+[^\\t\\n\\f\\r "'<>\\/=]+(?:${WS}*=${WS}*(?:"[^"]*"|'[^']*'))?)*)(${WS}*)(\\/?)>`,
  "y",
);
const ATTR_RE = new RegExp(
  `(${WS}+)([^\\t\\n\\f\\r "'<>\\/=]+)(?:${WS}*=${WS}*(?:"([^"]*)"|'([^']*)'))?`,
  "g",
);

type Attr = { name: string; value: string; raw: string };
type Tag = {
  close: boolean;
  name: string;
  attrs: Attr[];
  trailing: string; // the whitespace before `>` / `/>`
  selfClose: boolean;
  start: number;
  end: number; // index just past `>`
};

// Character references a browser decodes in an attribute value, so that the
// checks see what the browser will: numeric (decimal, hex) and named, with or
// without the `;`. Named ones are matched case-insensitively — decoding MORE
// than a browser would only makes the checks stricter.
const NAMED_REFS: Record<string, string> = {
  amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", colon: ":", tab: "\t",
  newline: "\n", nbsp: "\u00a0", lpar: "(", rpar: ")", sol: "/", bsol: "\\",
  num: "#", period: ".", excl: "!", semi: ";", comma: ",", equals: "=",
  plus: "+", dollar: "$", percnt: "%", ast: "*", lowbar: "_", hyphen: "-",
  dash: "-", quest: "?", commat: "@", lsqb: "[", rsqb: "]", lcub: "{",
  rcub: "}", verbar: "|", grave: "`", hat: "^",
};

export function decodeCharRefs(value: string): string {
  return value.replace(
    /&(#[xX][0-9a-fA-F]+|#[0-9]+|[A-Za-z][A-Za-z0-9]*);?/g,
    (m, ref: string) => {
      if (ref[0] === "#") {
        const hex = ref[1] === "x" || ref[1] === "X";
        const cp = hex ? parseInt(ref.slice(2), 16) : parseInt(ref.slice(1), 10);
        return Number.isFinite(cp) && cp > 0 && cp <= 0x10ffff ? String.fromCodePoint(cp) : "\ufffd";
      }
      return NAMED_REFS[ref.toLowerCase()] ?? m;
    },
  );
}

// Everything a browser ignores inside a URL, and case.
const squash = (v: string) => v.replace(/[\u0000-\u0020\u007f-\u00a0]+/g, "");

function attrProblem(element: string, a: Attr): string | null {
  const name = a.name.toLowerCase();
  if (name.startsWith("on")) return SVG_PROBLEM.handler;
  if (!ATTRIBUTES.has(name) && !ATTRIBUTE_PATTERNS.some((p) => p.test(name))) {
    return SVG_PROBLEM.attribute(a.name);
  }
  const decoded = decodeCharRefs(a.value);
  const tight = squash(decoded);
  const lower = tight.toLowerCase();
  if (lower.includes("javascript:") || lower.includes("vbscript:") || lower.includes("livescript:")) {
    return SVG_PROBLEM.script;
  }
  // A CSS escape can spell `url(` so no check sees it; a comment can split a
  // function name. Neither has a place in an icon's value.
  if (decoded.includes("\\") || decoded.includes("/*")) {
    return name === "style" ? SVG_PROBLEM.style : SVG_PROBLEM.external;
  }
  if (LOADING_FUNCTIONS.test(tight)) return SVG_PROBLEM.external;
  if (name === "href" || name === "xlink:href") {
    // Plain, as written: `&#35;a` or ` #a ` would name an id the render's
    // scoping cannot see.
    if (!FRAGMENT_RE.test(a.value)) return SVG_PROBLEM.external;
  }
  // Every url(…), wherever it is (a fill, a clip, a style): a fragment here,
  // and every one of them spelled so scopeSvgIds rewrites it.
  const urls = [...tight.matchAll(/url\(/gi)];
  for (const m of urls) {
    const rest = tight.slice(m.index);
    if (!/^url\((["']?)#[A-Za-z_][\w.:-]*\1\)/i.test(rest)) return SVG_PROBLEM.external;
  }
  if (urls.length > 0 && [...a.value.matchAll(RAW_URL_FRAGMENT)].length !== urls.length) {
    return SVG_PROBLEM.external;
  }
  if (name === "style") {
    for (const decl of decoded.split(";")) {
      if (!decl.trim()) continue;
      const colon = decl.indexOf(":");
      const prop = (colon < 0 ? decl : decl.slice(0, colon)).trim().toLowerCase();
      if (colon < 0 || !STYLE_PROPERTIES.has(prop)) return SVG_PROBLEM.style;
    }
  }
  if (name === "id" && !SVG_ID_RE.test(a.value)) return SVG_PROBLEM.id;
  if (ANIMATION.has(element) && name === "attributename") {
    const target = lower.trim();
    if (target.includes("href")) return SVG_PROBLEM.external;
    if (/(^|:)on/.test(target)) return SVG_PROBLEM.handler;
  }
  return null;
}

// One pass over the markup: its tags, or the first problem.
function scan(src: string): { tags: Tag[] } | { problem: string } {
  const tags: Tag[] = [];
  const stack: string[] = [];
  let i = 0;
  while (i < src.length) {
    const lt = src.indexOf("<", i);
    if (lt < 0) {
      // Only whitespace may follow the root's closing tag.
      return stack.length === 0 && tags.length > 0 && !src.slice(i).trim()
        ? { tags }
        : { problem: SVG_PROBLEM.markup };
    }
    if (stack.length === 0 && tags.length > 0) return { problem: SVG_PROBLEM.markup };
    if (stack.length === 0 && src.slice(i, lt).trim()) return { problem: SVG_PROBLEM.markup };
    if (src.startsWith("<!", lt) || src.startsWith("<?", lt)) return { problem: SVG_PROBLEM.markup };
    TAG_RE.lastIndex = lt;
    const m = TAG_RE.exec(src);
    if (!m) return { problem: SVG_PROBLEM.markup };
    const [whole, slash, name, attrText, trailing, selfSlash] = m;
    const close = slash === "/";
    const lname = name.toLowerCase();
    if (close && (attrText || selfSlash)) return { problem: SVG_PROBLEM.markup };
    if (!close) {
      if (lname === "script") return { problem: SVG_PROBLEM.script };
      if (!ELEMENTS.has(lname)) return { problem: SVG_PROBLEM.element(name) };
      if (tags.length === 0 && lname !== "svg") return { problem: SVG_PROBLEM.markup };
    }
    const attrs: Attr[] = [];
    for (const a of attrText.matchAll(ATTR_RE)) {
      attrs.push({ name: a[2], value: a[3] ?? a[4] ?? "", raw: a[0] });
    }
    for (const a of attrs) {
      const p = attrProblem(lname, a);
      if (p) return { problem: p };
    }
    if (close) {
      if (stack.pop() !== lname) return { problem: SVG_PROBLEM.markup };
    } else if (selfSlash !== "/") {
      stack.push(lname);
    }
    tags.push({
      close,
      name,
      attrs,
      trailing,
      selfClose: selfSlash === "/",
      start: lt,
      end: lt + whole.length,
    });
    i = lt + whole.length;
  }
  return stack.length === 0 && tags.length > 0 ? { tags } : { problem: SVG_PROBLEM.markup };
}

// What a pasted icon looks like before it is read: trimmed, with an XML
// declaration and a DOCTYPE (with no internal subset) removed from the very
// start, and every comment removed.
function prepare(raw: string): string {
  return raw
    .trim()
    .replace(/^<\?xml\b[^>]*\?>\s*/i, "")
    .replace(/^<!DOCTYPE\s+svg\b[^>[]*>\s*/i, "")
    .replace(/<!--[\s\S]*?-->/g, "")
    .replace(TEXT_ONLY_TITLE, "")
    .trim();
}

// A <title> or <desc> holding text only (or nothing), removed before the
// check: see the header. One with a child element stays, and is refused.
const TEXT_ONLY_TITLE = /<(title|desc)\b[^<>]*?(?:\/>|>[^<]*<\/\1\s*>)/gi;

// A paint that is not a colour: no paint (`none`, `transparent`), a paint
// server (a gradient or pattern, `url(#…)`, with or without a fallback), or
// what the element takes from its parent already. Never counted, never swapped.
const KEPT_PAINT = /^(?:none|transparent|currentcolor|inherit)$|^url\(/i;

// One solid colour however it is spelled, so `#FFF`, `#ffffff`, `white` and
// `rgb(255, 255, 255)` count as ONE colour of an icon, not four.
function paintKey(value: string): string {
  const v = value.trim().toLowerCase().replace(/\s+/g, "");
  if (v === "white") return "#ffffff";
  if (v === "black") return "#000000";
  const short = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/.exec(v);
  if (short) return `#${short[1]}${short[1]}${short[2]}${short[2]}${short[3]}${short[3]}`;
  const rgb = /^rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)$/.exec(v);
  if (rgb) {
    return `#${rgb
      .slice(1, 4)
      .map((n) => Math.min(255, Number(n)).toString(16).padStart(2, "0"))
      .join("")}`;
  }
  return v;
}

// Every fill of one tag, mapped: its `fill` attribute and any `fill:`
// declaration in its `style` (which beats the attribute). `fill-rule`,
// `fill-opacity`, strokes and gradient stops are not fills and are left alone.
function mapTagFills(tag: string, paint: (value: string) => string): string {
  return tag
    .replace(
      /(\sfill\s*=\s*)(?:"([^"]*)"|'([^']*)')/gi,
      (_m, pre: string, dq?: string, sq?: string) =>
        dq !== undefined ? `${pre}"${paint(dq)}"` : `${pre}'${paint(sq ?? "")}'`,
    )
    .replace(
      /(\sstyle\s*=\s*)(?:"([^"]*)"|'([^']*)')/gi,
      (_m, pre: string, dq?: string, sq?: string) => {
        const css = (dq ?? sq ?? "").replace(
          /(^|;)(\s*fill\s*:\s*)([^;]*)/gi,
          (_d, lead: string, prop: string, v: string) => `${lead}${prop}${paint(v)}`,
        );
        return dq !== undefined ? `${pre}"${css}"` : `${pre}'${css}'`;
      },
    );
}

// The children, tag by tag. Passed over whole, never read or changed:
//   - a <mask> (its white and black say how much shows through, not what
//     colour) and a <clipPath> (a clip never paints: only its shape counts —
//     Figma exports almost every icon as a path clipped by a
//     `<clipPath><rect fill="white"/></clipPath>`, release 11, O2b) —
//     self-closing first, so an empty `<mask …/>` or `<clipPath …/>` cannot
//     swallow everything up to the next closing tag;
//   - an animation tag, whose `fill="freeze"` / `fill="remove"` is timing.
const CHILD_TAG =
  /<(?:mask|clipPath)\b[^>]*\/>|<mask\b[\s\S]*?<\/mask\s*>|<clipPath\b[\s\S]*?<\/clipPath\s*>|<[a-zA-Z][^>]*>/gi;
const PASSED_OVER = /^<(?:mask|clipPath|animate\w*|set)\b/i;

function mapChildFills(body: string, paint: (value: string) => string): string {
  return body.replace(CHILD_TAG, (m) => (PASSED_OVER.test(m) ? m : mapTagFills(m, paint)));
}

// A root's own size as a viewBox — `0 0 W H` — when its `width` and `height`
// attributes are both positive numbers, unitless or in px. Anything else (a
// percentage, `em`, a missing or zero side) is no size.
const SVG_LENGTH_PX = /^\s*(\d+(?:\.\d+)?|\.\d+)\s*(?:px)?\s*$/i;

function viewBoxFromSize(attrs: readonly Attr[]): string | null {
  const side = (name: "width" | "height"): string | null => {
    const a = attrs.find((x) => x.name.toLowerCase() === name);
    const len = a ? SVG_LENGTH_PX.exec(a.value) : null;
    const n = len ? Number(len[1]) : NaN;
    return Number.isFinite(n) && n > 0 ? String(n) : null;
  };
  const w = side("width");
  const h = side("height");
  return w && h ? `0 0 ${w} ${h}` : null;
}

// Why a pasted icon cannot be stored, as one of SVG_PROBLEM's sentences, or
// null when normalizeSocialSvg accepts it.
export function socialSvgProblem(raw: unknown): string | null {
  if (typeof raw !== "string") return SVG_PROBLEM.markup;
  return normalize(raw).problem;
}

// Normalize an admin-provided SVG snippet for inline use in a header or a
// footer. Returns null on anything the checks above refuse, or that has no
// viewBox to scale by. Steps: read and check (above); give a root with no
// viewBox, but a numeric width and height (unitless or px), `viewBox="0 0 W
// H"` from them — a vendor's file pasted as downloaded often carries only its
// size — then strip width/height; theme a single-colour icon; add
// aria-hidden; check the result again.
//
// A SINGLE-COLOUR icon follows the theme: when its fills — the root's and its
// children's together, outside a <mask> or <clipPath> — hold at most one solid
// colour, each becomes `currentColor`, the link's colour. Drawn for one
// background, such an icon vanishes on another (X's official logo is a `<path
// fill="white">`: 1.11:1 on the light footer). An icon of TWO or more colours
// draws its shape with them (YouTube's mark is a red rounded rectangle with a
// white play triangle; flattened, it is a blank rectangle), carries its own
// contrast, and keeps every colour as pasted. Paints that are not colours
// (`none`, `url(…)`, `inherit`) are never counted or changed. Idempotent: a
// themed icon has no solid colour left.
export function normalizeSocialSvg(raw: string): string | null {
  if (typeof raw !== "string") return null;
  return normalize(raw).svg;
}

function normalize(raw: string): { svg: string | null; problem: string | null } {
  const refuse = (problem: string) => ({ svg: null, problem });
  const src = prepare(raw);
  if (/^<!DOCTYPE\b/i.test(src)) return refuse(SVG_PROBLEM.doctype);
  if (!src.startsWith("<svg") || !src.endsWith("</svg>")) return refuse(SVG_PROBLEM.markup);
  const scanned = scan(src);
  if ("problem" in scanned) return refuse(scanned.problem);
  const root = scanned.tags[0];

  // The root's opening tag, rebuilt from its own attributes (each exactly as
  // written), so a size read from inside another attribute's value can never
  // count, and stripping width/height removes those attributes and nothing else.
  let attrs = root.attrs;
  if (!attrs.some((a) => a.name.toLowerCase() === "viewbox")) {
    const box = viewBoxFromSize(attrs);
    if (box) attrs = [{ name: "viewBox", value: box, raw: ` viewBox="${box}"` }, ...attrs];
  }
  // A viewBox in single quotes has always been refused; it still is.
  if (!attrs.some((a) => a.name.toLowerCase() === "viewbox" && /^\s+viewBox\s*=\s*"/i.test(a.raw))) {
    return refuse(SVG_PROBLEM.viewBox);
  }
  attrs = attrs.filter((a) => !/^(width|height)$/i.test(a.name));
  let opening = `<${root.name}${attrs.map((a) => a.raw).join("")}${root.trailing}`;
  let body = src.slice(root.end - 1); // from the root's `>`

  const colours = new Set<string>();
  const count = (v: string) => {
    if (!KEPT_PAINT.test(v.trim())) colours.add(paintKey(v));
    return v;
  };
  mapTagFills(opening, count);
  mapChildFills(body, count);
  if (colours.size <= 1) {
    const themed = (v: string) => (KEPT_PAINT.test(v.trim()) ? v : "currentColor");
    opening = mapTagFills(opening, themed);
    body = mapChildFills(body, themed);
  }

  if (!/\sfill\s*=/i.test(opening)) {
    opening = opening.replace(/^<svg/i, '<svg fill="currentColor"');
  }
  if (!/\saria-hidden\s*=/i.test(opening)) {
    opening = opening.replace(/^<svg/i, '<svg aria-hidden="true"');
  }
  const out = opening + body;
  // The result is read and checked again: no transform above may assemble
  // what the input check refused.
  const again = scan(out);
  if ("problem" in again) return refuse(again.problem);
  return { svg: out, problem: null };
}