@weasel-js/geom 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 orochi235
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @weasel-js/geom
+
+Pure 2D geometry kernel for @weasel-js/core: affine, box, curve, polyline. Dependency-free core; polygon booleans in the ./booleans subpath.
+
+Part of [weasel](https://github.com/orochi235/weasel), a domain-agnostic 2D
+scene-graph canvas kit for React. See the
+[API reference](https://orochi235.github.io/weasel/api/).
+
+## Install
+
+```sh
+npm install @weasel-js/geom
+```
+
+## Usage
+
+```ts
+import { /* … */ } from '@weasel-js/geom';
+import { /* … */ } from '@weasel-js/geom/booleans';
+```
+
+## License
+
+MIT

package/dist/booleans/index.d.ts

@@ -0,0 +1,47 @@
+/** Minimal path input: a rect or a polygon command stream. geom does not
+ *  import @weasel-js/core's `Path`; the kit maps `Path` onto this shape. */
+type GeomPath = {
+    kind: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    kind: 'polygon';
+    commands: ArrayLike<number>;
+    coords: ArrayLike<number>;
+    fillRule?: 'nonzero' | 'evenodd';
+};
+/** Polygon result shape emitted by `multiPolygonToPath`. */
+type GeomPolygonPath = {
+    kind: 'polygon';
+    commands: Uint8Array;
+    coords: Float32Array;
+    fillRule: 'nonzero';
+};
+
+/** Union of N paths. Commutative. Returns an empty path if all inputs are empty. */
+declare function pathUnion(...paths: GeomPath[]): GeomPolygonPath;
+/** Intersection of N paths. Commutative. Empty result is an empty path. */
+declare function pathIntersect(...paths: GeomPath[]): GeomPolygonPath;
+/** Asymmetric difference: returns `a − b`. */
+declare function pathSubtract(a: GeomPath, b: GeomPath): GeomPolygonPath;
+/** Symmetric difference (XOR) of N paths. Commutative. */
+declare function pathExclude(...paths: GeomPath[]): GeomPolygonPath;
+/**
+ * Fracture N paths along every intersection into the maximal set of
+ * non-overlapping regions. Returns one polygon path per region.
+ *
+ * Algorithm: for every non-empty subset S ⊆ {A1..AN}, emit the region
+ * `(∩ S) − (∪ complement)` — points covered by exactly the members of S
+ * and no others. By construction the emitted regions are pairwise disjoint
+ * and their union equals `pathUnion(A1..AN)`.
+ *
+ * For N=2 this collapses to the three Illustrator "Divide" outputs
+ * (A−B, B−A, A∩B). For N=3 up to 7 regions are emitted. The 2^N − 1
+ * subset count limits this to small N in practice; passing more than ~8
+ * inputs is a misuse — the polygon-clipping kernel dominates anyway.
+ */
+declare function pathDivide(...paths: GeomPath[]): GeomPolygonPath[];
+
+export { type GeomPath, type GeomPolygonPath, pathDivide, pathExclude, pathIntersect, pathSubtract, pathUnion };

package/dist/booleans/index.js

@@ -0,0 +1,182 @@
+import { PATH_M, PATH_L, PATH_Z, PATH_Q, elevateQuadraticToCubic, flattenCubic, PATH_C } from '../chunk-K5JJ6WRB.js';
+import polygonClipping from 'polygon-clipping';
+
+// src/booleans/adapter.ts
+var DEFAULT_FLATTEN_TOLERANCE = 0.5;
+function pathToMultiPolygon(path, opts = {}) {
+  if (path.kind === "rect") {
+    const { x, y, width, height } = path;
+    const ring = [
+      [x, y],
+      [x + width, y],
+      [x + width, y + height],
+      [x, y + height],
+      [x, y]
+    ];
+    return [[ring]];
+  }
+  const tolerance = opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE;
+  const rings = [];
+  let current = null;
+  let cx = 0, cy = 0;
+  let ci = 0;
+  const { commands, coords } = path;
+  const finalizeCurrent = () => {
+    if (!current || current.length === 0) return;
+    const first = current[0];
+    const last = current[current.length - 1];
+    if (first[0] !== last[0] || first[1] !== last[1]) {
+      current.push([first[0], first[1]]);
+    }
+    if (current.length >= 4) rings.push(current);
+    current = null;
+  };
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    switch (cmd) {
+      case PATH_M: {
+        finalizeCurrent();
+        cx = coords[ci];
+        cy = coords[ci + 1];
+        current = [[cx, cy]];
+        ci += 2;
+        break;
+      }
+      case PATH_L: {
+        cx = coords[ci];
+        cy = coords[ci + 1];
+        if (current) current.push([cx, cy]);
+        ci += 2;
+        break;
+      }
+      case PATH_C: {
+        const x1 = coords[ci], y1 = coords[ci + 1];
+        const x2 = coords[ci + 2], y2 = coords[ci + 3];
+        const x3 = coords[ci + 4], y3 = coords[ci + 5];
+        const out = [];
+        flattenCubic(cx, cy, x1, y1, x2, y2, x3, y3, tolerance, out);
+        if (current) for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);
+        cx = x3;
+        cy = y3;
+        ci += 6;
+        break;
+      }
+      case PATH_Q: {
+        const x1 = coords[ci], y1 = coords[ci + 1];
+        const x2 = coords[ci + 2], y2 = coords[ci + 3];
+        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(cx, cy, x1, y1, x2, y2);
+        const out = [];
+        flattenCubic(cx, cy, c1x, c1y, c2x, c2y, x2, y2, tolerance, out);
+        if (current) for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);
+        cx = x2;
+        cy = y2;
+        ci += 4;
+        break;
+      }
+      case PATH_Z: {
+        finalizeCurrent();
+        break;
+      }
+    }
+  }
+  finalizeCurrent();
+  if (rings.length === 0) return [];
+  return rings.map((r) => [r]);
+}
+function multiPolygonToPath(mp) {
+  let nCmds = 0;
+  let nCoords = 0;
+  for (const poly of mp) {
+    for (const ring of poly) {
+      if (ring.length < 4) continue;
+      const unique = ring.length - 1;
+      nCmds += 1 + (unique - 1) + 1;
+      nCoords += unique * 2;
+    }
+  }
+  const commands = new Uint8Array(nCmds);
+  const coords = new Float32Array(nCoords);
+  let ci = 0;
+  let pi = 0;
+  for (const poly of mp) {
+    for (const ring of poly) {
+      if (ring.length < 4) continue;
+      const unique = ring.length - 1;
+      commands[ci++] = PATH_M;
+      coords[pi++] = ring[0][0];
+      coords[pi++] = ring[0][1];
+      for (let k = 1; k < unique; k++) {
+        commands[ci++] = PATH_L;
+        coords[pi++] = ring[k][0];
+        coords[pi++] = ring[k][1];
+      }
+      commands[ci++] = PATH_Z;
+    }
+  }
+  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+}
+
+// src/booleans/index.ts
+function pathUnion(...paths) {
+  if (paths.length === 0) return multiPolygonToPath([]);
+  const mps = paths.map((p) => pathToMultiPolygon(p));
+  const [head, ...rest] = mps;
+  return multiPolygonToPath(polygonClipping.union(head, ...rest));
+}
+function pathIntersect(...paths) {
+  if (paths.length === 0) return multiPolygonToPath([]);
+  const mps = paths.map((p) => pathToMultiPolygon(p));
+  const [head, ...rest] = mps;
+  return multiPolygonToPath(polygonClipping.intersection(head, ...rest));
+}
+function pathSubtract(a, b) {
+  return multiPolygonToPath(polygonClipping.difference(pathToMultiPolygon(a), pathToMultiPolygon(b)));
+}
+function pathExclude(...paths) {
+  if (paths.length === 0) return multiPolygonToPath([]);
+  const mps = paths.map((p) => pathToMultiPolygon(p));
+  const [head, ...rest] = mps;
+  return multiPolygonToPath(polygonClipping.xor(head, ...rest));
+}
+function pathDivide(...paths) {
+  if (paths.length === 0) return [];
+  if (paths.length === 1) {
+    return [multiPolygonToPath(pathToMultiPolygon(paths[0]))];
+  }
+  const mps = paths.map((p) => pathToMultiPolygon(p));
+  const n = mps.length;
+  const out = [];
+  const subsets = [];
+  for (let mask = 1; mask < 1 << n; mask++) subsets.push(mask);
+  subsets.sort((a, b) => popcount(a) - popcount(b) || a - b);
+  for (const mask of subsets) {
+    const inside = [];
+    const outside = [];
+    for (let i = 0; i < n; i++) {
+      (mask & 1 << i ? inside : outside).push(mps[i]);
+    }
+    const [insideHead, ...insideRest] = inside;
+    let region = insideRest.length === 0 ? insideHead : polygonClipping.intersection(insideHead, ...insideRest);
+    if (region.length === 0) continue;
+    if (outside.length > 0) {
+      const [outHead, ...outRest] = outside;
+      const outsideUnion = polygonClipping.union(outHead, ...outRest);
+      region = polygonClipping.difference(region, outsideUnion);
+      if (region.length === 0) continue;
+    }
+    out.push(multiPolygonToPath(region));
+  }
+  return out;
+}
+function popcount(n) {
+  let c = 0;
+  while (n) {
+    n &= n - 1;
+    c++;
+  }
+  return c;
+}
+
+export { pathDivide, pathExclude, pathIntersect, pathSubtract, pathUnion };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/booleans/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/booleans/adapter.ts","../../src/booleans/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Adapter between geom's path input shape and `polygon-clipping`'s\n * `MultiPolygon` format. Kept in a dedicated module so the dep is one\n * import away from being swappable. Ported from\n * `src/features/paths/booleans.adapter.ts`.\n *\n * `polygon-clipping` expects:\n *   MultiPolygon = Polygon[]\n *   Polygon      = Ring[]   (first ring outer, subsequent rings holes)\n *   Ring         = [x, y][] (closed — first vertex repeated as last)\n *\n * Bezier inputs are flattened (cubic; quadratics are degree-elevated to cubic\n * first) — v1 is straight-line only. Open contours are implicitly closed\n * because boolean ops are defined on closed regions; polylines have zero area\n * and would otherwise be silently dropped.\n *\n * The `[x,y][]` nested-array form here is the one place geom's flat-everywhere\n * rule is suspended — it is the third-party clipper's required API.\n */\nimport { PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z } from '../commands';\nimport { flattenCubic, elevateQuadraticToCubic } from '../curve';\n\n/** Minimal path input: a rect or a polygon command stream. geom does not\n *  import @weasel-js/core's `Path`; the kit maps `Path` onto this shape. */\nexport type GeomPath =\n  | { kind: 'rect'; x: number; y: number; width: number; height: number }\n  | { kind: 'polygon'; commands: ArrayLike<number>; coords: ArrayLike<number>; fillRule?: 'nonzero' | 'evenodd' };\n\nconst DEFAULT_FLATTEN_TOLERANCE = 0.5;\n\n/** A `[x, y]` 2-tuple. */\nexport type Pair = [number, number];\n/** Closed ring (first vertex repeated as last). */\nexport type Ring = Pair[];\n/** Polygon: one outer ring optionally followed by hole rings. */\nexport type Polygon = Ring[];\n/** MultiPolygon: list of polygons (used for boolean op I/O). */\nexport type MultiPolygon = Polygon[];\n\nexport interface PathToMultiPolygonOptions {\n  /** Flattening tolerance for bezier segments. Default: `DEFAULT_FLATTEN_TOLERANCE`. */\n  tolerance?: number;\n}\n\n/** Polygon result shape emitted by `multiPolygonToPath`. */\nexport type GeomPolygonPath = { kind: 'polygon'; commands: Uint8Array; coords: Float32Array; fillRule: 'nonzero' };\n\n/** Convert a `GeomPath` to a `MultiPolygon` suitable for `polygon-clipping`. */\nexport function pathToMultiPolygon(\n  path: GeomPath,\n  opts: PathToMultiPolygonOptions = {},\n): MultiPolygon {\n  if (path.kind === 'rect') {\n    const { x, y, width, height } = path;\n    const ring: Ring = [\n      [x, y],\n      [x + width, y],\n      [x + width, y + height],\n      [x, y + height],\n      [x, y],\n    ];\n    return [[ring]];\n  }\n\n  const tolerance = opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE;\n  const rings: Ring[] = [];\n  let current: Ring | null = null;\n  let cx = 0, cy = 0;\n  let ci = 0;\n  const { commands, coords } = path;\n\n  const finalizeCurrent = () => {\n    if (!current || current.length === 0) return;\n    // Close the ring by repeating the first vertex if not already closed.\n    const first = current[0];\n    const last = current[current.length - 1];\n    if (first[0] !== last[0] || first[1] !== last[1]) {\n      current.push([first[0], first[1]]);\n    }\n    if (current.length >= 4) rings.push(current); // 3 unique + 1 closing\n    current = null;\n  };\n\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    switch (cmd) {\n      case PATH_M: {\n        finalizeCurrent();\n        cx = coords[ci]; cy = coords[ci + 1];\n        current = [[cx, cy]];\n        ci += 2;\n        break;\n      }\n      case PATH_L: {\n        cx = coords[ci]; cy = coords[ci + 1];\n        if (current) current.push([cx, cy]);\n        ci += 2;\n        break;\n      }\n      case PATH_C: {\n        const x1 = coords[ci], y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const x3 = coords[ci + 4], y3 = coords[ci + 5];\n        const out: number[] = [];\n        flattenCubic(cx, cy, x1, y1, x2, y2, x3, y3, tolerance, out);\n        if (current) for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);\n        cx = x3; cy = y3;\n        ci += 6;\n        break;\n      }\n      case PATH_Q: {\n        const x1 = coords[ci], y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(cx, cy, x1, y1, x2, y2);\n        const out: number[] = [];\n        flattenCubic(cx, cy, c1x, c1y, c2x, c2y, x2, y2, tolerance, out);\n        if (current) for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);\n        cx = x2; cy = y2;\n        ci += 4;\n        break;\n      }\n      case PATH_Z: {\n        finalizeCurrent();\n        break;\n      }\n    }\n  }\n  finalizeCurrent();\n\n  if (rings.length === 0) return [];\n  // v1: emit every ring as its own polygon. `polygon-clipping`'s engine\n  // re-classifies winding internally during the op, so we don't need to\n  // pre-sort outer/hole rings.\n  return rings.map((r) => [r]);\n}\n\n/** Convert a `MultiPolygon` to a polygon path with `fillRule: 'nonzero'`. */\nexport function multiPolygonToPath(mp: MultiPolygon): GeomPolygonPath {\n  // First pass: count total commands and coord floats.\n  let nCmds = 0;\n  let nCoords = 0;\n  for (const poly of mp) {\n    for (const ring of poly) {\n      if (ring.length < 4) continue; // 3 unique + 1 closing minimum\n      // Drop the repeated closing vertex; emit M + (n-2) L + Z.\n      const unique = ring.length - 1;\n      nCmds += 1 + (unique - 1) + 1; // M + L*(unique-1) + Z\n      nCoords += unique * 2;\n    }\n  }\n  const commands = new Uint8Array(nCmds);\n  const coords = new Float32Array(nCoords);\n  let ci = 0;\n  let pi = 0;\n  for (const poly of mp) {\n    for (const ring of poly) {\n      if (ring.length < 4) continue;\n      const unique = ring.length - 1;\n      // M (first vertex)\n      commands[ci++] = PATH_M;\n      coords[pi++] = ring[0][0];\n      coords[pi++] = ring[0][1];\n      // L for vertices 1..unique-1\n      for (let k = 1; k < unique; k++) {\n        commands[ci++] = PATH_L;\n        coords[pi++] = ring[k][0];\n        coords[pi++] = ring[k][1];\n      }\n      // Z\n      commands[ci++] = PATH_Z;\n    }\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n","/**\n * Polygon-boolean operations on `GeomPath` values, backed by\n * `polygon-clipping`. Ported from `src/features/paths/booleans.ts`.\n *\n * v1 limitations (documented; see design doc):\n *   - Bezier inputs are flattened to straight-line segments before clipping.\n *     The result therefore contains only M/L/Z commands.\n *   - Open contours are treated as closed for boolean purposes (a polyline\n *     has zero area and would otherwise be silently dropped).\n *   - Output `fillRule` is always `'nonzero'`. The engine emits canonical\n *     non-overlapping rings, so the choice is cosmetic on its output.\n *\n * This is the ONLY geom module that depends on `polygon-clipping`; it lives in\n * the `@weasel-js/geom/booleans` subpath so the core stays `deps: {}`.\n */\nimport polygonClipping from 'polygon-clipping';\nimport { pathToMultiPolygon, multiPolygonToPath, type GeomPath, type GeomPolygonPath } from './adapter';\n\nexport type { GeomPath, GeomPolygonPath } from './adapter';\n\n/** Union of N paths. Commutative. Returns an empty path if all inputs are empty. */\nexport function pathUnion(...paths: GeomPath[]): GeomPolygonPath {\n  if (paths.length === 0) return multiPolygonToPath([]);\n  const mps = paths.map((p) => pathToMultiPolygon(p));\n  const [head, ...rest] = mps;\n  return multiPolygonToPath(polygonClipping.union(head, ...rest));\n}\n\n/** Intersection of N paths. Commutative. Empty result is an empty path. */\nexport function pathIntersect(...paths: GeomPath[]): GeomPolygonPath {\n  if (paths.length === 0) return multiPolygonToPath([]);\n  const mps = paths.map((p) => pathToMultiPolygon(p));\n  const [head, ...rest] = mps;\n  return multiPolygonToPath(polygonClipping.intersection(head, ...rest));\n}\n\n/** Asymmetric difference: returns `a − b`. */\nexport function pathSubtract(a: GeomPath, b: GeomPath): GeomPolygonPath {\n  return multiPolygonToPath(polygonClipping.difference(pathToMultiPolygon(a), pathToMultiPolygon(b)));\n}\n\n/** Symmetric difference (XOR) of N paths. Commutative. */\nexport function pathExclude(...paths: GeomPath[]): GeomPolygonPath {\n  if (paths.length === 0) return multiPolygonToPath([]);\n  const mps = paths.map((p) => pathToMultiPolygon(p));\n  const [head, ...rest] = mps;\n  return multiPolygonToPath(polygonClipping.xor(head, ...rest));\n}\n\n/**\n * Fracture N paths along every intersection into the maximal set of\n * non-overlapping regions. Returns one polygon path per region.\n *\n * Algorithm: for every non-empty subset S ⊆ {A1..AN}, emit the region\n * `(∩ S) − (∪ complement)` — points covered by exactly the members of S\n * and no others. By construction the emitted regions are pairwise disjoint\n * and their union equals `pathUnion(A1..AN)`.\n *\n * For N=2 this collapses to the three Illustrator \"Divide\" outputs\n * (A−B, B−A, A∩B). For N=3 up to 7 regions are emitted. The 2^N − 1\n * subset count limits this to small N in practice; passing more than ~8\n * inputs is a misuse — the polygon-clipping kernel dominates anyway.\n */\nexport function pathDivide(...paths: GeomPath[]): GeomPolygonPath[] {\n  if (paths.length === 0) return [];\n  if (paths.length === 1) {\n    return [multiPolygonToPath(pathToMultiPolygon(paths[0]))];\n  }\n  const mps = paths.map((p) => pathToMultiPolygon(p));\n  const n = mps.length;\n  const out: GeomPolygonPath[] = [];\n\n  // Iterate every non-empty subset via bitmask. Emit subsets in size-\n  // ascending order so the output is stable and reads \"exclusives first,\n  // then pairs, then triples, …\" — matches the old N=2 ordering.\n  const subsets: number[] = [];\n  for (let mask = 1; mask < 1 << n; mask++) subsets.push(mask);\n  subsets.sort((a, b) => popcount(a) - popcount(b) || a - b);\n\n  for (const mask of subsets) {\n    const inside: typeof mps = [];\n    const outside: typeof mps = [];\n    for (let i = 0; i < n; i++) {\n      (mask & (1 << i) ? inside : outside).push(mps[i]);\n    }\n    const [insideHead, ...insideRest] = inside;\n    let region = insideRest.length === 0\n      ? insideHead\n      : polygonClipping.intersection(insideHead, ...insideRest);\n    if (region.length === 0) continue;\n    if (outside.length > 0) {\n      const [outHead, ...outRest] = outside;\n      const outsideUnion = polygonClipping.union(outHead, ...outRest);\n      region = polygonClipping.difference(region, outsideUnion);\n      if (region.length === 0) continue;\n    }\n    out.push(multiPolygonToPath(region));\n  }\n\n  return out;\n}\n\nfunction popcount(n: number): number {\n  let c = 0;\n  while (n) { n &= n - 1; c++; }\n  return c;\n}\n"]}

package/dist/chunk-K5JJ6WRB.js

@@ -0,0 +1,106 @@
+// src/commands.ts
+var PATH_M = 0;
+var PATH_L = 1;
+var PATH_C = 2;
+var PATH_Q = 3;
+var PATH_Z = 4;
+var PATH_CMD_LENGTHS = [2, 2, 6, 4, 0];
+function forEachSegment(commands, coords, visit) {
+  let ci = 0;
+  let px = 0, py = 0;
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    visit(cmd, ci, px, py);
+    const len = PATH_CMD_LENGTHS[cmd];
+    if (len > 0) {
+      px = coords[ci + len - 2];
+      py = coords[ci + len - 1];
+      ci += len;
+    }
+  }
+}
+
+// src/curve.ts
+function cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t) {
+  const u = 1 - t;
+  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+  return [
+    a * x0 + b * x1 + c * x2 + d * x3,
+    a * y0 + b * y1 + c * y2 + d * y3
+  ];
+}
+function elevateQuadraticToCubic(q0x, q0y, cx, cy, q1x, q1y) {
+  return [
+    q0x + 2 / 3 * (cx - q0x),
+    q0y + 2 / 3 * (cy - q0y),
+    q1x + 2 / 3 * (cx - q1x),
+    q1y + 2 / 3 * (cy - q1y)
+  ];
+}
+function distPointToLine(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  if (len2 === 0) {
+    const ex = px - ax;
+    const ey = py - ay;
+    return Math.sqrt(ex * ex + ey * ey);
+  }
+  const cross = (px - ax) * dy - (py - ay) * dx;
+  return Math.abs(cross) / Math.sqrt(len2);
+}
+function flattenCubic(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
+  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);
+  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);
+  if (Math.max(d1, d2) <= tolerance) {
+    out.push(x3, y3);
+    return;
+  }
+  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
+  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
+  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;
+  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
+  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;
+  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;
+  flattenCubic(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);
+  flattenCubic(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);
+}
+function componentExtremaTs(p0, p1, p2, p3) {
+  const a = -p0 + 3 * p1 - 3 * p2 + p3;
+  const b = 2 * (p0 - 2 * p1 + p2);
+  const c = -p0 + p1;
+  const ts = [];
+  const push = (t) => {
+    if (t > 0 && t < 1) ts.push(t);
+  };
+  if (Math.abs(a) < 1e-12) {
+    if (Math.abs(b) > 1e-12) push(-c / b);
+  } else {
+    const disc = b * b - 4 * a * c;
+    if (disc >= 0) {
+      const sq = Math.sqrt(disc);
+      push((-b + sq) / (2 * a));
+      push((-b - sq) / (2 * a));
+    }
+  }
+  return ts;
+}
+function cubicBounds(x0, y0, x1, y1, x2, y2, x3, y3) {
+  let minX = Math.min(x0, x3), maxX = Math.max(x0, x3);
+  let minY = Math.min(y0, y3), maxY = Math.max(y0, y3);
+  for (const t of componentExtremaTs(x0, x1, x2, x3)) {
+    const [ex] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);
+    if (ex < minX) minX = ex;
+    if (ex > maxX) maxX = ex;
+  }
+  for (const t of componentExtremaTs(y0, y1, y2, y3)) {
+    const [, ey] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);
+    if (ey < minY) minY = ey;
+    if (ey > maxY) maxY = ey;
+  }
+  return [minX, minY, maxX, maxY];
+}
+
+export { PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, cubicBounds, cubicEvalAt, elevateQuadraticToCubic, flattenCubic, forEachSegment };
+//# sourceMappingURL=chunk-K5JJ6WRB.js.map
+//# sourceMappingURL=chunk-K5JJ6WRB.js.map

