dingbatch 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,69 @@
 import {
-  boomerang
-} from "./chunk-IAFZ3FNR.js";
+  arrow,
+  atomic,
+  bird,
+  blob,
+  boomerang,
+  bowtie,
+  cat,
+  chevron,
+  circle,
+  cross,
+  cursor,
+  diamond,
+  dog,
+  fish,
+  flower,
+  hexagon,
+  kidney,
+  leaf,
+  moon,
+  octagon,
+  oval,
+  pentagon,
+  polygon,
+  rectangle,
+  rocket,
+  semicircle,
+  spiral,
+  star,
+  starburst,
+  sun,
+  swallowtail,
+  triangle
+} from "./chunk-5A7FSZ3T.js";
 export {
-  boomerang
+  arrow,
+  atomic,
+  bird,
+  blob,
+  boomerang,
+  bowtie,
+  cat,
+  chevron,
+  circle,
+  cross,
+  cursor,
+  diamond,
+  dog,
+  fish,
+  flower,
+  hexagon,
+  kidney,
+  leaf,
+  moon,
+  octagon,
+  oval,
+  pentagon,
+  polygon,
+  rectangle,
+  rocket,
+  semicircle,
+  spiral,
+  star,
+  starburst,
+  sun,
+  swallowtail,
+  triangle
 };
 //# sourceMappingURL=index.js.map

package/dist/react/index.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { CSSProperties } from 'react';
-import { DingbatResult, BoomerangParams } from '../index.js';
+import { D as DingbatResult, B as BoomerangParams } from '../boomerang-s5naDBuf.js';
 
 interface DingbatProps {
     /** Shape result from a dingbatch generator */

package/dist/react/index.js

@@ -1,6 +1,6 @@
 import {
   boomerang
-} from "../chunk-IAFZ3FNR.js";
+} from "../chunk-5A7FSZ3T.js";
 
 // react/Dingbat.tsx
 import { jsx } from "react/jsx-runtime";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dingbatch",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Parametric MCM (Mid-Century Modern) dingbat shapes as SVGs",
   "type": "module",
   "main": "./dist/index.js",

package/dist/chunk-IAFZ3FNR.js

