@pibbl/core 0.0.1

package/dist/lib/geometry/regular-polygon.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/regular-polygon.ts"],
+  "sourcesContent": ["import type { LayoutBox } from '../layout/types.js';\nimport { createPolygonPath } from './polygon.js';\nimport {\n  resolveNumericCornerRadii,\n  type RoundedCornerPathOptions,\n} from './rounded-corners.js';\nimport {\n  finiteNumber,\n  integerAtLeast,\n  nonnegativeNumber,\n  pathRangeError,\n  type GeometryErrorFactory,\n} from './validation.js';\n\n/**\n * Center, side count, and rotation for a regular polygon path.\n *\n * @see {@link RegularPolygonPathOptions}\n */\nexport interface RegularPolygonPathPosition {\n  /** Number of sides of the regular polygon. See {@link RegularPolygonPathPosition}. */\n  sides: number;\n  /** Horizontal coordinate of the center. See {@link RegularPolygonPathPosition}. */\n  cx?: number;\n  /** Vertical coordinate of the center. See {@link RegularPolygonPathPosition}. */\n  cy?: number;\n  /** Rotation applied to the containing geometry. See {@link RegularPolygonPathPosition}. */\n  rotation?: number;\n}\n\n/**\n * Exactly one size measure for a regular polygon: circumradius, inradius, or side length.\n *\n * @see {@link RegularPolygonPathOptions}\n */\nexport type RegularPolygonNumericSize =\n  | {\n      /** Distance from the polygon center to a vertex. See {@link RegularPolygonNumericSize}. */\n      circumradius: number;\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link RegularPolygonNumericSize}.\n       */\n      inradius?: never;\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link RegularPolygonNumericSize}.\n       */\n      sideLength?: never;\n    }\n  | {\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link RegularPolygonNumericSize}.\n       */\n      circumradius?: never;\n      /** Distance from the polygon center to an edge. See {@link RegularPolygonNumericSize}. */\n      inradius: number;\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link RegularPolygonNumericSize}.\n       */\n      sideLength?: never;\n    }\n  | {\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link RegularPolygonNumericSize}.\n       */\n      circumradius?: never;\n      /**\n       * Not accepted in this variant; use the alternative fields instead. See\n       * {@link RegularPolygonNumericSize}.\n       */\n      inradius?: never;\n      /** Length of one polygon edge. See {@link RegularPolygonNumericSize}. */\n      sideLength: number;\n    };\n\n/**\n * Geometry and construction options for a regular polygon path.\n *\n * @see {@link RegularPolygonPathPosition}\n * @see {@link RegularPolygonNumericSize}\n * @see {@link RoundedCornerPathOptions}\n * @see {@link createRegularPolygonPath}\n */\nexport type RegularPolygonPathOptions = RegularPolygonPathPosition &\n  RegularPolygonNumericSize &\n  RoundedCornerPathOptions;\n\nexport interface ResolvedRegularPolygonGeometry {\n  path: Path2D;\n  vertices: readonly (readonly [number, number])[];\n  bounds?: LayoutBox;\n}\n\nconst SIZE_KEYS = ['circumradius', 'inradius', 'sideLength'] as const;\n\nexport function resolveRegularPolygonGeometry(\n  options: Readonly<RegularPolygonPathOptions>,\n  errorFactory: GeometryErrorFactory = pathRangeError,\n): ResolvedRegularPolygonGeometry {\n  const sides = integerAtLeast(options.sides, 3, 'sides', errorFactory);\n  const sizeKeys = SIZE_KEYS.filter(key => options[key] !== undefined);\n  if (sizeKeys.length !== 1) {\n    throw errorFactory(\n      'circumradius|inradius|sideLength',\n      options,\n      'must provide exactly one size option',\n    );\n  }\n\n  const sizeKind = sizeKeys[0];\n  const size = nonnegativeNumber(options[sizeKind], sizeKind, errorFactory);\n  const cx = finiteNumber(options.cx ?? 0, 'cx', errorFactory);\n  const cy = finiteNumber(options.cy ?? 0, 'cy', errorFactory);\n  const rotation = finiteNumber(\n    options.rotation ?? -Math.PI / 2,\n    'rotation',\n    errorFactory,\n  );\n  const radii = resolveNumericCornerRadii(sides, options, errorFactory);\n  const circumradius = sizeKind === 'circumradius' ? size :\n    sizeKind === 'inradius' ? size / Math.cos(Math.PI / sides) :\n      size / (2 * Math.sin(Math.PI / sides));\n\n  let left = Number.POSITIVE_INFINITY;\n  let right = Number.NEGATIVE_INFINITY;\n  let top = Number.POSITIVE_INFINITY;\n  let bottom = Number.NEGATIVE_INFINITY;\n  const vertices = Array.from({ length: sides }, (_, index) => {\n    const angle = rotation + (index * Math.PI * 2) / sides;\n    const vertex = [\n      cx + circumradius * Math.cos(angle),\n      cy + circumradius * Math.sin(angle),\n    ] as const;\n    left = Math.min(left, vertex[0]);\n    right = Math.max(right, vertex[0]);\n    top = Math.min(top, vertex[1]);\n    bottom = Math.max(bottom, vertex[1]);\n    return vertex;\n  });\n\n  return {\n    path: circumradius === 0 ? new Path2D() :\n      createPolygonPath({ coords: vertices, cornerRadii: radii }),\n    vertices,\n    bounds: {\n      x: left,\n      y: top,\n      width: right - left,\n      height: bottom - top,\n    },\n  };\n}\n\n/**\n * Creates a Canvas Path2D for regular polygon geometry from validated options.\n *\n * @param options - Polygon center, radius, side count, and rotation. See\n * {@link RegularPolygonPathOptions} .\n * @returns A native Canvas path containing the regular polygon.\n *\n * @see {@link RegularPolygonPathOptions}\n */\nexport function createRegularPolygonPath(\n  options: Readonly<RegularPolygonPathOptions>,\n): Path2D {\n  return resolveRegularPolygonGeometry(options).path;\n}\n"],
+  "mappings": "AACA,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,OAEK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAqFP,MAAM,YAAY,CAAC,gBAAgB,YAAY,YAAY;AAEpD,SAAS,8BACd,SACA,eAAqC,gBACL;AAChC,QAAM,QAAQ,eAAe,QAAQ,OAAO,GAAG,SAAS,YAAY;AACpE,QAAM,WAAW,UAAU,OAAO,SAAO,QAAQ,GAAG,MAAM,MAAS;AACnE,MAAI,SAAS,WAAW,GAAG;AACzB,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,WAAW,SAAS,CAAC;AAC3B,QAAM,OAAO,kBAAkB,QAAQ,QAAQ,GAAG,UAAU,YAAY;AACxE,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,MAAM,YAAY;AAC3D,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,MAAM,YAAY;AAC3D,QAAM,WAAW;AAAA,IACf,QAAQ,YAAY,CAAC,KAAK,KAAK;AAAA,IAC/B;AAAA,IACA;AAAA,EACF;AACA,QAAM,QAAQ,0BAA0B,OAAO,SAAS,YAAY;AACpE,QAAM,eAAe,aAAa,iBAAiB,OACjD,aAAa,aAAa,OAAO,KAAK,IAAI,KAAK,KAAK,KAAK,IACvD,QAAQ,IAAI,KAAK,IAAI,KAAK,KAAK,KAAK;AAExC,MAAI,OAAO,OAAO;AAClB,MAAI,QAAQ,OAAO;AACnB,MAAI,MAAM,OAAO;AACjB,MAAI,SAAS,OAAO;AACpB,QAAM,WAAW,MAAM,KAAK,EAAE,QAAQ,MAAM,GAAG,CAAC,GAAG,UAAU;AAC3D,UAAM,QAAQ,WAAY,QAAQ,KAAK,KAAK,IAAK;AACjD,UAAM,SAAS;AAAA,MACb,KAAK,eAAe,KAAK,IAAI,KAAK;AAAA,MAClC,KAAK,eAAe,KAAK,IAAI,KAAK;AAAA,IACpC;AACA,WAAO,KAAK,IAAI,MAAM,OAAO,CAAC,CAAC;AAC/B,YAAQ,KAAK,IAAI,OAAO,OAAO,CAAC,CAAC;AACjC,UAAM,KAAK,IAAI,KAAK,OAAO,CAAC,CAAC;AAC7B,aAAS,KAAK,IAAI,QAAQ,OAAO,CAAC,CAAC;AACnC,WAAO;AAAA,EACT,CAAC;AAED,SAAO;AAAA,IACL,MAAM,iBAAiB,IAAI,IAAI,OAAO,IACpC,kBAAkB,EAAE,QAAQ,UAAU,aAAa,MAAM,CAAC;AAAA,IAC5D;AAAA,IACA,QAAQ;AAAA,MACN,GAAG;AAAA,MACH,GAAG;AAAA,MACH,OAAO,QAAQ;AAAA,MACf,QAAQ,SAAS;AAAA,IACnB;AAAA,EACF;AACF;AAWO,SAAS,yBACd,SACQ;AACR,SAAO,8BAA8B,OAAO,EAAE;AAChD;",
+  "names": []
+}

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

