@pibbl/core 0.0.1

package/dist/lib/geometry/path-geometry.js

@@ -0,0 +1,557 @@
+import { arcPoint, arcSweep, TAU } from "./path-arc.js";
+const names = ["move", "line", "quadratic", "cubic", "close", "arc"];
+const widths = [2, 2, 4, 6, 0, 8];
+const storage = /* @__PURE__ */ new WeakMap();
+function state(path) {
+  const value = storage.get(path);
+  if (!value) throw new TypeError("Expected a PathGeometry.");
+  return value;
+}
+function visitPathGeometry(path, visit) {
+  const value = state(path);
+  let offset = 0;
+  for (let i = 0; i < value.count; i++) {
+    const type = value.types[i];
+    visit(type, value.data, offset);
+    offset += widths[type];
+  }
+}
+function ensureRevision(value) {
+  if (value.revision >= Number.MAX_SAFE_INTEGER) {
+    throw new RangeError("PathGeometry revision exhausted.");
+  }
+}
+function reserve(value, count, length) {
+  if (count > value.types.length) {
+    const next = new Uint8Array(Math.max(count, value.types.length * 2, 8));
+    next.set(value.types.subarray(0, value.count));
+    value.types = next;
+  }
+  if (length > value.data.length) {
+    const next = new Float64Array(Math.max(length, value.data.length * 2, 32));
+    next.set(value.data.subarray(0, value.length));
+    value.data = next;
+  }
+}
+function append(value, type, data) {
+  reserve(value, value.count + 1, value.length + data.length);
+  value.types[value.count++] = type;
+  value.data.set(data, value.length);
+  value.length += data.length;
+  updatePoint(value, type, data, 0);
+}
+function operands(segment) {
+  switch (segment.type) {
+    case "move":
+    case "line":
+      return [segment.x, segment.y];
+    case "quadratic":
+      return [segment.cpx, segment.cpy, segment.x, segment.y];
+    case "cubic":
+      return [segment.cp1x, segment.cp1y, segment.cp2x, segment.cp2y, segment.x, segment.y];
+    case "close":
+      return [];
+    case "arc":
+      return [segment.cx, segment.cy, segment.ux, segment.uy, segment.vx, segment.vy, segment.startAngle, segment.sweep];
+    default:
+      throw new TypeError("Unknown path segment type.");
+  }
+}
+class PathGeometry {
+  /**
+   * Creates empty geometry or an independent copy of the supplied path. See {@link PathGeometry}.
+   * @param source - Optional geometry whose segments are copied; omission creates an empty path.
+   * See {@link PathGeometry} .
+   */
+  constructor(source) {
+    const original = source === void 0 ? void 0 : state(source);
+    storage.set(this, {
+      types: original ? original.types.slice(0, original.count) : new Uint8Array(0),
+      data: original ? original.data.slice(0, original.length) : new Float64Array(0),
+      count: original?.count ?? 0,
+      length: original?.length ?? 0,
+      revision: 0,
+      x: original?.x ?? 0,
+      y: original?.y ?? 0,
+      startX: original?.startX ?? 0,
+      startY: original?.startY ?? 0
+    });
+  }
+  /**
+   * Monotonic mutation revision; changing geometry does not itself request a Pibbl frame. See
+   * {@link PathGeometry}.
+   * @returns The mutation revision used to invalidate cached representations.
+   */
+  get revision() {
+    return state(this).revision;
+  }
+  /**
+   * Number of stored path segments, including move and close commands. See {@link PathGeometry}.
+   * @returns The number of stored path segments.
+   */
+  get segmentCount() {
+    return state(this).count;
+  }
+  /**
+   * Returns an independent copy with its own mutation revision. See {@link PathGeometry}.
+   * @returns An independent copy of this path's segments. See {@link PathGeometry}.
+   */
+  clone() {
+    return new PathGeometry(this);
+  }
+  /** Removes all segments and resets the current point. See {@link PathGeometry}. */
+  clear() {
+    const value = state(this);
+    if (!value.count) return;
+    ensureRevision(value);
+    value.count = value.length = 0;
+    value.x = value.y = value.startX = value.startY = 0;
+    value.revision++;
+  }
+  /**
+   * Begins a subpath at the supplied coordinates. See {@link PathGeometry}.
+   * @param x - Horizontal coordinate of the new subpath's starting point.
+   * @param y - Vertical coordinate of the new subpath's starting point.
+   */
+  moveTo(x, y) {
+    this.#build(0, [x, y]);
+  }
+  /**
+   * Appends a straight segment to the supplied coordinates. See {@link PathGeometry}.
+   * @param x - Horizontal coordinate of the line endpoint.
+   * @param y - Vertical coordinate of the line endpoint.
+   */
+  lineTo(x, y) {
+    this.#build(1, [x, y]);
+  }
+  /**
+   * Appends a quadratic curve using one control point and an endpoint. See {@link PathGeometry}.
+   * @param cpx - Horizontal coordinate of the quadratic control point.
+   * @param cpy - Vertical coordinate of the quadratic control point.
+   * @param x - Horizontal coordinate of the curve endpoint.
+   * @param y - Vertical coordinate of the curve endpoint.
+   */
+  quadraticCurveTo(cpx, cpy, x, y) {
+    this.#build(2, [cpx, cpy, x, y]);
+  }
+  /**
+   * Appends a cubic curve using two control points and an endpoint. See {@link PathGeometry}.
+   * @param cp1x - Horizontal coordinate of the first control point.
+   * @param cp1y - Vertical coordinate of the first control point.
+   * @param cp2x - Horizontal coordinate of the second control point.
+   * @param cp2y - Vertical coordinate of the second control point.
+   * @param x - Horizontal coordinate of the curve endpoint.
+   * @param y - Vertical coordinate of the curve endpoint.
+   */
+  bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
+    this.#build(3, [cp1x, cp1y, cp2x, cp2y, x, y]);
+  }
+  /**
+   * Closes the current subpath; an already closed or empty path is unchanged. See
+   * {@link PathGeometry}.
+   */
+  closePath() {
+    const value = state(this);
+    if (!value.count || value.types[value.count - 1] === 4) return;
+    this.#build(4, []);
+  }
+  /**
+   * Appends a circular arc using Canvas-compatible angles in radians. See {@link PathGeometry}.
+   * @param x - Horizontal coordinate of the circle center.
+   * @param y - Vertical coordinate of the circle center.
+   * @param radius - Circle radius in path units.
+   * @param startAngle - Starting angle in radians.
+   * @param endAngle - Ending angle in radians.
+   * @param counterclockwise - Whether the arc runs counterclockwise; defaults to false.
+   */
+  arc(x, y, radius, startAngle, endAngle, counterclockwise = false) {
+    this.ellipse(x, y, radius, radius, 0, startAngle, endAngle, counterclockwise);
+  }
+  /**
+   * Appends an elliptical arc; rotation and arc angles are in radians. See {@link PathGeometry}.
+   * @param x - Horizontal coordinate of the ellipse center.
+   * @param y - Vertical coordinate of the ellipse center.
+   * @param radiusX - Horizontal radius in path units.
+   * @param radiusY - Vertical radius in path units.
+   * @param rotation - Ellipse rotation in radians.
+   * @param startAngle - Starting angle in radians.
+   * @param endAngle - Ending angle in radians.
+   * @param counterclockwise - Whether the arc runs counterclockwise; defaults to false.
+   */
+  ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise = false) {
+    if (![x, y, radiusX, radiusY, rotation, startAngle, endAngle].every(Number.isFinite)) return;
+    if (radiusX < 0 || radiusY < 0) throw new DOMException("Arc radii must not be negative.", "IndexSizeError");
+    const cos = Math.cos(rotation), sin = Math.sin(rotation);
+    const arc = {
+      type: "arc",
+      cx: x,
+      cy: y,
+      ux: radiusX * cos,
+      uy: radiusX * sin,
+      vx: -radiusY * sin,
+      vy: radiusY * cos,
+      startAngle: startAngle % TAU,
+      sweep: arcSweep(startAngle, endAngle, counterclockwise)
+    };
+    this.#appendArc(arc);
+  }
+  #appendArc(arc) {
+    const [x, y] = arcPoint(arc, arc.startAngle);
+    const end = arcPoint(arc, arc.startAngle + arc.sweep);
+    if (![x, y, ...end].every(Number.isFinite)) throw new RangeError("Arc coordinates overflowed.");
+    const value = state(this);
+    ensureRevision(value);
+    if (!value.count) append(value, 0, [x, y]);
+    else if (value.x !== x || value.y !== y) append(value, 1, [x, y]);
+    append(value, 5, operands(arc));
+    value.revision++;
+  }
+  /**
+   * Appends a circular arc tangent to two lines using Canvas-compatible geometry. See
+   * {@link PathGeometry}.
+   * @param x1 - Horizontal coordinate of the first tangent intersection.
+   * @param y1 - Vertical coordinate of the first tangent intersection.
+   * @param x2 - Horizontal coordinate of the second tangent endpoint.
+   * @param y2 - Vertical coordinate of the second tangent endpoint.
+   * @param radius - Arc radius in path units.
+   */
+  arcTo(x1, y1, x2, y2, radius) {
+    if (![x1, y1, x2, y2, radius].every(Number.isFinite)) return;
+    if (radius < 0) throw new DOMException("Arc radius must not be negative.", "IndexSizeError");
+    const value = state(this);
+    if (!value.count) {
+      this.moveTo(x1, y1);
+      return;
+    }
+    const ax = value.x - x1, ay = value.y - y1, bx = x2 - x1, by = y2 - y1;
+    const al = Math.hypot(ax, ay), bl = Math.hypot(bx, by);
+    if (al === 0 || bl === 0 || radius === 0) {
+      this.lineTo(x1, y1);
+      return;
+    }
+    const ux = ax / al, uy = ay / al, vx = bx / bl, vy = by / bl;
+    const cross = ux * vy - uy * vx;
+    if (cross === 0) {
+      this.lineTo(x1, y1);
+      return;
+    }
+    const dot = Math.max(-1, Math.min(1, ux * vx + uy * vy));
+    const distance = radius * (1 + dot) / Math.abs(cross);
+    const startX = x1 + ux * distance, startY = y1 + uy * distance;
+    const sign = cross < 0 ? -1 : 1;
+    const cx = startX - uy * radius * sign, cy = startY + ux * radius * sign;
+    const endX = x1 + vx * distance, endY = y1 + vy * distance;
+    const start = Math.atan2(startY - cy, startX - cx);
+    const end = Math.atan2(endY - cy, endX - cx);
+    if (![cx, cy, endX, endY].every(Number.isFinite)) throw new RangeError("Arc coordinates overflowed.");
+    this.#appendArc({
+      type: "arc",
+      cx,
+      cy,
+      ux: radius,
+      uy: 0,
+      vx: 0,
+      vy: radius,
+      startAngle: start,
+      sweep: arcSweep(start, end, cross > 0)
+    });
+  }
+  /**
+   * Appends a closed rectangle subpath. See {@link PathGeometry}.
+   * @param x - Horizontal coordinate of the rectangle origin.
+   * @param y - Vertical coordinate of the rectangle origin.
+   * @param width - Signed horizontal extent in path units.
+   * @param height - Signed vertical extent in path units.
+   */
+  rect(x, y, width, height) {
+    if (![x, y, width, height].every(Number.isFinite)) return;
+    if (![x + width, y + height].every(Number.isFinite)) throw new RangeError("Rectangle coordinates overflowed.");
+    const value = state(this);
+    ensureRevision(value);
+    append(value, 0, [x, y]);
+    append(value, 1, [x + width, y]);
+    append(value, 1, [x + width, y + height]);
+    append(value, 1, [x, y + height]);
+    append(value, 4, []);
+    append(value, 0, [x, y]);
+    value.revision++;
+  }
+  /**
+   * Appends a closed rectangle with Canvas-compatible corner radii. See {@link PathGeometry}.
+   * @param x - Horizontal coordinate of the rectangle origin.
+   * @param y - Vertical coordinate of the rectangle origin.
+   * @param width - Signed horizontal extent in path units.
+   * @param height - Signed vertical extent in path units.
+   * @param radii - Circular or elliptical corner radii, using Canvas roundRect ordering; defaults
+   * to zero.
+   */
+  roundRect(x, y, width, height, radii = 0) {
+    if (![x, y, width, height].every(Number.isFinite)) return;
+    const list = Array.isArray(radii) ? radii : [radii];
+    if (!list.length || list.length > 4) throw new RangeError("Expected one to four corner radii.");
+    const values = [];
+    for (const radius of list) {
+      const rx = typeof radius === "number" ? radius : radius.x ?? 0;
+      const ry = typeof radius === "number" ? radius : radius.y ?? 0;
+      if (![rx, ry].every(Number.isFinite)) return;
+      if (rx < 0 || ry < 0) throw new RangeError("Corner radii must not be negative.");
+      values.push([rx, ry]);
+    }
+    const corners = [values[0], values[1] ?? values[0], values[2] ?? values[0], values[3] ?? values[1] ?? values[0]];
+    const w = Math.abs(width), h = Math.abs(height);
+    const ratio = (length, sum) => sum === 0 ? 1 : length / sum;
+    const scale = Math.min(
+      1,
+      ratio(w, corners[0][0] + corners[1][0]),
+      ratio(w, corners[2][0] + corners[3][0]),
+      ratio(h, corners[0][1] + corners[3][1]),
+      ratio(h, corners[1][1] + corners[2][1])
+    );
+    const [tl, tr, br, bl] = corners.map(([rx, ry]) => [rx * scale, ry * scale]);
+    const path = new PathGeometry();
+    path.moveTo(tl[0], 0);
+    path.lineTo(w - tr[0], 0);
+    path.ellipse(w - tr[0], tr[1], tr[0], tr[1], 0, -Math.PI / 2, 0);
+    path.lineTo(w, h - br[1]);
+    path.ellipse(w - br[0], h - br[1], br[0], br[1], 0, 0, Math.PI / 2);
+    path.lineTo(bl[0], h);
+    path.ellipse(bl[0], h - bl[1], bl[0], bl[1], 0, Math.PI / 2, Math.PI);
+    path.lineTo(0, tl[1]);
+    path.ellipse(tl[0], tl[1], tl[0], tl[1], 0, Math.PI, Math.PI * 1.5);
+    path.closePath();
+    path.moveTo(width < 0 ? w : 0, height < 0 ? h : 0);
+    path.transform({ a: width < 0 ? -1 : 1, d: height < 0 ? -1 : 1, e: x, f: y });
+    this.#copyPath(path);
+  }
+  /**
+   * Appends a copy of another path, optionally transformed by a 2D matrix. See
+   * {@link PathGeometry}.
+   * @param other - Geometry whose segments are appended. See {@link PathGeometry}.
+   * @param matrix - Optional affine transform applied to the appended segments; defaults to
+   * identity.
+   */
+  addPath(other, matrix = {}) {
+    if (!state(other).count) return;
+    const normalized = DOMMatrix.fromMatrix(matrix);
+    if (!normalized.is2D) throw new TypeError("PathGeometry requires a 2D affine matrix.");
+    if (![normalized.a, normalized.b, normalized.c, normalized.d, normalized.e, normalized.f].every(Number.isFinite)) return;
+    const copy = other.clone();
+    copy.transform(normalized);
+    const value = state(copy);
+    append(value, 0, [value.x, value.y]);
+    this.#copyPath(copy);
+  }
+  #copyPath(other) {
+    const source = state(other), value = state(this);
+    ensureRevision(value);
+    reserve(value, value.count + source.count, value.length + source.length);
+    value.types.set(source.types.subarray(0, source.count), value.count);
+    value.data.set(source.data.subarray(0, source.length), value.length);
+    value.count += source.count;
+    value.length += source.length;
+    value.x = source.x;
+    value.y = source.y;
+    value.startX = source.startX;
+    value.startY = source.startY;
+    value.revision++;
+  }
+  /**
+   * Replaces a segment range with validated independent segment values. See {@link PathGeometry}.
+   * @param start - Index at which to begin replacing segments.
+   * @param deleteCount - Number of segments to remove.
+   * @param segments - Replacement segments; defaults to no inserted segments. See
+   * {@link PathSegment} .
+   */
+  spliceSegments(start, deleteCount, segments = []) {
+    const value = state(this);
+    if (!Number.isInteger(start) || start < 0 || start > value.count || !Number.isInteger(deleteCount) || deleteCount < 0 || deleteCount > value.count - start) {
+      throw new RangeError("Invalid path splice range.");
+    }
+    const additions = segments.map((segment) => ({ type: names.indexOf(segment.type), data: validatedOperands(segment) }));
+    const count = value.count - deleteCount + additions.length;
+    const firstType = start === 0 ? additions[0]?.type ?? value.types[deleteCount] : value.types[0];
+    if (count > 0 && firstType !== 0) throw new TypeError("A path must start with a move segment.");
+    if (!deleteCount && !additions.length) return;
+    ensureRevision(value);
+    let offset = 0, removed = 0;
+    for (let i = 0; i < start; i++) offset += widths[value.types[i]];
+    for (let i = start; i < start + deleteCount; i++) removed += widths[value.types[i]];
+    const added = additions.reduce((sum, segment) => sum + segment.data.length, 0);
+    const length = value.length - removed + added;
+    reserve(value, count, length);
+    value.types.copyWithin(start + additions.length, start + deleteCount, value.count);
+    value.data.copyWithin(offset + added, offset + removed, value.length);
+    for (let i = 0; i < additions.length; i++) {
+      value.types[start + i] = additions[i].type;
+      value.data.set(additions[i].data, offset);
+      offset += additions[i].data.length;
+    }
+    value.count = count;
+    value.length = length;
+    rebuildPoint(value);
+    value.revision++;
+  }
+  #build(type, data) {
+    if (!data.every(Number.isFinite)) return;
+    const value = state(this);
+    ensureRevision(value);
+    if (!value.count && type !== 0) {
+      append(value, 0, data.slice(0, 2));
+      if (type === 1) {
+        value.revision++;
+        return;
+      }
+    }
+    append(value, type, data);
+    value.revision++;
+  }
+  #offset(index) {
+    const value = state(this);
+    if (!Number.isInteger(index) || index < 0 || index >= value.count) {
+      throw new RangeError("Path segment index is out of range.");
+    }
+    let offset = 0;
+    for (let i = 0; i < index; i++) offset += widths[value.types[i]];
+    return offset;
+  }
+  /**
+   * Returns an independent segment value at the specified index. See {@link PathSegment}.
+   * @param index - Zero-based segment index.
+   * @returns The segment at the requested index. See {@link PathSegment}.
+   */
+  getSegment(index) {
+    return readSegment(state(this), index, this.#offset(index));
+  }
+  /**
+   * Replaces one stored segment with a validated independent value. See {@link PathGeometry}.
+   * @param index - Zero-based index of the segment to replace.
+   * @param segment - Replacement segment data. See {@link PathSegment}.
+   */
+  setSegment(index, segment) {
+    const offset = this.#offset(index);
+    const type = names.indexOf(segment.type);
+    const data = validatedOperands(segment);
+    if (!data.every(Number.isFinite)) throw new RangeError("Path coordinates must be finite.");
+    if (index === 0 && type !== 0) throw new TypeError("A path must start with a move segment.");
+    const value = state(this);
+    ensureRevision(value);
+    const oldWidth = widths[value.types[index]];
+    const length = value.length + data.length - oldWidth;
+    reserve(value, value.count, length);
+    value.data.copyWithin(offset + data.length, offset + oldWidth, value.length);
+    value.data.set(data, offset);
+    value.types[index] = type;
+    value.length = length;
+    rebuildPoint(value);
+    value.revision++;
+  }
+  /**
+   * Applies a finite 2D affine matrix. Old native conversions remain unchanged.
+   * @param matrix - Affine matrix applied to all segments in this path.
+   */
+  transform(matrix) {
+    const input = matrix;
+    const normalized = DOMMatrix.fromMatrix(input);
+    if (!normalized.is2D) throw new TypeError("PathGeometry requires a 2D affine matrix.");
+    const { a, b, c, d, e, f } = normalized;
+    if (![a, b, c, d, e, f].every(Number.isFinite)) {
+      throw new RangeError("Path transform must be finite.");
+    }
+    const value = state(this);
+    if (!value.count) return;
+    ensureRevision(value);
+    for (const write of [false, true]) {
+      visitPathGeometry(this, (type, data, offset) => {
+        const length = type === 5 ? 6 : widths[type];
+        for (let i = 0; i < length; i += 2) {
+          const x = data[offset + i], y = data[offset + i + 1];
+          const vector = type === 5 && i > 0;
+          const nextX = a * x + c * y + (vector ? 0 : e);
+          const nextY = b * x + d * y + (vector ? 0 : f);
+          if (!Number.isFinite(nextX) || !Number.isFinite(nextY)) {
+            throw new RangeError("Path transform coordinates overflowed.");
+          }
+          if (write) {
+            data[offset + i] = nextX;
+            data[offset + i + 1] = nextY;
+          }
+        }
+      });
+    }
+    rebuildPoint(value);
+    value.revision++;
+  }
+  /**
+   * Iterates over independent segment values in source order. See {@link PathSegment}.
+   * @returns An iterator over the path's segments in drawing order. See {@link PathSegment}.
+   */
+  *[Symbol.iterator]() {
+    const value = state(this);
+    const revision = value.revision;
+    let offset = 0;
+    for (let index = 0; index < value.count; index++) {
+      if (value.revision !== revision) throw new Error("PathGeometry changed during iteration.");
+      const width = widths[value.types[index]];
+      yield readSegment(value, index, offset);
+      if (value.revision !== revision) throw new Error("PathGeometry changed during iteration.");
+      offset += width;
+    }
+  }
+}
+function readSegment(value, index, offset) {
+  const d = value.data;
+  switch (value.types[index]) {
+    case 0:
+      return { type: "move", x: d[offset], y: d[offset + 1] };
+    case 1:
+      return { type: "line", x: d[offset], y: d[offset + 1] };
+    case 2:
+      return { type: "quadratic", cpx: d[offset], cpy: d[offset + 1], x: d[offset + 2], y: d[offset + 3] };
+    case 3:
+      return { type: "cubic", cp1x: d[offset], cp1y: d[offset + 1], cp2x: d[offset + 2], cp2y: d[offset + 3], x: d[offset + 4], y: d[offset + 5] };
+    case 5:
+      return { type: "arc", cx: d[offset], cy: d[offset + 1], ux: d[offset + 2], uy: d[offset + 3], vx: d[offset + 4], vy: d[offset + 5], startAngle: d[offset + 6], sweep: d[offset + 7] };
+    default:
+      return { type: "close" };
+  }
+}
+function validatedOperands(segment) {
+  const data = operands(segment);
+  if (!data.every(Number.isFinite)) throw new RangeError("Path coordinates must be finite.");
+  if (segment.type === "arc" && (Math.abs(segment.sweep) > TAU || Math.abs(segment.startAngle) > TAU)) {
+    throw new RangeError("Arc angles must be normalized to one revolution.");
+  }
+  return data;
+}
+function updatePoint(value, type, data, offset) {
+  if (type === 4) {
+    value.x = value.startX;
+    value.y = value.startY;
+    return;
+  }
+  if (type === 5) {
+    const angle = data[offset + 6] + data[offset + 7];
+    value.x = data[offset] + data[offset + 2] * Math.cos(angle) + data[offset + 4] * Math.sin(angle);
+    value.y = data[offset + 1] + data[offset + 3] * Math.cos(angle) + data[offset + 5] * Math.sin(angle);
+  } else {
+    value.x = data[offset + widths[type] - 2];
+    value.y = data[offset + widths[type] - 1];
+  }
+  if (type === 0) {
+    value.startX = value.x;
+    value.startY = value.y;
+  }
+}
+function rebuildPoint(value) {
+  value.x = value.y = value.startX = value.startY = 0;
+  let offset = 0;
+  for (let i = 0; i < value.count; i++) {
+    updatePoint(value, value.types[i], value.data, offset);
+    offset += widths[value.types[i]];
+  }
+}
+export {
+  PathGeometry,
+  visitPathGeometry
+};
+//# sourceMappingURL=path-geometry.js.map

