svg-vectordrawable 0.1.0

package/dist/browser.js

@@ -0,0 +1,1129 @@
+// src/svgo.ts
+import { optimize, _collections } from "svgo";
+
+// src/color.ts
+var NAMED = {
+  ..._collections.colorsNames ?? {},
+  transparent: "rgba(0,0,0,0)"
+};
+var clamp = (n2, min, max) => Math.min(Math.max(n2, min), max);
+var hex2 = (n2) => clamp(Math.round(n2), 0, 255).toString(16).padStart(2, "0");
+function hslToRgb(h, s, l) {
+  h = (h % 360 + 360) % 360;
+  s = clamp(s, 0, 1);
+  l = clamp(l, 0, 1);
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (h < 60) [r, g, b] = [c, x, 0];
+  else if (h < 120) [r, g, b] = [x, c, 0];
+  else if (h < 180) [r, g, b] = [0, c, x];
+  else if (h < 240) [r, g, b] = [0, x, c];
+  else if (h < 300) [r, g, b] = [x, 0, c];
+  else [r, g, b] = [c, 0, x];
+  return { r: (r + m) * 255, g: (g + m) * 255, b: (b + m) * 255, a: 1 };
+}
+function parseRgba(raw, currentColor, seen = 0) {
+  if (seen > 4) return null;
+  const value = raw.trim().toLowerCase();
+  if (value === "none") return null;
+  if (value === "currentcolor") return parseRgba(currentColor, currentColor, seen + 1);
+  if (value.startsWith("#")) {
+    const h = value.slice(1);
+    const expand = (s) => parseInt(s.length === 1 ? s + s : s, 16);
+    if (h.length === 3 || h.length === 4) {
+      return {
+        r: expand(h[0]),
+        g: expand(h[1]),
+        b: expand(h[2]),
+        a: h.length === 4 ? expand(h[3]) / 255 : 1
+      };
+    }
+    if (h.length === 6 || h.length === 8) {
+      return {
+        r: parseInt(h.slice(0, 2), 16),
+        g: parseInt(h.slice(2, 4), 16),
+        b: parseInt(h.slice(4, 6), 16),
+        a: h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1
+      };
+    }
+    return null;
+  }
+  const fn = value.match(/^(rgba?|hsla?)\(([^)]+)\)$/);
+  if (fn) {
+    const kind = fn[1];
+    const parts = fn[2].split(/[\s,/]+/).filter(Boolean);
+    const num2 = (s) => parseFloat(s ?? "0");
+    const alpha = parts[3] !== void 0 ? parts[3].endsWith("%") ? num2(parts[3]) / 100 : num2(parts[3]) : 1;
+    if (kind.startsWith("rgb")) {
+      const ch = (s) => s?.endsWith("%") ? num2(s) / 100 * 255 : num2(s);
+      return { r: ch(parts[0]), g: ch(parts[1]), b: ch(parts[2]), a: alpha };
+    }
+    const rgb = hslToRgb(num2(parts[0]), num2(parts[1]) / 100, num2(parts[2]) / 100);
+    return { ...rgb, a: alpha };
+  }
+  if (value in NAMED) return parseRgba(NAMED[value], currentColor, seen + 1);
+  return null;
+}
+function toAndroidColor(value, opacity, currentColor) {
+  if (value === void 0) return null;
+  const rgba = parseRgba(value, currentColor);
+  if (!rgba) return null;
+  const a = clamp(rgba.a * (opacity ?? 1), 0, 1);
+  return `#${hex2(a * 255)}${hex2(rgba.r)}${hex2(rgba.g)}${hex2(rgba.b)}`.toUpperCase();
+}
+
+// src/transform.ts
+var IDENTITY = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+function multiply(m1, m2) {
+  return {
+    a: m1.a * m2.a + m1.c * m2.b,
+    b: m1.b * m2.a + m1.d * m2.b,
+    c: m1.a * m2.c + m1.c * m2.d,
+    d: m1.b * m2.c + m1.d * m2.d,
+    e: m1.a * m2.e + m1.c * m2.f + m1.e,
+    f: m1.b * m2.e + m1.d * m2.f + m1.f
+  };
+}
+function applyPoint(m, x, y) {
+  return [m.a * x + m.c * y + m.e, m.b * x + m.d * y + m.f];
+}
+function scaleFactor(m) {
+  return Math.sqrt(Math.abs(m.a * m.d - m.b * m.c));
+}
+function parseTransform(transform) {
+  if (!transform) return null;
+  let m = IDENTITY;
+  let matched = false;
+  const re = /(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/gi;
+  let fn;
+  while ((fn = re.exec(transform)) !== null) {
+    const name = fn[1].toLowerCase();
+    const args = fn[2].split(/[\s,]+/).map(Number).filter((n2) => !Number.isNaN(n2));
+    let next = null;
+    switch (name) {
+      case "matrix":
+        if (args.length >= 6)
+          next = { a: args[0], b: args[1], c: args[2], d: args[3], e: args[4], f: args[5] };
+        break;
+      case "translate":
+        next = { ...IDENTITY, e: args[0] ?? 0, f: args[1] ?? 0 };
+        break;
+      case "scale":
+        next = { ...IDENTITY, a: args[0] ?? 1, d: args[1] ?? args[0] ?? 1 };
+        break;
+      case "rotate": {
+        const r = (args[0] ?? 0) * Math.PI / 180;
+        const cos = Math.cos(r);
+        const sin = Math.sin(r);
+        const rot = { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 };
+        if (args.length >= 3) {
+          const cx = args[1];
+          const cy = args[2];
+          next = multiply({ ...IDENTITY, e: cx, f: cy }, multiply(rot, { ...IDENTITY, e: -cx, f: -cy }));
+        } else next = rot;
+        break;
+      }
+      case "skewx":
+        next = { ...IDENTITY, c: Math.tan((args[0] ?? 0) * Math.PI / 180) };
+        break;
+      case "skewy":
+        next = { ...IDENTITY, b: Math.tan((args[0] ?? 0) * Math.PI / 180) };
+        break;
+    }
+    if (next) {
+      m = multiply(m, next);
+      matched = true;
+    }
+  }
+  return matched ? m : null;
+}
+function decompose(m) {
+  const { a, b, c, d, e, f } = m;
+  const scaleX = Math.hypot(a, b);
+  const rotation = Math.atan2(b, a);
+  const det = a * d - b * c;
+  const scaleY = scaleX === 0 ? 0 : det / scaleX;
+  const shear = scaleX === 0 ? 0 : (a * c + b * d) / (scaleX * scaleX);
+  return {
+    translateX: e,
+    translateY: f,
+    rotation: rotation * 180 / Math.PI,
+    scaleX,
+    scaleY,
+    hasSkew: Math.abs(shear) > 1e-4
+  };
+}
+
+// src/gradient.ts
+var SPREAD = { pad: "clamp", repeat: "repeated", reflect: "mirror" };
+var round = (v, p) => {
+  const f = 10 ** p;
+  return Math.round(v * f) / f;
+};
+function coord(value, fallback, ref) {
+  if (value === void 0) return fallback;
+  const v = value.trim();
+  if (v.endsWith("%")) return parseFloat(v) / 100 * ref;
+  const n2 = parseFloat(v);
+  return Number.isNaN(n2) ? fallback : n2;
+}
+function collectGradients(gradientEls, currentColor, _warn) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const el of gradientEls) {
+    const id = el.attributes?.id;
+    if (id) byId.set(id, el);
+  }
+  const attrsOf = (el, seen = 0) => {
+    const href = el.attributes?.href ?? el.attributes?.["xlink:href"];
+    const parent = seen < 10 && href?.startsWith("#") ? byId.get(href.slice(1)) : void 0;
+    return { ...parent ? attrsOf(parent, seen + 1) : {}, ...el.attributes };
+  };
+  const stopsOf = (el, seen = 0) => {
+    const own = (el.children ?? []).filter((c) => c.name === "stop");
+    if (own.length) return own;
+    const href = el.attributes?.href ?? el.attributes?.["xlink:href"];
+    const parent = seen < 10 && href?.startsWith("#") ? byId.get(href.slice(1)) : void 0;
+    return parent ? stopsOf(parent, seen + 1) : [];
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const el of gradientEls) {
+    const id = el.attributes?.id;
+    if (!id) continue;
+    const a = attrsOf(el);
+    const stops = stopsOf(el).map((s) => {
+      const off = s.attributes?.offset ?? "0";
+      const offset = off.endsWith("%") ? parseFloat(off) / 100 : parseFloat(off);
+      const color = toAndroidColor(
+        s.attributes?.["stop-color"] ?? "#000",
+        s.attributes?.["stop-opacity"] !== void 0 ? parseFloat(s.attributes["stop-opacity"]) : void 0,
+        currentColor
+      );
+      return color ? { offset: Number.isNaN(offset) ? 0 : offset, color } : null;
+    }).filter((s) => s !== null);
+    if (stops.length === 0) continue;
+    const tileMode = a.spreadMethod ? SPREAD[a.spreadMethod] : void 0;
+    out.set(id, {
+      type: el.name === "radialGradient" ? "radial" : "linear",
+      objectBox: (a.gradientUnits ?? "objectBoundingBox") !== "userSpaceOnUse",
+      attrs: a,
+      matrix: parseTransform(a.gradientTransform),
+      stops,
+      ...tileMode ? { tileMode } : {}
+    });
+  }
+  return out;
+}
+function resolveGradient(g, bbox, viewport, precision, warn) {
+  let base;
+  let refW;
+  let refH;
+  let refD;
+  if (g.objectBox) {
+    const bb = bbox ?? { x: 0, y: 0, width: viewport.width, height: viewport.height };
+    if (!bbox)
+      warn({
+        code: "gradient-bbox-unavailable",
+        message: "objectBoundingBox gradient could not use the path bounding box; approximated to the viewport."
+      });
+    base = multiply({ a: bb.width, b: 0, c: 0, d: bb.height, e: bb.x, f: bb.y }, g.matrix ?? IDENTITY);
+    refW = 1;
+    refH = 1;
+    refD = Math.SQRT2 / 2;
+  } else {
+    base = g.matrix ?? IDENTITY;
+    refW = viewport.width;
+    refH = viewport.height;
+    refD = Math.hypot(refW, refH) / Math.SQRT2;
+  }
+  const a = g.attrs;
+  const scale = scaleFactor(base);
+  if (g.type === "radial") {
+    const cx = coord(a.cx, 0.5 * refW, refW);
+    const cy = coord(a.cy, 0.5 * refH, refH);
+    const r = coord(a.r, 0.5 * refD, refD);
+    const [centerX, centerY] = applyPoint(base, cx, cy);
+    return {
+      type: "radial",
+      coords: {
+        centerX: round(centerX, precision),
+        centerY: round(centerY, precision),
+        gradientRadius: round(r * scale, precision)
+      },
+      stops: g.stops,
+      ...g.tileMode ? { tileMode: g.tileMode } : {}
+    };
+  }
+  const x1 = coord(a.x1, 0, refW);
+  const y1 = coord(a.y1, 0, refH);
+  const x2 = coord(a.x2, refW, refW);
+  const y2 = coord(a.y2, 0, refH);
+  const [sx, sy] = applyPoint(base, x1, y1);
+  const [ex, ey] = applyPoint(base, x2, y2);
+  return {
+    type: "linear",
+    coords: {
+      startX: round(sx, precision),
+      startY: round(sy, precision),
+      endX: round(ex, precision),
+      endY: round(ey, precision)
+    },
+    stops: g.stops,
+    ...g.tileMode ? { tileMode: g.tileMode } : {}
+  };
+}
+function renderGradient(g, pad, step) {
+  const inner = pad + step + step;
+  const coordLines = Object.entries(g.coords).map(([k, v]) => `${inner + step}android:${k}="${v}"`).join("\n");
+  const tile = g.tileMode ? `
+${inner + step}android:tileMode="${g.tileMode}"` : "";
+  const items = g.stops.map((s) => `${inner + step}<item android:offset="${s.offset}" android:color="${s.color}" />`).join("\n");
+  return `${pad + step}<aapt:attr name="android:fillColor">
+${inner}<gradient
+${coordLines}
+${inner + step}android:type="${g.type}"${tile}>
+${items}
+${inner}</gradient>
+${pad + step}</aapt:attr>`;
+}
+
+// src/normalize.ts
+var DEFAULT_CONFIG = {
+  plugins: [
+    {
+      name: "preset-default",
+      params: {
+        overrides: {
+          inlineStyles: { onlyMatchedOnce: false },
+          convertShapeToPath: { convertArcs: true },
+          // Keep ids: gradients / clip-paths are referenced by url(#id).
+          cleanupIds: { remove: false }
+        }
+      }
+    }
+  ]
+};
+function parseSvg(svg, optimizeFlag, svgoConfig) {
+  let captured = null;
+  const capture = {
+    name: "svgvd-capture",
+    fn: (root) => {
+      captured = root;
+      return {};
+    }
+  };
+  const base = optimizeFlag ? svgoConfig ?? DEFAULT_CONFIG : { plugins: [] };
+  const plugins = [...base.plugins ?? [], capture];
+  try {
+    optimize(svg, { ...base, plugins });
+  } catch (err) {
+    throw new Error(`Invalid SVG: ${err.message}`);
+  }
+  if (!captured) throw new Error("Failed to parse SVG: empty document");
+  return captured;
+}
+
+// src/pathData.ts
+var ARG_COUNT = {
+  M: 2,
+  L: 2,
+  H: 1,
+  V: 1,
+  C: 6,
+  S: 4,
+  Q: 4,
+  T: 2,
+  A: 7,
+  Z: 0
+};
+function parsePath(d) {
+  const commands = [];
+  const tokenRe = /([MmLlHhVvCcSsQqTtAaZz])|(-?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)/g;
+  const tokens = [];
+  let match;
+  while ((match = tokenRe.exec(d)) !== null) {
+    tokens.push(match[1] ?? match[2]);
+  }
+  let i = 0;
+  let prevCmd = "";
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    let cmd;
+    if (/[a-zA-Z]/.test(tok)) {
+      cmd = tok;
+      i += 1;
+    } else {
+      if (!prevCmd) break;
+      cmd = prevCmd === "M" ? "L" : prevCmd === "m" ? "l" : prevCmd;
+    }
+    const upper = cmd.toUpperCase();
+    const count = ARG_COUNT[upper];
+    if (count === void 0) break;
+    if (count === 0) {
+      commands.push({ cmd, args: [] });
+      prevCmd = cmd;
+      continue;
+    }
+    const args = [];
+    for (let k = 0; k < count; k += 1) {
+      const next = tokens[i];
+      if (next === void 0 || /[a-zA-Z]/.test(next)) break;
+      args.push(Number(next));
+      i += 1;
+    }
+    if (args.length < count) break;
+    commands.push({ cmd, args });
+    prevCmd = cmd;
+  }
+  return commands;
+}
+function pathBBox(d) {
+  const commands = parsePath(d);
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let seen = false;
+  const include = (x, y) => {
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+    seen = true;
+  };
+  const pen = { x: 0, y: 0, startX: 0, startY: 0 };
+  for (const { cmd, args } of commands) {
+    const abs = cmd === cmd.toUpperCase();
+    const upper = cmd.toUpperCase();
+    const ox = abs ? 0 : pen.x;
+    const oy = abs ? 0 : pen.y;
+    switch (upper) {
+      case "M": {
+        pen.x = ox + args[0];
+        pen.y = oy + args[1];
+        pen.startX = pen.x;
+        pen.startY = pen.y;
+        include(pen.x, pen.y);
+        break;
+      }
+      case "L": {
+        pen.x = ox + args[0];
+        pen.y = oy + args[1];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "H": {
+        pen.x = ox + args[0];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "V": {
+        pen.y = oy + args[0];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "C": {
+        include(ox + args[0], oy + args[1]);
+        include(ox + args[2], oy + args[3]);
+        pen.x = ox + args[4];
+        pen.y = oy + args[5];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "S": {
+        include(ox + args[0], oy + args[1]);
+        pen.x = ox + args[2];
+        pen.y = oy + args[3];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "Q": {
+        include(ox + args[0], oy + args[1]);
+        pen.x = ox + args[2];
+        pen.y = oy + args[3];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "T": {
+        pen.x = ox + args[0];
+        pen.y = oy + args[1];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "A": {
+        pen.x = ox + args[5];
+        pen.y = oy + args[6];
+        include(pen.x, pen.y);
+        break;
+      }
+      case "Z": {
+        pen.x = pen.startX;
+        pen.y = pen.startY;
+        break;
+      }
+    }
+  }
+  if (!seen) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function fmt(n2) {
+  if (!Number.isFinite(n2)) return "0";
+  let r = Math.round(n2 * 1e3) / 1e3;
+  if (Object.is(r, -0)) r = 0;
+  let s = r.toFixed(3).replace(/\.?0+$/, "");
+  if (s === "" || s === "-") s = "0";
+  return s;
+}
+function reflect(curr, prevControl) {
+  return 2 * curr - prevControl;
+}
+function arcToCubics(x1, y1, rxIn, ryIn, phiDeg, largeArc, sweep, x2, y2) {
+  if (rxIn === 0 || ryIn === 0 || x1 === x2 && y1 === y2) {
+    return [x1, y1, x2, y2, x2, y2];
+  }
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  const phi = phiDeg * Math.PI / 180;
+  const cosPhi = Math.cos(phi);
+  const sinPhi = Math.sin(phi);
+  const dx = (x1 - x2) / 2;
+  const dy = (y1 - y2) / 2;
+  const x1p = cosPhi * dx + sinPhi * dy;
+  const y1p = -sinPhi * dx + cosPhi * dy;
+  const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+  if (lambda > 1) {
+    const s = Math.sqrt(lambda);
+    rx *= s;
+    ry *= s;
+  }
+  const rxSq = rx * rx;
+  const rySq = ry * ry;
+  const x1pSq = x1p * x1p;
+  const y1pSq = y1p * y1p;
+  let num2 = rxSq * rySq - rxSq * y1pSq - rySq * x1pSq;
+  if (num2 < 0) num2 = 0;
+  const denom = rxSq * y1pSq + rySq * x1pSq;
+  let coef = denom === 0 ? 0 : Math.sqrt(num2 / denom);
+  if (largeArc === sweep) coef = -coef;
+  const cxp = coef * (rx * y1p) / ry;
+  const cyp = coef * -(ry * x1p) / rx;
+  const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
+  const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
+  const angle = (ux, uy, vx, vy) => {
+    const dot = ux * vx + uy * vy;
+    const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
+    let a = Math.acos(Math.min(1, Math.max(-1, len === 0 ? 1 : dot / len)));
+    if (ux * vy - uy * vx < 0) a = -a;
+    return a;
+  };
+  const theta1 = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+  let deltaTheta = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
+  if (!sweep && deltaTheta > 0) deltaTheta -= 2 * Math.PI;
+  else if (sweep && deltaTheta < 0) deltaTheta += 2 * Math.PI;
+  const segCount = Math.max(1, Math.ceil(Math.abs(deltaTheta) / (Math.PI / 2)));
+  const delta = deltaTheta / segCount;
+  const t = 4 / 3 * Math.tan(delta / 4);
+  const out = [];
+  let theta = theta1;
+  const pointAt = (a) => {
+    const cosA = Math.cos(a);
+    const sinA = Math.sin(a);
+    const ex = cosPhi * rx * cosA - sinPhi * ry * sinA + cx;
+    const ey = sinPhi * rx * cosA + cosPhi * ry * sinA + cy;
+    const dxA = -cosPhi * rx * sinA - sinPhi * ry * cosA;
+    const dyA = -sinPhi * rx * sinA + cosPhi * ry * cosA;
+    return { x: ex, y: ey, dxA, dyA };
+  };
+  for (let s = 0; s < segCount; s += 1) {
+    const p1 = pointAt(theta);
+    const thetaNext = theta + delta;
+    const p2 = pointAt(thetaNext);
+    const c1x = p1.x + t * p1.dxA;
+    const c1y = p1.y + t * p1.dyA;
+    const c2x = p2.x - t * p2.dxA;
+    const c2y = p2.y - t * p2.dyA;
+    out.push(c1x, c1y, c2x, c2y, p2.x, p2.y);
+    theta = thetaNext;
+  }
+  return out;
+}
+function toAbsolute(commands) {
+  const out = [];
+  const pen = { x: 0, y: 0, startX: 0, startY: 0 };
+  let lastCubicCx = null;
+  let lastCubicCy = null;
+  let lastQuadCx = null;
+  let lastQuadCy = null;
+  for (const { cmd, args } of commands) {
+    const abs = cmd === cmd.toUpperCase();
+    const upper = cmd.toUpperCase();
+    const ox = abs ? 0 : pen.x;
+    const oy = abs ? 0 : pen.y;
+    let producedCubic = false;
+    let producedQuad = false;
+    switch (upper) {
+      case "M": {
+        pen.x = ox + args[0];
+        pen.y = oy + args[1];
+        pen.startX = pen.x;
+        pen.startY = pen.y;
+        out.push({ cmd: "M", args: [pen.x, pen.y] });
+        break;
+      }
+      case "L": {
+        pen.x = ox + args[0];
+        pen.y = oy + args[1];
+        out.push({ cmd: "L", args: [pen.x, pen.y] });
+        break;
+      }
+      case "H": {
+        pen.x = ox + args[0];
+        out.push({ cmd: "L", args: [pen.x, pen.y] });
+        break;
+      }
+      case "V": {
+        pen.y = oy + args[0];
+        out.push({ cmd: "L", args: [pen.x, pen.y] });
+        break;
+      }
+      case "C": {
+        const c1x = ox + args[0];
+        const c1y = oy + args[1];
+        const c2x = ox + args[2];
+        const c2y = oy + args[3];
+        pen.x = ox + args[4];
+        pen.y = oy + args[5];
+        out.push({ cmd: "C", args: [c1x, c1y, c2x, c2y, pen.x, pen.y] });
+        lastCubicCx = c2x;
+        lastCubicCy = c2y;
+        producedCubic = true;
+        break;
+      }
+      case "S": {
+        const c1x = lastCubicCx !== null ? reflect(pen.x, lastCubicCx) : pen.x;
+        const c1y = lastCubicCy !== null ? reflect(pen.y, lastCubicCy) : pen.y;
+        const c2x = ox + args[0];
+        const c2y = oy + args[1];
+        pen.x = ox + args[2];
+        pen.y = oy + args[3];
+        out.push({ cmd: "C", args: [c1x, c1y, c2x, c2y, pen.x, pen.y] });
+        lastCubicCx = c2x;
+        lastCubicCy = c2y;
+        producedCubic = true;
+        break;
+      }
+      case "Q": {
+        const cqx = ox + args[0];
+        const cqy = oy + args[1];
+        pen.x = ox + args[2];
+        pen.y = oy + args[3];
+        out.push({ cmd: "Q", args: [cqx, cqy, pen.x, pen.y] });
+        lastQuadCx = cqx;
+        lastQuadCy = cqy;
+        producedQuad = true;
+        break;
+      }
+      case "T": {
+        const tcx = lastQuadCx !== null ? reflect(pen.x, lastQuadCx) : pen.x;
+        const tcy = lastQuadCy !== null ? reflect(pen.y, lastQuadCy) : pen.y;
+        pen.x = ox + args[0];
+        pen.y = oy + args[1];
+        out.push({ cmd: "Q", args: [tcx, tcy, pen.x, pen.y] });
+        lastQuadCx = tcx;
+        lastQuadCy = tcy;
+        producedQuad = true;
+        break;
+      }
+      case "A": {
+        const x2 = ox + args[5];
+        const y2 = oy + args[6];
+        const cubics = arcToCubics(
+          pen.x,
+          pen.y,
+          args[0],
+          args[1],
+          args[2],
+          args[3] !== 0,
+          args[4] !== 0,
+          x2,
+          y2
+        );
+        for (let k = 0; k + 5 < cubics.length; k += 6) {
+          out.push({
+            cmd: "C",
+            args: [
+              cubics[k],
+              cubics[k + 1],
+              cubics[k + 2],
+              cubics[k + 3],
+              cubics[k + 4],
+              cubics[k + 5]
+            ]
+          });
+        }
+        pen.x = x2;
+        pen.y = y2;
+        break;
+      }
+      case "Z": {
+        pen.x = pen.startX;
+        pen.y = pen.startY;
+        out.push({ cmd: "Z", args: [] });
+        break;
+      }
+    }
+    if (!producedCubic) {
+      lastCubicCx = null;
+      lastCubicCy = null;
+    }
+    if (!producedQuad) {
+      lastQuadCx = null;
+      lastQuadCy = null;
+    }
+  }
+  return out;
+}
+function transformPathData(d, m) {
+  const absCommands = toAbsolute(parsePath(d));
+  const parts = [];
+  for (const { cmd, args } of absCommands) {
+    if (cmd === "Z") {
+      parts.push("Z");
+      continue;
+    }
+    const mapped = [];
+    for (let k = 0; k + 1 < args.length; k += 2) {
+      const [tx, ty] = applyPoint(m, args[k], args[k + 1]);
+      mapped.push(fmt(tx), fmt(ty));
+    }
+    parts.push(cmd + mapped.join(" "));
+  }
+  return parts.join("");
+}
+
+// src/useResolver.ts
+var MAX_DEPTH = 10;
+var USE_GEOMETRY_ATTRS = /* @__PURE__ */ new Set(["href", "xlink:href", "x", "y", "width", "height", "id"]);
+var isElement = (node) => node.type === "element" && node.name !== void 0;
+function targetId(use) {
+  const href = use.attributes?.href ?? use.attributes?.["xlink:href"];
+  if (href === void 0 || !href.startsWith("#")) return void 0;
+  return href.slice(1);
+}
+function indexById(root) {
+  const byId = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    const id = node.attributes?.id;
+    if (id !== void 0 && !byId.has(id)) byId.set(id, node);
+    for (const child of node.children ?? []) visit(child);
+  };
+  visit(root);
+  return byId;
+}
+function cloneElement(node) {
+  const clone = { type: node.type };
+  if (node.name !== void 0) clone.name = node.name;
+  if (node.attributes !== void 0) clone.attributes = { ...node.attributes };
+  if (node.children !== void 0) clone.children = node.children.map(cloneElement);
+  return clone;
+}
+function buildReplacement(use, target) {
+  const clone = cloneElement(target);
+  if (clone.name === "symbol") clone.name = "g";
+  const attributes = {};
+  const useAttrs = use.attributes ?? {};
+  const x = useAttrs.x;
+  const y = useAttrs.y;
+  const baseTransform = useAttrs.transform;
+  const translate = x !== void 0 || y !== void 0 ? `translate(${x ?? "0"} ${y ?? "0"})` : void 0;
+  const transform = [baseTransform, translate].filter((t) => t !== void 0).join(" ");
+  if (transform.length > 0) attributes.transform = transform;
+  for (const [key, value] of Object.entries(useAttrs)) {
+    if (USE_GEOMETRY_ATTRS.has(key) || key === "transform") continue;
+    attributes[key] = value;
+  }
+  return { type: "element", name: "g", attributes, children: [clone] };
+}
+function resolveUses(root) {
+  const byId = indexById(root);
+  const resolveChildren = (node, depth) => {
+    const children = node.children;
+    if (children === void 0) return;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child === void 0) continue;
+      if (isElement(child) && child.name === "use") {
+        const id = depth > 0 ? targetId(child) : void 0;
+        const target = id !== void 0 ? byId.get(id) : void 0;
+        if (target !== void 0) {
+          const replacement = buildReplacement(child, target);
+          resolveChildren(replacement, depth - 1);
+          children[i] = replacement;
+          continue;
+        }
+      }
+      resolveChildren(child, depth);
+    }
+  };
+  resolveChildren(root, MAX_DEPTH);
+}
+
+// src/shapes.ts
+var n = (attrs, key, fallback = 0) => {
+  const v = attrs[key];
+  if (v === void 0) return fallback;
+  const parsed = parseFloat(v);
+  return Number.isNaN(parsed) ? fallback : parsed;
+};
+function shapeToPathData(name, attrs) {
+  switch (name) {
+    case "rect": {
+      const w = n(attrs, "width");
+      const h = n(attrs, "height");
+      if (w <= 0 || h <= 0) return null;
+      const x = n(attrs, "x");
+      const y = n(attrs, "y");
+      let rx = attrs.rx !== void 0 ? n(attrs, "rx") : n(attrs, "ry");
+      let ry = attrs.ry !== void 0 ? n(attrs, "ry") : n(attrs, "rx");
+      rx = Math.min(Math.max(rx, 0), w / 2);
+      ry = Math.min(Math.max(ry, 0), h / 2);
+      if (rx > 0 || ry > 0) {
+        return `M${x + rx},${y}h${w - 2 * rx}a${rx},${ry} 0 0 1 ${rx},${ry}v${h - 2 * ry}a${rx},${ry} 0 0 1 ${-rx},${ry}h${-(w - 2 * rx)}a${rx},${ry} 0 0 1 ${-rx},${-ry}v${-(h - 2 * ry)}a${rx},${ry} 0 0 1 ${rx},${-ry}z`;
+      }
+      return `M${x},${y}h${w}v${h}h${-w}z`;
+    }
+    case "circle": {
+      const r = n(attrs, "r");
+      if (r <= 0) return null;
+      const cx = n(attrs, "cx");
+      const cy = n(attrs, "cy");
+      return `M${cx - r},${cy}a${r},${r} 0 1 0 ${2 * r},0a${r},${r} 0 1 0 ${-2 * r},0z`;
+    }
+    case "ellipse": {
+      const rx = n(attrs, "rx");
+      const ry = n(attrs, "ry");
+      if (rx <= 0 || ry <= 0) return null;
+      const cx = n(attrs, "cx");
+      const cy = n(attrs, "cy");
+      return `M${cx - rx},${cy}a${rx},${ry} 0 1 0 ${2 * rx},0a${rx},${ry} 0 1 0 ${-2 * rx},0z`;
+    }
+    case "line":
+      return `M${n(attrs, "x1")},${n(attrs, "y1")}L${n(attrs, "x2")},${n(attrs, "y2")}`;
+    case "polyline":
+    case "polygon": {
+      const pts = (attrs.points ?? "").trim().split(/[\s,]+/).map(Number).filter((v) => !Number.isNaN(v));
+      if (pts.length < 4) return null;
+      let d = `M${pts[0]},${pts[1]}`;
+      for (let i = 2; i + 1 < pts.length; i += 2) d += `L${pts[i]},${pts[i + 1]}`;
+      return name === "polygon" ? d + "z" : d;
+    }
+    default:
+      return null;
+  }
+}
+var SHAPE_NAMES = /* @__PURE__ */ new Set(["rect", "circle", "ellipse", "line", "polyline", "polygon"]);
+
+// src/convert.ts
+var UNSUPPORTED = /* @__PURE__ */ new Set(["mask", "filter", "pattern", "image", "text", "foreignObject", "marker", "switch"]);
+var SKIP = /* @__PURE__ */ new Set([
+  "defs",
+  "symbol",
+  "metadata",
+  "title",
+  "desc",
+  "style",
+  "linearGradient",
+  "radialGradient",
+  "clipPath"
+]);
+var escapeXml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var INHERITABLE = [
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-opacity",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "color"
+];
+function parseStyle(style) {
+  if (!style) return {};
+  const out = {};
+  for (const decl of style.split(";")) {
+    const i = decl.indexOf(":");
+    if (i > 0) out[decl.slice(0, i).trim().toLowerCase()] = decl.slice(i + 1).trim();
+  }
+  return out;
+}
+function num(value, precision) {
+  const f = 10 ** precision;
+  return String(Math.round(parseFloat(value) * f) / f);
+}
+function collectByName(node, names, out) {
+  for (const child of node.children ?? []) {
+    if (child.type === "element") {
+      if (child.name && names.has(child.name)) out.push(child);
+      collectByName(child, names, out);
+    }
+  }
+}
+function convert(svg, options = {}) {
+  const {
+    optimize: optimize2 = true,
+    svgoConfig,
+    floatPrecision = 3,
+    currentColor = "#000000",
+    fillBlackForUnfilled = true,
+    strict = false,
+    indent = 4,
+    xmlTag = false,
+    tint,
+    onWarn
+  } = options;
+  const warnings = [];
+  const warn = (w) => {
+    if (strict) throw new Error(`[${w.code}] ${w.message}`);
+    warnings.push(w);
+    onWarn?.(w);
+  };
+  const root = parseSvg(svg, optimize2, svgoConfig);
+  resolveUses(root);
+  const svgEl = (root.children ?? []).find((c) => c.type === "element" && c.name === "svg");
+  if (!svgEl) throw new Error("No <svg> root element found");
+  const a = svgEl.attributes ?? {};
+  let viewBox = a.viewBox?.trim();
+  let vbParts = viewBox ? viewBox.split(/[\s,]+/).map(Number) : [];
+  if (vbParts.length !== 4 || vbParts.some(Number.isNaN)) {
+    const w = parseFloat(a.width ?? "") || 24;
+    const h = parseFloat(a.height ?? "") || 24;
+    vbParts = [0, 0, w, h];
+    viewBox = void 0;
+  }
+  const [, , vpW, vpH] = vbParts;
+  const width = parseFloat(a.width ?? "") || vpW || 24;
+  const height = parseFloat(a.height ?? "") || vpH || 24;
+  const gradientEls = [];
+  collectByName(svgEl, /* @__PURE__ */ new Set(["linearGradient", "radialGradient"]), gradientEls);
+  const gradients = collectGradients(gradientEls, currentColor, warn);
+  const clipEls = [];
+  collectByName(svgEl, /* @__PURE__ */ new Set(["clipPath"]), clipEls);
+  const clipPaths = /* @__PURE__ */ new Map();
+  for (const clip of clipEls) {
+    const id = clip.attributes?.id;
+    if (!id) continue;
+    const d = (clip.children ?? []).map(
+      (c) => c.name === "path" ? c.attributes?.d : SHAPE_NAMES.has(c.name ?? "") ? shapeToPathData(c.name, c.attributes ?? {}) : null
+    ).filter(Boolean).join("");
+    if (d) clipPaths.set(id, d);
+  }
+  const step = " ".repeat(indent);
+  let usesGradient = false;
+  const resolveStyle = (el, parent) => {
+    const attrs = el.attributes ?? {};
+    const style = parseStyle(attrs.style);
+    const get = (name) => style[name] ?? attrs[name];
+    const next = { ...parent };
+    for (const prop of INHERITABLE) {
+      const v = get(prop);
+      if (v === void 0) continue;
+      if (prop === "fill") next.fill = v;
+      else if (prop === "fill-opacity") next.fillOpacity = parseFloat(v);
+      else if (prop === "fill-rule") next.fillRule = v;
+      else if (prop === "stroke") next.stroke = v;
+      else if (prop === "stroke-opacity") next.strokeOpacity = parseFloat(v);
+      else if (prop === "stroke-width") next.strokeWidth = v;
+      else if (prop === "stroke-linecap") next.strokeLinecap = v;
+      else if (prop === "stroke-linejoin") next.strokeLinejoin = v;
+      else if (prop === "stroke-miterlimit") next.strokeMiterlimit = v;
+      else if (prop === "color") next.color = v;
+    }
+    const op = get("opacity");
+    next.opacityMul = parent.opacityMul * (op !== void 0 ? parseFloat(op) : 1);
+    return next;
+  };
+  const emitPath = (d, el, style, pad, bake) => {
+    const attrs = el.attributes ?? {};
+    const pd = bake ? transformPathData(d, bake) : d;
+    const lines = [`${pad}<path`, `${pad}${step}android:pathData="${escapeXml(pd)}"`];
+    let gradientChild = null;
+    const fillRaw = style.fill ?? (fillBlackForUnfilled ? "#000000" : "none");
+    const urlMatch = /^url\(#([^)]+)\)/.exec(fillRaw.trim());
+    if (urlMatch) {
+      const raw = gradients.get(urlMatch[1]);
+      if (raw) {
+        if (bake)
+          warn({
+            code: "gradient-under-skew",
+            message: "Gradient under a skewed/baked group may be imprecisely placed.",
+            node: "path"
+          });
+        const bbox = raw.objectBox ? pathBBox(pd) : null;
+        const resolved = resolveGradient(raw, bbox, { width: vpW, height: vpH }, floatPrecision, warn);
+        gradientChild = renderGradient(resolved, pad, step);
+        usesGradient = true;
+      } else {
+        warn({
+          code: "missing-gradient",
+          message: `Path references unknown gradient "${urlMatch[1]}"; using black.`,
+          node: "path"
+        });
+        lines.push(`${pad}${step}android:fillColor="#FF000000"`);
+      }
+    } else if (fillRaw.trim().toLowerCase() !== "none") {
+      const color = toAndroidColor(fillRaw, void 0, style.color);
+      if (color) lines.push(`${pad}${step}android:fillColor="${color}"`);
+    }
+    const fillAlpha = style.fillOpacity * style.opacityMul;
+    if (fillAlpha < 1) lines.push(`${pad}${step}android:fillAlpha="${Math.max(fillAlpha, 0)}"`);
+    if (style.fillRule === "evenodd") lines.push(`${pad}${step}android:fillType="evenOdd"`);
+    if (style.stroke && style.stroke.trim().toLowerCase() !== "none") {
+      const dash = parseStyle(attrs.style)["stroke-dasharray"] ?? attrs["stroke-dasharray"];
+      if (dash && dash.trim().toLowerCase() !== "none")
+        warn({
+          code: "unsupported-stroke-dasharray",
+          message: "stroke-dasharray is not representable on a VectorDrawable path; ignored.",
+          node: "path"
+        });
+      if (/^url\(/.test(style.stroke.trim())) {
+        warn({
+          code: "unsupported-stroke-gradient",
+          message: "Gradient strokes are not supported by VectorDrawable; stroke dropped.",
+          node: "path"
+        });
+      } else {
+        const sc = toAndroidColor(style.stroke, void 0, style.color);
+        if (sc) {
+          lines.push(`${pad}${step}android:strokeColor="${sc}"`);
+          lines.push(`${pad}${step}android:strokeWidth="${num(style.strokeWidth ?? "1", floatPrecision)}"`);
+          const sa = style.strokeOpacity * style.opacityMul;
+          if (sa < 1) lines.push(`${pad}${step}android:strokeAlpha="${Math.max(sa, 0)}"`);
+          if (style.strokeLinecap === "round" || style.strokeLinecap === "square")
+            lines.push(`${pad}${step}android:strokeLineCap="${style.strokeLinecap}"`);
+          if (style.strokeLinejoin === "round" || style.strokeLinejoin === "bevel" || style.strokeLinejoin === "miter")
+            lines.push(`${pad}${step}android:strokeLineJoin="${style.strokeLinejoin}"`);
+          if (style.strokeMiterlimit)
+            lines.push(
+              `${pad}${step}android:strokeMiterLimit="${num(style.strokeMiterlimit, floatPrecision)}"`
+            );
+        }
+      }
+    }
+    const clipD = clipRef(attrs);
+    const clip = clipD && bake ? transformPathData(clipD, bake) : clipD;
+    const body2 = gradientChild ? `${lines.join("\n")}>
+${gradientChild}
+${pad}</path>` : `${lines.join("\n")} />`;
+    return clip ? wrapClip(clip, body2, pad) : body2;
+  };
+  const clipRef = (attrs) => {
+    const m = /^url\(#([^)]+)\)/.exec((attrs["clip-path"] ?? "").trim());
+    if (!m) return null;
+    const d = clipPaths.get(m[1]);
+    if (!d) {
+      warn({ code: "missing-clip-path", message: `Unknown clip-path "${m[1]}"; ignored.`, node: "clip-path" });
+      return null;
+    }
+    return d;
+  };
+  const wrapClip = (d, body2, pad) => `${pad}<group>
+${pad}${step}<clip-path android:pathData="${escapeXml(d)}" />
+${body2.replace(/^/gm, step)}
+${pad}</group>`;
+  const r = (v) => String(Math.round(v * 10 ** floatPrecision) / 10 ** floatPrecision);
+  const walk = (el, parent, pad, bake) => {
+    const out = [];
+    for (const child of el.children ?? []) {
+      if (child.type !== "element" || !child.name) continue;
+      const name = child.name;
+      if (SKIP.has(name)) continue;
+      if (UNSUPPORTED.has(name)) {
+        warn({
+          code: "unsupported-element",
+          message: `<${name}> cannot be represented in a VectorDrawable; skipped.`,
+          node: name
+        });
+        continue;
+      }
+      const style = resolveStyle(child, parent);
+      if (name === "g") {
+        const matrix = parseTransform(child.attributes?.transform);
+        if (matrix) {
+          const dec = decompose(matrix);
+          if (bake || dec.hasSkew) {
+            if (dec.hasSkew && !bake)
+              warn({
+                code: "group-skew",
+                message: "A <g> uses skew/shear; baking the transform into path geometry.",
+                node: "g"
+              });
+            const inner = walk(child, style, pad, multiply(bake ?? IDENTITY, matrix));
+            if (inner.trim()) out.push(inner);
+          } else {
+            const inner = walk(child, style, pad + step);
+            if (inner.trim()) {
+              const attrs = [];
+              if (Math.abs(dec.translateX) > 1e-6)
+                attrs.push(`${pad}${step}android:translateX="${r(dec.translateX)}"`);
+              if (Math.abs(dec.translateY) > 1e-6)
+                attrs.push(`${pad}${step}android:translateY="${r(dec.translateY)}"`);
+              if (Math.abs(dec.rotation) > 1e-6)
+                attrs.push(`${pad}${step}android:rotation="${r(dec.rotation)}"`);
+              if (Math.abs(dec.scaleX - 1) > 1e-6)
+                attrs.push(`${pad}${step}android:scaleX="${r(dec.scaleX)}"`);
+              if (Math.abs(dec.scaleY - 1) > 1e-6)
+                attrs.push(`${pad}${step}android:scaleY="${r(dec.scaleY)}"`);
+              const head = attrs.length ? `${pad}<group
+${attrs.join("\n")}>` : `${pad}<group>`;
+              out.push(`${head}
+${inner}
+${pad}</group>`);
+            }
+          }
+        } else {
+          const inner = walk(child, style, pad, bake);
+          if (inner.trim()) out.push(inner);
+        }
+        continue;
+      }
+      let d = null;
+      if (name === "path") d = child.attributes?.d ?? null;
+      else if (SHAPE_NAMES.has(name)) d = shapeToPathData(name, child.attributes ?? {});
+      if (d) out.push(emitPath(d, child, style, pad, bake));
+      else if (name !== "use")
+        warn({ code: "empty-path", message: `<${name}> produced no drawable geometry; skipped.`, node: name });
+      else
+        warn({
+          code: "unsupported-element",
+          message: "<use> references are not resolved; skipped.",
+          node: "use"
+        });
+    }
+    return out.join("\n");
+  };
+  const rootStyle = { fillOpacity: 1, strokeOpacity: 1, color: currentColor, opacityMul: 1 };
+  const baseStyle = resolveStyle(svgEl, rootStyle);
+  const body = walk(svgEl, baseStyle, step);
+  const aapt = usesGradient ? `
+${step}xmlns:aapt="http://schemas.android.com/aapt"` : "";
+  const tintLine = tint ? `
+${step}android:tint="${tint.trim()}"` : "";
+  const decl = xmlTag ? '<?xml version="1.0" encoding="utf-8"?>\n' : "";
+  const xml = decl + `<vector xmlns:android="http://schemas.android.com/apk/res/android"${aapt}${tintLine}
+${step}android:width="${num(String(width), floatPrecision)}dp"
+${step}android:height="${num(String(height), floatPrecision)}dp"
+${step}android:viewportWidth="${num(String(vpW), floatPrecision)}"
+${step}android:viewportHeight="${num(String(vpH), floatPrecision)}">
+${body}
+</vector>
+`;
+  return { xml, warnings };
+}
+export {
+  convert
+};