@@ -0,0 +1,4 @@
+import { PathGeometry } from './path-geometry.js';
+export type PibblPathInput = Path2D | PathGeometry;
+/** @internal Resolves one immutable native snapshot for Pibbl-owned consumers. */
+export declare function resolvePath(input: PibblPathInput): Path2D;

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

@@ -0,0 +1,16 @@
+import { toPath2D } from "./path-conversion.js";
+import { PathGeometry } from "./path-geometry.js";
+const snapshots = /* @__PURE__ */ new WeakMap();
+function resolvePath(input) {
+  if (!(input instanceof PathGeometry)) return input;
+  const revision = input.revision;
+  const previous = snapshots.get(input);
+  if (previous?.revision === revision) return previous.path;
+  const path = toPath2D(input);
+  snapshots.set(input, { revision, path });
+  return path;
+}
+export {
+  resolvePath
+};
+//# sourceMappingURL=resolve-path.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/resolve-path.ts"],
+  "sourcesContent": ["import { toPath2D } from './path-conversion.js';\nimport { PathGeometry } from './path-geometry.js';\n\nexport type PibblPathInput = Path2D | PathGeometry;\n\ninterface PathSnapshot {\n  readonly revision: number;\n  readonly path: Path2D;\n}\n\nconst snapshots = new WeakMap<PathGeometry, PathSnapshot>();\n\n/** @internal Resolves one immutable native snapshot for Pibbl-owned consumers. */\nexport function resolvePath(input: PibblPathInput): Path2D {\n  if (!(input instanceof PathGeometry)) return input;\n\n  const revision = input.revision;\n  const previous = snapshots.get(input);\n  if (previous?.revision === revision) return previous.path;\n\n  const path = toPath2D(input);\n  snapshots.set(input, { revision, path });\n  return path;\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,oBAAoB;AAS7B,MAAM,YAAY,oBAAI,QAAoC;AAGnD,SAAS,YAAY,OAA+B;AACzD,MAAI,EAAE,iBAAiB,cAAe,QAAO;AAE7C,QAAM,WAAW,MAAM;AACvB,QAAM,WAAW,UAAU,IAAI,KAAK;AACpC,MAAI,UAAU,aAAa,SAAU,QAAO,SAAS;AAErD,QAAM,OAAO,SAAS,KAAK;AAC3B,YAAU,IAAI,OAAO,EAAE,UAAU,KAAK,CAAC;AACvC,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/geometry/rounded-corners.d.ts

@@ -0,0 +1,28 @@
+import type { PolygonPathOptions } from "./polygon.js";
+import type { RectanglePathOptions } from "./rectangle.js";
+import type { StarPathOptions } from "./star.js";
+import type { RegularPolygonPathOptions } from "./regular-polygon.js";
+import { type GeometryErrorFactory } from './validation.js';
+/**
+ * Uniform or per-corner radii for rounding supported path vertices.
+ *
+ * @see {@link PolygonPathOptions}
+ * @see {@link RectanglePathOptions}
+ * @see {@link StarPathOptions}
+ * @see {@link RegularPolygonPathOptions}
+ */
+export interface RoundedCornerPathOptions {
+    /**
+     * Uniform corner radius used where no per-corner override is supplied. See
+     * {@link RoundedCornerPathOptions}.
+     */
+    cornerRadius?: number;
+    /**
+     * Per-corner radii; nullish entries use the uniform corner radius. See
+     * {@link RoundedCornerPathOptions}.
+     */
+    cornerRadii?: readonly (number | null | undefined)[];
+}
+export type ResolvedCornerRadii = readonly number[];
+export declare function resolveNumericCornerRadii(cornerCount: number, options: Readonly<RoundedCornerPathOptions>, errorFactory?: GeometryErrorFactory): ResolvedCornerRadii;
+export declare function createRoundedClosedPolygonPath(coords: readonly (readonly [number, number])[], radii: ResolvedCornerRadii): Path2D;

package/dist/lib/geometry/rounded-corners.js

@@ -0,0 +1,118 @@
+import { createLinePath } from "./line.js";
+import {
+  nonnegativeNumber,
+  pathRangeError
+} from "./validation.js";
+function resolveNumericCornerRadii(cornerCount, options, errorFactory = pathRangeError) {
+  if (options.cornerRadii && options.cornerRadii.length > cornerCount) {
+    throw errorFactory(
+      "cornerRadii",
+      options.cornerRadii.length,
+      `length must not exceed corner count ${cornerCount}`
+    );
+  }
+  const cornerRadius = options.cornerRadius === void 0 ? 0 : nonnegativeNumber(options.cornerRadius, "cornerRadius", errorFactory);
+  const cornerRadii = options.cornerRadii;
+  if (cornerRadii) {
+    for (let index = 0; index < cornerRadii.length; index++) {
+      const radius = cornerRadii[index];
+      if (radius !== null && radius !== void 0) {
+        nonnegativeNumber(radius, `cornerRadii[${index}]`, errorFactory);
+      }
+    }
+  }
+  return Array.from(
+    { length: cornerCount },
+    (_, index) => cornerRadii?.[index] ?? cornerRadius
+  );
+}
+function createRoundedClosedPolygonPath(coords, radii) {
+  if (coords.length < 3) return new Path2D();
+  if (radii.every((radius) => radius === 0)) {
+    return createLinePath({ coords, closePath: true });
+  }
+  const corners = coords.map(([x, y], index) => {
+    const [previousX, previousY] = coords[(index - 1 + coords.length) % coords.length];
+    const [nextX, nextY] = coords[(index + 1) % coords.length];
+    const previousDx = previousX - x;
+    const previousDy = previousY - y;
+    const nextDx = nextX - x;
+    const nextDy = nextY - y;
+    const previousLength = Math.hypot(previousDx, previousDy);
+    const nextLength = Math.hypot(nextDx, nextDy);
+    const radius = radii[index];
+    const hasUnitRays = previousLength !== 0 && nextLength !== 0;
+    const towardPreviousX = hasUnitRays ? previousDx / previousLength : 0;
+    const towardPreviousY = hasUnitRays ? previousDy / previousLength : 0;
+    const towardNextX = hasUnitRays ? nextDx / nextLength : 0;
+    const towardNextY = hasUnitRays ? nextDy / nextLength : 0;
+    const exactlyCollinear = hasUnitRays && towardPreviousX * towardNextY === towardPreviousY * towardNextX;
+    if (radius === 0 || !hasUnitRays || exactlyCollinear) {
+      return {
+        x,
+        y,
+        towardPreviousX: 0,
+        towardPreviousY: 0,
+        towardNextX: 0,
+        towardNextY: 0,
+        radius,
+        demand: 0,
+        rounded: false
+      };
+    }
+    const dot = Math.max(-1, Math.min(
+      1,
+      towardPreviousX * towardNextX + towardPreviousY * towardNextY
+    ));
+    const theta = Math.acos(dot);
+    return {
+      x,
+      y,
+      towardPreviousX,
+      towardPreviousY,
+      towardNextX,
+      towardNextY,
+      radius,
+      demand: radius / Math.tan(theta / 2),
+      rounded: true
+    };
+  });
+  const edgeLengths = coords.map(([x, y], index) => {
+    const [nextX, nextY] = coords[(index + 1) % coords.length];
+    return Math.hypot(nextX - x, nextY - y);
+  });
+  const scale = edgeLengths.reduce((current, edgeLength, index) => {
+    const next = (index + 1) % corners.length;
+    const totalDemand = corners[index].demand + corners[next].demand;
+    return totalDemand > 0 ? Math.min(current, edgeLength / totalDemand) : current;
+  }, 1);
+  const scaledDemand = (corner) => scale === 0 ? 0 : corner.demand * scale;
+  const first = corners[0];
+  const firstDemand = scaledDemand(first);
+  const path = new Path2D();
+  path.moveTo(
+    first.x + first.towardPreviousX * firstDemand,
+    first.y + first.towardPreviousY * firstDemand
+  );
+  for (const corner of corners) {
+    if (!corner.rounded) {
+      path.lineTo(corner.x, corner.y);
+      continue;
+    }
+    const demand = scaledDemand(corner);
+    path.arcTo(
+      corner.x,
+      corner.y,
+      corner.x + corner.towardNextX * demand,
+      corner.y + corner.towardNextY * demand,
+      corner.radius * scale
+    );
+  }
+  path.closePath();
+  return path;
+}
+export {
+  createRoundedClosedPolygonPath,
+  resolveNumericCornerRadii
+};
+//# sourceMappingURL=rounded-corners.js.map

package/dist/lib/geometry/rounded-corners.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/rounded-corners.ts"],
+  "sourcesContent": ["import type { PolygonPathOptions } from './polygon.js';\nimport type { RectanglePathOptions } from './rectangle.js';\nimport type { StarPathOptions } from './star.js';\nimport type { RegularPolygonPathOptions } from './regular-polygon.js';\nimport { createLinePath } from './line.js';\nimport {\n  nonnegativeNumber,\n  pathRangeError,\n  type GeometryErrorFactory,\n} from './validation.js';\n\n/**\n * Uniform or per-corner radii for rounding supported path vertices.\n *\n * @see {@link PolygonPathOptions}\n * @see {@link RectanglePathOptions}\n * @see {@link StarPathOptions}\n * @see {@link RegularPolygonPathOptions}\n */\nexport interface RoundedCornerPathOptions {\n  /**\n   * Uniform corner radius used where no per-corner override is supplied. See\n   * {@link RoundedCornerPathOptions}.\n   */\n  cornerRadius?: number;\n  /**\n   * Per-corner radii; nullish entries use the uniform corner radius. See\n   * {@link RoundedCornerPathOptions}.\n   */\n  cornerRadii?: readonly (number | null | undefined)[];\n}\n\nexport type ResolvedCornerRadii = readonly number[];\n\nexport function resolveNumericCornerRadii(\n  cornerCount: number,\n  options: Readonly<RoundedCornerPathOptions>,\n  errorFactory: GeometryErrorFactory = pathRangeError,\n): ResolvedCornerRadii {\n  if (options.cornerRadii && options.cornerRadii.length > cornerCount) {\n    throw errorFactory(\n      'cornerRadii',\n      options.cornerRadii.length,\n      `length must not exceed corner count ${cornerCount}`,\n    );\n  }\n\n  const cornerRadius = options.cornerRadius === undefined ? 0 :\n    nonnegativeNumber(options.cornerRadius, 'cornerRadius', errorFactory);\n  const cornerRadii = options.cornerRadii;\n\n  if (cornerRadii) {\n    for (let index = 0; index < cornerRadii.length; index++) {\n      const radius = cornerRadii[index];\n      if (radius !== null && radius !== undefined) {\n        nonnegativeNumber(radius, `cornerRadii[${index}]`, errorFactory);\n      }\n    }\n  }\n\n  return Array.from(\n    { length: cornerCount },\n    (_, index) => cornerRadii?.[index] ?? cornerRadius,\n  );\n}\n\ninterface RoundedCorner {\n  x: number;\n  y: number;\n  towardPreviousX: number;\n  towardPreviousY: number;\n  towardNextX: number;\n  towardNextY: number;\n  radius: number;\n  demand: number;\n  rounded: boolean;\n}\n\nexport function createRoundedClosedPolygonPath(\n  coords: readonly (readonly [number, number])[],\n  radii: ResolvedCornerRadii,\n): Path2D {\n  if (coords.length < 3) return new Path2D();\n  if (radii.every(radius => radius === 0)) {\n    return createLinePath({ coords, closePath: true });\n  }\n\n  const corners = coords.map(([x, y], index): RoundedCorner => {\n    const [previousX, previousY] = coords[\n      (index - 1 + coords.length) % coords.length\n    ];\n    const [nextX, nextY] = coords[(index + 1) % coords.length];\n    const previousDx = previousX - x;\n    const previousDy = previousY - y;\n    const nextDx = nextX - x;\n    const nextDy = nextY - y;\n    const previousLength = Math.hypot(previousDx, previousDy);\n    const nextLength = Math.hypot(nextDx, nextDy);\n    const radius = radii[index];\n    const hasUnitRays = previousLength !== 0 && nextLength !== 0;\n    const towardPreviousX = hasUnitRays ? previousDx / previousLength : 0;\n    const towardPreviousY = hasUnitRays ? previousDy / previousLength : 0;\n    const towardNextX = hasUnitRays ? nextDx / nextLength : 0;\n    const towardNextY = hasUnitRays ? nextDy / nextLength : 0;\n    const exactlyCollinear = hasUnitRays &&\n      towardPreviousX * towardNextY === towardPreviousY * towardNextX;\n\n    if (\n      radius === 0 ||\n      !hasUnitRays ||\n      exactlyCollinear\n    ) {\n      return {\n        x,\n        y,\n        towardPreviousX: 0,\n        towardPreviousY: 0,\n        towardNextX: 0,\n        towardNextY: 0,\n        radius,\n        demand: 0,\n        rounded: false,\n      };\n    }\n\n    const dot = Math.max(-1, Math.min(1,\n      towardPreviousX * towardNextX + towardPreviousY * towardNextY,\n    ));\n    const theta = Math.acos(dot);\n\n    return {\n      x,\n      y,\n      towardPreviousX,\n      towardPreviousY,\n      towardNextX,\n      towardNextY,\n      radius,\n      demand: radius / Math.tan(theta / 2),\n      rounded: true,\n    };\n  });\n\n  const edgeLengths = coords.map(([x, y], index) => {\n    const [nextX, nextY] = coords[(index + 1) % coords.length];\n    return Math.hypot(nextX - x, nextY - y);\n  });\n  const scale = edgeLengths.reduce((current, edgeLength, index) => {\n    const next = (index + 1) % corners.length;\n    const totalDemand = corners[index].demand + corners[next].demand;\n    return totalDemand > 0 ?\n      Math.min(current, edgeLength / totalDemand) :\n      current;\n  }, 1);\n  const scaledDemand = (corner: RoundedCorner) =>\n    scale === 0 ? 0 : corner.demand * scale;\n  const first = corners[0];\n  const firstDemand = scaledDemand(first);\n  const path = new Path2D();\n  path.moveTo(\n    first.x + first.towardPreviousX * firstDemand,\n    first.y + first.towardPreviousY * firstDemand,\n  );\n\n  for (const corner of corners) {\n    if (!corner.rounded) {\n      path.lineTo(corner.x, corner.y);\n      continue;\n    }\n    const demand = scaledDemand(corner);\n    path.arcTo(\n      corner.x,\n      corner.y,\n      corner.x + corner.towardNextX * demand,\n      corner.y + corner.towardNextY * demand,\n      corner.radius * scale,\n    );\n  }\n  path.closePath();\n  return path;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/geometry/star.d.ts

@@ -0,0 +1,39 @@
+import type { LayoutBox } from '../layout/types.js';
+import { type RoundedCornerPathOptions } from './rounded-corners.js';
+import { type GeometryErrorFactory } from './validation.js';
+/**
+ * Geometry and construction options for a star path.
+ *
+ * @see {@link RoundedCornerPathOptions}
+ * @see {@link createStarPath}
+ */
+export interface StarPathOptions extends RoundedCornerPathOptions {
+    /** Points defining the geometry or reported by the contact query. See {@link StarPathOptions}. */
+    points: number;
+    /** Horizontal coordinate of the center. See {@link StarPathOptions}. */
+    cx?: number;
+    /** Vertical coordinate of the center. See {@link StarPathOptions}. */
+    cy?: number;
+    /** Radius of the outer boundary. See {@link StarPathOptions}. */
+    outerRadius: number;
+    /** Radius of the inner boundary. See {@link StarPathOptions}. */
+    innerRadius: number;
+    /** Rotation applied to the containing geometry. See {@link StarPathOptions}. */
+    rotation?: number;
+}
+export interface ResolvedStarGeometry {
+    path: Path2D;
+    vertices: readonly (readonly [number, number])[];
+    bounds?: LayoutBox;
+}
+export declare function resolveStarGeometry(options: Readonly<StarPathOptions>, errorFactory?: GeometryErrorFactory): ResolvedStarGeometry;
+/**
+ * Creates a Canvas Path2D for star geometry from validated options.
+ *
+ * @param options - Star center, inner and outer radii, point count, and rotation. See
+ * {@link StarPathOptions} .
+ * @returns A native Canvas path containing the star.
+ *
+ * @see {@link StarPathOptions}
+ */
+export declare function createStarPath(options: Readonly<StarPathOptions>): Path2D;

package/dist/lib/geometry/star.js

@@ -0,0 +1,90 @@
+import { createPolygonPath } from "./polygon.js";
+import {
+  resolveNumericCornerRadii
+} from "./rounded-corners.js";
+import {
+  finiteNumber,
+  integerAtLeast,
+  nonnegativeNumber,
+  pathRangeError
+} from "./validation.js";
+function resolveStarGeometry(options, errorFactory = pathRangeError) {
+  const points = integerAtLeast(options.points, 3, "points", errorFactory);
+  const outerRadius = nonnegativeNumber(
+    options.outerRadius,
+    "outerRadius",
+    errorFactory
+  );
+  const innerRadius = nonnegativeNumber(
+    options.innerRadius,
+    "innerRadius",
+    errorFactory
+  );
+  if (innerRadius > outerRadius) {
+    throw errorFactory(
+      "innerRadius",
+      innerRadius,
+      `must not exceed outerRadius ${outerRadius}`
+    );
+  }
+  const cx = finiteNumber(options.cx ?? 0, "cx", errorFactory);
+  const cy = finiteNumber(options.cy ?? 0, "cy", errorFactory);
+  const rotation = finiteNumber(
+    options.rotation ?? -Math.PI / 2,
+    "rotation",
+    errorFactory
+  );
+  const cornerCount = points * 2;
+  const radii = resolveNumericCornerRadii(
+    cornerCount,
+    options,
+    errorFactory
+  );
+  let left = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  const vertices = Array.from({ length: cornerCount }, (_, index) => {
+    const angle = rotation + index * Math.PI / points;
+    const radius = index % 2 === 0 ? outerRadius : innerRadius;
+    const vertex = [
+      cx + radius * Math.cos(angle),
+      cy + radius * Math.sin(angle)
+    ];
+    left = Math.min(left, vertex[0]);
+    right = Math.max(right, vertex[0]);
+    top = Math.min(top, vertex[1]);
+    bottom = Math.max(bottom, vertex[1]);
+    return vertex;
+  });
+  if (outerRadius === 0 || innerRadius === 0) {
+    return {
+      path: new Path2D(),
+      vertices,
+      bounds: {
+        x: left,
+        y: top,
+        width: right - left,
+        height: bottom - top
+      }
+    };
+  }
+  return {
+    path: createPolygonPath({ coords: vertices, cornerRadii: radii }),
+    vertices,
+    bounds: {
+      x: left,
+      y: top,
+      width: right - left,
+      height: bottom - top
+    }
+  };
+}
+function createStarPath(options) {
+  return resolveStarGeometry(options).path;
+}
+export {
+  createStarPath,
+  resolveStarGeometry
+};
+//# sourceMappingURL=star.js.map

package/dist/lib/geometry/star.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/star.ts"],
+  "sourcesContent": ["import type { LayoutBox } from '../layout/types.js';\nimport { createPolygonPath } from './polygon.js';\nimport {\n  resolveNumericCornerRadii,\n  type RoundedCornerPathOptions,\n} from './rounded-corners.js';\nimport {\n  finiteNumber,\n  integerAtLeast,\n  nonnegativeNumber,\n  pathRangeError,\n  type GeometryErrorFactory,\n} from './validation.js';\n\n/**\n * Geometry and construction options for a star path.\n *\n * @see {@link RoundedCornerPathOptions}\n * @see {@link createStarPath}\n */\nexport interface StarPathOptions extends RoundedCornerPathOptions {\n  /** Points defining the geometry or reported by the contact query. See {@link StarPathOptions}. */\n  points: number;\n  /** Horizontal coordinate of the center. See {@link StarPathOptions}. */\n  cx?: number;\n  /** Vertical coordinate of the center. See {@link StarPathOptions}. */\n  cy?: number;\n  /** Radius of the outer boundary. See {@link StarPathOptions}. */\n  outerRadius: number;\n  /** Radius of the inner boundary. See {@link StarPathOptions}. */\n  innerRadius: number;\n  /** Rotation applied to the containing geometry. See {@link StarPathOptions}. */\n  rotation?: number;\n}\n\nexport interface ResolvedStarGeometry {\n  path: Path2D;\n  vertices: readonly (readonly [number, number])[];\n  bounds?: LayoutBox;\n}\n\nexport function resolveStarGeometry(\n  options: Readonly<StarPathOptions>,\n  errorFactory: GeometryErrorFactory = pathRangeError,\n): ResolvedStarGeometry {\n  const points = integerAtLeast(options.points, 3, 'points', errorFactory);\n  const outerRadius = nonnegativeNumber(\n    options.outerRadius,\n    'outerRadius',\n    errorFactory,\n  );\n  const innerRadius = nonnegativeNumber(\n    options.innerRadius,\n    'innerRadius',\n    errorFactory,\n  );\n  if (innerRadius > outerRadius) {\n    throw errorFactory(\n      'innerRadius',\n      innerRadius,\n      `must not exceed outerRadius ${outerRadius}`,\n    );\n  }\n  const cx = finiteNumber(options.cx ?? 0, 'cx', errorFactory);\n  const cy = finiteNumber(options.cy ?? 0, 'cy', errorFactory);\n  const rotation = finiteNumber(\n    options.rotation ?? -Math.PI / 2,\n    'rotation',\n    errorFactory,\n  );\n  const cornerCount = points * 2;\n  const radii = resolveNumericCornerRadii(\n    cornerCount,\n    options,\n    errorFactory,\n  );\n\n  let left = Number.POSITIVE_INFINITY;\n  let right = Number.NEGATIVE_INFINITY;\n  let top = Number.POSITIVE_INFINITY;\n  let bottom = Number.NEGATIVE_INFINITY;\n  const vertices = Array.from({ length: cornerCount }, (_, index) => {\n    const angle = rotation + (index * Math.PI) / points;\n    const radius = index % 2 === 0 ? outerRadius : innerRadius;\n    const vertex = [\n      cx + radius * Math.cos(angle),\n      cy + radius * Math.sin(angle),\n    ] as const;\n    left = Math.min(left, vertex[0]);\n    right = Math.max(right, vertex[0]);\n    top = Math.min(top, vertex[1]);\n    bottom = Math.max(bottom, vertex[1]);\n    return vertex;\n  });\n\n  if (outerRadius === 0 || innerRadius === 0) {\n    return {\n      path: new Path2D(),\n      vertices,\n      bounds: {\n        x: left,\n        y: top,\n        width: right - left,\n        height: bottom - top,\n      },\n    };\n  }\n\n  return {\n    path: createPolygonPath({ coords: vertices, cornerRadii: radii }),\n    vertices,\n    bounds: {\n      x: left,\n      y: top,\n      width: right - left,\n      height: bottom - top,\n    },\n  };\n}\n\n/**\n * Creates a Canvas Path2D for star geometry from validated options.\n *\n * @param options - Star center, inner and outer radii, point count, and rotation. See\n * {@link StarPathOptions} .\n * @returns A native Canvas path containing the star.\n *\n * @see {@link StarPathOptions}\n */\nexport function createStarPath(\n  options: Readonly<StarPathOptions>,\n): Path2D {\n  return resolveStarGeometry(options).path;\n}\n"],
+  "mappings": "AACA,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,OAEK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AA6BA,SAAS,oBACd,SACA,eAAqC,gBACf;AACtB,QAAM,SAAS,eAAe,QAAQ,QAAQ,GAAG,UAAU,YAAY;AACvE,QAAM,cAAc;AAAA,IAClB,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,EACF;AACA,QAAM,cAAc;AAAA,IAClB,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,EACF;AACA,MAAI,cAAc,aAAa;AAC7B,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA,+BAA+B,WAAW;AAAA,IAC5C;AAAA,EACF;AACA,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,MAAM,YAAY;AAC3D,QAAM,KAAK,aAAa,QAAQ,MAAM,GAAG,MAAM,YAAY;AAC3D,QAAM,WAAW;AAAA,IACf,QAAQ,YAAY,CAAC,KAAK,KAAK;AAAA,IAC/B;AAAA,IACA;AAAA,EACF;AACA,QAAM,cAAc,SAAS;AAC7B,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,MAAI,OAAO,OAAO;AAClB,MAAI,QAAQ,OAAO;AACnB,MAAI,MAAM,OAAO;AACjB,MAAI,SAAS,OAAO;AACpB,QAAM,WAAW,MAAM,KAAK,EAAE,QAAQ,YAAY,GAAG,CAAC,GAAG,UAAU;AACjE,UAAM,QAAQ,WAAY,QAAQ,KAAK,KAAM;AAC7C,UAAM,SAAS,QAAQ,MAAM,IAAI,cAAc;AAC/C,UAAM,SAAS;AAAA,MACb,KAAK,SAAS,KAAK,IAAI,KAAK;AAAA,MAC5B,KAAK,SAAS,KAAK,IAAI,KAAK;AAAA,IAC9B;AACA,WAAO,KAAK,IAAI,MAAM,OAAO,CAAC,CAAC;AAC/B,YAAQ,KAAK,IAAI,OAAO,OAAO,CAAC,CAAC;AACjC,UAAM,KAAK,IAAI,KAAK,OAAO,CAAC,CAAC;AAC7B,aAAS,KAAK,IAAI,QAAQ,OAAO,CAAC,CAAC;AACnC,WAAO;AAAA,EACT,CAAC;AAED,MAAI,gBAAgB,KAAK,gBAAgB,GAAG;AAC1C,WAAO;AAAA,MACL,MAAM,IAAI,OAAO;AAAA,MACjB;AAAA,MACA,QAAQ;AAAA,QACN,GAAG;AAAA,QACH,GAAG;AAAA,QACH,OAAO,QAAQ;AAAA,QACf,QAAQ,SAAS;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM,kBAAkB,EAAE,QAAQ,UAAU,aAAa,MAAM,CAAC;AAAA,IAChE;AAAA,IACA,QAAQ;AAAA,MACN,GAAG;AAAA,MACH,GAAG;AAAA,MACH,OAAO,QAAQ;AAAA,MACf,QAAQ,SAAS;AAAA,IACnB;AAAA,EACF;AACF;AAWO,SAAS,eACd,SACQ;AACR,SAAO,oBAAoB,OAAO,EAAE;AACtC;",
+  "names": []
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Geometry and construction options for a svg path.
+ *
+ * @see {@link createSvgPath}
+ */
+export interface SvgPathOptions {
+    /**
+     * Geometry to draw or clip, supplied in the declared path representation. See
+     * {@link SvgPathOptions}.
+     */
+    d: string;
+}
+/**
+ * Creates a Canvas Path2D for svg geometry from validated options.
+ *
+ * @param options - SVG path data to parse. See {@link SvgPathOptions}.
+ * @returns A native Canvas path parsed from the supplied data.
+ *
+ * @see {@link SvgPathOptions}
+ */
+export declare function createSvgPath(options: Readonly<SvgPathOptions>): Path2D;

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

@@ -0,0 +1,7 @@
+function createSvgPath(options) {
+  return new Path2D(options.d);
+}
+export {
+  createSvgPath
+};
+//# sourceMappingURL=svg-path.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/svg-path.ts"],
+  "sourcesContent": ["/**\n * Geometry and construction options for a svg path.\n *\n * @see {@link createSvgPath}\n */\nexport interface SvgPathOptions {\n  /**\n   * Geometry to draw or clip, supplied in the declared path representation. See\n   * {@link SvgPathOptions}.\n   */\n  d: string;\n}\n\n/**\n * Creates a Canvas Path2D for svg geometry from validated options.\n *\n * @param options - SVG path data to parse. See {@link SvgPathOptions}.\n * @returns A native Canvas path parsed from the supplied data.\n *\n * @see {@link SvgPathOptions}\n */\nexport function createSvgPath(options: Readonly<SvgPathOptions>): Path2D {\n  return new Path2D(options.d);\n}\n"],
+  "mappings": "AAqBO,SAAS,cAAc,SAA2C;AACvE,SAAO,IAAI,OAAO,QAAQ,CAAC;AAC7B;",
+  "names": []
+}

package/dist/lib/geometry/transform-bend.d.ts

@@ -0,0 +1,46 @@
+import { type PathBendOptions, type BendPathAlongArcOptions } from './path-bending.js';
+import { PathGeometry } from './path-geometry.js';
+import { type PathTransform } from './path-transforms.js';
+/**
+ * Alignment, fitting, baseline, and overflow controls shared by reusable bend transforms.
+ *
+ * @see {@link PathBendTransformOptions}
+ */
+export type BendTransformOptions = Omit<PathBendOptions, 'tolerance' | 'maxSegments'>;
+/**
+ * Circular bending parameters for a reusable arc transform; accuracy is supplied when applying it.
+ *
+ * @see {@link arcBendTransform}
+ */
+export type ArcBendTransformOptions = Omit<BendPathAlongArcOptions, 'tolerance' | 'maxSegments'>;
+/**
+ * Guide path and bending parameters for a reusable path transform.
+ *
+ * @see {@link PathGeometry}
+ * @see {@link pathBendTransform}
+ */
+export type PathBendTransformOptions = Omit<PathBendOptions, 'tolerance' | 'maxSegments'> & {
+    /** Path used as the bending guide. See {@link PathGeometry}. */
+    readonly guide: PathGeometry;
+};
+/**
+ * Creates a reusable mapping that bends source geometry around a circular arc.
+ *
+ * @param options - Source bounds and circular bend geometry. See {@link ArcBendTransformOptions}.
+ * @returns A point mapping that bends the source along a circular arc. See {@link PathTransform}.
+ *
+ * @see {@link ArcBendTransformOptions}
+ * @see {@link PathTransform}
+ */
+export declare function arcBendTransform(options: ArcBendTransformOptions): PathTransform;
+/**
+ * Creates a reusable mapping that bends source geometry along a guide path.
+ *
+ * @param options - Source bounds, target guide, and alignment along that guide. See
+ * {@link PathBendTransformOptions} .
+ * @returns A point mapping that bends the source along the target path. See {@link PathTransform}.
+ *
+ * @see {@link PathBendTransformOptions}
+ * @see {@link PathTransform}
+ */
+export declare function pathBendTransform(options: PathBendTransformOptions): PathTransform;