package/dist/lib/geometry/path-geometry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-geometry.ts"],
+  "sourcesContent": ["import { arcPoint, arcSweep, TAU, type ArcSegment } from './path-arc.js';\n/**\n * A canonical, independently editable path segment.\n *\n * @see {@link PathGeometry}\n */\nexport type PathSegment =\n  | {\n      /** Selects `\"move\"`, `\"line\"` for type. See {@link PathSegment}. */\n      type: 'move' | 'line';\n      /**\n       * Horizontal coordinate or displacement in the containing coordinate system. See\n       * {@link PathSegment}.\n       */\n      x: number;\n      /**\n       * Vertical coordinate or displacement in the containing coordinate system. See\n       * {@link PathSegment}.\n       */\n      y: number;\n    }\n  | {\n      /** The literal \"quadratic\" identifying this variant. See {@link PathSegment}. */\n      type: 'quadratic';\n      /** Horizontal coordinate of the quadratic control point. See {@link PathSegment}. */\n      cpx: number;\n      /** Vertical coordinate of the quadratic control point. See {@link PathSegment}. */\n      cpy: number;\n      /**\n       * Horizontal coordinate or displacement in the containing coordinate system. See\n       * {@link PathSegment}.\n       */\n      x: number;\n      /**\n       * Vertical coordinate or displacement in the containing coordinate system. See\n       * {@link PathSegment}.\n       */\n      y: number;\n    }\n  | {\n      /** The literal \"cubic\" identifying this variant. See {@link PathSegment}. */\n      type: 'cubic';\n      /** Horizontal coordinate of the first cubic control point. See {@link PathSegment}. */\n      cp1x: number;\n      /** Vertical coordinate of the first cubic control point. See {@link PathSegment}. */\n      cp1y: number;\n      /** Horizontal coordinate of the second cubic control point. See {@link PathSegment}. */\n      cp2x: number;\n      /** Vertical coordinate of the second cubic control point. See {@link PathSegment}. */\n      cp2y: number;\n      /**\n       * Horizontal coordinate or displacement in the containing coordinate system. See\n       * {@link PathSegment}.\n       */\n      x: number;\n      /**\n       * Vertical coordinate or displacement in the containing coordinate system. See\n       * {@link PathSegment}.\n       */\n      y: number;\n    }\n  | ArcSegment\n  | {\n      /** The literal \"close\" identifying this variant. See {@link PathSegment}. */\n      type: 'close';\n    };\n\nconst names = ['move', 'line', 'quadratic', 'cubic', 'close', 'arc'] as const;\nconst widths = [2, 2, 4, 6, 0, 8] as const;\ninterface Storage {\n  types: Uint8Array;\n  data: Float64Array;\n  count: number;\n  length: number;\n  revision: number;\n  x: number; y: number; startX: number; startY: number;\n}\nconst storage = new WeakMap<PathGeometry, Storage>();\n\nfunction state(path: PathGeometry): Storage {\n  const value = storage.get(path);\n  if (!value) throw new TypeError('Expected a PathGeometry.');\n  return value;\n}\n\n/** @internal Borrowed buffers must never escape this synchronous traversal. */\nexport function visitPathGeometry(\n  path: PathGeometry,\n  visit: (type: number, data: Float64Array, offset: number) => void,\n): void {\n  const value = state(path);\n  let offset = 0;\n  for (let i = 0; i < value.count; i++) {\n    const type = value.types[i];\n    visit(type, value.data, offset);\n    offset += widths[type];\n  }\n}\n\nfunction ensureRevision(value: Storage): void {\n  if (value.revision >= Number.MAX_SAFE_INTEGER) {\n    throw new RangeError('PathGeometry revision exhausted.');\n  }\n}\n\nfunction reserve(value: Storage, count: number, length: number): void {\n  if (count > value.types.length) {\n    const next = new Uint8Array(Math.max(count, value.types.length * 2, 8));\n    next.set(value.types.subarray(0, value.count));\n    value.types = next;\n  }\n  if (length > value.data.length) {\n    const next = new Float64Array(Math.max(length, value.data.length * 2, 32));\n    next.set(value.data.subarray(0, value.length));\n    value.data = next;\n  }\n}\n\nfunction append(value: Storage, type: number, data: readonly number[]): void {\n  reserve(value, value.count + 1, value.length + data.length);\n  value.types[value.count++] = type;\n  value.data.set(data, value.length);\n  value.length += data.length;\n  updatePoint(value, type, data, 0);\n}\n\nfunction operands(segment: PathSegment): number[] {\n  switch (segment.type) {\n    case 'move': case 'line': return [segment.x, segment.y];\n    case 'quadratic': return [segment.cpx, segment.cpy, segment.x, segment.y];\n    case 'cubic': return [segment.cp1x, segment.cp1y, segment.cp2x, segment.cp2y, segment.x, segment.y];\n    case 'close': return [];\n    case 'arc': return [segment.cx, segment.cy, segment.ux, segment.uy, segment.vx, segment.vy, segment.startAngle, segment.sweep];\n    default: throw new TypeError('Unknown path segment type.');\n  }\n}\n\n/**\n * Mutable packed geometry. Mutations do not schedule Pibbl rendering.\n *\n * @see {@link PathSegment}\n */\nexport class PathGeometry implements Iterable<PathSegment> {\n  /**\n   * Creates empty geometry or an independent copy of the supplied path. See {@link PathGeometry}.\n   * @param source - Optional geometry whose segments are copied; omission creates an empty path.\n   * See {@link PathGeometry} .\n   */\n  constructor(source?: PathGeometry) {\n    const original = source === undefined ? undefined : state(source);\n    storage.set(this, {\n      types: original ? original.types.slice(0, original.count) : new Uint8Array(0),\n      data: original ? original.data.slice(0, original.length) : new Float64Array(0),\n      count: original?.count ?? 0,\n      length: original?.length ?? 0,\n      revision: 0,\n      x: original?.x ?? 0, y: original?.y ?? 0,\n      startX: original?.startX ?? 0, startY: original?.startY ?? 0,\n    });\n  }\n\n  /**\n   * Monotonic mutation revision; changing geometry does not itself request a Pibbl frame. See\n   * {@link PathGeometry}.\n   * @returns The mutation revision used to invalidate cached representations.\n   */\n  get revision(): number { return state(this).revision; }\n  /**\n   * Number of stored path segments, including move and close commands. See {@link PathGeometry}.\n   * @returns The number of stored path segments.\n   */\n  get segmentCount(): number { return state(this).count; }\n\n  /**\n   * Returns an independent copy with its own mutation revision. See {@link PathGeometry}.\n   * @returns An independent copy of this path's segments. See {@link PathGeometry}.\n   */\n  clone(): PathGeometry { return new PathGeometry(this); }\n\n  /** Removes all segments and resets the current point. See {@link PathGeometry}. */\n  clear(): void {\n    const value = state(this);\n    if (!value.count) return;\n    ensureRevision(value);\n    value.count = value.length = 0;\n    value.x = value.y = value.startX = value.startY = 0;\n    value.revision++;\n  }\n\n  /**\n   * Begins a subpath at the supplied coordinates. See {@link PathGeometry}.\n   * @param x - Horizontal coordinate of the new subpath's starting point.\n   * @param y - Vertical coordinate of the new subpath's starting point.\n   */\n  moveTo(x: number, y: number): void { this.#build(0, [x, y]); }\n  /**\n   * Appends a straight segment to the supplied coordinates. See {@link PathGeometry}.\n   * @param x - Horizontal coordinate of the line endpoint.\n   * @param y - Vertical coordinate of the line endpoint.\n   */\n  lineTo(x: number, y: number): void { this.#build(1, [x, y]); }\n  /**\n   * Appends a quadratic curve using one control point and an endpoint. See {@link PathGeometry}.\n   * @param cpx - Horizontal coordinate of the quadratic control point.\n   * @param cpy - Vertical coordinate of the quadratic control point.\n   * @param x - Horizontal coordinate of the curve endpoint.\n   * @param y - Vertical coordinate of the curve endpoint.\n   */\n  quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void {\n    this.#build(2, [cpx, cpy, x, y]);\n  }\n  /**\n   * Appends a cubic curve using two control points and an endpoint. See {@link PathGeometry}.\n   * @param cp1x - Horizontal coordinate of the first control point.\n   * @param cp1y - Vertical coordinate of the first control point.\n   * @param cp2x - Horizontal coordinate of the second control point.\n   * @param cp2y - Vertical coordinate of the second control point.\n   * @param x - Horizontal coordinate of the curve endpoint.\n   * @param y - Vertical coordinate of the curve endpoint.\n   */\n  bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void {\n    this.#build(3, [cp1x, cp1y, cp2x, cp2y, x, y]);\n  }\n  /**\n   * Closes the current subpath; an already closed or empty path is unchanged. See\n   * {@link PathGeometry}.\n   */\n  closePath(): void {\n    const value = state(this);\n    if (!value.count || value.types[value.count - 1] === 4) return;\n    this.#build(4, []);\n  }\n\n  /**\n   * Appends a circular arc using Canvas-compatible angles in radians. See {@link PathGeometry}.\n   * @param x - Horizontal coordinate of the circle center.\n   * @param y - Vertical coordinate of the circle center.\n   * @param radius - Circle radius in path units.\n   * @param startAngle - Starting angle in radians.\n   * @param endAngle - Ending angle in radians.\n   * @param counterclockwise - Whether the arc runs counterclockwise; defaults to false.\n   */\n  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise = false): void {\n    this.ellipse(x, y, radius, radius, 0, startAngle, endAngle, counterclockwise);\n  }\n\n  /**\n   * Appends an elliptical arc; rotation and arc angles are in radians. See {@link PathGeometry}.\n   * @param x - Horizontal coordinate of the ellipse center.\n   * @param y - Vertical coordinate of the ellipse center.\n   * @param radiusX - Horizontal radius in path units.\n   * @param radiusY - Vertical radius in path units.\n   * @param rotation - Ellipse rotation in radians.\n   * @param startAngle - Starting angle in radians.\n   * @param endAngle - Ending angle in radians.\n   * @param counterclockwise - Whether the arc runs counterclockwise; defaults to false.\n   */\n  ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise = false): void {\n    if (![x, y, radiusX, radiusY, rotation, startAngle, endAngle].every(Number.isFinite)) return;\n    if (radiusX < 0 || radiusY < 0) throw new DOMException('Arc radii must not be negative.', 'IndexSizeError');\n    const cos = Math.cos(rotation), sin = Math.sin(rotation);\n    const arc: ArcSegment = {\n      type: 'arc', cx: x, cy: y, ux: radiusX * cos, uy: radiusX * sin,\n      vx: -radiusY * sin, vy: radiusY * cos, startAngle: startAngle % TAU,\n      sweep: arcSweep(startAngle, endAngle, counterclockwise),\n    };\n    this.#appendArc(arc);\n  }\n\n  #appendArc(arc: ArcSegment): void {\n    const [x, y] = arcPoint(arc, arc.startAngle);\n    const end = arcPoint(arc, arc.startAngle + arc.sweep);\n    if (![x, y, ...end].every(Number.isFinite)) throw new RangeError('Arc coordinates overflowed.');\n    const value = state(this);\n    ensureRevision(value);\n    if (!value.count) append(value, 0, [x, y]);\n    else if (value.x !== x || value.y !== y) append(value, 1, [x, y]);\n    append(value, 5, operands(arc));\n    value.revision++;\n  }\n\n  /**\n   * Appends a circular arc tangent to two lines using Canvas-compatible geometry. See\n   * {@link PathGeometry}.\n   * @param x1 - Horizontal coordinate of the first tangent intersection.\n   * @param y1 - Vertical coordinate of the first tangent intersection.\n   * @param x2 - Horizontal coordinate of the second tangent endpoint.\n   * @param y2 - Vertical coordinate of the second tangent endpoint.\n   * @param radius - Arc radius in path units.\n   */\n  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void {\n    if (![x1, y1, x2, y2, radius].every(Number.isFinite)) return;\n    if (radius < 0) throw new DOMException('Arc radius must not be negative.', 'IndexSizeError');\n    const value = state(this);\n    if (!value.count) { this.moveTo(x1, y1); return; }\n    const ax = value.x - x1, ay = value.y - y1, bx = x2 - x1, by = y2 - y1;\n    const al = Math.hypot(ax, ay), bl = Math.hypot(bx, by);\n    if (al === 0 || bl === 0 || radius === 0) { this.lineTo(x1, y1); return; }\n    const ux = ax / al, uy = ay / al, vx = bx / bl, vy = by / bl;\n    const cross = ux * vy - uy * vx;\n    if (cross === 0) { this.lineTo(x1, y1); return; }\n    const dot = Math.max(-1, Math.min(1, ux * vx + uy * vy));\n    const distance = radius * (1 + dot) / Math.abs(cross);\n    const startX = x1 + ux * distance, startY = y1 + uy * distance;\n    const sign = cross < 0 ? -1 : 1;\n    const cx = startX - uy * radius * sign, cy = startY + ux * radius * sign;\n    const endX = x1 + vx * distance, endY = y1 + vy * distance;\n    const start = Math.atan2(startY - cy, startX - cx);\n    const end = Math.atan2(endY - cy, endX - cx);\n    if (![cx, cy, endX, endY].every(Number.isFinite)) throw new RangeError('Arc coordinates overflowed.');\n    this.#appendArc({ type: 'arc', cx, cy, ux: radius, uy: 0, vx: 0, vy: radius,\n      startAngle: start, sweep: arcSweep(start, end, cross > 0) });\n  }\n\n  /**\n   * Appends a closed rectangle subpath. See {@link PathGeometry}.\n   * @param x - Horizontal coordinate of the rectangle origin.\n   * @param y - Vertical coordinate of the rectangle origin.\n   * @param width - Signed horizontal extent in path units.\n   * @param height - Signed vertical extent in path units.\n   */\n  rect(x: number, y: number, width: number, height: number): void {\n    if (![x, y, width, height].every(Number.isFinite)) return;\n    if (![x + width, y + height].every(Number.isFinite)) throw new RangeError('Rectangle coordinates overflowed.');\n    const value = state(this);\n    ensureRevision(value);\n    append(value, 0, [x, y]);\n    append(value, 1, [x + width, y]);\n    append(value, 1, [x + width, y + height]);\n    append(value, 1, [x, y + height]);\n    append(value, 4, []);\n    append(value, 0, [x, y]);\n    value.revision++;\n  }\n\n  /**\n   * Appends a closed rectangle with Canvas-compatible corner radii. See {@link PathGeometry}.\n   * @param x - Horizontal coordinate of the rectangle origin.\n   * @param y - Vertical coordinate of the rectangle origin.\n   * @param width - Signed horizontal extent in path units.\n   * @param height - Signed vertical extent in path units.\n   * @param radii - Circular or elliptical corner radii, using Canvas roundRect ordering; defaults\n   * to zero.\n   */\n  roundRect(x: number, y: number, width: number, height: number,\n    radii: number | DOMPointInit | (number | DOMPointInit)[] = 0): void {\n    if (![x, y, width, height].every(Number.isFinite)) return;\n    const list = Array.isArray(radii) ? radii : [radii];\n    if (!list.length || list.length > 4) throw new RangeError('Expected one to four corner radii.');\n    const values: [number, number][] = [];\n    for (const radius of list) {\n      const rx = typeof radius === 'number' ? radius : radius.x ?? 0;\n      const ry = typeof radius === 'number' ? radius : radius.y ?? 0;\n      if (![rx, ry].every(Number.isFinite)) return;\n      if (rx < 0 || ry < 0) throw new RangeError('Corner radii must not be negative.');\n      values.push([rx, ry]);\n    }\n    const corners = [values[0], values[1] ?? values[0], values[2] ?? values[0], values[3] ?? values[1] ?? values[0]];\n    const w = Math.abs(width), h = Math.abs(height);\n    const ratio = (length: number, sum: number) => sum === 0 ? 1 : length / sum;\n    const scale = Math.min(1, ratio(w, corners[0][0] + corners[1][0]), ratio(w, corners[2][0] + corners[3][0]),\n      ratio(h, corners[0][1] + corners[3][1]), ratio(h, corners[1][1] + corners[2][1]));\n    const [tl, tr, br, bl] = corners.map(([rx, ry]) => [rx * scale, ry * scale]);\n    const path = new PathGeometry();\n    path.moveTo(tl[0], 0);\n    path.lineTo(w - tr[0], 0);\n    path.ellipse(w - tr[0], tr[1], tr[0], tr[1], 0, -Math.PI / 2, 0);\n    path.lineTo(w, h - br[1]);\n    path.ellipse(w - br[0], h - br[1], br[0], br[1], 0, 0, Math.PI / 2);\n    path.lineTo(bl[0], h);\n    path.ellipse(bl[0], h - bl[1], bl[0], bl[1], 0, Math.PI / 2, Math.PI);\n    path.lineTo(0, tl[1]);\n    path.ellipse(tl[0], tl[1], tl[0], tl[1], 0, Math.PI, Math.PI * 1.5);\n    path.closePath();\n    // Chromium resumes at the normalized rectangle origin after negative dimensions.\n    path.moveTo(width < 0 ? w : 0, height < 0 ? h : 0);\n    path.transform({ a: width < 0 ? -1 : 1, d: height < 0 ? -1 : 1, e: x, f: y });\n    this.#copyPath(path);\n  }\n\n  /**\n   * Appends a copy of another path, optionally transformed by a 2D matrix. See\n   * {@link PathGeometry}.\n   * @param other - Geometry whose segments are appended. See {@link PathGeometry}.\n   * @param matrix - Optional affine transform applied to the appended segments; defaults to\n   * identity.\n   */\n  addPath(other: PathGeometry, matrix: DOMMatrix2DInit = {}): void {\n    if (!state(other).count) return;\n    const normalized = DOMMatrix.fromMatrix(matrix);\n    if (!normalized.is2D) throw new TypeError('PathGeometry requires a 2D affine matrix.');\n    if (![normalized.a, normalized.b, normalized.c, normalized.d, normalized.e, normalized.f].every(Number.isFinite)) return;\n    const copy = other.clone();\n    copy.transform(normalized);\n    const value = state(copy);\n    append(value, 0, [value.x, value.y]);\n    this.#copyPath(copy);\n  }\n\n  #copyPath(other: PathGeometry): void {\n    const source = state(other), value = state(this);\n    ensureRevision(value);\n    reserve(value, value.count + source.count, value.length + source.length);\n    value.types.set(source.types.subarray(0, source.count), value.count);\n    value.data.set(source.data.subarray(0, source.length), value.length);\n    value.count += source.count; value.length += source.length;\n    value.x = source.x; value.y = source.y;\n    value.startX = source.startX; value.startY = source.startY;\n    value.revision++;\n  }\n\n  /**\n   * Replaces a segment range with validated independent segment values. See {@link PathGeometry}.\n   * @param start - Index at which to begin replacing segments.\n   * @param deleteCount - Number of segments to remove.\n   * @param segments - Replacement segments; defaults to no inserted segments. See\n   * {@link PathSegment} .\n   */\n  spliceSegments(start: number, deleteCount: number, segments: readonly PathSegment[] = []): void {\n    const value = state(this);\n    if (!Number.isInteger(start) || start < 0 || start > value.count ||\n      !Number.isInteger(deleteCount) || deleteCount < 0 || deleteCount > value.count - start) {\n      throw new RangeError('Invalid path splice range.');\n    }\n    const additions = segments.map(segment => ({ type: names.indexOf(segment.type), data: validatedOperands(segment) }));\n    const count = value.count - deleteCount + additions.length;\n    const firstType = start === 0 ? (additions[0]?.type ?? value.types[deleteCount]) : value.types[0];\n    if (count > 0 && firstType !== 0) throw new TypeError('A path must start with a move segment.');\n    if (!deleteCount && !additions.length) return;\n    ensureRevision(value);\n    let offset = 0, removed = 0;\n    for (let i = 0; i < start; i++) offset += widths[value.types[i]];\n    for (let i = start; i < start + deleteCount; i++) removed += widths[value.types[i]];\n    const added = additions.reduce((sum, segment) => sum + segment.data.length, 0);\n    const length = value.length - removed + added;\n    reserve(value, count, length);\n    value.types.copyWithin(start + additions.length, start + deleteCount, value.count);\n    value.data.copyWithin(offset + added, offset + removed, value.length);\n    for (let i = 0; i < additions.length; i++) {\n      value.types[start + i] = additions[i].type;\n      value.data.set(additions[i].data, offset);\n      offset += additions[i].data.length;\n    }\n    value.count = count; value.length = length;\n    rebuildPoint(value);\n    value.revision++;\n  }\n\n  #build(type: number, data: number[]): void {\n    if (!data.every(Number.isFinite)) return;\n    const value = state(this);\n    ensureRevision(value);\n    if (!value.count && type !== 0) {\n      // Canvas starts a missing subpath at the first control point (or endpoint).\n      append(value, 0, data.slice(0, 2));\n      if (type === 1) {\n        value.revision++;\n        return;\n      }\n    }\n    append(value, type, data);\n    value.revision++;\n  }\n\n  #offset(index: number): number {\n    const value = state(this);\n    if (!Number.isInteger(index) || index < 0 || index >= value.count) {\n      throw new RangeError('Path segment index is out of range.');\n    }\n    let offset = 0;\n    for (let i = 0; i < index; i++) offset += widths[value.types[i]];\n    return offset;\n  }\n\n  /**\n   * Returns an independent segment value at the specified index. See {@link PathSegment}.\n   * @param index - Zero-based segment index.\n   * @returns The segment at the requested index. See {@link PathSegment}.\n   */\n  getSegment(index: number): PathSegment {\n    return readSegment(state(this), index, this.#offset(index));\n  }\n\n  /**\n   * Replaces one stored segment with a validated independent value. See {@link PathGeometry}.\n   * @param index - Zero-based index of the segment to replace.\n   * @param segment - Replacement segment data. See {@link PathSegment}.\n   */\n  setSegment(index: number, segment: PathSegment): void {\n    const offset = this.#offset(index);\n    const type = names.indexOf(segment.type);\n    const data = validatedOperands(segment);\n    if (!data.every(Number.isFinite)) throw new RangeError('Path coordinates must be finite.');\n    if (index === 0 && type !== 0) throw new TypeError('A path must start with a move segment.');\n    const value = state(this);\n    ensureRevision(value);\n    const oldWidth = widths[value.types[index]];\n    const length = value.length + data.length - oldWidth;\n    reserve(value, value.count, length);\n    value.data.copyWithin(offset + data.length, offset + oldWidth, value.length);\n    value.data.set(data, offset);\n    value.types[index] = type;\n    value.length = length;\n    rebuildPoint(value);\n    value.revision++;\n  }\n\n  /**\n   * Applies a finite 2D affine matrix. Old native conversions remain unchanged.\n   * @param matrix - Affine matrix applied to all segments in this path.\n   */\n  transform(matrix: DOMMatrix2DInit): void {\n    const input = matrix as DOMMatrixInit;\n    const normalized = DOMMatrix.fromMatrix(input);\n    if (!normalized.is2D) throw new TypeError('PathGeometry requires a 2D affine matrix.');\n    const { a, b, c, d, e, f } = normalized;\n    if (![a, b, c, d, e, f].every(Number.isFinite)) {\n      throw new RangeError('Path transform must be finite.');\n    }\n    const value = state(this);\n    if (!value.count) return;\n    ensureRevision(value);\n    // Two passes keep overflow errors atomic without allocating another buffer.\n    for (const write of [false, true]) {\n      visitPathGeometry(this, (type, data, offset) => {\n        const length = type === 5 ? 6 : widths[type];\n        for (let i = 0; i < length; i += 2) {\n          const x = data[offset + i], y = data[offset + i + 1];\n          const vector = type === 5 && i > 0;\n          const nextX = a * x + c * y + (vector ? 0 : e);\n          const nextY = b * x + d * y + (vector ? 0 : f);\n          if (!Number.isFinite(nextX) || !Number.isFinite(nextY)) {\n            throw new RangeError('Path transform coordinates overflowed.');\n          }\n          if (write) { data[offset + i] = nextX; data[offset + i + 1] = nextY; }\n        }\n      });\n    }\n    rebuildPoint(value);\n    value.revision++;\n  }\n\n  /**\n   * Iterates over independent segment values in source order. See {@link PathSegment}.\n   * @returns An iterator over the path's segments in drawing order. See {@link PathSegment}.\n   */\n  *[Symbol.iterator](): IterableIterator<PathSegment> {\n    const value = state(this);\n    const revision = value.revision;\n    let offset = 0;\n    for (let index = 0; index < value.count; index++) {\n      if (value.revision !== revision) throw new Error('PathGeometry changed during iteration.');\n      const width = widths[value.types[index]];\n      yield readSegment(value, index, offset);\n      if (value.revision !== revision) throw new Error('PathGeometry changed during iteration.');\n      offset += width;\n    }\n  }\n}\n\nfunction readSegment(value: Storage, index: number, offset: number): PathSegment {\n  const d = value.data;\n  switch (value.types[index]) {\n    case 0: return { type: 'move', x: d[offset], y: d[offset + 1] };\n    case 1: return { type: 'line', x: d[offset], y: d[offset + 1] };\n    case 2: return { type: 'quadratic', cpx: d[offset], cpy: d[offset + 1], x: d[offset + 2], y: d[offset + 3] };\n    case 3: return { type: 'cubic', cp1x: d[offset], cp1y: d[offset + 1], cp2x: d[offset + 2], cp2y: d[offset + 3], x: d[offset + 4], y: d[offset + 5] };\n    case 5: return { type: 'arc', cx: d[offset], cy: d[offset + 1], ux: d[offset + 2], uy: d[offset + 3], vx: d[offset + 4], vy: d[offset + 5], startAngle: d[offset + 6], sweep: d[offset + 7] };\n    default: return { type: 'close' };\n  }\n}\n\nfunction validatedOperands(segment: PathSegment): number[] {\n  const data = operands(segment);\n  if (!data.every(Number.isFinite)) throw new RangeError('Path coordinates must be finite.');\n  if (segment.type === 'arc' && (Math.abs(segment.sweep) > TAU || Math.abs(segment.startAngle) > TAU)) {\n    throw new RangeError('Arc angles must be normalized to one revolution.');\n  }\n  return data;\n}\n\nfunction updatePoint(value: Storage, type: number, data: ArrayLike<number>, offset: number): void {\n  if (type === 4) { value.x = value.startX; value.y = value.startY; return; }\n  if (type === 5) {\n    const angle = data[offset + 6] + data[offset + 7];\n    value.x = data[offset] + data[offset + 2] * Math.cos(angle) + data[offset + 4] * Math.sin(angle);\n    value.y = data[offset + 1] + data[offset + 3] * Math.cos(angle) + data[offset + 5] * Math.sin(angle);\n  } else {\n    value.x = data[offset + widths[type] - 2]; value.y = data[offset + widths[type] - 1];\n  }\n  if (type === 0) { value.startX = value.x; value.startY = value.y; }\n}\nfunction rebuildPoint(value: Storage): void {\n  value.x = value.y = value.startX = value.startY = 0;\n  let offset = 0;\n  for (let i = 0; i < value.count; i++) {\n    updatePoint(value, value.types[i], value.data, offset);\n    offset += widths[value.types[i]];\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,UAAU,UAAU,WAA4B;AAmEzD,MAAM,QAAQ,CAAC,QAAQ,QAAQ,aAAa,SAAS,SAAS,KAAK;AACnE,MAAM,SAAS,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAShC,MAAM,UAAU,oBAAI,QAA+B;AAEnD,SAAS,MAAM,MAA6B;AAC1C,QAAM,QAAQ,QAAQ,IAAI,IAAI;AAC9B,MAAI,CAAC,MAAO,OAAM,IAAI,UAAU,0BAA0B;AAC1D,SAAO;AACT;AAGO,SAAS,kBACd,MACA,OACM;AACN,QAAM,QAAQ,MAAM,IAAI;AACxB,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,OAAO,KAAK;AACpC,UAAM,OAAO,MAAM,MAAM,CAAC;AAC1B,UAAM,MAAM,MAAM,MAAM,MAAM;AAC9B,cAAU,OAAO,IAAI;AAAA,EACvB;AACF;AAEA,SAAS,eAAe,OAAsB;AAC5C,MAAI,MAAM,YAAY,OAAO,kBAAkB;AAC7C,UAAM,IAAI,WAAW,kCAAkC;AAAA,EACzD;AACF;AAEA,SAAS,QAAQ,OAAgB,OAAe,QAAsB;AACpE,MAAI,QAAQ,MAAM,MAAM,QAAQ;AAC9B,UAAM,OAAO,IAAI,WAAW,KAAK,IAAI,OAAO,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC;AACtE,SAAK,IAAI,MAAM,MAAM,SAAS,GAAG,MAAM,KAAK,CAAC;AAC7C,UAAM,QAAQ;AAAA,EAChB;AACA,MAAI,SAAS,MAAM,KAAK,QAAQ;AAC9B,UAAM,OAAO,IAAI,aAAa,KAAK,IAAI,QAAQ,MAAM,KAAK,SAAS,GAAG,EAAE,CAAC;AACzE,SAAK,IAAI,MAAM,KAAK,SAAS,GAAG,MAAM,MAAM,CAAC;AAC7C,UAAM,OAAO;AAAA,EACf;AACF;AAEA,SAAS,OAAO,OAAgB,MAAc,MAA+B;AAC3E,UAAQ,OAAO,MAAM,QAAQ,GAAG,MAAM,SAAS,KAAK,MAAM;AAC1D,QAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAM,KAAK,IAAI,MAAM,MAAM,MAAM;AACjC,QAAM,UAAU,KAAK;AACrB,cAAY,OAAO,MAAM,MAAM,CAAC;AAClC;AAEA,SAAS,SAAS,SAAgC;AAChD,UAAQ,QAAQ,MAAM;AAAA,IACpB,KAAK;AAAA,IAAQ,KAAK;AAAQ,aAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAAA,IACtD,KAAK;AAAa,aAAO,CAAC,QAAQ,KAAK,QAAQ,KAAK,QAAQ,GAAG,QAAQ,CAAC;AAAA,IACxE,KAAK;AAAS,aAAO,CAAC,QAAQ,MAAM,QAAQ,MAAM,QAAQ,MAAM,QAAQ,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAAA,IAClG,KAAK;AAAS,aAAO,CAAC;AAAA,IACtB,KAAK;AAAO,aAAO,CAAC,QAAQ,IAAI,QAAQ,IAAI,QAAQ,IAAI,QAAQ,IAAI,QAAQ,IAAI,QAAQ,IAAI,QAAQ,YAAY,QAAQ,KAAK;AAAA,IAC7H;AAAS,YAAM,IAAI,UAAU,4BAA4B;AAAA,EAC3D;AACF;AAOO,MAAM,aAA8C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMzD,YAAY,QAAuB;AACjC,UAAM,WAAW,WAAW,SAAY,SAAY,MAAM,MAAM;AAChE,YAAQ,IAAI,MAAM;AAAA,MAChB,OAAO,WAAW,SAAS,MAAM,MAAM,GAAG,SAAS,KAAK,IAAI,IAAI,WAAW,CAAC;AAAA,MAC5E,MAAM,WAAW,SAAS,KAAK,MAAM,GAAG,SAAS,MAAM,IAAI,IAAI,aAAa,CAAC;AAAA,MAC7E,OAAO,UAAU,SAAS;AAAA,MAC1B,QAAQ,UAAU,UAAU;AAAA,MAC5B,UAAU;AAAA,MACV,GAAG,UAAU,KAAK;AAAA,MAAG,GAAG,UAAU,KAAK;AAAA,MACvC,QAAQ,UAAU,UAAU;AAAA,MAAG,QAAQ,UAAU,UAAU;AAAA,IAC7D,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAI,WAAmB;AAAE,WAAO,MAAM,IAAI,EAAE;AAAA,EAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtD,IAAI,eAAuB;AAAE,WAAO,MAAM,IAAI,EAAE;AAAA,EAAO;AAAA;AAAA;AAAA;AAAA;AAAA,EAMvD,QAAsB;AAAE,WAAO,IAAI,aAAa,IAAI;AAAA,EAAG;AAAA;AAAA,EAGvD,QAAc;AACZ,UAAM,QAAQ,MAAM,IAAI;AACxB,QAAI,CAAC,MAAM,MAAO;AAClB,mBAAe,KAAK;AACpB,UAAM,QAAQ,MAAM,SAAS;AAC7B,UAAM,IAAI,MAAM,IAAI,MAAM,SAAS,MAAM,SAAS;AAClD,UAAM;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,GAAW,GAAiB;AAAE,SAAK,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;AAAA,EAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM7D,OAAO,GAAW,GAAiB;AAAE,SAAK,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;AAAA,EAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ7D,iBAAiB,KAAa,KAAa,GAAW,GAAiB;AACrE,SAAK,OAAO,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC,CAAC;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,cAAc,MAAc,MAAc,MAAc,MAAc,GAAW,GAAiB;AAChG,SAAK,OAAO,GAAG,CAAC,MAAM,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,YAAkB;AAChB,UAAM,QAAQ,MAAM,IAAI;AACxB,QAAI,CAAC,MAAM,SAAS,MAAM,MAAM,MAAM,QAAQ,CAAC,MAAM,EAAG;AACxD,SAAK,OAAO,GAAG,CAAC,CAAC;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,IAAI,GAAW,GAAW,QAAgB,YAAoB,UAAkB,mBAAmB,OAAa;AAC9G,SAAK,QAAQ,GAAG,GAAG,QAAQ,QAAQ,GAAG,YAAY,UAAU,gBAAgB;AAAA,EAC9E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,QAAQ,GAAW,GAAW,SAAiB,SAAiB,UAAkB,YAAoB,UAAkB,mBAAmB,OAAa;AACtJ,QAAI,CAAC,CAAC,GAAG,GAAG,SAAS,SAAS,UAAU,YAAY,QAAQ,EAAE,MAAM,OAAO,QAAQ,EAAG;AACtF,QAAI,UAAU,KAAK,UAAU,EAAG,OAAM,IAAI,aAAa,mCAAmC,gBAAgB;AAC1G,UAAM,MAAM,KAAK,IAAI,QAAQ,GAAG,MAAM,KAAK,IAAI,QAAQ;AACvD,UAAM,MAAkB;AAAA,MACtB,MAAM;AAAA,MAAO,IAAI;AAAA,MAAG,IAAI;AAAA,MAAG,IAAI,UAAU;AAAA,MAAK,IAAI,UAAU;AAAA,MAC5D,IAAI,CAAC,UAAU;AAAA,MAAK,IAAI,UAAU;AAAA,MAAK,YAAY,aAAa;AAAA,MAChE,OAAO,SAAS,YAAY,UAAU,gBAAgB;AAAA,IACxD;AACA,SAAK,WAAW,GAAG;AAAA,EACrB;AAAA,EAEA,WAAW,KAAuB;AAChC,UAAM,CAAC,GAAG,CAAC,IAAI,SAAS,KAAK,IAAI,UAAU;AAC3C,UAAM,MAAM,SAAS,KAAK,IAAI,aAAa,IAAI,KAAK;AACpD,QAAI,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,EAAE,MAAM,OAAO,QAAQ,EAAG,OAAM,IAAI,WAAW,6BAA6B;AAC9F,UAAM,QAAQ,MAAM,IAAI;AACxB,mBAAe,KAAK;AACpB,QAAI,CAAC,MAAM,MAAO,QAAO,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;AAAA,aAChC,MAAM,MAAM,KAAK,MAAM,MAAM,EAAG,QAAO,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;AAChE,WAAO,OAAO,GAAG,SAAS,GAAG,CAAC;AAC9B,UAAM;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAM,IAAY,IAAY,IAAY,IAAY,QAAsB;AAC1E,QAAI,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,MAAM,EAAE,MAAM,OAAO,QAAQ,EAAG;AACtD,QAAI,SAAS,EAAG,OAAM,IAAI,aAAa,oCAAoC,gBAAgB;AAC3F,UAAM,QAAQ,MAAM,IAAI;AACxB,QAAI,CAAC,MAAM,OAAO;AAAE,WAAK,OAAO,IAAI,EAAE;AAAG;AAAA,IAAQ;AACjD,UAAM,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK;AACpE,UAAM,KAAK,KAAK,MAAM,IAAI,EAAE,GAAG,KAAK,KAAK,MAAM,IAAI,EAAE;AACrD,QAAI,OAAO,KAAK,OAAO,KAAK,WAAW,GAAG;AAAE,WAAK,OAAO,IAAI,EAAE;AAAG;AAAA,IAAQ;AACzE,UAAM,KAAK,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK;AAC1D,UAAM,QAAQ,KAAK,KAAK,KAAK;AAC7B,QAAI,UAAU,GAAG;AAAE,WAAK,OAAO,IAAI,EAAE;AAAG;AAAA,IAAQ;AAChD,UAAM,MAAM,KAAK,IAAI,IAAI,KAAK,IAAI,GAAG,KAAK,KAAK,KAAK,EAAE,CAAC;AACvD,UAAM,WAAW,UAAU,IAAI,OAAO,KAAK,IAAI,KAAK;AACpD,UAAM,SAAS,KAAK,KAAK,UAAU,SAAS,KAAK,KAAK;AACtD,UAAM,OAAO,QAAQ,IAAI,KAAK;AAC9B,UAAM,KAAK,SAAS,KAAK,SAAS,MAAM,KAAK,SAAS,KAAK,SAAS;AACpE,UAAM,OAAO,KAAK,KAAK,UAAU,OAAO,KAAK,KAAK;AAClD,UAAM,QAAQ,KAAK,MAAM,SAAS,IAAI,SAAS,EAAE;AACjD,UAAM,MAAM,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE;AAC3C,QAAI,CAAC,CAAC,IAAI,IAAI,MAAM,IAAI,EAAE,MAAM,OAAO,QAAQ,EAAG,OAAM,IAAI,WAAW,6BAA6B;AACpG,SAAK,WAAW;AAAA,MAAE,MAAM;AAAA,MAAO;AAAA,MAAI;AAAA,MAAI,IAAI;AAAA,MAAQ,IAAI;AAAA,MAAG,IAAI;AAAA,MAAG,IAAI;AAAA,MACnE,YAAY;AAAA,MAAO,OAAO,SAAS,OAAO,KAAK,QAAQ,CAAC;AAAA,IAAE,CAAC;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,KAAK,GAAW,GAAW,OAAe,QAAsB;AAC9D,QAAI,CAAC,CAAC,GAAG,GAAG,OAAO,MAAM,EAAE,MAAM,OAAO,QAAQ,EAAG;AACnD,QAAI,CAAC,CAAC,IAAI,OAAO,IAAI,MAAM,EAAE,MAAM,OAAO,QAAQ,EAAG,OAAM,IAAI,WAAW,mCAAmC;AAC7G,UAAM,QAAQ,MAAM,IAAI;AACxB,mBAAe,KAAK;AACpB,WAAO,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;AACvB,WAAO,OAAO,GAAG,CAAC,IAAI,OAAO,CAAC,CAAC;AAC/B,WAAO,OAAO,GAAG,CAAC,IAAI,OAAO,IAAI,MAAM,CAAC;AACxC,WAAO,OAAO,GAAG,CAAC,GAAG,IAAI,MAAM,CAAC;AAChC,WAAO,OAAO,GAAG,CAAC,CAAC;AACnB,WAAO,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;AACvB,UAAM;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,UAAU,GAAW,GAAW,OAAe,QAC7C,QAA2D,GAAS;AACpE,QAAI,CAAC,CAAC,GAAG,GAAG,OAAO,MAAM,EAAE,MAAM,OAAO,QAAQ,EAAG;AACnD,UAAM,OAAO,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;AAClD,QAAI,CAAC,KAAK,UAAU,KAAK,SAAS,EAAG,OAAM,IAAI,WAAW,oCAAoC;AAC9F,UAAM,SAA6B,CAAC;AACpC,eAAW,UAAU,MAAM;AACzB,YAAM,KAAK,OAAO,WAAW,WAAW,SAAS,OAAO,KAAK;AAC7D,YAAM,KAAK,OAAO,WAAW,WAAW,SAAS,OAAO,KAAK;AAC7D,UAAI,CAAC,CAAC,IAAI,EAAE,EAAE,MAAM,OAAO,QAAQ,EAAG;AACtC,UAAI,KAAK,KAAK,KAAK,EAAG,OAAM,IAAI,WAAW,oCAAoC;AAC/E,aAAO,KAAK,CAAC,IAAI,EAAE,CAAC;AAAA,IACtB;AACA,UAAM,UAAU,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,KAAK,OAAO,CAAC,GAAG,OAAO,CAAC,KAAK,OAAO,CAAC,GAAG,OAAO,CAAC,KAAK,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC;AAC/G,UAAM,IAAI,KAAK,IAAI,KAAK,GAAG,IAAI,KAAK,IAAI,MAAM;AAC9C,UAAM,QAAQ,CAAC,QAAgB,QAAgB,QAAQ,IAAI,IAAI,SAAS;AACxE,UAAM,QAAQ,KAAK;AAAA,MAAI;AAAA,MAAG,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AAAA,MAAG,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AAAA,MACvG,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AAAA,MAAG,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AAAA,IAAC;AAClF,UAAM,CAAC,IAAI,IAAI,IAAI,EAAE,IAAI,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,OAAO,KAAK,KAAK,CAAC;AAC3E,UAAM,OAAO,IAAI,aAAa;AAC9B,SAAK,OAAO,GAAG,CAAC,GAAG,CAAC;AACpB,SAAK,OAAO,IAAI,GAAG,CAAC,GAAG,CAAC;AACxB,SAAK,QAAQ,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC;AAC/D,SAAK,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC;AACxB,SAAK,QAAQ,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,KAAK,KAAK,CAAC;AAClE,SAAK,OAAO,GAAG,CAAC,GAAG,CAAC;AACpB,SAAK,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,KAAK,KAAK,GAAG,KAAK,EAAE;AACpE,SAAK,OAAO,GAAG,GAAG,CAAC,CAAC;AACpB,SAAK,QAAQ,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,KAAK,IAAI,KAAK,KAAK,GAAG;AAClE,SAAK,UAAU;AAEf,SAAK,OAAO,QAAQ,IAAI,IAAI,GAAG,SAAS,IAAI,IAAI,CAAC;AACjD,SAAK,UAAU,EAAE,GAAG,QAAQ,IAAI,KAAK,GAAG,GAAG,SAAS,IAAI,KAAK,GAAG,GAAG,GAAG,GAAG,EAAE,CAAC;AAC5E,SAAK,UAAU,IAAI;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,QAAQ,OAAqB,SAA0B,CAAC,GAAS;AAC/D,QAAI,CAAC,MAAM,KAAK,EAAE,MAAO;AACzB,UAAM,aAAa,UAAU,WAAW,MAAM;AAC9C,QAAI,CAAC,WAAW,KAAM,OAAM,IAAI,UAAU,2CAA2C;AACrF,QAAI,CAAC,CAAC,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC,EAAE,MAAM,OAAO,QAAQ,EAAG;AAClH,UAAM,OAAO,MAAM,MAAM;AACzB,SAAK,UAAU,UAAU;AACzB,UAAM,QAAQ,MAAM,IAAI;AACxB,WAAO,OAAO,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AACnC,SAAK,UAAU,IAAI;AAAA,EACrB;AAAA,EAEA,UAAU,OAA2B;AACnC,UAAM,SAAS,MAAM,KAAK,GAAG,QAAQ,MAAM,IAAI;AAC/C,mBAAe,KAAK;AACpB,YAAQ,OAAO,MAAM,QAAQ,OAAO,OAAO,MAAM,SAAS,OAAO,MAAM;AACvE,UAAM,MAAM,IAAI,OAAO,MAAM,SAAS,GAAG,OAAO,KAAK,GAAG,MAAM,KAAK;AACnE,UAAM,KAAK,IAAI,OAAO,KAAK,SAAS,GAAG,OAAO,MAAM,GAAG,MAAM,MAAM;AACnE,UAAM,SAAS,OAAO;AAAO,UAAM,UAAU,OAAO;AACpD,UAAM,IAAI,OAAO;AAAG,UAAM,IAAI,OAAO;AACrC,UAAM,SAAS,OAAO;AAAQ,UAAM,SAAS,OAAO;AACpD,UAAM;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,eAAe,OAAe,aAAqB,WAAmC,CAAC,GAAS;AAC9F,UAAM,QAAQ,MAAM,IAAI;AACxB,QAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAQ,MAAM,SACzD,CAAC,OAAO,UAAU,WAAW,KAAK,cAAc,KAAK,cAAc,MAAM,QAAQ,OAAO;AACxF,YAAM,IAAI,WAAW,4BAA4B;AAAA,IACnD;AACA,UAAM,YAAY,SAAS,IAAI,cAAY,EAAE,MAAM,MAAM,QAAQ,QAAQ,IAAI,GAAG,MAAM,kBAAkB,OAAO,EAAE,EAAE;AACnH,UAAM,QAAQ,MAAM,QAAQ,cAAc,UAAU;AACpD,UAAM,YAAY,UAAU,IAAK,UAAU,CAAC,GAAG,QAAQ,MAAM,MAAM,WAAW,IAAK,MAAM,MAAM,CAAC;AAChG,QAAI,QAAQ,KAAK,cAAc,EAAG,OAAM,IAAI,UAAU,wCAAwC;AAC9F,QAAI,CAAC,eAAe,CAAC,UAAU,OAAQ;AACvC,mBAAe,KAAK;AACpB,QAAI,SAAS,GAAG,UAAU;AAC1B,aAAS,IAAI,GAAG,IAAI,OAAO,IAAK,WAAU,OAAO,MAAM,MAAM,CAAC,CAAC;AAC/D,aAAS,IAAI,OAAO,IAAI,QAAQ,aAAa,IAAK,YAAW,OAAO,MAAM,MAAM,CAAC,CAAC;AAClF,UAAM,QAAQ,UAAU,OAAO,CAAC,KAAK,YAAY,MAAM,QAAQ,KAAK,QAAQ,CAAC;AAC7E,UAAM,SAAS,MAAM,SAAS,UAAU;AACxC,YAAQ,OAAO,OAAO,MAAM;AAC5B,UAAM,MAAM,WAAW,QAAQ,UAAU,QAAQ,QAAQ,aAAa,MAAM,KAAK;AACjF,UAAM,KAAK,WAAW,SAAS,OAAO,SAAS,SAAS,MAAM,MAAM;AACpE,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,YAAM,MAAM,QAAQ,CAAC,IAAI,UAAU,CAAC,EAAE;AACtC,YAAM,KAAK,IAAI,UAAU,CAAC,EAAE,MAAM,MAAM;AACxC,gBAAU,UAAU,CAAC,EAAE,KAAK;AAAA,IAC9B;AACA,UAAM,QAAQ;AAAO,UAAM,SAAS;AACpC,iBAAa,KAAK;AAClB,UAAM;AAAA,EACR;AAAA,EAEA,OAAO,MAAc,MAAsB;AACzC,QAAI,CAAC,KAAK,MAAM,OAAO,QAAQ,EAAG;AAClC,UAAM,QAAQ,MAAM,IAAI;AACxB,mBAAe,KAAK;AACpB,QAAI,CAAC,MAAM,SAAS,SAAS,GAAG;AAE9B,aAAO,OAAO,GAAG,KAAK,MAAM,GAAG,CAAC,CAAC;AACjC,UAAI,SAAS,GAAG;AACd,cAAM;AACN;AAAA,MACF;AAAA,IACF;AACA,WAAO,OAAO,MAAM,IAAI;AACxB,UAAM;AAAA,EACR;AAAA,EAEA,QAAQ,OAAuB;AAC7B,UAAM,QAAQ,MAAM,IAAI;AACxB,QAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,SAAS,MAAM,OAAO;AACjE,YAAM,IAAI,WAAW,qCAAqC;AAAA,IAC5D;AACA,QAAI,SAAS;AACb,aAAS,IAAI,GAAG,IAAI,OAAO,IAAK,WAAU,OAAO,MAAM,MAAM,CAAC,CAAC;AAC/D,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,WAAW,OAA4B;AACrC,WAAO,YAAY,MAAM,IAAI,GAAG,OAAO,KAAK,QAAQ,KAAK,CAAC;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,WAAW,OAAe,SAA4B;AACpD,UAAM,SAAS,KAAK,QAAQ,KAAK;AACjC,UAAM,OAAO,MAAM,QAAQ,QAAQ,IAAI;AACvC,UAAM,OAAO,kBAAkB,OAAO;AACtC,QAAI,CAAC,KAAK,MAAM,OAAO,QAAQ,EAAG,OAAM,IAAI,WAAW,kCAAkC;AACzF,QAAI,UAAU,KAAK,SAAS,EAAG,OAAM,IAAI,UAAU,wCAAwC;AAC3F,UAAM,QAAQ,MAAM,IAAI;AACxB,mBAAe,KAAK;AACpB,UAAM,WAAW,OAAO,MAAM,MAAM,KAAK,CAAC;AAC1C,UAAM,SAAS,MAAM,SAAS,KAAK,SAAS;AAC5C,YAAQ,OAAO,MAAM,OAAO,MAAM;AAClC,UAAM,KAAK,WAAW,SAAS,KAAK,QAAQ,SAAS,UAAU,MAAM,MAAM;AAC3E,UAAM,KAAK,IAAI,MAAM,MAAM;AAC3B,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,SAAS;AACf,iBAAa,KAAK;AAClB,UAAM;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAU,QAA+B;AACvC,UAAM,QAAQ;AACd,UAAM,aAAa,UAAU,WAAW,KAAK;AAC7C,QAAI,CAAC,WAAW,KAAM,OAAM,IAAI,UAAU,2CAA2C;AACrF,UAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,IAAI;AAC7B,QAAI,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,MAAM,OAAO,QAAQ,GAAG;AAC9C,YAAM,IAAI,WAAW,gCAAgC;AAAA,IACvD;AACA,UAAM,QAAQ,MAAM,IAAI;AACxB,QAAI,CAAC,MAAM,MAAO;AAClB,mBAAe,KAAK;AAEpB,eAAW,SAAS,CAAC,OAAO,IAAI,GAAG;AACjC,wBAAkB,MAAM,CAAC,MAAM,MAAM,WAAW;AAC9C,cAAM,SAAS,SAAS,IAAI,IAAI,OAAO,IAAI;AAC3C,iBAAS,IAAI,GAAG,IAAI,QAAQ,KAAK,GAAG;AAClC,gBAAM,IAAI,KAAK,SAAS,CAAC,GAAG,IAAI,KAAK,SAAS,IAAI,CAAC;AACnD,gBAAM,SAAS,SAAS,KAAK,IAAI;AACjC,gBAAM,QAAQ,IAAI,IAAI,IAAI,KAAK,SAAS,IAAI;AAC5C,gBAAM,QAAQ,IAAI,IAAI,IAAI,KAAK,SAAS,IAAI;AAC5C,cAAI,CAAC,OAAO,SAAS,KAAK,KAAK,CAAC,OAAO,SAAS,KAAK,GAAG;AACtD,kBAAM,IAAI,WAAW,wCAAwC;AAAA,UAC/D;AACA,cAAI,OAAO;AAAE,iBAAK,SAAS,CAAC,IAAI;AAAO,iBAAK,SAAS,IAAI,CAAC,IAAI;AAAA,UAAO;AAAA,QACvE;AAAA,MACF,CAAC;AAAA,IACH;AACA,iBAAa,KAAK;AAClB,UAAM;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,EAAE,OAAO,QAAQ,IAAmC;AAClD,UAAM,QAAQ,MAAM,IAAI;AACxB,UAAM,WAAW,MAAM;AACvB,QAAI,SAAS;AACb,aAAS,QAAQ,GAAG,QAAQ,MAAM,OAAO,SAAS;AAChD,UAAI,MAAM,aAAa,SAAU,OAAM,IAAI,MAAM,wCAAwC;AACzF,YAAM,QAAQ,OAAO,MAAM,MAAM,KAAK,CAAC;AACvC,YAAM,YAAY,OAAO,OAAO,MAAM;AACtC,UAAI,MAAM,aAAa,SAAU,OAAM,IAAI,MAAM,wCAAwC;AACzF,gBAAU;AAAA,IACZ;AAAA,EACF;AACF;AAEA,SAAS,YAAY,OAAgB,OAAe,QAA6B;AAC/E,QAAM,IAAI,MAAM;AAChB,UAAQ,MAAM,MAAM,KAAK,GAAG;AAAA,IAC1B,KAAK;AAAG,aAAO,EAAE,MAAM,QAAQ,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE;AAAA,IAC9D,KAAK;AAAG,aAAO,EAAE,MAAM,QAAQ,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE;AAAA,IAC9D,KAAK;AAAG,aAAO,EAAE,MAAM,aAAa,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,SAAS,CAAC,GAAG,GAAG,EAAE,SAAS,CAAC,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE;AAAA,IAC3G,KAAK;AAAG,aAAO,EAAE,MAAM,SAAS,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,SAAS,CAAC,GAAG,GAAG,EAAE,SAAS,CAAC,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE;AAAA,IACnJ,KAAK;AAAG,aAAO,EAAE,MAAM,OAAO,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC,GAAG,YAAY,EAAE,SAAS,CAAC,GAAG,OAAO,EAAE,SAAS,CAAC,EAAE;AAAA,IAC5L;AAAS,aAAO,EAAE,MAAM,QAAQ;AAAA,EAClC;AACF;AAEA,SAAS,kBAAkB,SAAgC;AACzD,QAAM,OAAO,SAAS,OAAO;AAC7B,MAAI,CAAC,KAAK,MAAM,OAAO,QAAQ,EAAG,OAAM,IAAI,WAAW,kCAAkC;AACzF,MAAI,QAAQ,SAAS,UAAU,KAAK,IAAI,QAAQ,KAAK,IAAI,OAAO,KAAK,IAAI,QAAQ,UAAU,IAAI,MAAM;AACnG,UAAM,IAAI,WAAW,kDAAkD;AAAA,EACzE;AACA,SAAO;AACT;AAEA,SAAS,YAAY,OAAgB,MAAc,MAAyB,QAAsB;AAChG,MAAI,SAAS,GAAG;AAAE,UAAM,IAAI,MAAM;AAAQ,UAAM,IAAI,MAAM;AAAQ;AAAA,EAAQ;AAC1E,MAAI,SAAS,GAAG;AACd,UAAM,QAAQ,KAAK,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC;AAChD,UAAM,IAAI,KAAK,MAAM,IAAI,KAAK,SAAS,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,SAAS,CAAC,IAAI,KAAK,IAAI,KAAK;AAC/F,UAAM,IAAI,KAAK,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,SAAS,CAAC,IAAI,KAAK,IAAI,KAAK;AAAA,EACrG,OAAO;AACL,UAAM,IAAI,KAAK,SAAS,OAAO,IAAI,IAAI,CAAC;AAAG,UAAM,IAAI,KAAK,SAAS,OAAO,IAAI,IAAI,CAAC;AAAA,EACrF;AACA,MAAI,SAAS,GAAG;AAAE,UAAM,SAAS,MAAM;AAAG,UAAM,SAAS,MAAM;AAAA,EAAG;AACpE;AACA,SAAS,aAAa,OAAsB;AAC1C,QAAM,IAAI,MAAM,IAAI,MAAM,SAAS,MAAM,SAAS;AAClD,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,OAAO,KAAK;AACpC,gBAAY,OAAO,MAAM,MAAM,CAAC,GAAG,MAAM,MAAM,MAAM;AACrD,cAAU,OAAO,MAAM,MAAM,CAAC,CAAC;AAAA,EACjC;AACF;",
+  "names": []
+}

package/dist/lib/geometry/path-radial.d.ts

@@ -0,0 +1,15 @@
+import { PathGeometry } from './path-geometry.js';
+import { type SimplifyPathOptions } from './path-utilities.js';
+/**
+ * Simplifies line-only paths with a radial-distance prepass followed by the
+ * default Douglas--Peucker implementation. Each stage receives half of the
+ * requested error budget, so their errors compose within `tolerance`.
+ *
+ * @param path - Source geometry; it is not modified. See {@link PathGeometry}.
+ * @param options - Simplification tolerance and work limits. See {@link SimplifyPathOptions}.
+ * @returns Independent geometry with redundant line vertices removed. See {@link PathGeometry}.
+ *
+ * @see {@link PathGeometry}
+ * @see {@link SimplifyPathOptions}
+ */
+export declare function simplifyPathRadial(path: PathGeometry, options: Readonly<SimplifyPathOptions>): PathGeometry;