package/dist/chunk-K5JJ6WRB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands.ts","../src/curve.ts"],"names":[],"mappings":"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","file":"chunk-K5JJ6WRB.js","sourcesContent":["/**\n * SVG-style command-stream encoding — geom's canonical copy. `Path` in\n * @weasel-js/core wraps this with `kind` + `fillRule`. Codes lifted from\n * features/paths/types.ts; Spec 2 re-points that file to re-export these.\n */\nexport const PATH_M = 0; // moveTo\nexport const PATH_L = 1; // lineTo\nexport const PATH_C = 2; // cubic bezier\nexport const PATH_Q = 3; // quadratic bezier\nexport const PATH_Z = 4; // close subpath\n\n/** Float coords consumed by each command, indexed by command code. */\nexport const PATH_CMD_LENGTHS: readonly number[] = [2, 2, 6, 4, 0];\n\n/**\n * Visit each command with its coord offset and the pen position BEFORE the\n * command consumes its coords (the segment start). The callback receives\n * (cmd, coordIndex, penX, penY). The pen advances to the command's last\n * coord pair afterward (Z leaves the pen unchanged).\n */\nexport function forEachSegment(\n  commands: ArrayLike<number>,\n  coords: ArrayLike<number>,\n  visit: (cmd: number, coordIndex: number, penX: number, penY: number) => void,\n): void {\n  let ci = 0;\n  let px = 0, py = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    visit(cmd, ci, px, py);\n    const len = PATH_CMD_LENGTHS[cmd];\n    if (len > 0) {\n      px = coords[ci + len - 2];\n      py = coords[ci + len - 1];\n      ci += len;\n    }\n  }\n}\n","import type { Box } from './box';\n\n/** Cubic Bezier point at parameter t (de Casteljau / Bernstein form). */\nexport function cubicEvalAt(\n  x0: number, y0: number, x1: number, y1: number,\n  x2: number, y2: number, x3: number, y3: number, t: number,\n): [number, number] {\n  const u = 1 - t;\n  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;\n  return [\n    a * x0 + b * x1 + c * x2 + d * x3,\n    a * y0 + b * y1 + c * y2 + d * y3,\n  ];\n}\n\n/**\n * Degree-elevate a quadratic (q0, ctrl, q1) to a cubic. Returns the two\n * cubic control points [c1x, c1y, c2x, c2y]; the cubic endpoints equal the\n * quadratic endpoints. c1 = q0 + 2/3(ctrl-q0), c2 = q1 + 2/3(ctrl-q1).\n */\nexport function elevateQuadraticToCubic(\n  q0x: number, q0y: number, cx: number, cy: number, q1x: number, q1y: number,\n): [number, number, number, number] {\n  return [\n    q0x + (2 / 3) * (cx - q0x),\n    q0y + (2 / 3) * (cy - q0y),\n    q1x + (2 / 3) * (cx - q1x),\n    q1y + (2 / 3) * (cy - q1y),\n  ];\n}\n\n/** Distance from point P to line AB (perpendicular). Ported verbatim from\n *  features/paths/flatten.ts (helper for flattenCubic's flatness predicate). */\nfunction distPointToLine(px: number, py: number, ax: number, ay: number, bx: number, by: number): number {\n  const dx = bx - ax;\n  const dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) {\n    const ex = px - ax;\n    const ey = py - ay;\n    return Math.sqrt(ex * ex + ey * ey);\n  }\n  const cross = (px - ax) * dy - (py - ay) * dx;\n  return Math.abs(cross) / Math.sqrt(len2);\n}\n\n/**\n * Adaptive flatten of a cubic into interleaved points appended to `out`\n * (excludes the start point, includes the endpoint). Ported verbatim from\n * features/paths/flatten.ts:37.\n */\nexport function flattenCubic(\n  x0: number, y0: number, x1: number, y1: number,\n  x2: number, y2: number, x3: number, y3: number,\n  tolerance: number, out: number[],\n): void {\n  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);\n  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);\n  if (Math.max(d1, d2) <= tolerance) {\n    out.push(x3, y3);\n    return;\n  }\n  // De Casteljau split at t=0.5\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;\n  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;\n  flattenCubic(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);\n  flattenCubic(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);\n}\n\n/** Axis-aligned extrema parameters of one cubic component (the 0,1 ends plus\n *  any derivative roots in (0,1)). Used by cubicBounds. */\nfunction componentExtremaTs(p0: number, p1: number, p2: number, p3: number): number[] {\n  // B'(t)=0 → quadratic a t² + b t + c = 0 with:\n  const a = -p0 + 3 * p1 - 3 * p2 + p3;\n  const b = 2 * (p0 - 2 * p1 + p2);\n  const c = -p0 + p1;\n  const ts: number[] = [];\n  const push = (t: number) => { if (t > 0 && t < 1) ts.push(t); };\n  if (Math.abs(a) < 1e-12) {\n    if (Math.abs(b) > 1e-12) push(-c / b);\n  } else {\n    const disc = b * b - 4 * a * c;\n    if (disc >= 0) {\n      const sq = Math.sqrt(disc);\n      push((-b + sq) / (2 * a));\n      push((-b - sq) / (2 * a));\n    }\n  }\n  return ts;\n}\n\n/** Tight AABB of a cubic, evaluating only extrema that lie on the curve. */\nexport function cubicBounds(\n  x0: number, y0: number, x1: number, y1: number,\n  x2: number, y2: number, x3: number, y3: number,\n): Box {\n  let minX = Math.min(x0, x3), maxX = Math.max(x0, x3);\n  let minY = Math.min(y0, y3), maxY = Math.max(y0, y3);\n  for (const t of componentExtremaTs(x0, x1, x2, x3)) {\n    const [ex] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);\n    if (ex < minX) minX = ex;\n    if (ex > maxX) maxX = ex;\n  }\n  for (const t of componentExtremaTs(y0, y1, y2, y3)) {\n    const [, ey] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);\n    if (ey < minY) minY = ey;\n    if (ey > maxY) maxY = ey;\n  }\n  return [minX, minY, maxX, maxY];\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Scalar / 2-vector primitives and the kernel-wide epsilon policy.
+ *
+ * Points are scalar pairs (px, py); there is no point struct. All math is
+ * f64 (JS-native). Epsilons are f32-SCALE and magnitude-relative, because
+ * stored coords are quantized to Float32 (~7 significant digits) — see the
+ * geometry-kernel spec.
+ */
+/** Base relative epsilon, sized for Float32 storage (~1 part in 1e-6). */
+declare const EPS = 0.000001;
+/** 2D cross (wedge) product of vectors (ax,ay) and (bx,by). */
+declare function cross(ax: number, ay: number, bx: number, by: number): number;
+/** 2D dot product. */
+declare function dot(ax: number, ay: number, bx: number, by: number): number;
+/** Component difference (ax-bx, ay-by) as a tuple. Cold-path use only. */
+declare function sub(ax: number, ay: number, bx: number, by: number): [number, number];
+/** Squared length of (x,y). Avoids the sqrt; compare against squared thresholds. */
+declare function len2(x: number, y: number): number;
+/** Three-valued sign. */
+declare function sign(n: number): -1 | 0 | 1;
+/**
+ * Magnitude-scaled approximate equality. Two values are equal when their
+ * absolute difference is within EPS scaled by the larger magnitude. This is
+ * the ONLY equality the kernel uses on computed coordinates — never `===`,
+ * never an f64-tight literal.
+ */
+declare function approxEq(a: number, b: number, eps?: number): boolean;
+
+/**
+ * 2D affine transforms in canvas/DOMMatrix order: [a, b, c, d, e, f].
+ *   x' = a·x + c·y + e
+ *   y' = b·x + d·y + f
+ * Represented as a 6-element number[] (f64). The affine tier of the kernel.
+ *
+ * Convention alignment: the renderer already has a `Mat3` in
+ * `src/renderer/math/mat3.ts`. That one is a 9-element column-major
+ * `Float32Array` (a full 3×3) shaped for `uniformMatrix3fv` — a deliberately
+ * different *representation* for the WebGL upload path. Its *logical element
+ * order* is identical to ours: `create(a, b, c, d, tx, ty)` maps
+ * `x' = a·x + c·y + tx`, `y' = b·x + d·y + ty` (canvas/DOMMatrix a,b,c,d,e,f).
+ * We keep the pure 6-tuple f64 form here (the kernel form); the 9-element f32
+ * form stays a render-layer concern. No second logical convention is created.
+ */
+type Mat3 = number[];
+declare function identity(): Mat3;
+declare function translate(tx: number, ty: number): Mat3;
+declare function scale(sx: number, sy: number): Mat3;
+declare function rotate(rad: number): Mat3;
+/** Compose: result applies `n` first, then `m` (m·n). */
+declare function multiply(m: Mat3, n: Mat3): Mat3;
+/** Inverse, or null when the matrix is singular (|det| below the epsilon). */
+declare function invert(m: Mat3): Mat3 | null;
+/** Apply to a point, returning a tuple. Cold-path use; hot loops inline. */
+declare function applyToPoint(m: Mat3, x: number, y: number): [number, number];
+/** Affine that maps source box (sx,sy,sw,sh) onto destination box (dx,dy,dw,dh). */
+declare function boxToBox(sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): Mat3;
+/** Rotation by `rad` about pivot (cx,cy): translate(c)·rotate·translate(-c). */
+declare function rotateAboutPoint(cx: number, cy: number, rad: number): Mat3;
+
+/** Axis-aligned box as [minX, minY, maxX, maxY]. */
+type Box = [number, number, number, number];
+/** Tight bounds of an interleaved coord stream, or null if empty. */
+declare function boundsOfCoords(coords: ArrayLike<number>): Box | null;
+/** Smallest box containing both inputs. */
+declare function unionBox(a: Box, b: Box): Box;
+/** Inclusive point-in-box test. */
+declare function boxContainsPoint(b: Box, x: number, y: number): boolean;
+/** Closed interleaved ring (first vertex repeated) for a rect at (x,y,w,h). */
+declare function rectToContour(x: number, y: number, w: number, h: number): Float64Array;
+
+/**
+ * SVG-style command-stream encoding — geom's canonical copy. `Path` in
+ * @weasel-js/core wraps this with `kind` + `fillRule`. Codes lifted from
+ * features/paths/types.ts; Spec 2 re-points that file to re-export these.
+ */
+declare const PATH_M = 0;
+declare const PATH_L = 1;
+declare const PATH_C = 2;
+declare const PATH_Q = 3;
+declare const PATH_Z = 4;
+/** Float coords consumed by each command, indexed by command code. */
+declare const PATH_CMD_LENGTHS: readonly number[];
+/**
+ * Visit each command with its coord offset and the pen position BEFORE the
+ * command consumes its coords (the segment start). The callback receives
+ * (cmd, coordIndex, penX, penY). The pen advances to the command's last
+ * coord pair afterward (Z leaves the pen unchanged).
+ */
+declare function forEachSegment(commands: ArrayLike<number>, coords: ArrayLike<number>, visit: (cmd: number, coordIndex: number, penX: number, penY: number) => void): void;
+
+/** Cubic Bezier point at parameter t (de Casteljau / Bernstein form). */
+declare function cubicEvalAt(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): [number, number];
+/**
+ * Degree-elevate a quadratic (q0, ctrl, q1) to a cubic. Returns the two
+ * cubic control points [c1x, c1y, c2x, c2y]; the cubic endpoints equal the
+ * quadratic endpoints. c1 = q0 + 2/3(ctrl-q0), c2 = q1 + 2/3(ctrl-q1).
+ */
+declare function elevateQuadraticToCubic(q0x: number, q0y: number, cx: number, cy: number, q1x: number, q1y: number): [number, number, number, number];
+/**
+ * Adaptive flatten of a cubic into interleaved points appended to `out`
+ * (excludes the start point, includes the endpoint). Ported verbatim from
+ * features/paths/flatten.ts:37.
+ */
+declare function flattenCubic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, tolerance: number, out: number[]): void;
+/** Tight AABB of a cubic, evaluating only extrema that lie on the curve. */
+declare function cubicBounds(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): Box;
+
+/**
+ * Even-odd ray-cast point-in-polygon over an interleaved, unclosed contour
+ * [x0,y0,x1,y1,…]. The closing edge (last→first) is implicit. Flat rewrite of
+ * features/paths/polygonHitTestRect.ts pointInPolygon — same algorithm.
+ */
+declare function pointInPolygon(coords: ArrayLike<number>, px: number, py: number): boolean;
+/** True if segment (ax,ay)-(bx,by) properly crosses (cx,cy)-(dx,dy). Flat
+ *  rewrite of polygonHitTestRect.ts segmentsCross. */
+declare function segmentsCross(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, dx: number, dy: number): boolean;
+/** Squared distance from (px,py) to segment (ax,ay)-(bx,by), endpoint-clamped. */
+declare function pointSegmentDist2(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
+
+/**
+ * Apply an affine to an interleaved coord stream, returning a fresh f64
+ * buffer. Command codes are unaffected — for a Bezier the transformed control
+ * points define the transformed curve exactly (affine invariance), so callers
+ * pass `path.coords` straight through and keep `path.commands` as-is.
+ */
+declare function transformCoords(coords: ArrayLike<number>, m: Mat3): Float64Array;
+
+export { type Box, EPS, type Mat3, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, applyToPoint, approxEq, boundsOfCoords, boxContainsPoint, boxToBox, cross, cubicBounds, cubicEvalAt, dot, elevateQuadraticToCubic, flattenCubic, forEachSegment, identity, invert, len2, multiply, pointInPolygon, pointSegmentDist2, rectToContour, rotate, rotateAboutPoint, scale, segmentsCross, sign, sub, transformCoords, translate, unionBox };

package/dist/index.js

@@ -0,0 +1,146 @@
+export { PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, cubicBounds, cubicEvalAt, elevateQuadraticToCubic, flattenCubic, forEachSegment } from './chunk-K5JJ6WRB.js';
+
+// src/scalar.ts
+var EPS = 1e-6;
+function cross(ax, ay, bx, by) {
+  return ax * by - ay * bx;
+}
+function dot(ax, ay, bx, by) {
+  return ax * bx + ay * by;
+}
+function sub(ax, ay, bx, by) {
+  return [ax - bx, ay - by];
+}
+function len2(x, y) {
+  return x * x + y * y;
+}
+function sign(n) {
+  return n > 0 ? 1 : n < 0 ? -1 : 0;
+}
+function approxEq(a, b, eps = EPS) {
+  const diff = Math.abs(a - b);
+  if (diff === 0) return true;
+  const scale2 = Math.max(1, Math.abs(a), Math.abs(b));
+  return diff <= eps * scale2;
+}
+
+// src/mat3.ts
+function identity() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function translate(tx, ty) {
+  return [1, 0, 0, 1, tx, ty];
+}
+function scale(sx, sy) {
+  return [sx, 0, 0, sy, 0, 0];
+}
+function rotate(rad) {
+  const c = Math.cos(rad);
+  const s = Math.sin(rad);
+  return [c, s, -s, c, 0, 0];
+}
+function multiply(m, n) {
+  return [
+    m[0] * n[0] + m[2] * n[1],
+    m[1] * n[0] + m[3] * n[1],
+    m[0] * n[2] + m[2] * n[3],
+    m[1] * n[2] + m[3] * n[3],
+    m[0] * n[4] + m[2] * n[5] + m[4],
+    m[1] * n[4] + m[3] * n[5] + m[5]
+  ];
+}
+function invert(m) {
+  const det = m[0] * m[3] - m[1] * m[2];
+  if (Math.abs(det) < 1e-12) return null;
+  const id = 1 / det;
+  const a = m[3] * id;
+  const b = -m[1] * id;
+  const c = -m[2] * id;
+  const d = m[0] * id;
+  return [a, b, c, d, -(m[4] * a + m[5] * c), -(m[4] * b + m[5] * d)];
+}
+function applyToPoint(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function boxToBox(sx, sy, sw, sh, dx, dy, dw, dh) {
+  const kx = sw === 0 ? 1 : dw / sw;
+  const ky = sh === 0 ? 1 : dh / sh;
+  return [kx, 0, 0, ky, dx - sx * kx, dy - sy * ky];
+}
+function rotateAboutPoint(cx, cy, rad) {
+  return multiply(translate(cx, cy), multiply(rotate(rad), translate(-cx, -cy)));
+}
+
+// src/box.ts
+function boundsOfCoords(coords) {
+  if (coords.length < 2) return null;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i + 1 < coords.length; i += 2) {
+    const x = coords[i], y = coords[i + 1];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  }
+  return [minX, minY, maxX, maxY];
+}
+function unionBox(a, b) {
+  return [
+    Math.min(a[0], b[0]),
+    Math.min(a[1], b[1]),
+    Math.max(a[2], b[2]),
+    Math.max(a[3], b[3])
+  ];
+}
+function boxContainsPoint(b, x, y) {
+  return x >= b[0] && x <= b[2] && y >= b[1] && y <= b[3];
+}
+function rectToContour(x, y, w, h) {
+  return Float64Array.of(x, y, x + w, y, x + w, y + h, x, y + h, x, y);
+}
+
+// src/polyline.ts
+function pointInPolygon(coords, px, py) {
+  const n = coords.length >> 1;
+  if (n < 3) return false;
+  let inside = false;
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const xi = coords[i * 2], yi = coords[i * 2 + 1];
+    const xj = coords[j * 2], yj = coords[j * 2 + 1];
+    const crosses = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi;
+    if (crosses) inside = !inside;
+  }
+  return inside;
+}
+function segmentsCross(ax, ay, bx, by, cx, cy, dx, dy) {
+  const d1 = sign((dx - cx) * (ay - cy) - (dy - cy) * (ax - cx));
+  const d2 = sign((dx - cx) * (by - cy) - (dy - cy) * (bx - cx));
+  const d3 = sign((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));
+  const d4 = sign((bx - ax) * (dy - ay) - (by - ay) * (dx - ax));
+  return d1 !== d2 && d3 !== d4;
+}
+function pointSegmentDist2(px, py, ax, ay, bx, by) {
+  const vx = bx - ax, vy = by - ay;
+  const wx = px - ax, wy = py - ay;
+  const vv = len2(vx, vy);
+  let t = vv === 0 ? 0 : dot(wx, wy, vx, vy) / vv;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const dx = px - (ax + t * vx), dy = py - (ay + t * vy);
+  return len2(dx, dy);
+}
+
+// src/affine.ts
+function transformCoords(coords, m) {
+  const out = new Float64Array(coords.length);
+  const a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];
+  for (let i = 0; i + 1 < coords.length; i += 2) {
+    const x = coords[i], y = coords[i + 1];
+    out[i] = a * x + c * y + e;
+    out[i + 1] = b * x + d * y + f;
+  }
+  return out;
+}
+
+export { EPS, applyToPoint, approxEq, boundsOfCoords, boxContainsPoint, boxToBox, cross, dot, identity, invert, len2, multiply, pointInPolygon, pointSegmentDist2, rectToContour, rotate, rotateAboutPoint, scale, segmentsCross, sign, sub, transformCoords, translate, unionBox };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/scalar.ts","../src/mat3.ts","../src/box.ts","../src/polyline.ts","../src/affine.ts"],"names":["scale"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Scalar / 2-vector primitives and the kernel-wide epsilon policy.\n *\n * Points are scalar pairs (px, py); there is no point struct. All math is\n * f64 (JS-native). Epsilons are f32-SCALE and magnitude-relative, because\n * stored coords are quantized to Float32 (~7 significant digits) — see the\n * geometry-kernel spec.\n */\n\n/** Base relative epsilon, sized for Float32 storage (~1 part in 1e-6). */\nexport const EPS = 1e-6;\n\n/** 2D cross (wedge) product of vectors (ax,ay) and (bx,by). */\nexport function cross(ax: number, ay: number, bx: number, by: number): number {\n  return ax * by - ay * bx;\n}\n\n/** 2D dot product. */\nexport function dot(ax: number, ay: number, bx: number, by: number): number {\n  return ax * bx + ay * by;\n}\n\n/** Component difference (ax-bx, ay-by) as a tuple. Cold-path use only. */\nexport function sub(ax: number, ay: number, bx: number, by: number): [number, number] {\n  return [ax - bx, ay - by];\n}\n\n/** Squared length of (x,y). Avoids the sqrt; compare against squared thresholds. */\nexport function len2(x: number, y: number): number {\n  return x * x + y * y;\n}\n\n/** Three-valued sign. */\nexport function sign(n: number): -1 | 0 | 1 {\n  return n > 0 ? 1 : n < 0 ? -1 : 0;\n}\n\n/**\n * Magnitude-scaled approximate equality. Two values are equal when their\n * absolute difference is within EPS scaled by the larger magnitude. This is\n * the ONLY equality the kernel uses on computed coordinates — never `===`,\n * never an f64-tight literal.\n */\nexport function approxEq(a: number, b: number, eps: number = EPS): boolean {\n  const diff = Math.abs(a - b);\n  if (diff === 0) return true;\n  const scale = Math.max(1, Math.abs(a), Math.abs(b));\n  return diff <= eps * scale;\n}\n","/**\n * 2D affine transforms in canvas/DOMMatrix order: [a, b, c, d, e, f].\n *   x' = a·x + c·y + e\n *   y' = b·x + d·y + f\n * Represented as a 6-element number[] (f64). The affine tier of the kernel.\n *\n * Convention alignment: the renderer already has a `Mat3` in\n * `src/renderer/math/mat3.ts`. That one is a 9-element column-major\n * `Float32Array` (a full 3×3) shaped for `uniformMatrix3fv` — a deliberately\n * different *representation* for the WebGL upload path. Its *logical element\n * order* is identical to ours: `create(a, b, c, d, tx, ty)` maps\n * `x' = a·x + c·y + tx`, `y' = b·x + d·y + ty` (canvas/DOMMatrix a,b,c,d,e,f).\n * We keep the pure 6-tuple f64 form here (the kernel form); the 9-element f32\n * form stays a render-layer concern. No second logical convention is created.\n */\nexport type Mat3 = number[];\n\nexport function identity(): Mat3 {\n  return [1, 0, 0, 1, 0, 0];\n}\n\nexport function translate(tx: number, ty: number): Mat3 {\n  return [1, 0, 0, 1, tx, ty];\n}\n\nexport function scale(sx: number, sy: number): Mat3 {\n  return [sx, 0, 0, sy, 0, 0];\n}\n\nexport function rotate(rad: number): Mat3 {\n  const c = Math.cos(rad);\n  const s = Math.sin(rad);\n  return [c, s, -s, c, 0, 0];\n}\n\n/** Compose: result applies `n` first, then `m` (m·n). */\nexport function multiply(m: Mat3, n: Mat3): Mat3 {\n  return [\n    m[0] * n[0] + m[2] * n[1],\n    m[1] * n[0] + m[3] * n[1],\n    m[0] * n[2] + m[2] * n[3],\n    m[1] * n[2] + m[3] * n[3],\n    m[0] * n[4] + m[2] * n[5] + m[4],\n    m[1] * n[4] + m[3] * n[5] + m[5],\n  ];\n}\n\n/** Inverse, or null when the matrix is singular (|det| below the epsilon). */\nexport function invert(m: Mat3): Mat3 | null {\n  const det = m[0] * m[3] - m[1] * m[2];\n  if (Math.abs(det) < 1e-12) return null;\n  const id = 1 / det;\n  const a = m[3] * id;\n  const b = -m[1] * id;\n  const c = -m[2] * id;\n  const d = m[0] * id;\n  return [a, b, c, d, -(m[4] * a + m[5] * c), -(m[4] * b + m[5] * d)];\n}\n\n/** Apply to a point, returning a tuple. Cold-path use; hot loops inline. */\nexport function applyToPoint(m: Mat3, x: number, y: number): [number, number] {\n  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];\n}\n\n/** Affine that maps source box (sx,sy,sw,sh) onto destination box (dx,dy,dw,dh). */\nexport function boxToBox(\n  sx: number, sy: number, sw: number, sh: number,\n  dx: number, dy: number, dw: number, dh: number,\n): Mat3 {\n  const kx = sw === 0 ? 1 : dw / sw;\n  const ky = sh === 0 ? 1 : dh / sh;\n  // translate(dx,dy) · scale(kx,ky) · translate(-sx,-sy)\n  return [kx, 0, 0, ky, dx - sx * kx, dy - sy * ky];\n}\n\n/** Rotation by `rad` about pivot (cx,cy): translate(c)·rotate·translate(-c). */\nexport function rotateAboutPoint(cx: number, cy: number, rad: number): Mat3 {\n  return multiply(translate(cx, cy), multiply(rotate(rad), translate(-cx, -cy)));\n}\n","/** Axis-aligned box as [minX, minY, maxX, maxY]. */\nexport type Box = [number, number, number, number];\n\n/** Tight bounds of an interleaved coord stream, or null if empty. */\nexport function boundsOfCoords(coords: ArrayLike<number>): Box | null {\n  if (coords.length < 2) return null;\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  return [minX, minY, maxX, maxY];\n}\n\n/** Smallest box containing both inputs. */\nexport function unionBox(a: Box, b: Box): Box {\n  return [\n    Math.min(a[0], b[0]),\n    Math.min(a[1], b[1]),\n    Math.max(a[2], b[2]),\n    Math.max(a[3], b[3]),\n  ];\n}\n\n/** Inclusive point-in-box test. */\nexport function boxContainsPoint(b: Box, x: number, y: number): boolean {\n  return x >= b[0] && x <= b[2] && y >= b[1] && y <= b[3];\n}\n\n/** Closed interleaved ring (first vertex repeated) for a rect at (x,y,w,h). */\nexport function rectToContour(x: number, y: number, w: number, h: number): Float64Array {\n  return Float64Array.of(x, y, x + w, y, x + w, y + h, x, y + h, x, y);\n}\n","import { sign, dot, len2 } from './scalar';\n\n/**\n * Even-odd ray-cast point-in-polygon over an interleaved, unclosed contour\n * [x0,y0,x1,y1,…]. The closing edge (last→first) is implicit. Flat rewrite of\n * features/paths/polygonHitTestRect.ts pointInPolygon — same algorithm.\n */\nexport function pointInPolygon(coords: ArrayLike<number>, px: number, py: number): boolean {\n  const n = coords.length >> 1;\n  if (n < 3) return false;\n  let inside = false;\n  for (let i = 0, j = n - 1; i < n; j = i++) {\n    const xi = coords[i * 2], yi = coords[i * 2 + 1];\n    const xj = coords[j * 2], yj = coords[j * 2 + 1];\n    const crosses =\n      (yi > py) !== (yj > py) &&\n      px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;\n    if (crosses) inside = !inside;\n  }\n  return inside;\n}\n\n/** True if segment (ax,ay)-(bx,by) properly crosses (cx,cy)-(dx,dy). Flat\n *  rewrite of polygonHitTestRect.ts segmentsCross. */\nexport function segmentsCross(\n  ax: number, ay: number, bx: number, by: number,\n  cx: number, cy: number, dx: number, dy: number,\n): boolean {\n  const d1 = sign((dx - cx) * (ay - cy) - (dy - cy) * (ax - cx));\n  const d2 = sign((dx - cx) * (by - cy) - (dy - cy) * (bx - cx));\n  const d3 = sign((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));\n  const d4 = sign((bx - ax) * (dy - ay) - (by - ay) * (dx - ax));\n  return d1 !== d2 && d3 !== d4;\n}\n\n/** Squared distance from (px,py) to segment (ax,ay)-(bx,by), endpoint-clamped. */\nexport function pointSegmentDist2(\n  px: number, py: number, ax: number, ay: number, bx: number, by: number,\n): number {\n  const vx = bx - ax, vy = by - ay;\n  const wx = px - ax, wy = py - ay;\n  const vv = len2(vx, vy);\n  let t = vv === 0 ? 0 : dot(wx, wy, vx, vy) / vv;\n  t = t < 0 ? 0 : t > 1 ? 1 : t;\n  const dx = px - (ax + t * vx), dy = py - (ay + t * vy);\n  return len2(dx, dy);\n}\n","import type { Mat3 } from './mat3';\n\n/**\n * Apply an affine to an interleaved coord stream, returning a fresh f64\n * buffer. Command codes are unaffected — for a Bezier the transformed control\n * points define the transformed curve exactly (affine invariance), so callers\n * pass `path.coords` straight through and keep `path.commands` as-is.\n */\nexport function transformCoords(coords: ArrayLike<number>, m: Mat3): Float64Array {\n  const out = new Float64Array(coords.length);\n  const a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    out[i] = a * x + c * y + e;\n    out[i + 1] = b * x + d * y + f;\n  }\n  return out;\n}\n"]}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@weasel-js/geom",
+  "version": "0.5.0",
+  "description": "Pure 2D geometry kernel for @weasel-js/core: affine, box, curve, polyline. Dependency-free core; polygon booleans in the ./booleans subpath.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./booleans": {
+      "import": "./dist/booleans/index.js",
+      "types": "./dist/booleans/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "polygon-clipping": "^0.15.7"
+  },
+  "author": "orochi235",
+  "homepage": "https://orochi235.github.io/weasel/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orochi235/weasel.git",
+    "directory": "packages/geom"
+  },
+  "bugs": {
+    "url": "https://github.com/orochi235/weasel/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsup"
+  }
+}