@weasel-js/geom 1.15.2 → 1.16.0

package/dist/chunk-IOD2NFHQ.js

@@ -0,0 +1,212 @@
+// src/paths/segmentLength.ts
+var GL_X = [
+  -0.9602898564975363,
+  -0.7966664774136267,
+  -0.525532409916329,
+  -0.1834346424956498,
+  0.1834346424956498,
+  0.525532409916329,
+  0.7966664774136267,
+  0.9602898564975363
+];
+var GL_W = [
+  0.1012285362903763,
+  0.2223810344533745,
+  0.3137066458778873,
+  0.362683783378362,
+  0.362683783378362,
+  0.3137066458778873,
+  0.2223810344533745,
+  0.1012285362903763
+];
+var G4_X = [-0.8611363115940526, -0.3399810435848563, 0.3399810435848563, 0.8611363115940526];
+var G4_W = [0.3478548451374538, 0.6521451548625461, 0.6521451548625461, 0.3478548451374538];
+var PANEL_AGREE = 1e-9;
+var DIP_PANELS = 1;
+var EDGE_NEAR = 0.05;
+var SETTLE = 1e-13;
+function speed(c, dim, t) {
+  const n = c.length / dim - 1;
+  const u = 1 - t;
+  let sum = 0;
+  for (let k = 0; k < dim; k++) {
+    const d0 = c[dim + k] - c[k];
+    const v = n === 1 ? d0 : n === 2 ? 2 * (u * d0 + t * (c[2 * dim + k] - c[dim + k])) : 3 * (u * u * d0 + 2 * u * t * (c[2 * dim + k] - c[dim + k]) + t * t * (c[3 * dim + k] - c[2 * dim + k]));
+    sum += v * v;
+  }
+  return Math.sqrt(sum);
+}
+function rule(c, dim, a, b, xs, ws) {
+  const mid = (a + b) / 2, half = (b - a) / 2;
+  let sum = 0;
+  for (let i = 0; i < xs.length; i++) sum += ws[i] * speed(c, dim, mid + xs[i] * half);
+  return sum * half;
+}
+function refined(c, dim, a, b, whole, tol, depth) {
+  const m = (a + b) / 2;
+  const l = rule(c, dim, a, m, GL_X, GL_W), r = rule(c, dim, m, b, GL_X, GL_W);
+  if (depth >= 20 || !(Math.abs(l + r - whole) > tol)) return l + r;
+  return refined(c, dim, a, m, l, tol, depth + 1) + refined(c, dim, m, b, r, tol, depth + 1);
+}
+function hullLength(c, dim) {
+  let sum = 0;
+  for (let i = dim; i < c.length; i += dim) {
+    let d2 = 0;
+    for (let k = 0; k < dim; k++) d2 += (c[i + k] - c[i - dim + k]) ** 2;
+    sum += Math.sqrt(d2);
+  }
+  return sum;
+}
+function finite(c) {
+  for (let i = 0; i < c.length; i++) if (!Number.isFinite(c[i])) return false;
+  return true;
+}
+function derivativeRoots(c, dim, a, b) {
+  const n = c.length / dim - 1;
+  const out = [];
+  const keep = (t) => {
+    if (t > a && t < b) out.push(t);
+  };
+  for (let k = 0; k < dim; k++) {
+    const d0 = c[dim + k] - c[k];
+    const d1 = c[2 * dim + k] - c[dim + k];
+    if (n === 2) {
+      if (d0 !== d1) keep(d0 / (d0 - d1));
+      continue;
+    }
+    const d2 = c[3 * dim + k] - c[2 * dim + k];
+    const A = d0 - 2 * d1 + d2, B = 2 * (d1 - d0), C = d0;
+    if (Math.abs(A) <= 1e-12 * (Math.abs(B) + Math.abs(C))) {
+      if (B !== 0) keep(-C / B);
+      continue;
+    }
+    const disc = B * B - 4 * A * C;
+    if (disc < 0) continue;
+    const q = -(B + Math.sign(B || 1) * Math.sqrt(disc)) / 2;
+    keep(q / A);
+    if (q !== 0) keep(C / q);
+  }
+  out.sort((x, y) => x - y);
+  return out.filter((t, i) => i === 0 || t !== out[i - 1]);
+}
+function panelLength(c, dim, p0, p1, size, beside) {
+  if (!(p1 > p0)) return 0;
+  const g8 = rule(c, dim, p0, p1, GL_X, GL_W);
+  const settled = !beside && !(Math.abs(g8 - rule(c, dim, p0, p1, G4_X, G4_W)) > PANEL_AGREE * size);
+  return settled ? g8 : refined(c, dim, p0, p1, g8, SETTLE * size, 0);
+}
+function segmentLength(coords, dim, a = 0, b = 1) {
+  if (!finite(coords)) return NaN;
+  if (coords.length === 2 * dim) return speed(coords, dim, 0) * (b - a);
+  const size = hullLength(coords, dim);
+  return lengthOver(coords, dim, a, b, size, speedDips(coords, dim));
+}
+function bend(c, dim, t) {
+  const n = c.length / dim - 1;
+  let sum = 0;
+  for (let k = 0; k < dim; k++) {
+    const e0 = c[2 * dim + k] - 2 * c[dim + k] + c[k];
+    const v = n === 2 ? 2 * e0 : 6 * ((1 - t) * e0 + t * (c[3 * dim + k] - 2 * c[2 * dim + k] + c[dim + k]));
+    sum += v * v;
+  }
+  return Math.sqrt(sum);
+}
+function speedDips(c, dim) {
+  return derivativeRoots(c, dim, 0, 1).map((t) => {
+    const b = bend(c, dim, t);
+    return { t, width: b > 0 ? speed(c, dim, t) / b : Infinity };
+  });
+}
+function dipsFor(dips, h) {
+  const out = [];
+  for (const d of dips) if (d.width < DIP_PANELS * h) out.push(d.t);
+  return out;
+}
+function lengthOver(c, dim, a, b, size, dips, panels = 8) {
+  const h = (b - a) / panels;
+  const last = panels - 1;
+  let sum = 0;
+  const roots = dipsFor(dips, h);
+  if (roots.length === 0) {
+    for (let k = 0; k < panels; k++) sum += panelLength(c, dim, a + k * h, k === last ? b : a + (k + 1) * h, size, false);
+    return sum;
+  }
+  const near = (t) => roots.some((r2) => Math.abs(r2 - t) <= EDGE_NEAR * h);
+  let r = 0;
+  while (r < roots.length && roots[r] <= a) r++;
+  for (let k = 0; k < panels; k++) {
+    const p0 = a + k * h, p1 = k === last ? b : p0 + h;
+    let from = p0;
+    while (r < roots.length && roots[r] < p1) {
+      sum += panelLength(c, dim, from, roots[r], size, true);
+      from = roots[r++];
+    }
+    sum += panelLength(c, dim, from, p1, size, near(from) || near(p1));
+  }
+  return sum;
+}
+function segmentTAtLength(coords, dim, length, total = segmentLength(coords, dim)) {
+  if (length <= 0 || !(total > 0) || !Number.isFinite(total)) return 0;
+  if (length >= total) return 1;
+  if (coords.length === 2 * dim) return length / total;
+  const size = hullLength(coords, dim);
+  const dips = speedDips(coords, dim);
+  let lo = 0, hi = 1, t = length / total;
+  for (let i = 0; i < 30; i++) {
+    const err = lengthOver(coords, dim, 0, t, size, dips) - length;
+    if (Math.abs(err) < 1e-10 * total) break;
+    if (err > 0) hi = t;
+    else lo = t;
+    const v = speed(coords, dim, t);
+    let next = v > 0 ? t - err / v : NaN;
+    if (!(next > lo && next < hi)) next = (lo + hi) / 2;
+    t = next;
+  }
+  return t;
+}
+var STEPS = 16;
+function arcLookup(coords, dim) {
+  const size = hullLength(coords, dim);
+  const dips = finite(coords) ? speedDips(coords, dim) : [];
+  const s = new Float64Array(STEPS + 1);
+  for (let k = 0; k < STEPS; k++) s[k + 1] = s[k] + lengthOver(coords, dim, k / STEPS, (k + 1) / STEPS, size, dips, 1);
+  return { s, size, dips };
+}
+function lookupLength(coords, dim, lk, t) {
+  const f = Math.min(Math.max(t, 0), 1);
+  const k = Math.min(Math.floor(f * STEPS), STEPS - 1);
+  return lk.s[k] + lengthOver(coords, dim, k / STEPS, f, lk.size, lk.dips, 1);
+}
+function lookupT(coords, dim, lk, length) {
+  const { s } = lk;
+  const total = s[STEPS];
+  if (length <= 0 || !(total > 0) || !Number.isFinite(total)) return 0;
+  if (length >= total) return 1;
+  let k = 0;
+  let hi = STEPS - 1;
+  while (k < hi) {
+    const mid = k + hi + 1 >> 1;
+    if (s[mid] <= length) k = mid;
+    else hi = mid - 1;
+  }
+  const a = k / STEPS;
+  let lo = a, top = (k + 1) / STEPS;
+  const step = s[k + 1] - s[k];
+  let t = step > 0 ? a + (length - s[k]) / step / STEPS : a;
+  for (let i = 0; i < 30; i++) {
+    const err = s[k] + lengthOver(coords, dim, a, t, lk.size, lk.dips, 1) - length;
+    if (Math.abs(err) < 1e-10 * total) break;
+    if (err > 0) top = t;
+    else lo = t;
+    const v = speed(coords, dim, t);
+    let next = v > 0 ? t - err / v : NaN;
+    if (!(next > lo && next < top)) next = (lo + top) / 2;
+    t = next;
+  }
+  return t;
+}
+var flatPoints = (pts) => pts.flatMap((p) => [p.x, p.y]);
+
+export { arcLookup, flatPoints, lookupLength, lookupT, segmentLength, segmentTAtLength };
+//# sourceMappingURL=chunk-IOD2NFHQ.js.map
+//# sourceMappingURL=chunk-IOD2NFHQ.js.map

