@pibbl/core 0.0.1

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

@@ -0,0 +1,478 @@
+import { PathGeometry } from "./path-geometry.js";
+import {
+  bendSpans,
+  bendSpanBounds,
+  splitBendSpan
+} from "./path-bend-spans.js";
+import {
+  absI,
+  constant,
+  add,
+  sub,
+  scale,
+  mul,
+  lerp,
+  reciprocal
+} from "./transform-math.js";
+import {
+  snapshotGuide,
+  sampleGuide
+} from "./transform-guide.js";
+import {
+  warpPath
+} from "./path-warp.js";
+const definitions = /* @__PURE__ */ new WeakMap();
+const MAX_WORK = 2e6;
+const coordinate = (value, label = "coordinate") => {
+  if (typeof value !== "number")
+    throw new TypeError(`${label} must be a number.`);
+  if (!Number.isFinite(value)) throw new RangeError(`${label} must be finite.`);
+  return value;
+};
+const positive = (value, label) => {
+  coordinate(value, label);
+  if (value <= 0) throw new RangeError(`${label} must be positive.`);
+  return value;
+};
+function rectangle(input) {
+  return {
+    x: coordinate(input?.x),
+    y: coordinate(input?.y),
+    width: positive(input?.width, "source.width"),
+    height: positive(input?.height, "source.height")
+  };
+}
+const normalize = (input, r) => [
+  scale(sub(input[0], constant(r.x)), 1 / r.width),
+  scale(sub(input[1], constant(r.y)), 1 / r.height)
+];
+function make(factories) {
+  let cachedAccuracy = NaN, cached = [];
+  const prepare = (accuracy) => {
+    if (accuracy !== cachedAccuracy) {
+      cached = factories.map((f) => f(accuracy));
+      cachedAccuracy = accuracy;
+    }
+    return cached;
+  };
+  const value = Object.freeze({
+    mapPoint(point, options = {}) {
+      const tolerance = positive(options.tolerance ?? 1e-4, "tolerance");
+      const input = [
+        constant(coordinate(point?.x)),
+        constant(coordinate(point?.y))
+      ];
+      for (let accuracy = tolerance / 16, attempt = 0; attempt < 9; attempt++, accuracy /= 16) {
+        const result = evaluate(prepare(accuracy), input);
+        const x = result.value[0].v[0], y = result.value[1].v[0];
+        if (!result.domain)
+          throw new RangeError(
+            "Point lies outside a transformation source rectangle."
+          );
+        if (result.error + roundoff(result.value) <= tolerance)
+          return { x: coordinate(x), y: coordinate(y) };
+      }
+      throw new RangeError(
+        "Cannot certify point accuracy at available precision."
+      );
+    }
+  });
+  definitions.set(value, factories);
+  return value;
+}
+function definition(value) {
+  const result = definitions.get(value);
+  if (!result)
+    throw new TypeError("Expected a constructor-created PathTransform.");
+  return result;
+}
+function composeTransforms(...transforms) {
+  return make(transforms.flatMap((t) => [...definition(t)]));
+}
+function affineTransform(matrix = {}) {
+  const m = affineMatrix(matrix);
+  return make([
+    () => ({
+      affine: m,
+      error: () => 0,
+      evaluate: ([x, y]) => [
+        add(add(scale(x, m.a), scale(y, m.c)), constant(m.e)),
+        add(add(scale(x, m.b), scale(y, m.d)), constant(m.f))
+      ]
+    })
+  ]);
+}
+function quadTransform(options) {
+  const source = rectangle(options.source), mode = options.mode === void 0 ? "bilinear" : options.mode;
+  const names = ["topLeft", "topRight", "bottomLeft", "bottomRight"];
+  const corners = names.map((n) => ({
+    x: coordinate(options.destination?.[n]?.x),
+    y: coordinate(options.destination?.[n]?.y)
+  }));
+  const destination = Object.fromEntries(
+    names.map((n, i) => [n, corners[i]])
+  );
+  warpPath(new PathGeometry(), { source, destination, mode, tolerance: 1 });
+  const [a, b, c, d] = corners;
+  const dx1 = b.x - d.x, dx2 = c.x - d.x, dx3 = a.x - b.x - c.x + d.x;
+  const dy1 = b.y - d.y, dy2 = c.y - d.y, dy3 = a.y - b.y - c.y + d.y;
+  const det = dx1 * dy2 - dx2 * dy1;
+  const g = mode === "perspective" ? (dx3 * dy2 - dx2 * dy3) / det : 0;
+  const h = mode === "perspective" ? (dx1 * dy3 - dx3 * dy1) / det : 0;
+  return make([
+    () => ({
+      apply: (path, quality) => warpPath(path, {
+        source,
+        destination,
+        mode,
+        tolerance: quality.tolerance,
+        maxSegments: quality.maxSegments
+      }),
+      error: () => 0,
+      evaluate: (input) => {
+        const [u, v] = normalize(input, source);
+        if (mode === "bilinear")
+          return [
+            lerp(
+              lerp(constant(a.x), constant(b.x), u),
+              lerp(constant(c.x), constant(d.x), u),
+              v
+            ),
+            lerp(
+              lerp(constant(a.y), constant(b.y), u),
+              lerp(constant(c.y), constant(d.y), u),
+              v
+            )
+          ];
+        const w = reciprocal(add(add(scale(u, g), scale(v, h)), constant(1)));
+        return [
+          mul(
+            add(
+              add(scale(u, b.x - a.x + g * b.x), scale(v, c.x - a.x + h * c.x)),
+              constant(a.x)
+            ),
+            w
+          ),
+          mul(
+            add(
+              add(scale(u, b.y - a.y + g * b.y), scale(v, c.y - a.y + h * c.y)),
+              constant(a.y)
+            ),
+            w
+          )
+        ];
+      }
+    })
+  ]);
+}
+function envelopeTransform(options) {
+  const source = rectangle(options.source);
+  if (options.interpolation !== void 0 && options.interpolation !== "linear")
+    throw new TypeError("Unsupported envelope interpolation.");
+  if (options.guides && (options.top || options.bottom))
+    throw new TypeError("Specify guides or top/bottom, not both.");
+  const guides = (options.guides ?? [
+    { at: 0, path: options.top },
+    { at: 1, path: options.bottom }
+  ]).map((g) => ({ at: coordinate(g.at), guide: snapshotGuide(g.path) }));
+  if (guides.length < 2 || guides[0].at !== 0 || guides.at(-1).at !== 1 || guides.some((g, i) => i > 0 && g.at <= guides[i - 1].at))
+    throw new RangeError("Envelope guides must strictly increase from 0 to 1.");
+  return make([
+    (accuracy) => {
+      const sampled = guides.map((g) => sampleGuide(g.guide, accuracy));
+      const error = Math.max(...sampled.map((g) => g.error));
+      const evaluateBand = (input, i) => {
+        const [u, v] = normalize(input, source), a = sampled[i].evaluate(u), b = sampled[i + 1].evaluate(u);
+        const t = scale(
+          sub(v, constant(guides[i].at)),
+          1 / (guides[i + 1].at - guides[i].at)
+        );
+        return [lerp(a[0], b[0], t), lerp(a[1], b[1], t)];
+      };
+      return {
+        error: () => error,
+        domain: (input, margin) => input[0].v[0] >= source.x - margin && input[0].v[1] <= source.x + source.width + margin && input[1].v[0] >= source.y - margin && input[1].v[1] <= source.y + source.height + margin,
+        evaluate: (input) => {
+          const v0 = (input[1].v[0] - source.y) / source.height, v1 = (input[1].v[1] - source.y) / source.height;
+          let first = 0;
+          while (first < guides.length - 2 && guides[first + 1].at <= v0)
+            first++;
+          let last = first;
+          while (last < guides.length - 2 && guides[last + 1].at < v1) last++;
+          if (first === last) return evaluateBand(input, first);
+          const outputs = [];
+          for (let i = first; i <= last; i++) {
+            const y = {
+              ...input[1],
+              v: [
+                Math.max(
+                  input[1].v[0],
+                  source.y + guides[i].at * source.height
+                ),
+                Math.min(
+                  input[1].v[1],
+                  source.y + guides[i + 1].at * source.height
+                )
+              ]
+            };
+            outputs.push(evaluateBand([input[0], y], i));
+          }
+          return [0, 1].map((axis) => ({
+            v: [
+              Math.min(...outputs.map((p) => p[axis].v[0])),
+              Math.max(...outputs.map((p) => p[axis].v[1]))
+            ],
+            d: [
+              Math.min(...outputs.map((p) => p[axis].d[0])),
+              Math.max(...outputs.map((p) => p[axis].d[1]))
+            ],
+            dd: [-Infinity, Infinity]
+          }));
+        }
+      };
+    }
+  ]);
+}
+function roundoff(pair) {
+  return Number.EPSILON * 512 * Math.max(1, ...pair.map((p) => absI(p.v)));
+}
+function evaluate(stages, input) {
+  let value = input, error = 0, domain = true;
+  for (const stage of stages) {
+    if (error > 0) {
+      const box = value.map((p) => ({
+        v: [p.v[0] - error, p.v[1] + error],
+        d: [0, 0],
+        dd: [0, 0]
+      }));
+      const dx = stage.evaluate([{ ...box[0], d: [1, 1] }, box[1]]);
+      const dy = stage.evaluate([box[0], { ...box[1], d: [1, 1] }]);
+      error *= Math.hypot(
+        absI(dx[0].d),
+        absI(dx[1].d),
+        absI(dy[0].d),
+        absI(dy[1].d)
+      );
+    }
+    domain &&= stage.domain?.(value, roundoff(value)) ?? true;
+    error += stage.error(value);
+    value = stage.evaluate(value);
+  }
+  return { value, error, domain };
+}
+function transformPath(path, transform, options) {
+  if (!(path instanceof PathGeometry))
+    throw new TypeError("transformPath requires PathGeometry.");
+  const factories = definition(transform), tolerance = positive(options?.tolerance, "tolerance");
+  const maxSegments = positive(
+    options.maxSegments === void 0 ? 1e6 : options.maxSegments,
+    "maxSegments"
+  );
+  if (!Number.isSafeInteger(maxSegments))
+    throw new RangeError("maxSegments must be a safe integer.");
+  let work = 0;
+  for (let attempt = 0, accuracy = tolerance / 32; attempt < 9; attempt++, accuracy /= 16) {
+    const stages = factories.map((f) => f(accuracy));
+    if (stages.length === 1 && stages[0].apply)
+      return stages[0].apply(path, options);
+    if (stages.every((s) => s.affine)) {
+      if (path.segmentCount > maxSegments)
+        throw new RangeError("transformPath exceeded maxSegments.");
+      let result = path.clone();
+      for (const s of stages) result = applyAffine(result, s.affine);
+      return result;
+    }
+    const output = new PathGeometry();
+    let retry = false;
+    const reserve = () => {
+      if (output.segmentCount >= maxSegments)
+        throw new RangeError("transformPath exceeded maxSegments.");
+    };
+    for (const item of bendSpans(path)) {
+      if (item.type === "close") {
+        reserve();
+        output.closePath();
+        continue;
+      }
+      if (item.type === "move") {
+        const r = evaluate(stages, [
+          constant(item.point[0]),
+          constant(item.point[1])
+        ]);
+        if (!r.domain)
+          throw new RangeError(
+            "Path lies outside a transformation source rectangle."
+          );
+        if (r.error > tolerance / 4) {
+          retry = true;
+          break;
+        }
+        if (r.error + roundoff(r.value) > tolerance)
+          throw new RangeError("Cannot certify transform precision.");
+        reserve();
+        output.moveTo(coordinate(r.value[0].v[0]), coordinate(r.value[1].v[0]));
+        continue;
+      }
+      const stack = [
+        { span: item.span, depth: 0 }
+      ];
+      while (stack.length) {
+        if (++work > MAX_WORK)
+          throw new RangeError("transformPath exceeded its work limit.");
+        const { span, depth } = stack.pop(), b = bendSpanBounds(span);
+        const r = evaluate(stages, [
+          { v: [b.xmin, b.xmax], d: [-b.dx, b.dx], dd: [-b.ddx, b.ddx] },
+          { v: [b.ymin, b.ymax], d: [-b.dy, b.dy], dd: [-b.ddy, b.ddy] }
+        ]);
+        if (r.error > tolerance / 4) {
+          retry = true;
+          break;
+        }
+        const second = Math.hypot(absI(r.value[0].dd), absI(r.value[1].dd)) / 8;
+        const first = Math.hypot(absI(r.value[0].d), absI(r.value[1].d)) / 2;
+        const bound = Math.min(second, first) + 2 * r.error + roundoff(r.value);
+        if (r.domain && bound <= tolerance) {
+          const end = "points" in span ? span.points.at(-1) : [
+            span.arc.cx + span.arc.ux * Math.cos(span.arc.startAngle + span.arc.sweep) + span.arc.vx * Math.sin(span.arc.startAngle + span.arc.sweep),
+            span.arc.cy + span.arc.uy * Math.cos(span.arc.startAngle + span.arc.sweep) + span.arc.vy * Math.sin(span.arc.startAngle + span.arc.sweep)
+          ];
+          const p = evaluate(stages, [constant(end[0]), constant(end[1])]);
+          reserve();
+          output.lineTo(
+            coordinate(p.value[0].v[0]),
+            coordinate(p.value[1].v[0])
+          );
+        } else {
+          if (depth >= 52)
+            throw new RangeError(
+              "Cannot certify transform tolerance or source domain."
+            );
+          const [left, right] = splitBendSpan(span);
+          stack.push(
+            { span: right, depth: depth + 1 },
+            { span: left, depth: depth + 1 }
+          );
+        }
+      }
+      if (retry) break;
+    }
+    if (!retry) return output;
+  }
+  throw new RangeError("Cannot certify composed guide accuracy.");
+}
+function mergePairs(outputs) {
+  return [0, 1].map((axis) => ({
+    v: [
+      Math.min(...outputs.map((p) => p[axis].v[0])),
+      Math.max(...outputs.map((p) => p[axis].v[1]))
+    ],
+    d: [
+      Math.min(...outputs.map((p) => p[axis].d[0])),
+      Math.max(...outputs.map((p) => p[axis].d[1]))
+    ],
+    dd: [-Infinity, Infinity]
+  }));
+}
+function sourceDomain(input, source, margin) {
+  return input[0].v[0] >= source.x - margin && input[0].v[1] <= source.x + source.width + margin && input[1].v[0] >= source.y - margin && input[1].v[1] <= source.y + source.height + margin;
+}
+import { meshTransform } from "./transform-mesh.js";
+import {
+  arcBendTransform,
+  pathBendTransform
+} from "./transform-bend.js";
+function affineMatrix(matrix) {
+  if (!matrix || typeof matrix !== "object")
+    throw new TypeError("Expected a finite 2D affine matrix.");
+  const value = matrix;
+  if (value.is2D === false || ["m13", "m14", "m23", "m24", "m31", "m32", "m34", "m43"].some(
+    (k) => value[k] !== void 0 && value[k] !== 0
+  ) || [value.m33, value.m44].some((n) => n !== void 0 && n !== 1))
+    throw new RangeError("Expected a finite 2D affine matrix.");
+  const pairs = [
+    ["a", "m11", 1],
+    ["b", "m12", 0],
+    ["c", "m21", 0],
+    ["d", "m22", 1],
+    ["e", "m41", 0],
+    ["f", "m42", 0]
+  ];
+  const result = {};
+  for (const [key, alias, fallback] of pairs) {
+    const a = value[key], b = value[alias];
+    if (a !== void 0 && b !== void 0 && a !== b)
+      throw new TypeError("Conflicting affine matrix aliases.");
+    result[key] = coordinate(
+      a === void 0 ? b === void 0 ? fallback : b : a
+    );
+  }
+  return result;
+}
+function applyAffine(path, m) {
+  const p = (x, y, vector = false) => ({
+    x: coordinate(m.a * x + m.c * y + (vector ? 0 : m.e)),
+    y: coordinate(m.b * x + m.d * y + (vector ? 0 : m.f))
+  });
+  const segments = Array.from(path, (segment) => {
+    switch (segment.type) {
+      case "close":
+        return segment;
+      case "move":
+      case "line":
+        return { ...segment, ...p(segment.x, segment.y) };
+      case "quadratic": {
+        const control = p(segment.cpx, segment.cpy);
+        return {
+          ...segment,
+          ...p(segment.x, segment.y),
+          cpx: control.x,
+          cpy: control.y
+        };
+      }
+      case "cubic": {
+        const a = p(segment.cp1x, segment.cp1y), b = p(segment.cp2x, segment.cp2y);
+        return {
+          ...segment,
+          ...p(segment.x, segment.y),
+          cp1x: a.x,
+          cp1y: a.y,
+          cp2x: b.x,
+          cp2y: b.y
+        };
+      }
+      case "arc": {
+        const center = p(segment.cx, segment.cy), u = p(segment.ux, segment.uy, true), v = p(segment.vx, segment.vy, true);
+        return {
+          ...segment,
+          cx: center.x,
+          cy: center.y,
+          ux: u.x,
+          uy: u.y,
+          vx: v.x,
+          vy: v.y
+        };
+      }
+    }
+  });
+  const result = new PathGeometry();
+  result.spliceSegments(0, 0, segments);
+  return result;
+}
+export {
+  affineTransform,
+  arcBendTransform,
+  composeTransforms,
+  coordinate,
+  envelopeTransform,
+  make,
+  mergePairs,
+  meshTransform,
+  normalize,
+  pathBendTransform,
+  positive,
+  quadTransform,
+  rectangle,
+  sourceDomain,
+  transformPath
+};
+//# sourceMappingURL=path-transforms.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-transforms.ts"],
+  "sourcesContent": ["import { PathGeometry } from './path-geometry.js';\nimport {\n  bendSpans,\n  bendSpanBounds,\n  splitBendSpan,\n  type BendSpan,\n} from './path-bend-spans.js';\nimport {\n  absI,\n  constant,\n  add,\n  sub,\n  scale,\n  mul,\n  lerp,\n  reciprocal,\n  type Pair,\n} from './transform-math.js';\nimport {\n  snapshotGuide,\n  sampleGuide,\n  type PathGuide,\n} from './transform-guide.js';\nimport {\n  warpPath,\n  type PathWarpCorners,\n  type PathWarpMode,\n} from './path-warp.js';\n\n/**\n * A point in source or destination path coordinates.\n *\n * @see {@link PathTransform}\n * @see {@link PathRect}\n */\nexport interface PathPoint {\n  /**\n   * Horizontal coordinate or displacement in the containing coordinate system. See\n   * {@link PathPoint}.\n   */\n  readonly x: number;\n  /**\n   * Vertical coordinate or displacement in the containing coordinate system. See {@link PathPoint}\n   * .\n   */\n  readonly y: number;\n}\n/**\n * A source rectangle with an origin and finite positive dimensions.\n *\n * @see {@link PathPoint}\n * @see {@link QuadTransformOptions}\n * @see {@link EnvelopeTransformOptions}\n */\nexport interface PathRect extends PathPoint {\n  /** Horizontal extent in the units of the containing geometry or surface. See {@link PathRect}. */\n  readonly width: number;\n  /** Vertical extent in the units of the containing geometry or surface. See {@link PathRect}. */\n  readonly height: number;\n}\ndeclare const transformBrand: unique symbol;\n/**\n * A constructor-created, reusable coordinate mapping for path transformation.\n *\n * @see {@link PathPoint}\n * @see {@link transformPath}\n * @see {@link composeTransforms}\n * @see {@link affineTransform}\n */\nexport interface PathTransform {\n  readonly [transformBrand]: true;\n  /**\n   * Evaluate in ordinary source/destination coordinates. Guide approximation is bounded by\n   * tolerance.\n   * @param point - Source point in the transform's input coordinate system. See {@link PathPoint}.\n   * @param options - Optional approximation tolerance for evaluating the mapping.\n   * @returns The mapped point in the transform's output coordinate system. See {@link PathPoint}.\n   */\n  mapPoint(\n    point: PathPoint,\n    options?: {\n      /** Positive maximum geometric approximation error. See {@link PathTransform}. */\n      readonly tolerance?: number;\n    },\n  ): PathPoint;\n}\n/**\n * Accuracy and output-segment limits for applying a path transform.\n *\n * @see {@link transformPath}\n */\nexport interface TransformPathOptions {\n  /** Positive maximum geometric approximation error. See {@link TransformPathOptions}. */\n  readonly tolerance: number;\n  /** Upper bound on the number of output path segments. See {@link TransformPathOptions}. */\n  readonly maxSegments?: number;\n}\n/**\n * The four destination corners used by a quadrilateral path transform.\n *\n * @see {@link QuadTransformOptions}\n */\nexport type PathQuadCorners = PathWarpCorners;\n/**\n * Selects bilinear or perspective interpolation for a quadrilateral transform.\n *\n * @see {@link QuadTransformOptions}\n */\nexport type PathQuadMode = PathWarpMode;\n/**\n * Source rectangle, destination corners, and interpolation mode for a quadrilateral transform.\n *\n * @see {@link PathRect}\n * @see {@link PathQuadCorners}\n * @see {@link PathQuadMode}\n * @see {@link quadTransform}\n */\nexport interface QuadTransformOptions {\n  /** Source rectangle mapped to the destination quadrilateral. See {@link PathRect}. */\n  readonly source: PathRect;\n  /** Destination corners into which the source rectangle maps. See {@link PathQuadCorners}. */\n  readonly destination: PathQuadCorners;\n  /** Selects the supported mapping, placement, or result policy. See {@link PathQuadMode}. */\n  readonly mode?: PathQuadMode;\n}\n/**\n * A guide path positioned at a normalized station across an envelope.\n *\n * @see {@link PathGuide}\n * @see {@link EnvelopeTransformOptions}\n */\nexport interface EnvelopeGuide {\n  /** Normalized station position. See {@link EnvelopeGuide}. */\n  readonly at: number;\n  /** Path geometry used by this operation. See {@link PathGuide}. */\n  readonly path: PathGuide;\n}\n/**\n * Source rectangle and either a top/bottom pair or ordered envelope guides.\n *\n * @see {@link PathRect}\n * @see {@link PathGuide}\n * @see {@link EnvelopeGuide}\n * @see {@link envelopeTransform}\n */\nexport type EnvelopeTransformOptions = {\n  /** Source rectangle mapped between the envelope guides. See {@link PathRect}. */\n  readonly source: PathRect;\n  /** Interpolation between successive guide paths; only linear interpolation is supported. See {@link EnvelopeTransformOptions}. */\n  readonly interpolation?: 'linear';\n} & (\n  | {\n      /** Top edge value or top envelope guide. See {@link PathGuide}. */\n      readonly top: PathGuide;\n      /** Bottom edge value or bottom envelope guide. See {@link PathGuide}. */\n      readonly bottom: PathGuide;\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link EnvelopeTransformOptions}.\n       */\n      readonly guides?: never;\n    }\n  | {\n      /**\n       * Ordered guide paths defining the envelope from its first to last station. See\n       * {@link EnvelopeGuide}.\n       */\n      readonly guides: readonly EnvelopeGuide[];\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link EnvelopeTransformOptions}.\n       */\n      readonly top?: never;\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link EnvelopeTransformOptions}.\n       */\n      readonly bottom?: never;\n    }\n);\nexport type {\n  PathGuide,\n  PathGuideOptions,\n  PathGuideStation,\n} from './transform-guide.js';\n\nexport interface Stage {\n  apply?(path: PathGeometry, options: TransformPathOptions): PathGeometry;\n  evaluate(input: Pair): Pair;\n  error(input: Pair): number;\n  domain?(point: Pair, margin: number): boolean;\n  affine?: Affine;\n}\nexport type Factory = (accuracy: number) => Stage;\nconst definitions = new WeakMap<PathTransform, readonly Factory[]>();\nconst MAX_WORK = 2_000_000;\nexport const coordinate = (value: number, label = 'coordinate') => {\n  if (typeof value !== 'number')\n    throw new TypeError(`${label} must be a number.`);\n  if (!Number.isFinite(value)) throw new RangeError(`${label} must be finite.`);\n  return value;\n};\nexport const positive = (value: number, label: string) => {\n  coordinate(value, label);\n  if (value <= 0) throw new RangeError(`${label} must be positive.`);\n  return value;\n};\nexport function rectangle(input: PathRect): PathRect {\n  return {\n    x: coordinate(input?.x),\n    y: coordinate(input?.y),\n    width: positive(input?.width, 'source.width'),\n    height: positive(input?.height, 'source.height'),\n  };\n}\nexport const normalize = (input: Pair, r: PathRect): Pair => [\n  scale(sub(input[0], constant(r.x)), 1 / r.width),\n  scale(sub(input[1], constant(r.y)), 1 / r.height),\n];\nexport function make(factories: readonly Factory[]): PathTransform {\n  // One cached preparation only; drag sessions cannot grow a tolerance cache indefinitely.\n  let cachedAccuracy = NaN,\n    cached: readonly Stage[] = [];\n  const prepare = (accuracy: number) => {\n    if (accuracy !== cachedAccuracy) {\n      cached = factories.map((f) => f(accuracy));\n      cachedAccuracy = accuracy;\n    }\n    return cached;\n  };\n  const value = Object.freeze({\n    mapPoint(point: PathPoint, options: { tolerance?: number } = {}) {\n      const tolerance = positive(options.tolerance ?? 0.0001, 'tolerance');\n      const input: Pair = [\n        constant(coordinate(point?.x)),\n        constant(coordinate(point?.y)),\n      ];\n      for (\n        let accuracy = tolerance / 16, attempt = 0;\n        attempt < 9;\n        attempt++, accuracy /= 16\n      ) {\n        const result = evaluate(prepare(accuracy), input);\n        const x = result.value[0].v[0],\n          y = result.value[1].v[0];\n        if (!result.domain)\n          throw new RangeError(\n            'Point lies outside a transformation source rectangle.',\n          );\n        if (result.error + roundoff(result.value) <= tolerance)\n          return { x: coordinate(x), y: coordinate(y) };\n      }\n      throw new RangeError(\n        'Cannot certify point accuracy at available precision.',\n      );\n    },\n  }) as PathTransform;\n  definitions.set(value, factories);\n  return value;\n}\nfunction definition(value: PathTransform): readonly Factory[] {\n  const result = definitions.get(value);\n  if (!result)\n    throw new TypeError('Expected a constructor-created PathTransform.');\n  return result;\n}\n/**\n * Apply mappings in the order written. Empty composition is identity.\n *\n * @param transforms - Point mappings in the order they should be applied. See\n * {@link PathTransform} .\n * @returns One mapping that applies each supplied transform in order. See {@link PathTransform}.\n *\n * @see {@link PathTransform}\n */\nexport function composeTransforms(\n  ...transforms: readonly PathTransform[]\n): PathTransform {\n  return make(transforms.flatMap((t) => [...definition(t)]));\n}\n/**\n * Creates a reusable 2D affine mapping; an omitted matrix produces identity.\n *\n * @param matrix - Affine matrix coefficients; omitted coefficients use the identity matrix.\n * @returns A point mapping applying the matrix. See {@link PathTransform}.\n *\n * @see {@link PathTransform}\n */\nexport function affineTransform(matrix: DOMMatrix2DInit = {}): PathTransform {\n  const m = affineMatrix(matrix);\n  return make([\n    () => ({\n      affine: m,\n      error: () => 0,\n      evaluate: ([x, y]) => [\n        add(add(scale(x, m.a), scale(y, m.c)), constant(m.e)),\n        add(add(scale(x, m.b), scale(y, m.d)), constant(m.f)),\n      ],\n    }),\n  ]);\n}\n/**\n * Maps a source rectangle into four destination corners using bilinear or perspective\n * interpolation.\n *\n * @param options - Source rectangle and destination corner positions. See\n * {@link QuadTransformOptions} .\n * @returns A point mapping from the source rectangle to the destination quadrilateral. See\n * {@link PathTransform} .\n *\n * @see {@link QuadTransformOptions}\n * @see {@link PathTransform}\n */\nexport function quadTransform(options: QuadTransformOptions): PathTransform {\n  const source = rectangle(options.source),\n    mode = options.mode === undefined ? 'bilinear' : options.mode;\n  const names = ['topLeft', 'topRight', 'bottomLeft', 'bottomRight'] as const;\n  const corners = names.map((n) => ({\n    x: coordinate(options.destination?.[n]?.x),\n    y: coordinate(options.destination?.[n]?.y),\n  }));\n  const destination = Object.fromEntries(\n    names.map((n, i) => [n, corners[i]]),\n  ) as unknown as PathWarpCorners;\n  // Reuse the existing convexity/pole validation, including empty geometry validation.\n  warpPath(new PathGeometry(), { source, destination, mode, tolerance: 1 });\n  const [a, b, c, d] = corners;\n  const dx1 = b.x - d.x,\n    dx2 = c.x - d.x,\n    dx3 = a.x - b.x - c.x + d.x;\n  const dy1 = b.y - d.y,\n    dy2 = c.y - d.y,\n    dy3 = a.y - b.y - c.y + d.y;\n  const det = dx1 * dy2 - dx2 * dy1;\n  const g = mode === 'perspective' ? (dx3 * dy2 - dx2 * dy3) / det : 0;\n  const h = mode === 'perspective' ? (dx1 * dy3 - dx3 * dy1) / det : 0;\n  return make([\n    () => ({\n      apply: (path, quality) =>\n        warpPath(path, {\n          source,\n          destination,\n          mode,\n          tolerance: quality.tolerance,\n          maxSegments: quality.maxSegments,\n        }),\n      error: () => 0,\n      evaluate: (input) => {\n        const [u, v] = normalize(input, source);\n        if (mode === 'bilinear')\n          return [\n            lerp(\n              lerp(constant(a.x), constant(b.x), u),\n              lerp(constant(c.x), constant(d.x), u),\n              v,\n            ),\n            lerp(\n              lerp(constant(a.y), constant(b.y), u),\n              lerp(constant(c.y), constant(d.y), u),\n              v,\n            ),\n          ];\n        const w = reciprocal(add(add(scale(u, g), scale(v, h)), constant(1)));\n        return [\n          mul(\n            add(\n              add(scale(u, b.x - a.x + g * b.x), scale(v, c.x - a.x + h * c.x)),\n              constant(a.x),\n            ),\n            w,\n          ),\n          mul(\n            add(\n              add(scale(u, b.y - a.y + g * b.y), scale(v, c.y - a.y + h * c.y)),\n              constant(a.y),\n            ),\n            w,\n          ),\n        ];\n      },\n    }),\n  ]);\n}\n/**\n * Maps a source rectangle between ordered guide paths using linear interpolation.\n *\n * @param options - Source bounds and envelope guides defining the deformation. See\n * {@link EnvelopeTransformOptions} .\n * @returns A point mapping that deforms the source into the envelope. See {@link PathTransform}.\n *\n * @see {@link EnvelopeTransformOptions}\n * @see {@link PathTransform}\n */\nexport function envelopeTransform(\n  options: EnvelopeTransformOptions,\n): PathTransform {\n  const source = rectangle(options.source);\n  if (options.interpolation !== undefined && options.interpolation !== 'linear')\n    throw new TypeError('Unsupported envelope interpolation.');\n  if (options.guides && (options.top || options.bottom))\n    throw new TypeError('Specify guides or top/bottom, not both.');\n  const guides = (\n    options.guides ?? [\n      { at: 0, path: options.top! },\n      { at: 1, path: options.bottom! },\n    ]\n  ).map((g) => ({ at: coordinate(g.at), guide: snapshotGuide(g.path) }));\n  if (\n    guides.length < 2 ||\n    guides[0].at !== 0 ||\n    guides.at(-1)!.at !== 1 ||\n    guides.some((g, i) => i > 0 && g.at <= guides[i - 1].at)\n  )\n    throw new RangeError('Envelope guides must strictly increase from 0 to 1.');\n  return make([\n    (accuracy) => {\n      const sampled = guides.map((g) => sampleGuide(g.guide, accuracy));\n      const error = Math.max(...sampled.map((g) => g.error));\n      const evaluateBand = (input: Pair, i: number): Pair => {\n        const [u, v] = normalize(input, source),\n          a = sampled[i].evaluate(u),\n          b = sampled[i + 1].evaluate(u);\n        const t = scale(\n          sub(v, constant(guides[i].at)),\n          1 / (guides[i + 1].at - guides[i].at),\n        );\n        return [lerp(a[0], b[0], t), lerp(a[1], b[1], t)];\n      };\n      return {\n        error: () => error,\n        domain: (input, margin) =>\n          input[0].v[0] >= source.x - margin &&\n          input[0].v[1] <= source.x + source.width + margin &&\n          input[1].v[0] >= source.y - margin &&\n          input[1].v[1] <= source.y + source.height + margin,\n        evaluate: (input) => {\n          const v0 = (input[1].v[0] - source.y) / source.height,\n            v1 = (input[1].v[1] - source.y) / source.height;\n          let first = 0;\n          while (first < guides.length - 2 && guides[first + 1].at <= v0)\n            first++;\n          let last = first;\n          while (last < guides.length - 2 && guides[last + 1].at < v1) last++;\n          if (first === last) return evaluateBand(input, first);\n          const outputs: Pair[] = [];\n          for (let i = first; i <= last; i++) {\n            const y = {\n              ...input[1],\n              v: [\n                Math.max(\n                  input[1].v[0],\n                  source.y + guides[i].at * source.height,\n                ),\n                Math.min(\n                  input[1].v[1],\n                  source.y + guides[i + 1].at * source.height,\n                ),\n              ] as const,\n            };\n            outputs.push(evaluateBand([input[0], y], i));\n          }\n          return [0, 1].map((axis) => ({\n            v: [\n              Math.min(...outputs.map((p) => p[axis].v[0])),\n              Math.max(...outputs.map((p) => p[axis].v[1])),\n            ],\n            d: [\n              Math.min(...outputs.map((p) => p[axis].d[0])),\n              Math.max(...outputs.map((p) => p[axis].d[1])),\n            ],\n            dd: [-Infinity, Infinity],\n          })) as unknown as Pair;\n        },\n      };\n    },\n  ]);\n}\nfunction roundoff(pair: Pair): number {\n  return Number.EPSILON * 512 * Math.max(1, ...pair.map((p) => absI(p.v)));\n}\nfunction evaluate(\n  stages: readonly Stage[],\n  input: Pair,\n): { value: Pair; error: number; domain: boolean } {\n  let value = input,\n    error = 0,\n    domain = true;\n  for (const stage of stages) {\n    // Bound propagation of guide approximation through every later map via its Jacobian.\n    if (error > 0) {\n      const box = value.map((p) => ({\n        v: [p.v[0] - error, p.v[1] + error] as const,\n        d: [0, 0] as const,\n        dd: [0, 0] as const,\n      })) as unknown as Pair;\n      const dx = stage.evaluate([{ ...box[0], d: [1, 1] }, box[1]]);\n      const dy = stage.evaluate([box[0], { ...box[1], d: [1, 1] }]);\n      error *= Math.hypot(\n        absI(dx[0].d),\n        absI(dx[1].d),\n        absI(dy[0].d),\n        absI(dy[1].d),\n      );\n    }\n    domain &&= stage.domain?.(value, roundoff(value)) ?? true;\n    error += stage.error(value);\n    value = stage.evaluate(value);\n  }\n  return { value, error, domain };\n}\n/**\n * Return independent geometry. Nonlinear mappings approximate the final composed curve once.\n *\n * @param path - Source geometry; it is not modified. See {@link PathGeometry}.\n * @param transform - Point mapping to apply to the source. See {@link PathTransform}.\n * @param options - Approximation tolerance and work limits for transformed curves. See\n * {@link TransformPathOptions} .\n * @returns Independent geometry containing the transformed path. See {@link PathGeometry}.\n *\n * @see {@link PathGeometry}\n * @see {@link PathTransform}\n * @see {@link TransformPathOptions}\n */\nexport function transformPath(\n  path: PathGeometry,\n  transform: PathTransform,\n  options: TransformPathOptions,\n): PathGeometry {\n  if (!(path instanceof PathGeometry))\n    throw new TypeError('transformPath requires PathGeometry.');\n  const factories = definition(transform),\n    tolerance = positive(options?.tolerance, 'tolerance');\n  const maxSegments = positive(\n    options.maxSegments === undefined ? 1_000_000 : options.maxSegments,\n    'maxSegments',\n  );\n  if (!Number.isSafeInteger(maxSegments))\n    throw new RangeError('maxSegments must be a safe integer.');\n  let work = 0;\n  for (\n    let attempt = 0, accuracy = tolerance / 32;\n    attempt < 9;\n    attempt++, accuracy /= 16\n  ) {\n    const stages = factories.map((f) => f(accuracy));\n    if (stages.length === 1 && stages[0].apply)\n      return stages[0].apply(path, options);\n    if (stages.every((s) => s.affine)) {\n      if (path.segmentCount > maxSegments)\n        throw new RangeError('transformPath exceeded maxSegments.');\n      let result = path.clone();\n      for (const s of stages) result = applyAffine(result, s.affine!);\n      return result;\n    }\n    const output = new PathGeometry();\n    let retry = false;\n    const reserve = () => {\n      if (output.segmentCount >= maxSegments)\n        throw new RangeError('transformPath exceeded maxSegments.');\n    };\n    for (const item of bendSpans(path)) {\n      if (item.type === 'close') {\n        reserve();\n        output.closePath();\n        continue;\n      }\n      if (item.type === 'move') {\n        const r = evaluate(stages, [\n          constant(item.point[0]),\n          constant(item.point[1]),\n        ]);\n        if (!r.domain)\n          throw new RangeError(\n            'Path lies outside a transformation source rectangle.',\n          );\n        if (r.error > tolerance / 4) {\n          retry = true;\n          break;\n        }\n        if (r.error + roundoff(r.value) > tolerance)\n          throw new RangeError('Cannot certify transform precision.');\n        reserve();\n        output.moveTo(coordinate(r.value[0].v[0]), coordinate(r.value[1].v[0]));\n        continue;\n      }\n      const stack: { span: BendSpan; depth: number }[] = [\n        { span: item.span, depth: 0 },\n      ];\n      while (stack.length) {\n        if (++work > MAX_WORK)\n          throw new RangeError('transformPath exceeded its work limit.');\n        const { span, depth } = stack.pop()!,\n          b = bendSpanBounds(span);\n        const r = evaluate(stages, [\n          { v: [b.xmin, b.xmax], d: [-b.dx, b.dx], dd: [-b.ddx, b.ddx] },\n          { v: [b.ymin, b.ymax], d: [-b.dy, b.dy], dd: [-b.ddy, b.ddy] },\n        ]);\n        if (r.error > tolerance / 4) {\n          retry = true;\n          break;\n        }\n        const second = Math.hypot(absI(r.value[0].dd), absI(r.value[1].dd)) / 8;\n        // A Lipschitz bound also covers piecewise-smooth guides and crossed cell boundaries.\n        const first = Math.hypot(absI(r.value[0].d), absI(r.value[1].d)) / 2;\n        const bound = Math.min(second, first) + 2 * r.error + roundoff(r.value);\n        if (r.domain && bound <= tolerance) {\n          const end =\n            'points' in span\n              ? span.points.at(-1)!\n              : [\n                  span.arc.cx +\n                    span.arc.ux *\n                      Math.cos(span.arc.startAngle + span.arc.sweep) +\n                    span.arc.vx *\n                      Math.sin(span.arc.startAngle + span.arc.sweep),\n                  span.arc.cy +\n                    span.arc.uy *\n                      Math.cos(span.arc.startAngle + span.arc.sweep) +\n                    span.arc.vy *\n                      Math.sin(span.arc.startAngle + span.arc.sweep),\n                ];\n          const p = evaluate(stages, [constant(end[0]), constant(end[1])]);\n          reserve();\n          output.lineTo(\n            coordinate(p.value[0].v[0]),\n            coordinate(p.value[1].v[0]),\n          );\n        } else {\n          if (depth >= 52)\n            throw new RangeError(\n              'Cannot certify transform tolerance or source domain.',\n            );\n          const [left, right] = splitBendSpan(span);\n          stack.push(\n            { span: right, depth: depth + 1 },\n            { span: left, depth: depth + 1 },\n          );\n        }\n      }\n      if (retry) break;\n    }\n    if (!retry) return output;\n  }\n  throw new RangeError('Cannot certify composed guide accuracy.');\n}\n\n/** @internal Merge cell enclosures; derivatives may jump at the shared edge. */\nexport function mergePairs(outputs: readonly Pair[]): Pair {\n  return [0, 1].map((axis) => ({\n    v: [\n      Math.min(...outputs.map((p) => p[axis].v[0])),\n      Math.max(...outputs.map((p) => p[axis].v[1])),\n    ],\n    d: [\n      Math.min(...outputs.map((p) => p[axis].d[0])),\n      Math.max(...outputs.map((p) => p[axis].d[1])),\n    ],\n    dd: [-Infinity, Infinity],\n  })) as unknown as Pair;\n}\nexport function sourceDomain(\n  input: Pair,\n  source: PathRect,\n  margin: number,\n): boolean {\n  return (\n    input[0].v[0] >= source.x - margin &&\n    input[0].v[1] <= source.x + source.width + margin &&\n    input[1].v[0] >= source.y - margin &&\n    input[1].v[1] <= source.y + source.height + margin\n  );\n}\nexport { meshTransform, type MeshTransformOptions } from './transform-mesh.js';\nexport {\n  arcBendTransform,\n  pathBendTransform,\n  type ArcBendTransformOptions,\n  type PathBendTransformOptions,\n  type BendTransformOptions,\n} from './transform-bend.js';\n\ninterface Affine {\n  readonly a: number;\n  readonly b: number;\n  readonly c: number;\n  readonly d: number;\n  readonly e: number;\n  readonly f: number;\n}\nfunction affineMatrix(matrix: DOMMatrix2DInit): Affine {\n  if (!matrix || typeof matrix !== 'object')\n    throw new TypeError('Expected a finite 2D affine matrix.');\n  const value = matrix as DOMMatrixInit;\n  if (\n    value.is2D === false ||\n    ['m13', 'm14', 'm23', 'm24', 'm31', 'm32', 'm34', 'm43'].some(\n      (k) =>\n        value[k as keyof DOMMatrixInit] !== undefined &&\n        value[k as keyof DOMMatrixInit] !== 0,\n    ) ||\n    [value.m33, value.m44].some((n) => n !== undefined && n !== 1)\n  )\n    throw new RangeError('Expected a finite 2D affine matrix.');\n  const pairs = [\n    ['a', 'm11', 1],\n    ['b', 'm12', 0],\n    ['c', 'm21', 0],\n    ['d', 'm22', 1],\n    ['e', 'm41', 0],\n    ['f', 'm42', 0],\n  ] as const;\n  const result = {} as Record<string, number>;\n  for (const [key, alias, fallback] of pairs) {\n    const a = value[key],\n      b = value[alias];\n    if (a !== undefined && b !== undefined && a !== b)\n      throw new TypeError('Conflicting affine matrix aliases.');\n    result[key] = coordinate(\n      a === undefined ? (b === undefined ? fallback : b) : a,\n    );\n  }\n  return result as unknown as Affine;\n}\nfunction applyAffine(path: PathGeometry, m: Affine): PathGeometry {\n  const p = (x: number, y: number, vector = false) => ({\n    x: coordinate(m.a * x + m.c * y + (vector ? 0 : m.e)),\n    y: coordinate(m.b * x + m.d * y + (vector ? 0 : m.f)),\n  });\n  const segments = Array.from(path, (segment) => {\n    switch (segment.type) {\n      case 'close':\n        return segment;\n      case 'move':\n      case 'line':\n        return { ...segment, ...p(segment.x, segment.y) };\n      case 'quadratic': {\n        const control = p(segment.cpx, segment.cpy);\n        return {\n          ...segment,\n          ...p(segment.x, segment.y),\n          cpx: control.x,\n          cpy: control.y,\n        };\n      }\n      case 'cubic': {\n        const a = p(segment.cp1x, segment.cp1y),\n          b = p(segment.cp2x, segment.cp2y);\n        return {\n          ...segment,\n          ...p(segment.x, segment.y),\n          cp1x: a.x,\n          cp1y: a.y,\n          cp2x: b.x,\n          cp2y: b.y,\n        };\n      }\n      case 'arc': {\n        const center = p(segment.cx, segment.cy),\n          u = p(segment.ux, segment.uy, true),\n          v = p(segment.vx, segment.vy, true);\n        return {\n          ...segment,\n          cx: center.x,\n          cy: center.y,\n          ux: u.x,\n          uy: u.y,\n          vx: v.x,\n          vy: v.y,\n        };\n      }\n    }\n  });\n  const result = new PathGeometry();\n  result.spliceSegments(0, 0, segments);\n  return result;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAC7B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OAEK;AACP;AAAA,EACE;AAAA,OAGK;AAuKP,MAAM,cAAc,oBAAI,QAA2C;AACnE,MAAM,WAAW;AACV,MAAM,aAAa,CAAC,OAAe,QAAQ,iBAAiB;AACjE,MAAI,OAAO,UAAU;AACnB,UAAM,IAAI,UAAU,GAAG,KAAK,oBAAoB;AAClD,MAAI,CAAC,OAAO,SAAS,KAAK,EAAG,OAAM,IAAI,WAAW,GAAG,KAAK,kBAAkB;AAC5E,SAAO;AACT;AACO,MAAM,WAAW,CAAC,OAAe,UAAkB;AACxD,aAAW,OAAO,KAAK;AACvB,MAAI,SAAS,EAAG,OAAM,IAAI,WAAW,GAAG,KAAK,oBAAoB;AACjE,SAAO;AACT;AACO,SAAS,UAAU,OAA2B;AACnD,SAAO;AAAA,IACL,GAAG,WAAW,OAAO,CAAC;AAAA,IACtB,GAAG,WAAW,OAAO,CAAC;AAAA,IACtB,OAAO,SAAS,OAAO,OAAO,cAAc;AAAA,IAC5C,QAAQ,SAAS,OAAO,QAAQ,eAAe;AAAA,EACjD;AACF;AACO,MAAM,YAAY,CAAC,OAAa,MAAsB;AAAA,EAC3D,MAAM,IAAI,MAAM,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK;AAAA,EAC/C,MAAM,IAAI,MAAM,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,MAAM;AAClD;AACO,SAAS,KAAK,WAA8C;AAEjE,MAAI,iBAAiB,KACnB,SAA2B,CAAC;AAC9B,QAAM,UAAU,CAAC,aAAqB;AACpC,QAAI,aAAa,gBAAgB;AAC/B,eAAS,UAAU,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC;AACzC,uBAAiB;AAAA,IACnB;AACA,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,OAAO,OAAO;AAAA,IAC1B,SAAS,OAAkB,UAAkC,CAAC,GAAG;AAC/D,YAAM,YAAY,SAAS,QAAQ,aAAa,MAAQ,WAAW;AACnE,YAAM,QAAc;AAAA,QAClB,SAAS,WAAW,OAAO,CAAC,CAAC;AAAA,QAC7B,SAAS,WAAW,OAAO,CAAC,CAAC;AAAA,MAC/B;AACA,eACM,WAAW,YAAY,IAAI,UAAU,GACzC,UAAU,GACV,WAAW,YAAY,IACvB;AACA,cAAM,SAAS,SAAS,QAAQ,QAAQ,GAAG,KAAK;AAChD,cAAM,IAAI,OAAO,MAAM,CAAC,EAAE,EAAE,CAAC,GAC3B,IAAI,OAAO,MAAM,CAAC,EAAE,EAAE,CAAC;AACzB,YAAI,CAAC,OAAO;AACV,gBAAM,IAAI;AAAA,YACR;AAAA,UACF;AACF,YAAI,OAAO,QAAQ,SAAS,OAAO,KAAK,KAAK;AAC3C,iBAAO,EAAE,GAAG,WAAW,CAAC,GAAG,GAAG,WAAW,CAAC,EAAE;AAAA,MAChD;AACA,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACD,cAAY,IAAI,OAAO,SAAS;AAChC,SAAO;AACT;AACA,SAAS,WAAW,OAA0C;AAC5D,QAAM,SAAS,YAAY,IAAI,KAAK;AACpC,MAAI,CAAC;AACH,UAAM,IAAI,UAAU,+CAA+C;AACrE,SAAO;AACT;AAUO,SAAS,qBACX,YACY;AACf,SAAO,KAAK,WAAW,QAAQ,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AAC3D;AASO,SAAS,gBAAgB,SAA0B,CAAC,GAAkB;AAC3E,QAAM,IAAI,aAAa,MAAM;AAC7B,SAAO,KAAK;AAAA,IACV,OAAO;AAAA,MACL,QAAQ;AAAA,MACR,OAAO,MAAM;AAAA,MACb,UAAU,CAAC,CAAC,GAAG,CAAC,MAAM;AAAA,QACpB,IAAI,IAAI,MAAM,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,EAAE,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC;AAAA,QACpD,IAAI,IAAI,MAAM,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,EAAE,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC;AAAA,MACtD;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAaO,SAAS,cAAc,SAA8C;AAC1E,QAAM,SAAS,UAAU,QAAQ,MAAM,GACrC,OAAO,QAAQ,SAAS,SAAY,aAAa,QAAQ;AAC3D,QAAM,QAAQ,CAAC,WAAW,YAAY,cAAc,aAAa;AACjE,QAAM,UAAU,MAAM,IAAI,CAAC,OAAO;AAAA,IAChC,GAAG,WAAW,QAAQ,cAAc,CAAC,GAAG,CAAC;AAAA,IACzC,GAAG,WAAW,QAAQ,cAAc,CAAC,GAAG,CAAC;AAAA,EAC3C,EAAE;AACF,QAAM,cAAc,OAAO;AAAA,IACzB,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;AAAA,EACrC;AAEA,WAAS,IAAI,aAAa,GAAG,EAAE,QAAQ,aAAa,MAAM,WAAW,EAAE,CAAC;AACxE,QAAM,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI;AACrB,QAAM,MAAM,EAAE,IAAI,EAAE,GAClB,MAAM,EAAE,IAAI,EAAE,GACd,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AAC5B,QAAM,MAAM,EAAE,IAAI,EAAE,GAClB,MAAM,EAAE,IAAI,EAAE,GACd,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AAC5B,QAAM,MAAM,MAAM,MAAM,MAAM;AAC9B,QAAM,IAAI,SAAS,iBAAiB,MAAM,MAAM,MAAM,OAAO,MAAM;AACnE,QAAM,IAAI,SAAS,iBAAiB,MAAM,MAAM,MAAM,OAAO,MAAM;AACnE,SAAO,KAAK;AAAA,IACV,OAAO;AAAA,MACL,OAAO,CAAC,MAAM,YACZ,SAAS,MAAM;AAAA,QACb;AAAA,QACA;AAAA,QACA;AAAA,QACA,WAAW,QAAQ;AAAA,QACnB,aAAa,QAAQ;AAAA,MACvB,CAAC;AAAA,MACH,OAAO,MAAM;AAAA,MACb,UAAU,CAAC,UAAU;AACnB,cAAM,CAAC,GAAG,CAAC,IAAI,UAAU,OAAO,MAAM;AACtC,YAAI,SAAS;AACX,iBAAO;AAAA,YACL;AAAA,cACE,KAAK,SAAS,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,CAAC;AAAA,cACpC,KAAK,SAAS,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,CAAC;AAAA,cACpC;AAAA,YACF;AAAA,YACA;AAAA,cACE,KAAK,SAAS,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,CAAC;AAAA,cACpC,KAAK,SAAS,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,CAAC;AAAA,cACpC;AAAA,YACF;AAAA,UACF;AACF,cAAM,IAAI,WAAW,IAAI,IAAI,MAAM,GAAG,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;AACpE,eAAO;AAAA,UACL;AAAA,YACE;AAAA,cACE,IAAI,MAAM,GAAG,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,GAAG,MAAM,GAAG,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;AAAA,cAChE,SAAS,EAAE,CAAC;AAAA,YACd;AAAA,YACA;AAAA,UACF;AAAA,UACA;AAAA,YACE;AAAA,cACE,IAAI,MAAM,GAAG,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,GAAG,MAAM,GAAG,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;AAAA,cAChE,SAAS,EAAE,CAAC;AAAA,YACd;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAWO,SAAS,kBACd,SACe;AACf,QAAM,SAAS,UAAU,QAAQ,MAAM;AACvC,MAAI,QAAQ,kBAAkB,UAAa,QAAQ,kBAAkB;AACnE,UAAM,IAAI,UAAU,qCAAqC;AAC3D,MAAI,QAAQ,WAAW,QAAQ,OAAO,QAAQ;AAC5C,UAAM,IAAI,UAAU,yCAAyC;AAC/D,QAAM,UACJ,QAAQ,UAAU;AAAA,IAChB,EAAE,IAAI,GAAG,MAAM,QAAQ,IAAK;AAAA,IAC5B,EAAE,IAAI,GAAG,MAAM,QAAQ,OAAQ;AAAA,EACjC,GACA,IAAI,CAAC,OAAO,EAAE,IAAI,WAAW,EAAE,EAAE,GAAG,OAAO,cAAc,EAAE,IAAI,EAAE,EAAE;AACrE,MACE,OAAO,SAAS,KAChB,OAAO,CAAC,EAAE,OAAO,KACjB,OAAO,GAAG,EAAE,EAAG,OAAO,KACtB,OAAO,KAAK,CAAC,GAAG,MAAM,IAAI,KAAK,EAAE,MAAM,OAAO,IAAI,CAAC,EAAE,EAAE;AAEvD,UAAM,IAAI,WAAW,qDAAqD;AAC5E,SAAO,KAAK;AAAA,IACV,CAAC,aAAa;AACZ,YAAM,UAAU,OAAO,IAAI,CAAC,MAAM,YAAY,EAAE,OAAO,QAAQ,CAAC;AAChE,YAAM,QAAQ,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC;AACrD,YAAM,eAAe,CAAC,OAAa,MAAoB;AACrD,cAAM,CAAC,GAAG,CAAC,IAAI,UAAU,OAAO,MAAM,GACpC,IAAI,QAAQ,CAAC,EAAE,SAAS,CAAC,GACzB,IAAI,QAAQ,IAAI,CAAC,EAAE,SAAS,CAAC;AAC/B,cAAM,IAAI;AAAA,UACR,IAAI,GAAG,SAAS,OAAO,CAAC,EAAE,EAAE,CAAC;AAAA,UAC7B,KAAK,OAAO,IAAI,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE;AAAA,QACpC;AACA,eAAO,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;AAAA,MAClD;AACA,aAAO;AAAA,QACL,OAAO,MAAM;AAAA,QACb,QAAQ,CAAC,OAAO,WACd,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,UAC5B,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,OAAO,QAAQ,UAC3C,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,UAC5B,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,OAAO,SAAS;AAAA,QAC9C,UAAU,CAAC,UAAU;AACnB,gBAAM,MAAM,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI,OAAO,KAAK,OAAO,QAC7C,MAAM,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI,OAAO,KAAK,OAAO;AAC3C,cAAI,QAAQ;AACZ,iBAAO,QAAQ,OAAO,SAAS,KAAK,OAAO,QAAQ,CAAC,EAAE,MAAM;AAC1D;AACF,cAAI,OAAO;AACX,iBAAO,OAAO,OAAO,SAAS,KAAK,OAAO,OAAO,CAAC,EAAE,KAAK,GAAI;AAC7D,cAAI,UAAU,KAAM,QAAO,aAAa,OAAO,KAAK;AACpD,gBAAM,UAAkB,CAAC;AACzB,mBAAS,IAAI,OAAO,KAAK,MAAM,KAAK;AAClC,kBAAM,IAAI;AAAA,cACR,GAAG,MAAM,CAAC;AAAA,cACV,GAAG;AAAA,gBACD,KAAK;AAAA,kBACH,MAAM,CAAC,EAAE,EAAE,CAAC;AAAA,kBACZ,OAAO,IAAI,OAAO,CAAC,EAAE,KAAK,OAAO;AAAA,gBACnC;AAAA,gBACA,KAAK;AAAA,kBACH,MAAM,CAAC,EAAE,EAAE,CAAC;AAAA,kBACZ,OAAO,IAAI,OAAO,IAAI,CAAC,EAAE,KAAK,OAAO;AAAA,gBACvC;AAAA,cACF;AAAA,YACF;AACA,oBAAQ,KAAK,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAAA,UAC7C;AACA,iBAAO,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,UAAU;AAAA,YAC3B,GAAG;AAAA,cACD,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,cAC5C,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,YAC9C;AAAA,YACA,GAAG;AAAA,cACD,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,cAC5C,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,YAC9C;AAAA,YACA,IAAI,CAAC,WAAW,QAAQ;AAAA,UAC1B,EAAE;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACH;AACA,SAAS,SAAS,MAAoB;AACpC,SAAO,OAAO,UAAU,MAAM,KAAK,IAAI,GAAG,GAAG,KAAK,IAAI,CAAC,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC;AACzE;AACA,SAAS,SACP,QACA,OACiD;AACjD,MAAI,QAAQ,OACV,QAAQ,GACR,SAAS;AACX,aAAW,SAAS,QAAQ;AAE1B,QAAI,QAAQ,GAAG;AACb,YAAM,MAAM,MAAM,IAAI,CAAC,OAAO;AAAA,QAC5B,GAAG,CAAC,EAAE,EAAE,CAAC,IAAI,OAAO,EAAE,EAAE,CAAC,IAAI,KAAK;AAAA,QAClC,GAAG,CAAC,GAAG,CAAC;AAAA,QACR,IAAI,CAAC,GAAG,CAAC;AAAA,MACX,EAAE;AACF,YAAM,KAAK,MAAM,SAAS,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;AAC5D,YAAM,KAAK,MAAM,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AAC5D,eAAS,KAAK;AAAA,QACZ,KAAK,GAAG,CAAC,EAAE,CAAC;AAAA,QACZ,KAAK,GAAG,CAAC,EAAE,CAAC;AAAA,QACZ,KAAK,GAAG,CAAC,EAAE,CAAC;AAAA,QACZ,KAAK,GAAG,CAAC,EAAE,CAAC;AAAA,MACd;AAAA,IACF;AACA,eAAW,MAAM,SAAS,OAAO,SAAS,KAAK,CAAC,KAAK;AACrD,aAAS,MAAM,MAAM,KAAK;AAC1B,YAAQ,MAAM,SAAS,KAAK;AAAA,EAC9B;AACA,SAAO,EAAE,OAAO,OAAO,OAAO;AAChC;AAcO,SAAS,cACd,MACA,WACA,SACc;AACd,MAAI,EAAE,gBAAgB;AACpB,UAAM,IAAI,UAAU,sCAAsC;AAC5D,QAAM,YAAY,WAAW,SAAS,GACpC,YAAY,SAAS,SAAS,WAAW,WAAW;AACtD,QAAM,cAAc;AAAA,IAClB,QAAQ,gBAAgB,SAAY,MAAY,QAAQ;AAAA,IACxD;AAAA,EACF;AACA,MAAI,CAAC,OAAO,cAAc,WAAW;AACnC,UAAM,IAAI,WAAW,qCAAqC;AAC5D,MAAI,OAAO;AACX,WACM,UAAU,GAAG,WAAW,YAAY,IACxC,UAAU,GACV,WAAW,YAAY,IACvB;AACA,UAAM,SAAS,UAAU,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC;AAC/C,QAAI,OAAO,WAAW,KAAK,OAAO,CAAC,EAAE;AACnC,aAAO,OAAO,CAAC,EAAE,MAAM,MAAM,OAAO;AACtC,QAAI,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG;AACjC,UAAI,KAAK,eAAe;AACtB,cAAM,IAAI,WAAW,qCAAqC;AAC5D,UAAI,SAAS,KAAK,MAAM;AACxB,iBAAW,KAAK,OAAQ,UAAS,YAAY,QAAQ,EAAE,MAAO;AAC9D,aAAO;AAAA,IACT;AACA,UAAM,SAAS,IAAI,aAAa;AAChC,QAAI,QAAQ;AACZ,UAAM,UAAU,MAAM;AACpB,UAAI,OAAO,gBAAgB;AACzB,cAAM,IAAI,WAAW,qCAAqC;AAAA,IAC9D;AACA,eAAW,QAAQ,UAAU,IAAI,GAAG;AAClC,UAAI,KAAK,SAAS,SAAS;AACzB,gBAAQ;AACR,eAAO,UAAU;AACjB;AAAA,MACF;AACA,UAAI,KAAK,SAAS,QAAQ;AACxB,cAAM,IAAI,SAAS,QAAQ;AAAA,UACzB,SAAS,KAAK,MAAM,CAAC,CAAC;AAAA,UACtB,SAAS,KAAK,MAAM,CAAC,CAAC;AAAA,QACxB,CAAC;AACD,YAAI,CAAC,EAAE;AACL,gBAAM,IAAI;AAAA,YACR;AAAA,UACF;AACF,YAAI,EAAE,QAAQ,YAAY,GAAG;AAC3B,kBAAQ;AACR;AAAA,QACF;AACA,YAAI,EAAE,QAAQ,SAAS,EAAE,KAAK,IAAI;AAChC,gBAAM,IAAI,WAAW,qCAAqC;AAC5D,gBAAQ;AACR,eAAO,OAAO,WAAW,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,WAAW,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AACtE;AAAA,MACF;AACA,YAAM,QAA6C;AAAA,QACjD,EAAE,MAAM,KAAK,MAAM,OAAO,EAAE;AAAA,MAC9B;AACA,aAAO,MAAM,QAAQ;AACnB,YAAI,EAAE,OAAO;AACX,gBAAM,IAAI,WAAW,wCAAwC;AAC/D,cAAM,EAAE,MAAM,MAAM,IAAI,MAAM,IAAI,GAChC,IAAI,eAAe,IAAI;AACzB,cAAM,IAAI,SAAS,QAAQ;AAAA,UACzB,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,GAAG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE;AAAA,UAC7D,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,GAAG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE;AAAA,QAC/D,CAAC;AACD,YAAI,EAAE,QAAQ,YAAY,GAAG;AAC3B,kBAAQ;AACR;AAAA,QACF;AACA,cAAM,SAAS,KAAK,MAAM,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI;AAEtE,cAAM,QAAQ,KAAK,MAAM,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,IAAI;AACnE,cAAM,QAAQ,KAAK,IAAI,QAAQ,KAAK,IAAI,IAAI,EAAE,QAAQ,SAAS,EAAE,KAAK;AACtE,YAAI,EAAE,UAAU,SAAS,WAAW;AAClC,gBAAM,MACJ,YAAY,OACR,KAAK,OAAO,GAAG,EAAE,IACjB;AAAA,YACE,KAAK,IAAI,KACP,KAAK,IAAI,KACP,KAAK,IAAI,KAAK,IAAI,aAAa,KAAK,IAAI,KAAK,IAC/C,KAAK,IAAI,KACP,KAAK,IAAI,KAAK,IAAI,aAAa,KAAK,IAAI,KAAK;AAAA,YACjD,KAAK,IAAI,KACP,KAAK,IAAI,KACP,KAAK,IAAI,KAAK,IAAI,aAAa,KAAK,IAAI,KAAK,IAC/C,KAAK,IAAI,KACP,KAAK,IAAI,KAAK,IAAI,aAAa,KAAK,IAAI,KAAK;AAAA,UACnD;AACN,gBAAM,IAAI,SAAS,QAAQ,CAAC,SAAS,IAAI,CAAC,CAAC,GAAG,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC;AAC/D,kBAAQ;AACR,iBAAO;AAAA,YACL,WAAW,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;AAAA,YAC1B,WAAW,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;AAAA,UAC5B;AAAA,QACF,OAAO;AACL,cAAI,SAAS;AACX,kBAAM,IAAI;AAAA,cACR;AAAA,YACF;AACF,gBAAM,CAAC,MAAM,KAAK,IAAI,cAAc,IAAI;AACxC,gBAAM;AAAA,YACJ,EAAE,MAAM,OAAO,OAAO,QAAQ,EAAE;AAAA,YAChC,EAAE,MAAM,MAAM,OAAO,QAAQ,EAAE;AAAA,UACjC;AAAA,QACF;AAAA,MACF;AACA,UAAI,MAAO;AAAA,IACb;AACA,QAAI,CAAC,MAAO,QAAO;AAAA,EACrB;AACA,QAAM,IAAI,WAAW,yCAAyC;AAChE;AAGO,SAAS,WAAW,SAAgC;AACzD,SAAO,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,UAAU;AAAA,IAC3B,GAAG;AAAA,MACD,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,MAC5C,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,IAC9C;AAAA,IACA,GAAG;AAAA,MACD,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,MAC5C,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAAA,IAC9C;AAAA,IACA,IAAI,CAAC,WAAW,QAAQ;AAAA,EAC1B,EAAE;AACJ;AACO,SAAS,aACd,OACA,QACA,QACS;AACT,SACE,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,UAC5B,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,OAAO,QAAQ,UAC3C,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,UAC5B,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,IAAI,OAAO,SAAS;AAEhD;AACA,SAAS,qBAAgD;AACzD;AAAA,EACE;AAAA,EACA;AAAA,OAIK;AAUP,SAAS,aAAa,QAAiC;AACrD,MAAI,CAAC,UAAU,OAAO,WAAW;AAC/B,UAAM,IAAI,UAAU,qCAAqC;AAC3D,QAAM,QAAQ;AACd,MACE,MAAM,SAAS,SACf,CAAC,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,KAAK,EAAE;AAAA,IACvD,CAAC,MACC,MAAM,CAAwB,MAAM,UACpC,MAAM,CAAwB,MAAM;AAAA,EACxC,KACA,CAAC,MAAM,KAAK,MAAM,GAAG,EAAE,KAAK,CAAC,MAAM,MAAM,UAAa,MAAM,CAAC;AAE7D,UAAM,IAAI,WAAW,qCAAqC;AAC5D,QAAM,QAAQ;AAAA,IACZ,CAAC,KAAK,OAAO,CAAC;AAAA,IACd,CAAC,KAAK,OAAO,CAAC;AAAA,IACd,CAAC,KAAK,OAAO,CAAC;AAAA,IACd,CAAC,KAAK,OAAO,CAAC;AAAA,IACd,CAAC,KAAK,OAAO,CAAC;AAAA,IACd,CAAC,KAAK,OAAO,CAAC;AAAA,EAChB;AACA,QAAM,SAAS,CAAC;AAChB,aAAW,CAAC,KAAK,OAAO,QAAQ,KAAK,OAAO;AAC1C,UAAM,IAAI,MAAM,GAAG,GACjB,IAAI,MAAM,KAAK;AACjB,QAAI,MAAM,UAAa,MAAM,UAAa,MAAM;AAC9C,YAAM,IAAI,UAAU,oCAAoC;AAC1D,WAAO,GAAG,IAAI;AAAA,MACZ,MAAM,SAAa,MAAM,SAAY,WAAW,IAAK;AAAA,IACvD;AAAA,EACF;AACA,SAAO;AACT;AACA,SAAS,YAAY,MAAoB,GAAyB;AAChE,QAAM,IAAI,CAAC,GAAW,GAAW,SAAS,WAAW;AAAA,IACnD,GAAG,WAAW,EAAE,IAAI,IAAI,EAAE,IAAI,KAAK,SAAS,IAAI,EAAE,EAAE;AAAA,IACpD,GAAG,WAAW,EAAE,IAAI,IAAI,EAAE,IAAI,KAAK,SAAS,IAAI,EAAE,EAAE;AAAA,EACtD;AACA,QAAM,WAAW,MAAM,KAAK,MAAM,CAAC,YAAY;AAC7C,YAAQ,QAAQ,MAAM;AAAA,MACpB,KAAK;AACH,eAAO;AAAA,MACT,KAAK;AAAA,MACL,KAAK;AACH,eAAO,EAAE,GAAG,SAAS,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAAC,EAAE;AAAA,MAClD,KAAK,aAAa;AAChB,cAAM,UAAU,EAAE,QAAQ,KAAK,QAAQ,GAAG;AAC1C,eAAO;AAAA,UACL,GAAG;AAAA,UACH,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAAA,UACzB,KAAK,QAAQ;AAAA,UACb,KAAK,QAAQ;AAAA,QACf;AAAA,MACF;AAAA,MACA,KAAK,SAAS;AACZ,cAAM,IAAI,EAAE,QAAQ,MAAM,QAAQ,IAAI,GACpC,IAAI,EAAE,QAAQ,MAAM,QAAQ,IAAI;AAClC,eAAO;AAAA,UACL,GAAG;AAAA,UACH,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAAA,UACzB,MAAM,EAAE;AAAA,UACR,MAAM,EAAE;AAAA,UACR,MAAM,EAAE;AAAA,UACR,MAAM,EAAE;AAAA,QACV;AAAA,MACF;AAAA,MACA,KAAK,OAAO;AACV,cAAM,SAAS,EAAE,QAAQ,IAAI,QAAQ,EAAE,GACrC,IAAI,EAAE,QAAQ,IAAI,QAAQ,IAAI,IAAI,GAClC,IAAI,EAAE,QAAQ,IAAI,QAAQ,IAAI,IAAI;AACpC,eAAO;AAAA,UACL,GAAG;AAAA,UACH,IAAI,OAAO;AAAA,UACX,IAAI,OAAO;AAAA,UACX,IAAI,EAAE;AAAA,UACN,IAAI,EAAE;AAAA,UACN,IAAI,EAAE;AAAA,UACN,IAAI,EAAE;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACD,QAAM,SAAS,IAAI,aAAa;AAChC,SAAO,eAAe,GAAG,GAAG,QAAQ;AACpC,SAAO;AACT;",
+  "names": []
+}

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