@@ -1,531 +0,0 @@
-// src/generators/utils/svg.ts
-function wrapPath(path, width, height) {
-  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}"><path d="${path}" fill="currentColor"/></svg>`;
-}
-function addSvgFields(result) {
-  const viewBox = `0 0 ${result.width} ${result.height}`;
-  const svg = wrapPath(result.path, result.width, result.height);
-  return { ...result, viewBox, svg };
-}
-
-// src/presets/boomerang.ts
-var crescent = {
-  style: "crescent",
-  armLength: 50,
-  bendAngle: 160,
-  thickness: 35,
-  taper: 0.5,
-  tipRoundness: 0.2,
-  armCurvature: 0,
-  bendSharpness: 0
-};
-var fatMoon = {
-  style: "crescent",
-  armLength: 45,
-  bendAngle: 180,
-  thickness: 50,
-  taper: 0.3,
-  tipRoundness: 0.6,
-  armCurvature: 0,
-  bendSharpness: 0
-};
-var sharpChevron = {
-  style: "chevron",
-  armLength: 55,
-  bendAngle: 60,
-  thickness: 40,
-  taper: 1,
-  tipRoundness: 0,
-  armCurvature: 0,
-  bendSharpness: 0
-};
-var thinArc = {
-  style: "crescent",
-  armLength: 60,
-  bendAngle: 140,
-  thickness: 20,
-  taper: 0.7,
-  tipRoundness: 0.1,
-  armCurvature: 0,
-  bendSharpness: 0
-};
-var horseshoe = {
-  style: "horseshoe",
-  armLength: 80,
-  bendAngle: 50,
-  thickness: 18,
-  taper: 0.2,
-  tipRoundness: 0.3,
-  armCurvature: 0.4,
-  bendSharpness: 0
-};
-
-// src/generators/curved/boomerang.ts
-function boomerangBase(params) {
-  const style = params.style || "classic";
-  switch (style) {
-    case "crescent":
-      return generateCrescent(params);
-    case "horseshoe":
-      return generateHorseshoe(params);
-    case "chevron":
-      return generateChevron(params);
-    case "classic":
-    default:
-      return generateClassic(params);
-  }
-}
-var boomerang = Object.assign(boomerangBase, {
-  crescent: (overrides) => boomerangBase({ ...crescent, ...overrides }),
-  fatMoon: (overrides) => boomerangBase({ ...fatMoon, ...overrides }),
-  sharpChevron: (overrides) => boomerangBase({ ...sharpChevron, ...overrides }),
-  thinArc: (overrides) => boomerangBase({ ...thinArc, ...overrides }),
-  horseshoe: (overrides) => boomerangBase({ ...horseshoe, ...overrides })
-});
-function generateClassic(params) {
-  const {
-    armLength,
-    bendAngle,
-    armCurvature,
-    bendSharpness,
-    thickness,
-    taper,
-    tipRoundness,
-    armBalance = 1,
-    thicknessBalance = 0,
-    rotation = 0
-  } = params;
-  const clampedBendAngle = Math.max(30, Math.min(180, bendAngle));
-  const clampedArmCurvature = Math.max(0, Math.min(1, armCurvature));
-  const clampedBendSharpness = Math.max(0, Math.min(1, bendSharpness));
-  const clampedTaper = Math.max(0, Math.min(1, taper));
-  const clampedTipRoundness = Math.max(0, Math.min(1, tipRoundness));
-  const clampedArmBalance = Math.max(0.5, Math.min(2, armBalance));
-  const clampedThicknessBalance = Math.max(-1, Math.min(1, thicknessBalance));
-  const arm1Length = armLength * (2 / (1 + clampedArmBalance));
-  const arm2Length = armLength * (2 * clampedArmBalance / (1 + clampedArmBalance));
-  const halfAngle = clampedBendAngle / 2 * Math.PI / 180;
-  const arm1Dir = { x: -Math.sin(halfAngle), y: -Math.cos(halfAngle) };
-  const arm2Dir = { x: Math.sin(halfAngle), y: -Math.cos(halfAngle) };
-  const tip1 = { x: arm1Dir.x * arm1Length, y: arm1Dir.y * arm1Length };
-  const tip2 = { x: arm2Dir.x * arm2Length, y: arm2Dir.y * arm2Length };
-  const bendPoint = { x: 0, y: 0 };
-  const numSamples = 20;
-  const arm1Spine = generateArmSpine(tip1, bendPoint, arm1Dir, arm1Length, clampedArmCurvature, numSamples);
-  const arm2Spine = generateArmSpine(bendPoint, tip2, arm2Dir, arm2Length, clampedArmCurvature, numSamples);
-  const minThickness = thickness * clampedTaper;
-  function getThicknessAlongArm(t, isArm1) {
-    const tipFade = Math.sin(t * Math.PI / 2);
-    const baseThickness = minThickness + (thickness - minThickness) * tipFade;
-    const balanceFactor = isArm1 ? 1 - clampedThicknessBalance * 0.3 : 1 + clampedThicknessBalance * 0.3;
-    return baseThickness * balanceFactor;
-  }
-  const arm1Outer = [];
-  const arm1Inner = [];
-  const arm2Outer = [];
-  const arm2Inner = [];
-  for (let i = 0; i < arm1Spine.length; i++) {
-    const t = i / (arm1Spine.length - 1);
-    const point = arm1Spine[i];
-    const tangent = getSpineTangent(arm1Spine, i);
-    const normal = { x: -tangent.y, y: tangent.x };
-    const halfThick = getThicknessAlongArm(t, true) / 2;
-    arm1Outer.push({ x: point.x + normal.x * halfThick, y: point.y + normal.y * halfThick });
-    arm1Inner.push({ x: point.x - normal.x * halfThick, y: point.y - normal.y * halfThick });
-  }
-  for (let i = 0; i < arm2Spine.length; i++) {
-    const t = 1 - i / (arm2Spine.length - 1);
-    const point = arm2Spine[i];
-    const tangent = getSpineTangent(arm2Spine, i);
-    const normal = { x: -tangent.y, y: tangent.x };
-    const halfThick = getThicknessAlongArm(t, false) / 2;
-    arm2Outer.push({ x: point.x + normal.x * halfThick, y: point.y + normal.y * halfThick });
-    arm2Inner.push({ x: point.x - normal.x * halfThick, y: point.y - normal.y * halfThick });
-  }
-  const pathParts = [];
-  pathParts.push(`M ${arm1Outer[0].x.toFixed(2)},${arm1Outer[0].y.toFixed(2)}`);
-  const tip1Curve = clampedTipRoundness * thickness * 0.3;
-  pathParts.push(`Q ${(tip1.x + arm1Dir.x * tip1Curve).toFixed(2)},${(tip1.y + arm1Dir.y * tip1Curve).toFixed(2)} ${arm1Inner[0].x.toFixed(2)},${arm1Inner[0].y.toFixed(2)}`);
-  pathParts.push(smoothCurveThroughPoints(arm1Inner));
-  const bendInner2 = arm2Inner[0];
-  if (clampedBendSharpness < 0.3) {
-    pathParts.push(`L ${bendInner2.x.toFixed(2)},${bendInner2.y.toFixed(2)}`);
-  } else {
-    const bendInnerOffset = thickness * 0.2 * clampedBendSharpness;
-    const bendInnerCtrl = { x: 0, y: bendInnerOffset };
-    pathParts.push(`Q ${bendInnerCtrl.x.toFixed(2)},${bendInnerCtrl.y.toFixed(2)} ${bendInner2.x.toFixed(2)},${bendInner2.y.toFixed(2)}`);
-  }
-  pathParts.push(smoothCurveThroughPoints(arm2Inner));
-  const tip2Curve = clampedTipRoundness * thickness * 0.3;
-  pathParts.push(`Q ${(tip2.x + arm2Dir.x * tip2Curve).toFixed(2)},${(tip2.y + arm2Dir.y * tip2Curve).toFixed(2)} ${arm2Outer[arm2Outer.length - 1].x.toFixed(2)},${arm2Outer[arm2Outer.length - 1].y.toFixed(2)}`);
-  const arm2OuterReversed = [...arm2Outer].reverse();
-  pathParts.push(smoothCurveThroughPoints(arm2OuterReversed));
-  const bendOuter1 = arm1Outer[arm1Outer.length - 1];
-  if (clampedBendSharpness < 0.3) {
-    pathParts.push(`L ${bendOuter1.x.toFixed(2)},${bendOuter1.y.toFixed(2)}`);
-  } else {
-    const bendOuterOffset = -thickness * 0.4 * clampedBendSharpness;
-    const bendOuterCtrl = { x: 0, y: bendOuterOffset };
-    pathParts.push(`Q ${bendOuterCtrl.x.toFixed(2)},${bendOuterCtrl.y.toFixed(2)} ${bendOuter1.x.toFixed(2)},${bendOuter1.y.toFixed(2)}`);
-  }
-  const arm1OuterReversed = [...arm1Outer].reverse();
-  pathParts.push(smoothCurveThroughPoints(arm1OuterReversed));
-  pathParts.push("Z");
-  let path = pathParts.join(" ");
-  const allPoints = [...arm1Outer, ...arm1Inner, ...arm2Outer, ...arm2Inner];
-  let minX = Math.min(...allPoints.map((p) => p.x));
-  let maxX = Math.max(...allPoints.map((p) => p.x));
-  let minY = Math.min(...allPoints.map((p) => p.y));
-  let maxY = Math.max(...allPoints.map((p) => p.y));
-  const padding = thickness * 0.3 * clampedTipRoundness;
-  minX -= padding;
-  maxX += padding;
-  minY -= padding;
-  const width = maxX - minX;
-  const height = maxY - minY;
-  path = normalizePath(path, minX, minY);
-  if (rotation !== 0) {
-    path = rotatePath(path, rotation, width, height);
-  }
-  return addSvgFields({ path, width, height, centerX: width / 2, centerY: height / 2 });
-}
-function generateCrescent(params) {
-  const {
-    armLength,
-    // Used as arc radius
-    bendAngle,
-    // Used as arc span (degrees, 30-300)
-    thickness,
-    taper,
-    tipRoundness,
-    armBalance = 1,
-    // Asymmetric arc thickness along length
-    rotation = 0
-  } = params;
-  const radius = Math.max(20, armLength);
-  const arcSpan = Math.max(30, Math.min(300, bendAngle)) * Math.PI / 180;
-  const clampedTaper = Math.max(0, Math.min(1, taper));
-  const clampedTipRoundness = Math.max(0, Math.min(1, tipRoundness));
-  const clampedArmBalance = Math.max(0.5, Math.min(2, armBalance));
-  const numSamples = 30;
-  const startAngle = -arcSpan / 2;
-  const endAngle = arcSpan / 2;
-  const spine = [];
-  for (let i = 0; i <= numSamples; i++) {
-    const t = i / numSamples;
-    const angle = startAngle + (endAngle - startAngle) * t;
-    spine.push({
-      x: Math.sin(angle) * radius,
-      y: -Math.cos(angle) * radius + radius
-      // Shift so bottom of arc is at y=0
-    });
-  }
-  const minThickness = thickness * clampedTaper;
-  function getThicknessAtT(t) {
-    const balanceShift = (t - 0.5) * (clampedArmBalance - 1) * 0.5;
-    const adjustedT = Math.max(0, Math.min(1, t + balanceShift));
-    const adjustedDist = Math.min(adjustedT, 1 - adjustedT) * 2;
-    const adjustedFactor = Math.sin(adjustedDist * Math.PI / 2);
-    return minThickness + (thickness - minThickness) * adjustedFactor;
-  }
-  const outer = [];
-  const inner = [];
-  for (let i = 0; i < spine.length; i++) {
-    const t = i / (spine.length - 1);
-    const point = spine[i];
-    const tangent = getSpineTangent(spine, i);
-    const normal = { x: -tangent.y, y: tangent.x };
-    const halfThick = getThicknessAtT(t) / 2;
-    outer.push({ x: point.x + normal.x * halfThick, y: point.y + normal.y * halfThick });
-    inner.push({ x: point.x - normal.x * halfThick, y: point.y - normal.y * halfThick });
-  }
-  const pathParts = [];
-  pathParts.push(`M ${outer[0].x.toFixed(2)},${outer[0].y.toFixed(2)}`);
-  const startTipCurve = clampedTipRoundness * thickness * 0.4;
-  const startTangent = getSpineTangent(spine, 0);
-  pathParts.push(`Q ${(spine[0].x - startTangent.x * startTipCurve).toFixed(2)},${(spine[0].y - startTangent.y * startTipCurve).toFixed(2)} ${inner[0].x.toFixed(2)},${inner[0].y.toFixed(2)}`);
-  pathParts.push(smoothCurveThroughPoints(inner));
-  const endTipCurve = clampedTipRoundness * thickness * 0.4;
-  const endTangent = getSpineTangent(spine, spine.length - 1);
-  pathParts.push(`Q ${(spine[spine.length - 1].x + endTangent.x * endTipCurve).toFixed(2)},${(spine[spine.length - 1].y + endTangent.y * endTipCurve).toFixed(2)} ${outer[outer.length - 1].x.toFixed(2)},${outer[outer.length - 1].y.toFixed(2)}`);
-  const outerReversed = [...outer].reverse();
-  pathParts.push(smoothCurveThroughPoints(outerReversed));
-  pathParts.push("Z");
-  let path = pathParts.join(" ");
-  const allPoints = [...outer, ...inner];
-  let minX = Math.min(...allPoints.map((p) => p.x));
-  let maxX = Math.max(...allPoints.map((p) => p.x));
-  let minY = Math.min(...allPoints.map((p) => p.y));
-  let maxY = Math.max(...allPoints.map((p) => p.y));
-  const padding = thickness * 0.3 * clampedTipRoundness;
-  minX -= padding;
-  maxX += padding;
-  minY -= padding;
-  maxY += padding;
-  const width = maxX - minX;
-  const height = maxY - minY;
-  path = normalizePath(path, minX, minY);
-  if (rotation !== 0) {
-    path = rotatePath(path, rotation, width, height);
-  }
-  return addSvgFields({ path, width, height, centerX: width / 2, centerY: height / 2 });
-}
-function generateHorseshoe(params) {
-  const {
-    armLength,
-    // Length of the vertical arms
-    bendAngle,
-    // Spacing between arms (width at top)
-    armCurvature,
-    // How curved the bottom connection is
-    thickness,
-    taper,
-    tipRoundness,
-    armBalance = 1,
-    // Asymmetric arm lengths
-    rotation = 0
-  } = params;
-  const spacing = Math.max(20, bendAngle);
-  const clampedArmCurvature = Math.max(0, Math.min(1, armCurvature));
-  const clampedTaper = Math.max(0, Math.min(1, taper));
-  const clampedTipRoundness = Math.max(0, Math.min(1, tipRoundness));
-  const clampedArmBalance = Math.max(0.5, Math.min(2, armBalance));
-  const arm1Len = armLength * (2 / (1 + clampedArmBalance));
-  const arm2Len = armLength * (2 * clampedArmBalance / (1 + clampedArmBalance));
-  const halfSpacing = spacing / 2;
-  const halfThick = thickness / 2;
-  const tipThick = thickness * clampedTaper / 2;
-  const leftOuterX = -halfSpacing - halfThick;
-  const leftInnerX = -halfSpacing + halfThick;
-  const rightInnerX = halfSpacing - halfThick;
-  const rightOuterX = halfSpacing + halfThick;
-  const leftTopY = 0;
-  const leftBottomY = arm1Len;
-  const rightBottomY = arm2Len;
-  const rightTopY = 0;
-  const bottomY = Math.max(arm1Len, arm2Len);
-  const curveDepth = halfSpacing * clampedArmCurvature;
-  const pathParts = [];
-  const leftTipOuterX = -halfSpacing - tipThick;
-  const leftTipInnerX = -halfSpacing + tipThick;
-  const rightTipInnerX = halfSpacing - tipThick;
-  const rightTipOuterX = halfSpacing + tipThick;
-  pathParts.push(`M ${leftTipOuterX.toFixed(2)},${leftTopY.toFixed(2)}`);
-  if (clampedTipRoundness > 0) {
-    const tipCurve = clampedTipRoundness * thickness * 0.3;
-    pathParts.push(`Q ${(-halfSpacing).toFixed(2)},${(leftTopY - tipCurve).toFixed(2)} ${leftTipInnerX.toFixed(2)},${leftTopY.toFixed(2)}`);
-  } else {
-    pathParts.push(`L ${leftTipInnerX.toFixed(2)},${leftTopY.toFixed(2)}`);
-  }
-  pathParts.push(`L ${leftInnerX.toFixed(2)},${leftBottomY.toFixed(2)}`);
-  if (clampedArmCurvature > 0.1) {
-    const innerCtrlY = bottomY + curveDepth;
-    pathParts.push(`Q ${0},${innerCtrlY.toFixed(2)} ${rightInnerX.toFixed(2)},${rightBottomY.toFixed(2)}`);
-  } else {
-    pathParts.push(`L ${rightInnerX.toFixed(2)},${rightBottomY.toFixed(2)}`);
-  }
-  pathParts.push(`L ${rightTipInnerX.toFixed(2)},${rightTopY.toFixed(2)}`);
-  if (clampedTipRoundness > 0) {
-    const tipCurve = clampedTipRoundness * thickness * 0.3;
-    pathParts.push(`Q ${halfSpacing.toFixed(2)},${(rightTopY - tipCurve).toFixed(2)} ${rightTipOuterX.toFixed(2)},${rightTopY.toFixed(2)}`);
-  } else {
-    pathParts.push(`L ${rightTipOuterX.toFixed(2)},${rightTopY.toFixed(2)}`);
-  }
-  pathParts.push(`L ${rightOuterX.toFixed(2)},${rightBottomY.toFixed(2)}`);
-  if (clampedArmCurvature > 0.1) {
-    const outerCtrlY = bottomY + curveDepth + thickness;
-    pathParts.push(`Q ${0},${outerCtrlY.toFixed(2)} ${leftOuterX.toFixed(2)},${leftBottomY.toFixed(2)}`);
-  } else {
-    pathParts.push(`L ${leftOuterX.toFixed(2)},${leftBottomY.toFixed(2)}`);
-  }
-  pathParts.push(`L ${leftTipOuterX.toFixed(2)},${leftTopY.toFixed(2)}`);
-  pathParts.push("Z");
-  let path = pathParts.join(" ");
-  const padding = thickness * 0.3;
-  let minX = leftOuterX - padding;
-  let maxX = rightOuterX + padding;
-  let minY = -padding - clampedTipRoundness * thickness * 0.3;
-  let maxY = bottomY + curveDepth + thickness + padding;
-  const width = maxX - minX;
-  const height = maxY - minY;
-  path = normalizePath(path, minX, minY);
-  if (rotation !== 0) {
-    path = rotatePath(path, rotation, width, height);
-  }
-  return addSvgFields({ path, width, height, centerX: width / 2, centerY: height / 2 });
-}
-function generateChevron(params) {
-  const {
-    armLength,
-    // Length of the arms
-    bendAngle,
-    // Angle of the V (smaller = sharper point)
-    thickness,
-    // Controls arm width (proportional)
-    taper = 0,
-    // 0 = V with cutout, 1 = solid triangle (no cutout)
-    tipRoundness = 0,
-    // Roundness at the tip
-    armBalance = 1,
-    // Asymmetric arm lengths
-    rotation = 0
-  } = params;
-  const clampedBendAngle = Math.max(20, Math.min(160, bendAngle));
-  const clampedTaper = Math.max(0, Math.min(1, taper));
-  const clampedTipRoundness = Math.max(0, Math.min(1, tipRoundness));
-  const clampedArmBalance = Math.max(0.5, Math.min(2, armBalance));
-  const armWidth = Math.max(armLength * 0.15, thickness * 0.5);
-  const cutoutDepth = armLength * 0.6 * (1 - clampedTaper);
-  const arm1Len = armLength * (2 / (1 + clampedArmBalance));
-  const arm2Len = armLength * (2 * clampedArmBalance / (1 + clampedArmBalance));
-  const halfAngle = clampedBendAngle / 2 * Math.PI / 180;
-  const tip = { x: 0, y: 0 };
-  const arm1End = { x: -Math.sin(halfAngle) * arm1Len, y: -Math.cos(halfAngle) * arm1Len };
-  const arm2End = { x: Math.sin(halfAngle) * arm2Len, y: -Math.cos(halfAngle) * arm2Len };
-  const arm1Perp = { x: -Math.cos(halfAngle), y: Math.sin(halfAngle) };
-  const arm2Perp = { x: Math.cos(halfAngle), y: Math.sin(halfAngle) };
-  const arm1OuterCorner = {
-    x: arm1End.x + arm1Perp.x * armWidth / 2,
-    y: arm1End.y + arm1Perp.y * armWidth / 2
-  };
-  const arm1InnerCorner = {
-    x: arm1End.x - arm1Perp.x * armWidth / 2,
-    y: arm1End.y - arm1Perp.y * armWidth / 2
-  };
-  const arm2OuterCorner = {
-    x: arm2End.x + arm2Perp.x * armWidth / 2,
-    y: arm2End.y + arm2Perp.y * armWidth / 2
-  };
-  const arm2InnerCorner = {
-    x: arm2End.x - arm2Perp.x * armWidth / 2,
-    y: arm2End.y - arm2Perp.y * armWidth / 2
-  };
-  const innerTip = {
-    x: 0,
-    y: -cutoutDepth
-  };
-  const pathParts = [];
-  if (clampedTipRoundness > 0) {
-    const roundAmount = clampedTipRoundness * armWidth * 0.3;
-    const tipStart = {
-      x: tip.x + arm1Perp.x * roundAmount,
-      y: tip.y + arm1Perp.y * roundAmount - roundAmount * 0.5
-    };
-    pathParts.push(`M ${tipStart.x.toFixed(2)},${tipStart.y.toFixed(2)}`);
-    const tipEnd = {
-      x: tip.x + arm2Perp.x * roundAmount,
-      y: tip.y + arm2Perp.y * roundAmount - roundAmount * 0.5
-    };
-    pathParts.push(`Q ${tip.x.toFixed(2)},${tip.y.toFixed(2)} ${tipEnd.x.toFixed(2)},${tipEnd.y.toFixed(2)}`);
-  } else {
-    pathParts.push(`M ${tip.x.toFixed(2)},${tip.y.toFixed(2)}`);
-  }
-  pathParts.push(`L ${arm2OuterCorner.x.toFixed(2)},${arm2OuterCorner.y.toFixed(2)}`);
-  pathParts.push(`L ${arm2InnerCorner.x.toFixed(2)},${arm2InnerCorner.y.toFixed(2)}`);
-  if (cutoutDepth > 5 && clampedTaper < 0.9) {
-    pathParts.push(`L ${innerTip.x.toFixed(2)},${innerTip.y.toFixed(2)}`);
-  }
-  pathParts.push(`L ${arm1InnerCorner.x.toFixed(2)},${arm1InnerCorner.y.toFixed(2)}`);
-  pathParts.push(`L ${arm1OuterCorner.x.toFixed(2)},${arm1OuterCorner.y.toFixed(2)}`);
-  pathParts.push("Z");
-  let path = pathParts.join(" ");
-  const allPoints = [tip, arm1End, arm2End, arm1OuterCorner, arm1InnerCorner, arm2OuterCorner, arm2InnerCorner];
-  if (cutoutDepth > 5 && clampedTaper < 0.9) {
-    allPoints.push(innerTip);
-  }
-  let minX = Math.min(...allPoints.map((p) => p.x));
-  let maxX = Math.max(...allPoints.map((p) => p.x));
-  let minY = Math.min(...allPoints.map((p) => p.y));
-  let maxY = Math.max(...allPoints.map((p) => p.y));
-  const padding = armWidth * 0.2;
-  minX -= padding;
-  maxX += padding;
-  minY -= padding;
-  maxY += padding;
-  const width = maxX - minX;
-  const height = maxY - minY;
-  path = normalizePath(path, minX, minY);
-  if (rotation !== 0) {
-    path = rotatePath(path, rotation, width, height);
-  }
-  return addSvgFields({ path, width, height, centerX: width / 2, centerY: height / 2 });
-}
-function generateArmSpine(start, end, direction, length, curvature, numSamples) {
-  const points = [];
-  const perpDir = { x: direction.y, y: -direction.x };
-  const bowAmount = length * 0.4 * curvature;
-  const midPoint = { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 };
-  const controlPoint = {
-    x: midPoint.x + perpDir.x * bowAmount,
-    y: midPoint.y + perpDir.y * bowAmount
-  };
-  for (let i = 0; i <= numSamples; i++) {
-    const t = i / numSamples;
-    if (curvature < 0.1) {
-      points.push({
-        x: start.x + (end.x - start.x) * t,
-        y: start.y + (end.y - start.y) * t
-      });
-    } else {
-      const mt = 1 - t;
-      points.push({
-        x: mt * mt * start.x + 2 * mt * t * controlPoint.x + t * t * end.x,
-        y: mt * mt * start.y + 2 * mt * t * controlPoint.y + t * t * end.y
-      });
-    }
-  }
-  return points;
-}
-function getSpineTangent(spine, index) {
-  const prev = spine[Math.max(0, index - 1)];
-  const next = spine[Math.min(spine.length - 1, index + 1)];
-  const dx = next.x - prev.x;
-  const dy = next.y - prev.y;
-  const len = Math.sqrt(dx * dx + dy * dy);
-  return len > 0 ? { x: dx / len, y: dy / len } : { x: 1, y: 0 };
-}
-function smoothCurveThroughPoints(points) {
-  if (points.length < 2) return "";
-  const parts = [];
-  const tension = 0.3;
-  for (let i = 0; i < points.length - 1; i++) {
-    const p0 = points[Math.max(0, i - 1)];
-    const p1 = points[i];
-    const p2 = points[i + 1];
-    const p3 = points[Math.min(points.length - 1, i + 2)];
-    const cp1x = p1.x + (p2.x - p0.x) * tension;
-    const cp1y = p1.y + (p2.y - p0.y) * tension;
-    const cp2x = p2.x - (p3.x - p1.x) * tension;
-    const cp2y = p2.y - (p3.y - p1.y) * tension;
-    parts.push(`C ${cp1x.toFixed(2)},${cp1y.toFixed(2)} ${cp2x.toFixed(2)},${cp2y.toFixed(2)} ${p2.x.toFixed(2)},${p2.y.toFixed(2)}`);
-  }
-  return parts.join(" ");
-}
-function normalizePath(path, minX, minY) {
-  return path.replace(
-    /([-\d.]+),([-\d.]+)/g,
-    (_, x, y) => `${(parseFloat(x) - minX).toFixed(2)},${(parseFloat(y) - minY).toFixed(2)}`
-  );
-}
-function rotatePath(path, rotation, width, height) {
-  const rad = rotation * Math.PI / 180;
-  const cos = Math.cos(rad);
-  const sin = Math.sin(rad);
-  const cx = width / 2;
-  const cy = height / 2;
-  return path.replace(
-    /([-\d.]+),([-\d.]+)/g,
-    (_, xStr, yStr) => {
-      const x = parseFloat(xStr) - cx;
-      const y = parseFloat(yStr) - cy;
-      const rx = x * cos - y * sin + cx;
-      const ry = x * sin + y * cos + cy;
-      return `${rx.toFixed(2)},${ry.toFixed(2)}`;
-    }
-  );
-}
-
-export {
-  boomerang
-};
-//# sourceMappingURL=chunk-IAFZ3FNR.js.map