package/dist/chunk-IOD2NFHQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/paths/segmentLength.ts"],"names":["r"],"mappings":"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","file":"chunk-IOD2NFHQ.js","sourcesContent":["/** Measuring one Bézier segment by arc length, and finding where a run of it ends. */\n\nconst GL_X = [-0.9602898564975363, -0.7966664774136267, -0.5255324099163290, -0.1834346424956498,\n  0.1834346424956498, 0.5255324099163290, 0.7966664774136267, 0.9602898564975363];\nconst GL_W = [0.1012285362903763, 0.2223810344533745, 0.3137066458778873, 0.3626837833783620,\n  0.3626837833783620, 0.3137066458778873, 0.2223810344533745, 0.1012285362903763];\n\nconst G4_X = [-0.8611363115940526, -0.3399810435848563, 0.3399810435848563, 0.8611363115940526];\nconst G4_W = [0.3478548451374538, 0.6521451548625461, 0.6521451548625461, 0.3478548451374538];\n\n/** How far the eight-point rule may sit from the four-point one on a panel, as a share of the\n *  segment's size, before the panel is refined. */\nconst PANEL_AGREE = 1e-9;\n/** A derivative root is a cusp or a dip in speed when the dip is narrower than this many panel\n *  widths: its speed over the curvature of its path there, `|B′| / |B″|`, a width in `t`. */\nconst DIP_PANELS = 1;\n/** A dip this share of a panel from its edge marks the panel across the edge too: its shoulder\n *  sits in the gap before the edge's nearest Gauss node. */\nconst EDGE_NEAR = 0.05;\n/** How closely a refined panel's halves must agree, as a share of the segment's size. */\nconst SETTLE = 1e-13;\n\n/** The speed of the segment at `t`: the length of its derivative. */\nfunction speed(c: ArrayLike<number>, dim: number, t: number): number {\n  const n = c.length / dim - 1;\n  const u = 1 - t;\n  let sum = 0;\n  for (let k = 0; k < dim; k++) {\n    const d0 = c[dim + k] - c[k];\n    const v = n === 1 ? d0\n      : n === 2 ? 2 * (u * d0 + t * (c[2 * dim + k] - c[dim + k]))\n        : 3 * (u * u * d0 + 2 * u * t * (c[2 * dim + k] - c[dim + k]) + t * t * (c[3 * dim + k] - c[2 * dim + k]));\n    sum += v * v;\n  }\n  return Math.sqrt(sum);\n}\n\nfunction rule(c: ArrayLike<number>, dim: number, a: number, b: number, xs: readonly number[], ws: readonly number[]): number {\n  const mid = (a + b) / 2, half = (b - a) / 2;\n  let sum = 0;\n  for (let i = 0; i < xs.length; i++) sum += ws[i] * speed(c, dim, mid + xs[i] * half);\n  return sum * half;\n}\n\n/** `whole`, the eight-point length over `a..b`, refined by halves until they agree within `tol`.\n *  A difference that is not a number counts as settled. */\nfunction refined(c: ArrayLike<number>, dim: number, a: number, b: number, whole: number, tol: number, depth: number): number {\n  const m = (a + b) / 2;\n  const l = rule(c, dim, a, m, GL_X, GL_W), r = rule(c, dim, m, b, GL_X, GL_W);\n  if (depth >= 20 || !(Math.abs(l + r - whole) > tol)) return l + r;\n  return refined(c, dim, a, m, l, tol, depth + 1) + refined(c, dim, m, b, r, tol, depth + 1);\n}\n\n/** The length of the control polygon: the segment's own size, which tolerances scale by. */\nfunction hullLength(c: ArrayLike<number>, dim: number): number {\n  let sum = 0;\n  for (let i = dim; i < c.length; i += dim) {\n    let d2 = 0;\n    for (let k = 0; k < dim; k++) d2 += (c[i + k] - c[i - dim + k]) ** 2;\n    sum += Math.sqrt(d2);\n  }\n  return sum;\n}\n\nfunction finite(c: ArrayLike<number>): boolean {\n  for (let i = 0; i < c.length; i++) if (!Number.isFinite(c[i])) return false;\n  return true;\n}\n\n/** Where a component of the segment's derivative is zero, strictly inside `a..b`, ascending:\n *  the only places a cusp or a dip in speed can sit, which an error estimate can step over. */\nfunction derivativeRoots(c: ArrayLike<number>, dim: number, a: number, b: number): number[] {\n  const n = c.length / dim - 1;\n  const out: number[] = [];\n  const keep = (t: number) => { if (t > a && t < b) out.push(t); };\n  for (let k = 0; k < dim; k++) {\n    const d0 = c[dim + k] - c[k];\n    const d1 = c[2 * dim + k] - c[dim + k];\n    if (n === 2) {\n      if (d0 !== d1) keep(d0 / (d0 - d1));\n      continue;\n    }\n    // Bernstein (d0, d1, d2) as A t² + B t + C.\n    const d2 = c[3 * dim + k] - c[2 * dim + k];\n    const A = d0 - 2 * d1 + d2, B = 2 * (d1 - d0), C = d0;\n    if (Math.abs(A) <= 1e-12 * (Math.abs(B) + Math.abs(C))) {\n      if (B !== 0) keep(-C / B);\n      continue;\n    }\n    const disc = B * B - 4 * A * C;\n    if (disc < 0) continue;\n    // The stable pair: one root from the sum that cannot cancel, the other from the product.\n    const q = -(B + Math.sign(B || 1) * Math.sqrt(disc)) / 2;\n    keep(q / A);\n    if (q !== 0) keep(C / q);\n  }\n  out.sort((x, y) => x - y);\n  return out.filter((t, i) => i === 0 || t !== out[i - 1]);\n}\n\n/** The eight-point length over `p0..p1`, refined when it sits beside a slow root or its\n *  four-point rule disagrees. */\nfunction panelLength(c: ArrayLike<number>, dim: number, p0: number, p1: number, size: number, beside: boolean): number {\n  if (!(p1 > p0)) return 0;\n  const g8 = rule(c, dim, p0, p1, GL_X, GL_W);\n  const settled = !beside && !(Math.abs(g8 - rule(c, dim, p0, p1, G4_X, G4_W)) > PANEL_AGREE * size);\n  return settled ? g8 : refined(c, dim, p0, p1, g8, SETTLE * size, 0);\n}\n\n/**\n * Length of a Bézier segment between parameters `a` and `b`, by Gauss–Legendre\n * over eight panels, split where a component of its derivative is zero and\n * the speed dips there within a panel's width. The panels beside such a root\n * are halved until they settle, and so is any other where the eight- and\n * four-point rules disagree. `coords` holds its control\n * points flat, `dim` components each: two points for a line, three for a\n * quadratic, four for a cubic. NaN when a coordinate is not finite.\n */\nexport function segmentLength(coords: ArrayLike<number>, dim: 2 | 3, a = 0, b = 1): number {\n  if (!finite(coords)) return NaN;\n  if (coords.length === 2 * dim) return speed(coords, dim, 0) * (b - a);\n  const size = hullLength(coords, dim);\n  return lengthOver(coords, dim, a, b, size, speedDips(coords, dim));\n}\n\n/** The length of the segment's second derivative at `t`. */\nfunction bend(c: ArrayLike<number>, dim: number, t: number): number {\n  const n = c.length / dim - 1;\n  let sum = 0;\n  for (let k = 0; k < dim; k++) {\n    const e0 = c[2 * dim + k] - 2 * c[dim + k] + c[k];\n    const v = n === 2 ? 2 * e0 : 6 * ((1 - t) * e0 + t * (c[3 * dim + k] - 2 * c[2 * dim + k] + c[dim + k]));\n    sum += v * v;\n  }\n  return Math.sqrt(sum);\n}\n\n/** A derivative root inside 0..1, and how wide its dip in speed is, in `t`. */\ninterface Dip { t: number; width: number }\n\n/** @internal The derivative roots inside 0..1, each with the width of its dip. */\nexport function speedDips(c: ArrayLike<number>, dim: number): Dip[] {\n  return derivativeRoots(c, dim, 0, 1).map((t) => {\n    const b = bend(c, dim, t);\n    return { t, width: b > 0 ? speed(c, dim, t) / b : Infinity };\n  });\n}\n\n/** @internal The dips a panel `h` wide cannot be trusted to see: narrower than {@link DIP_PANELS} panels. */\nexport function dipsFor(dips: readonly Dip[], h: number): number[] {\n  const out: number[] = [];\n  for (const d of dips) if (d.width < DIP_PANELS * h) out.push(d.t);\n  return out;\n}\n\n/** {@link segmentLength} over `a..b` in `panels` panels, given the segment's size and its dips. */\nfunction lengthOver(\n  c: ArrayLike<number>, dim: number, a: number, b: number, size: number, dips: readonly Dip[], panels = 8,\n): number {\n  const h = (b - a) / panels;\n  const last = panels - 1;\n  let sum = 0;\n  const roots = dipsFor(dips, h);\n  if (roots.length === 0) {\n    for (let k = 0; k < panels; k++) sum += panelLength(c, dim, a + k * h, k === last ? b : a + (k + 1) * h, size, false);\n    return sum;\n  }\n  const near = (t: number): boolean => roots.some((r) => Math.abs(r - t) <= EDGE_NEAR * h);\n  let r = 0;\n  while (r < roots.length && roots[r] <= a) r++;\n  for (let k = 0; k < panels; k++) {\n    const p0 = a + k * h, p1 = k === last ? b : p0 + h;\n    let from = p0;\n    // A dip splits its panel, and every piece that touches one, or comes near, is refined.\n    while (r < roots.length && roots[r] < p1) {\n      sum += panelLength(c, dim, from, roots[r], size, true);\n      from = roots[r++];\n    }\n    sum += panelLength(c, dim, from, p1, size, near(from) || near(p1));\n  }\n  return sum;\n}\n\n/**\n * The parameter at which the segment {@link segmentLength} reads has run\n * `length` from its start, clamped to 0..1: Newton steps on the arc length,\n * held inside a shrinking bracket. `total` is its whole length, when the\n * caller has it; it is trusted, not checked, and a wrong one misplaces the\n * clamp and the first guess. 0 when a coordinate is not finite, as for a\n * segment of no length.\n */\nexport function segmentTAtLength(\n  coords: ArrayLike<number>, dim: 2 | 3, length: number, total = segmentLength(coords, dim),\n): number {\n  if (length <= 0 || !(total > 0) || !Number.isFinite(total)) return 0;\n  if (length >= total) return 1;\n  if (coords.length === 2 * dim) return length / total;\n  const size = hullLength(coords, dim);\n  const dips = speedDips(coords, dim);\n  let lo = 0, hi = 1, t = length / total;\n  for (let i = 0; i < 30; i++) {\n    const err = lengthOver(coords, dim, 0, t, size, dips) - length;\n    if (Math.abs(err) < 1e-10 * total) break;\n    if (err > 0) hi = t; else lo = t;\n    const v = speed(coords, dim, t);\n    let next = v > 0 ? t - err / v : NaN;\n    if (!(next > lo && next < hi)) next = (lo + hi) / 2;\n    t = next;\n  }\n  return t;\n}\n\nconst STEPS = 16;\n\n/** A curved segment's exact arc length at evenly spaced parameters: what repeated length queries on one segment start from. */\nexport interface ArcLookup {\n  /** The length from the start to parameter `k / 16`, `k` = 0..16. */\n  readonly s: Float64Array;\n  readonly size: number;\n  readonly dips: readonly Dip[];\n}\n\n/** @internal The {@link ArcLookup} of curved segment `coords`, each step measured as one panel of {@link segmentLength}'s rule. */\nexport function arcLookup(coords: ArrayLike<number>, dim: 2 | 3): ArcLookup {\n  const size = hullLength(coords, dim);\n  const dips = finite(coords) ? speedDips(coords, dim) : [];\n  const s = new Float64Array(STEPS + 1);\n  for (let k = 0; k < STEPS; k++) s[k + 1] = s[k] + lengthOver(coords, dim, k / STEPS, (k + 1) / STEPS, size, dips, 1);\n  return { s, size, dips };\n}\n\n/** @internal The length from the start of `coords` to parameter `t`, read from its lookup `lk`. */\nexport function lookupLength(coords: ArrayLike<number>, dim: 2 | 3, lk: ArcLookup, t: number): number {\n  const f = Math.min(Math.max(t, 0), 1);\n  const k = Math.min(Math.floor(f * STEPS), STEPS - 1);\n  return lk.s[k] + lengthOver(coords, dim, k / STEPS, f, lk.size, lk.dips, 1);\n}\n\n/**\n * @internal {@link segmentTAtLength} from a lookup: the step holding `length`\n * gives the first guess and the bracket, and Newton steps on one panel's\n * length finish it, so a query costs a few panels rather than a whole-segment solve.\n */\nexport function lookupT(coords: ArrayLike<number>, dim: 2 | 3, lk: ArcLookup, length: number): number {\n  const { s } = lk;\n  const total = s[STEPS];\n  if (length <= 0 || !(total > 0) || !Number.isFinite(total)) return 0;\n  if (length >= total) return 1;\n  let k = 0;\n  let hi = STEPS - 1;\n  while (k < hi) {\n    const mid = (k + hi + 1) >> 1;\n    if (s[mid] <= length) k = mid;\n    else hi = mid - 1;\n  }\n  const a = k / STEPS;\n  let lo = a, top = (k + 1) / STEPS;\n  const step = s[k + 1] - s[k];\n  let t = step > 0 ? a + ((length - s[k]) / step) / STEPS : a;\n  for (let i = 0; i < 30; i++) {\n    const err = s[k] + lengthOver(coords, dim, a, t, lk.size, lk.dips, 1) - length;\n    if (Math.abs(err) < 1e-10 * total) break;\n    if (err > 0) top = t; else lo = t;\n    const v = speed(coords, dim, t);\n    let next = v > 0 ? t - err / v : NaN;\n    if (!(next > lo && next < top)) next = (lo + top) / 2;\n    t = next;\n  }\n  return t;\n}\n\n/** `pts` as the flat 2D coords {@link segmentLength} reads. */\nexport const flatPoints = (pts: readonly { x: number; y: number }[]): number[] => pts.flatMap((p) => [p.x, p.y]);\n"]}

package/dist/{chunk-OQP5M5VD.js → chunk-OBPXEPUH.js}

@@ -1,4 +1,4 @@
-import { cornerCuts, decodeContours, ringSignedArea, fillsOpenSubpaths, resolveCorners, segmentsCross, pointInPolygon } from './chunk-GA5R5KWD.js';
+import { cornerCuts, decodeContours, ringSignedArea, fillsOpenSubpaths, resolveCorners, segmentsCross, pointInPolygon } from './chunk-TBS4NHGQ.js';
 import { withoutCorners, compactCorners, worldCoords, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, originFor, coordsFrom, forEachSegment, pathCommandCoordCount, PathBuilder, distance, splitQuadraticAt, splitCubicAt, nearestOnLine, nearestOnCubic, lerpPoint } from './chunk-346XYYMX.js';
 import { EPS } from './chunk-DNX24KBT.js';
 
@@ -677,5 +677,5 @@ function writePath(subpaths, fillRule) {
 }
 
 export { CORNER_RESTORE_TOLERANCE, anchorRange, assembleRegions, carryCorners, contoursIntersect, cornerTraces, derivSeg, endSide, evalSeg, extentOf, intersectSegments, keepCorners, negligibleArea, orientBoundaries, parseContours, parseSubpaths, regionArea, restoreCorners, reverseContour, sampleContour, sideCoeffs, signChanges, signedArea, subSeg, toPath, windingAt, writePath };
-//# sourceMappingURL=chunk-OQP5M5VD.js.map
-//# sourceMappingURL=chunk-OQP5M5VD.js.map
+//# sourceMappingURL=chunk-OBPXEPUH.js.map
+//# sourceMappingURL=chunk-OBPXEPUH.js.map