@@ -0,0 +1,78 @@
+import type { flattenPathWang } from "./path-wang.js";
+import type { simplifyPathRadial } from "./path-radial.js";
+import { PathGeometry } from './path-geometry.js';
+/**
+ * Positive approximation tolerance and output-segment budget for curve flattening.
+ *
+ * @see {@link flattenPath}
+ * @see {@link flattenPathWang}
+ */
+export interface FlattenPathOptions {
+    /** Positive maximum geometric approximation error. See {@link FlattenPathOptions}. */
+    readonly tolerance: number;
+    /** Upper bound on the number of output path segments. See {@link FlattenPathOptions}. */
+    readonly maxSegments?: number;
+}
+/**
+ * Positive tolerance and output-segment budget for polyline simplification.
+ *
+ * @see {@link simplifyPath}
+ * @see {@link simplifyPathRadial}
+ */
+export interface SimplifyPathOptions {
+    /** Positive maximum geometric approximation error. See {@link SimplifyPathOptions}. */
+    readonly tolerance: number;
+    /** Upper bound on the number of output path segments. See {@link SimplifyPathOptions}. */
+    readonly maxSegments?: number;
+}
+/**
+ * Subdivision count and output-segment budget for splitting path segments.
+ *
+ * @see {@link subdividePath}
+ */
+export interface SubdividePathOptions {
+    /**
+     * Number of pieces produced from each drawable path segment. See {@link SubdividePathOptions}.
+     */
+    readonly divisions: number;
+    /** Upper bound on the number of output path segments. See {@link SubdividePathOptions}. */
+    readonly maxSegments?: number;
+}
+/**
+ * Returns independent geometry with curves approximated by line segments within the requested
+ * tolerance.
+ *
+ * @param path - Source geometry; it is not modified. See {@link PathGeometry}.
+ * @param options - Maximum approximation error and flattening work limits. See
+ * {@link FlattenPathOptions} .
+ * @returns Independent geometry with curves replaced by line segments. See {@link PathGeometry}.
+ *
+ * @see {@link PathGeometry}
+ * @see {@link FlattenPathOptions}
+ */
+export declare function flattenPath(path: PathGeometry, options: Readonly<FlattenPathOptions>): PathGeometry;
+/**
+ * Returns independent geometry with each drawable segment split into the requested number of
+ * pieces.
+ *
+ * @param path - Source geometry; it is not modified. See {@link PathGeometry}.
+ * @param options - Subdivision length and work limits. See {@link SubdividePathOptions}.
+ * @returns Independent geometry with segments split according to the requested limits. See
+ * {@link PathGeometry} .
+ *
+ * @see {@link PathGeometry}
+ * @see {@link SubdividePathOptions}
+ */
+export declare function subdividePath(path: PathGeometry, options: Readonly<SubdividePathOptions>): PathGeometry;
+/**
+ * Returns independent polyline geometry with redundant points removed within the requested
+ * 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 simplifyPath(path: PathGeometry, options: Readonly<SimplifyPathOptions>): PathGeometry;