@number10/jsx-core 5.0.0

package/dist/animation/useTween.js

@@ -0,0 +1,208 @@
+import { useRef, getCurrentCtx, useEffect } from "../hooks.js";
+import { animatedSignal } from "./animated-signal.js";
+import { Easing } from "./easing.js";
+import { createTween } from "./tween.js";
+const TWEEN_PRESETS = {
+  /** Standard transition (300ms, quadOut) */
+  default: { duration: 300, ease: Easing.quadOut },
+  /** Quick transition (150ms, quadOut) */
+  fast: { duration: 150, ease: Easing.quadOut },
+  /** Slow, deliberate transition (600ms, quadOut) */
+  slow: { duration: 600, ease: Easing.quadOut },
+  /** Slightly bouncy quick transition (200ms, backOut) */
+  snappy: { duration: 200, ease: Easing.backOut },
+  /** Elastic feel (400ms, elasticOut) */
+  elastic: { duration: 400, ease: Easing.elasticOut },
+  /** Snap to value instantly (0ms) — useful for reset patterns */
+  instant: { duration: 0 }
+};
+function useTween(initialValue, config, onComplete) {
+  const resolvedBaseConfig = typeof config === "string" ? TWEEN_PRESETS[config] : config ?? TWEEN_PRESETS.default;
+  const resolvedTo = resolvedBaseConfig.to;
+  const isLooping = resolvedBaseConfig.loop !== void 0 && resolvedBaseConfig.loop !== false;
+  const valueSignal = useRef(null);
+  if (valueSignal.current === null) {
+    valueSignal.current = animatedSignal(initialValue);
+  }
+  const ctx = getCurrentCtx();
+  const schedulerRef = useRef(ctx?.surface?.scheduler ?? null);
+  if (ctx?.surface?.scheduler && schedulerRef.current !== ctx.surface.scheduler) {
+    schedulerRef.current = ctx.surface.scheduler;
+  }
+  const currentTarget = useRef(resolvedTo ?? initialValue);
+  const tweenCleanupRef = useRef(null);
+  const setValueRef = useRef(
+    null
+  );
+  if (!setValueRef.current) {
+    setValueRef.current = (newTarget) => {
+      const resolved = typeof newTarget === "function" ? newTarget(currentTarget.current) : newTarget;
+      currentTarget.current = resolved;
+      startTween();
+    };
+  }
+  const startTween = () => {
+    const scheduler = schedulerRef.current;
+    if (!scheduler) {
+      if (valueSignal.current) {
+        valueSignal.current.value = currentTarget.current;
+      }
+      return;
+    }
+    tweenCleanupRef.current?.();
+    const signal = valueSignal.current;
+    if (!signal) return;
+    const resolvedConfig = resolvedBaseConfig;
+    const steps = resolvedConfig.steps ?? [
+      {
+        to: currentTarget.current,
+        duration: resolvedConfig.duration ?? 300,
+        ease: resolvedConfig.ease
+      }
+    ];
+    const onAllStepsComplete = () => {
+      if (isLooping && resolvedTo !== void 0) {
+        signal.value = initialValue;
+        currentTarget.current = resolvedTo;
+        startTween();
+        return;
+      }
+      onComplete?.();
+    };
+    let stepIndex = 0;
+    let currentHandle = null;
+    resolvedConfig.onStart?.();
+    const runNextStep = () => {
+      if (stepIndex >= steps.length) {
+        onAllStepsComplete();
+        return;
+      }
+      const step = steps[stepIndex];
+      if (!step) return;
+      const startValue = signal.value;
+      currentHandle = createTween(
+        { value: startValue },
+        {
+          to: { value: step.to },
+          duration: step.duration,
+          ease: step.ease ?? Easing.quadOut,
+          onUpdate: (t) => {
+            signal.value = t.value;
+            resolvedConfig.onUpdate?.(t.value);
+          },
+          onComplete: () => {
+            stepIndex++;
+            runNextStep();
+          }
+        },
+        scheduler
+      );
+    };
+    runNextStep();
+    tweenCleanupRef.current = () => {
+      currentHandle?.stop();
+    };
+  };
+  useEffect(() => {
+    if (currentTarget.current !== initialValue) {
+      startTween();
+    }
+    return () => {
+      tweenCleanupRef.current?.();
+      tweenCleanupRef.current = null;
+    };
+  }, []);
+  if (!valueSignal.current) {
+    throw new Error("useTween: Failed to initialize animated signal");
+  }
+  return [
+    valueSignal.current,
+    setValueRef.current
+  ];
+}
+function useTweens(initialValues, config, onComplete) {
+  const keys = Object.keys(initialValues);
+  const resolvedConfig = typeof config === "string" ? TWEEN_PRESETS[config] : config ?? TWEEN_PRESETS.default;
+  const tweenMap = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  keys.forEach((key) => {
+    if (!tweenMap.current.has(key)) {
+      const initialValue = initialValues[key];
+      tweenMap.current.set(key, {
+        signal: animatedSignal(initialValue),
+        target: { value: initialValue }
+      });
+    }
+  });
+  const ctx = getCurrentCtx();
+  const scheduler = ctx?.surface?.scheduler ?? null;
+  const schedulerRef = useRef(scheduler);
+  if (scheduler && schedulerRef.current !== scheduler) {
+    schedulerRef.current = scheduler;
+  }
+  const handlesRef = useRef([]);
+  const setValues = (values) => {
+    const currentScheduler = schedulerRef.current;
+    const entries = Object.entries(values).filter(([, v]) => v !== void 0);
+    if (!currentScheduler) {
+      entries.forEach(([key, val]) => {
+        const entry = tweenMap.current.get(key);
+        if (entry) {
+          entry.signal.value = typeof val === "function" ? val(entry.target.value) : val;
+          entry.target.value = entry.signal.value;
+        }
+      });
+      return;
+    }
+    handlesRef.current.forEach((h) => h.stop());
+    handlesRef.current = [];
+    let completedCount = 0;
+    const totalAnimations = entries.length;
+    entries.forEach(([key, val]) => {
+      const entry = tweenMap.current.get(key);
+      if (!entry) return;
+      const toValue = typeof val === "function" ? val(entry.target.value) : val;
+      entry.target.value = toValue;
+      const handle = createTween(
+        { value: entry.signal.value },
+        {
+          to: { value: toValue },
+          duration: resolvedConfig.duration ?? 300,
+          ease: resolvedConfig.ease ?? Easing.quadOut,
+          onUpdate: (t) => {
+            entry.signal.value = t.value;
+          },
+          onComplete: () => {
+            completedCount++;
+            if (completedCount >= totalAnimations) {
+              onComplete?.();
+            }
+          }
+        },
+        currentScheduler
+      );
+      handlesRef.current.push(handle);
+    });
+  };
+  useEffect(() => {
+    return () => {
+      handlesRef.current.forEach((h) => h.stop());
+      handlesRef.current = [];
+    };
+  }, []);
+  const signals = {};
+  keys.forEach((key) => {
+    const entry = tweenMap.current.get(key);
+    if (entry) {
+      signals[key] = entry.signal;
+    }
+  });
+  return [signals, setValues];
+}
+export {
+  TWEEN_PRESETS,
+  useTween,
+  useTweens
+};
+//# sourceMappingURL=useTween.js.map

package/dist/animation/useTween.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTween.js","sources":["../../src/animation/useTween.ts"],"sourcesContent":["/**\n * Tween animation hook — declarative time-based animations via signals.\n *\n * Counterpart to useSpring. Uses createTween internally, driven by\n * HostScheduler.onFrame(). Returns an AnimatedSignal that components\n * can bind to JSX props for direct VDOM-bypassing updates.\n *\n * @example\n * ```tsx\n * const [x, setX] = useTween(0, { duration: 500, ease: Easing.quadOut })\n * <View x={x} />\n * setX(200) // animates from current to 200 over 500ms\n *\n * // Multi-step:\n * const [scale, setScale] = useTween(1, {\n *   steps: [\n *     { to: 1.3, duration: 150, ease: Easing.quadOut },\n *     { to: 1.0, duration: 150, ease: Easing.backOut },\n *   ]\n * })\n * ```\n */\n\nimport { getCurrentCtx, useEffect, useRef, type HookContext } from '../hooks'\nimport type { HostScheduler } from '../host-adapter'\nimport { animatedSignal, type AnimatedSignal } from './animated-signal'\nimport { Easing, type EasingFn } from './easing'\nimport { createTween } from './tween'\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Configuration for a single tween step in a multi-step animation */\nexport interface TweenAnimationStep {\n  /** Target value */\n  to: number\n  /** Duration in ms */\n  duration: number\n  /** Easing function (default: quadOut) */\n  ease?: EasingFn | undefined\n}\n\n/** Configuration for useTween */\nexport interface TweenConfig {\n  /** Duration in ms (default: 300) */\n  duration?: number | undefined\n  /** Easing function (default: Easing.quadOut) */\n  ease?: EasingFn | undefined\n  /** Multi-step tween sequence (overrides duration/ease) */\n  steps?: TweenAnimationStep[] | undefined\n  /**\n   * Target value — auto-starts the tween from initialValue to `to`.\n   * No need to call the setter for the first animation.\n   *\n   * When combined with `loop`, the animation restarts from initialValue\n   * to `to` on each completion.\n   */\n  to?: number | undefined\n  /**\n   * Loop the animation. When `true`, restarts from initialValue to `to`\n   * each time the tween completes. Use with `to` for auto-starting loops.\n   *\n   * @example\n   * ```tsx\n   * // Continuous rotation — no effect, no ref, no onComplete needed\n   * const [rotation] = useTween(0, { to: Math.PI * 2, duration: 8000, ease: Easing.linear, loop: true })\n   * <View rotation={rotation} />\n   * ```\n   */\n  loop?: boolean | { reverse?: boolean } | undefined\n  /**\n   * Called once when the tween starts (including on restart/loop).\n   * Fires BEFORE the first frame is rendered.\n   */\n  onStart?: (() => void) | undefined\n  /**\n   * Called on every frame with the current interpolated value.\n   * Useful for syncing non-signal state (logging, analytics).\n   */\n  onUpdate?: ((value: number) => void) | undefined\n}\n\n/**\n * Preset tween configurations for common animation durations.\n *\n * @example\n * ```tsx\n * const [x, setX] = useTween(0, TWEEN_PRESETS.snappy)\n * setX(200)\n * ```\n */\nexport const TWEEN_PRESETS = {\n  /** Standard transition (300ms, quadOut) */\n  default: { duration: 300, ease: Easing.quadOut } as TweenConfig,\n  /** Quick transition (150ms, quadOut) */\n  fast: { duration: 150, ease: Easing.quadOut } as TweenConfig,\n  /** Slow, deliberate transition (600ms, quadOut) */\n  slow: { duration: 600, ease: Easing.quadOut } as TweenConfig,\n  /** Slightly bouncy quick transition (200ms, backOut) */\n  snappy: { duration: 200, ease: Easing.backOut } as TweenConfig,\n  /** Elastic feel (400ms, elasticOut) */\n  elastic: { duration: 400, ease: Easing.elasticOut } as TweenConfig,\n  /** Snap to value instantly (0ms) — useful for reset patterns */\n  instant: { duration: 0 } as TweenConfig,\n} as const\n\n/**\n * Type for tween preset keys\n */\nexport type TweenPreset = keyof typeof TWEEN_PRESETS\n\n// ---------------------------------------------------------------------------\n// useTween\n// ---------------------------------------------------------------------------\n\n/**\n * Creates an animated signal that transitions to target values\n * over a fixed duration with configurable easing.\n *\n * @param initialValue - Initial value\n * @param config - Duration, easing, or multi-step config\n * @param onComplete - Optional callback when animation completes\n * @returns Tuple of [animated signal, setter function]\n */\nexport function useTween(\n  initialValue: number,\n  config?: TweenConfig | TweenPreset,\n  onComplete?: () => void\n): [AnimatedSignal, (target: number | ((prev: number) => number)) => void] {\n  // Resolve config — supports preset names\n  const resolvedBaseConfig: TweenConfig =\n    typeof config === 'string' ? TWEEN_PRESETS[config] : (config ?? TWEEN_PRESETS.default)\n\n  const resolvedTo = resolvedBaseConfig.to\n  const isLooping = resolvedBaseConfig.loop !== undefined && resolvedBaseConfig.loop !== false\n\n  const valueSignal = useRef<AnimatedSignal | null>(null)\n  if (valueSignal.current === null) {\n    valueSignal.current = animatedSignal(initialValue)\n  }\n\n  // Capture scheduler from surface context\n  const ctx = getCurrentCtx() as HookContext | null\n  const schedulerRef = useRef<HostScheduler | null>(ctx?.surface?.scheduler ?? null)\n\n  // Update scheduler ref if it changes\n  if (ctx?.surface?.scheduler && schedulerRef.current !== ctx.surface.scheduler) {\n    schedulerRef.current = ctx.surface.scheduler\n  }\n\n  // Auto-start: if `to` is specified, use it as the initial target\n  const currentTarget = useRef<number>(resolvedTo ?? initialValue)\n  const tweenCleanupRef = useRef<(() => void) | null>(null)\n\n  // Stable setter — avoids re-running effects that depend on it\n  const setValueRef = useRef<((newTarget: number | ((prev: number) => number)) => void) | null>(\n    null\n  )\n  if (!setValueRef.current) {\n    setValueRef.current = (newTarget: number | ((prev: number) => number)): void => {\n      const resolved =\n        typeof newTarget === 'function' ? newTarget(currentTarget.current) : newTarget\n      currentTarget.current = resolved\n      startTween()\n    }\n  }\n\n  const startTween = (): void => {\n    const scheduler = schedulerRef.current\n    if (!scheduler) {\n      // Fallback: set value immediately\n      if (valueSignal.current) {\n        valueSignal.current.value = currentTarget.current\n      }\n      return\n    }\n\n    // Cleanup previous tween\n    tweenCleanupRef.current?.()\n\n    const signal = valueSignal.current\n    if (!signal) return\n\n    const resolvedConfig = resolvedBaseConfig\n\n    // Build step array\n    const steps: TweenAnimationStep[] = resolvedConfig.steps ?? [\n      {\n        to: currentTarget.current,\n        duration: resolvedConfig.duration ?? 300,\n        ease: resolvedConfig.ease,\n      },\n    ]\n\n    // Completion handler — supports loop restart\n    const onAllStepsComplete = (): void => {\n      if (isLooping && resolvedTo !== undefined) {\n        // Reset signal to initialValue and restart tween\n        signal.value = initialValue\n        currentTarget.current = resolvedTo\n        startTween()\n        return\n      }\n      onComplete?.()\n    }\n\n    let stepIndex = 0\n    let currentHandle: ReturnType<typeof createTween> | null = null\n\n    // Fire onStart when the first step begins\n    resolvedConfig.onStart?.()\n\n    const runNextStep = (): void => {\n      if (stepIndex >= steps.length) {\n        onAllStepsComplete()\n        return\n      }\n\n      const step = steps[stepIndex]\n      if (!step) return\n\n      const startValue = signal.value\n\n      currentHandle = createTween(\n        { value: startValue },\n        {\n          to: { value: step.to },\n          duration: step.duration,\n          ease: step.ease ?? Easing.quadOut,\n          onUpdate: (t) => {\n            signal.value = t.value\n            resolvedConfig.onUpdate?.(t.value)\n          },\n          onComplete: () => {\n            stepIndex++\n            runNextStep()\n          },\n        },\n        scheduler\n      )\n    }\n\n    runNextStep()\n\n    tweenCleanupRef.current = () => {\n      currentHandle?.stop()\n    }\n  }\n\n  // Start initial animation if target differs from initial\n  useEffect(() => {\n    if (currentTarget.current !== initialValue) {\n      startTween()\n    }\n\n    return () => {\n      tweenCleanupRef.current?.()\n      tweenCleanupRef.current = null\n    }\n  }, [])\n\n  if (!valueSignal.current) {\n    throw new Error('useTween: Failed to initialize animated signal')\n  }\n\n  return [\n    valueSignal.current,\n    setValueRef.current as (target: number | ((prev: number) => number)) => void,\n  ]\n}\n\n// ---------------------------------------------------------------------------\n// useTweens — multi-value tween hook\n// ---------------------------------------------------------------------------\n\n/**\n * Multi-tween animation hook.\n *\n * Creates multiple animated signals that share the same tween configuration.\n * Counterpart to `useSprings`.\n *\n * @param initialValues - Object with initial numeric values\n * @param config - Tween config or preset name (shared across all properties)\n * @param onComplete - Called when ALL tweens complete (fires once per setValues call)\n * @returns Tuple of [animated signals object, setter function]\n *\n * @example\n * ```tsx\n * const [pos, setPos] = useTweens({ x: 0, y: 0 }, 'snappy')\n * <View x={pos.x} y={pos.y} />\n * setPos({ x: 100, y: 200 })  // both animate to target simultaneously\n * ```\n */\nexport function useTweens<T extends Record<string, number>>(\n  initialValues: T,\n  config?: TweenConfig | TweenPreset,\n  onComplete?: () => void\n): [\n  { [K in keyof T]: AnimatedSignal },\n  (values: Partial<{ [K in keyof T]: number | ((prev: number) => number) }>) => void,\n] {\n  const keys = Object.keys(initialValues) as (keyof T)[]\n\n  // Resolve config — supports preset names\n  const resolvedConfig: TweenConfig =\n    typeof config === 'string' ? TWEEN_PRESETS[config] : (config ?? TWEEN_PRESETS.default)\n\n  // Initialize signals and targets\n  const tweenMap = useRef<Map<keyof T, { signal: AnimatedSignal; target: { value: number } }>>(\n    new Map()\n  )\n\n  keys.forEach((key) => {\n    if (!tweenMap.current.has(key)) {\n      const initialValue = initialValues[key] as number\n      tweenMap.current.set(key, {\n        signal: animatedSignal(initialValue),\n        target: { value: initialValue },\n      })\n    }\n  })\n\n  // Capture scheduler from surface context\n  const ctx = getCurrentCtx() as HookContext | null\n  const scheduler = ctx?.surface?.scheduler ?? null\n  const schedulerRef = useRef<HostScheduler | null>(scheduler)\n  if (scheduler && schedulerRef.current !== scheduler) {\n    schedulerRef.current = scheduler\n  }\n\n  // Track active tween handles for cleanup\n  const handlesRef = useRef<ReturnType<typeof createTween>[]>([])\n\n  // Setter function\n  const setValues = (\n    values: Partial<{ [K in keyof T]: number | ((prev: number) => number) }>\n  ): void => {\n    const currentScheduler = schedulerRef.current\n\n    // Filter out undefined values (Partial may include them)\n    const entries = Object.entries(values).filter(([, v]) => v !== undefined) as [\n      string,\n      number | ((prev: number) => number),\n    ][]\n\n    if (!currentScheduler) {\n      // Fallback: set values immediately\n      entries.forEach(([key, val]) => {\n        const entry = tweenMap.current.get(key as keyof T)\n        if (entry) {\n          entry.signal.value = typeof val === 'function' ? val(entry.target.value) : val\n          entry.target.value = entry.signal.value\n        }\n      })\n      return\n    }\n\n    // Cleanup previous tweens\n    handlesRef.current.forEach((h) => h.stop())\n    handlesRef.current = []\n\n    let completedCount = 0\n    const totalAnimations = entries.length\n\n    entries.forEach(([key, val]) => {\n      const entry = tweenMap.current.get(key as keyof T)\n      if (!entry) return\n\n      const toValue = typeof val === 'function' ? val(entry.target.value) : val\n      entry.target.value = toValue\n\n      const handle = createTween(\n        { value: entry.signal.value },\n        {\n          to: { value: toValue },\n          duration: resolvedConfig.duration ?? 300,\n          ease: resolvedConfig.ease ?? Easing.quadOut,\n          onUpdate: (t) => {\n            entry.signal.value = t.value\n          },\n          onComplete: () => {\n            completedCount++\n            if (completedCount >= totalAnimations) {\n              onComplete?.()\n            }\n          },\n        },\n        currentScheduler\n      )\n\n      handlesRef.current.push(handle)\n    })\n  }\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      handlesRef.current.forEach((h) => h.stop())\n      handlesRef.current = []\n    }\n  }, [])\n\n  // Build result object\n  const signals = {} as { [K in keyof T]: AnimatedSignal }\n  keys.forEach((key) => {\n    const entry = tweenMap.current.get(key)\n    if (entry) {\n      signals[key] = entry.signal\n    }\n  })\n\n  return [signals, setValues]\n}\n"],"names":[],"mappings":"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"}

package/dist/border-geometry.cjs

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function resolveBorderSides(width) {
+  if (width === void 0) return { top: 0, right: 0, bottom: 0, left: 0 };
+  if (typeof width === "number") {
+    const w = Math.max(0, width);
+    return { top: w, right: w, bottom: w, left: w };
+  }
+  return {
+    top: Math.max(0, width.top ?? 0),
+    right: Math.max(0, width.right ?? 0),
+    bottom: Math.max(0, width.bottom ?? 0),
+    left: Math.max(0, width.left ?? 0)
+  };
+}
+function isUniformBorder(sides) {
+  return sides.top === sides.right && sides.right === sides.bottom && sides.bottom === sides.left;
+}
+function resolveCornerRadii(cr) {
+  if (typeof cr === "number") {
+    const r = Math.max(0, cr);
+    return { tl: r, tr: r, bl: r, br: r };
+  }
+  if (cr) {
+    return {
+      tl: Math.max(0, cr.tl ?? 0),
+      tr: Math.max(0, cr.tr ?? 0),
+      bl: Math.max(0, cr.bl ?? 0),
+      br: Math.max(0, cr.br ?? 0)
+    };
+  }
+  return { tl: 0, tr: 0, bl: 0, br: 0 };
+}
+function hasAnyCornerRadius(corners) {
+  return corners.tl > 0 || corners.tr > 0 || corners.bl > 0 || corners.br > 0;
+}
+function shouldUseCoreBorderGeometry(border, rendererIssues) {
+  const sides = resolveBorderSides(border.width);
+  const asymmetric = !isUniformBorder(sides);
+  if (asymmetric) return true;
+  if (rendererIssues && rendererIssues.length > 0) {
+    if (rendererIssues.includes("all")) return true;
+    if (rendererIssues.includes("rounded-dotted") && border.style === "dotted") {
+      return true;
+    }
+    if (rendererIssues.includes("rounded-dashed-cap") && border.style === "dashed") {
+      return true;
+    }
+  }
+  return false;
+}
+function pushPerimeterPoint(points, pt, width) {
+  const last = points[points.length - 1];
+  if (!last || Math.abs(last.x - pt.x) > 1e-3 || Math.abs(last.y - pt.y) > 1e-3) {
+    points.push({ x: pt.x, y: pt.y, width });
+    return;
+  }
+  last.width = width;
+}
+function appendPerimeterArcPoints(points, corner, startAngle, endAngle, widthStart, widthEnd) {
+  const start = pointOnEllipse(corner, startAngle);
+  pushPerimeterPoint(points, start, widthStart);
+  if (corner.rx <= 0 || corner.ry <= 0) {
+    pushPerimeterPoint(points, pointOnEllipse(corner, endAngle), widthEnd);
+    return;
+  }
+  const span = endAngle - startAngle;
+  const maxR = Math.max(corner.rx, corner.ry);
+  const steps = Math.max(1, Math.min(24, Math.ceil(Math.abs(span) * maxR / 8)));
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps;
+    const angle = startAngle + span * t;
+    const width = widthStart + (widthEnd - widthStart) * t;
+    pushPerimeterPoint(points, pointOnEllipse(corner, angle), width);
+  }
+}
+function buildPerimeterPoints(w, h, sides, corners, align) {
+  const offsets = resolveBorderOffsets(sides, align);
+  const outer = buildOuterContour(w, h, corners, offsets.outer);
+  const inner = buildInnerContour(w, h, corners, offsets.inner);
+  const mid = averageContours(outer, inner);
+  const points = [];
+  pushPerimeterPoint(points, { x: mid.tl.cx, y: mid.top }, sides.top);
+  pushPerimeterPoint(points, { x: mid.tr.cx, y: mid.top }, sides.top);
+  appendPerimeterArcPoints(points, mid.tr, -Math.PI / 2, 0, sides.top, sides.right);
+  pushPerimeterPoint(points, { x: mid.right, y: mid.br.cy }, sides.right);
+  appendPerimeterArcPoints(points, mid.br, 0, Math.PI / 2, sides.right, sides.bottom);
+  pushPerimeterPoint(points, { x: mid.bl.cx, y: mid.bottom }, sides.bottom);
+  appendPerimeterArcPoints(points, mid.bl, Math.PI / 2, Math.PI, sides.bottom, sides.left);
+  pushPerimeterPoint(points, { x: mid.left, y: mid.tl.cy }, sides.left);
+  appendPerimeterArcPoints(points, mid.tl, Math.PI, Math.PI * 1.5, sides.left, sides.top);
+  if (points.length > 1) {
+    const first = points[0] ?? { x: 0, y: 0 };
+    const last = points[points.length - 1] ?? { x: 0, y: 0 };
+    if (Math.abs(first.x - last.x) <= 1e-3 && Math.abs(first.y - last.y) <= 1e-3) {
+      points.pop();
+    }
+  }
+  return points;
+}
+function buildPerimeterSegments(points) {
+  if (points.length < 2) return [];
+  const segs = [];
+  for (let i = 0; i < points.length; i++) {
+    const p1 = points[i] ?? { x: 0, y: 0, width: 0 };
+    const p2 = points[(i + 1) % points.length] ?? { x: 0, y: 0, width: 0 };
+    const dx = p2.x - p1.x;
+    const dy = p2.y - p1.y;
+    const length = Math.sqrt(dx * dx + dy * dy);
+    if (length <= 1e-3) continue;
+    segs.push({
+      x1: p1.x,
+      y1: p1.y,
+      x2: p2.x,
+      y2: p2.y,
+      width1: p1.width,
+      width2: p2.width,
+      length
+    });
+  }
+  return segs;
+}
+function pointAtDistance(seg, t) {
+  const frac = seg.length > 0 ? t / seg.length : 0;
+  return {
+    x: seg.x1 + (seg.x2 - seg.x1) * frac,
+    y: seg.y1 + (seg.y2 - seg.y1) * frac,
+    width: seg.width1 + (seg.width2 - seg.width1) * frac
+  };
+}
+function resolveBorderOffsets(sides, align) {
+  if (align === "inside") {
+    return {
+      outer: { top: 0, right: 0, bottom: 0, left: 0 },
+      inner: { ...sides }
+    };
+  }
+  if (align === "outside") {
+    return {
+      outer: { ...sides },
+      inner: { top: 0, right: 0, bottom: 0, left: 0 }
+    };
+  }
+  return {
+    outer: {
+      top: sides.top / 2,
+      right: sides.right / 2,
+      bottom: sides.bottom / 2,
+      left: sides.left / 2
+    },
+    inner: {
+      top: sides.top / 2,
+      right: sides.right / 2,
+      bottom: sides.bottom / 2,
+      left: sides.left / 2
+    }
+  };
+}
+function buildOuterContour(w, h, corners, offsets) {
+  const left = -offsets.left;
+  const top = -offsets.top;
+  const right = w + offsets.right;
+  const bottom = h + offsets.bottom;
+  return {
+    left,
+    top,
+    right,
+    bottom,
+    tl: {
+      cx: corners.tl,
+      cy: corners.tl,
+      rx: corners.tl + offsets.left,
+      ry: corners.tl + offsets.top
+    },
+    tr: {
+      cx: w - corners.tr,
+      cy: corners.tr,
+      rx: corners.tr + offsets.right,
+      ry: corners.tr + offsets.top
+    },
+    br: {
+      cx: w - corners.br,
+      cy: h - corners.br,
+      rx: corners.br + offsets.right,
+      ry: corners.br + offsets.bottom
+    },
+    bl: {
+      cx: corners.bl,
+      cy: h - corners.bl,
+      rx: corners.bl + offsets.left,
+      ry: corners.bl + offsets.bottom
+    }
+  };
+}
+function buildInnerContour(w, h, corners, offsets) {
+  const left = offsets.left;
+  const top = offsets.top;
+  const right = w - offsets.right;
+  const bottom = h - offsets.bottom;
+  const tlRx = Math.max(0, corners.tl - offsets.left);
+  const tlRy = Math.max(0, corners.tl - offsets.top);
+  const trRx = Math.max(0, corners.tr - offsets.right);
+  const trRy = Math.max(0, corners.tr - offsets.top);
+  const brRx = Math.max(0, corners.br - offsets.right);
+  const brRy = Math.max(0, corners.br - offsets.bottom);
+  const blRx = Math.max(0, corners.bl - offsets.left);
+  const blRy = Math.max(0, corners.bl - offsets.bottom);
+  return {
+    left,
+    top,
+    right,
+    bottom,
+    tl: { cx: left + tlRx, cy: top + tlRy, rx: tlRx, ry: tlRy },
+    tr: { cx: right - trRx, cy: top + trRy, rx: trRx, ry: trRy },
+    br: { cx: right - brRx, cy: bottom - brRy, rx: brRx, ry: brRy },
+    bl: { cx: left + blRx, cy: bottom - blRy, rx: blRx, ry: blRy }
+  };
+}
+function averageContours(a, b) {
+  const avgCorner = (ca, cb, sideX, sideY, right = false, bottom = false) => {
+    const rx = (ca.rx + cb.rx) / 2;
+    const ry = (ca.ry + cb.ry) / 2;
+    return {
+      cx: right ? sideX - rx : sideX + rx,
+      cy: bottom ? sideY - ry : sideY + ry,
+      rx,
+      ry
+    };
+  };
+  return {
+    left: (a.left + b.left) / 2,
+    top: (a.top + b.top) / 2,
+    right: (a.right + b.right) / 2,
+    bottom: (a.bottom + b.bottom) / 2,
+    tl: avgCorner(a.tl, b.tl, (a.left + b.left) / 2, (a.top + b.top) / 2),
+    tr: avgCorner(a.tr, b.tr, (a.right + b.right) / 2, (a.top + b.top) / 2, true, false),
+    br: avgCorner(a.br, b.br, (a.right + b.right) / 2, (a.bottom + b.bottom) / 2, true, true),
+    bl: avgCorner(a.bl, b.bl, (a.left + b.left) / 2, (a.bottom + b.bottom) / 2, false, true)
+  };
+}
+function pointOnEllipse(corner, angle) {
+  return {
+    x: corner.cx + corner.rx * Math.cos(angle),
+    y: corner.cy + corner.ry * Math.sin(angle)
+  };
+}
+function pushPoint(points, pt) {
+  const last = points[points.length - 1];
+  if (!last || Math.abs(last.x - pt.x) > 1e-3 || Math.abs(last.y - pt.y) > 1e-3) {
+    points.push(pt);
+  }
+}
+function appendEllipseArcPoints(points, corner, startAngle, endAngle) {
+  const start = pointOnEllipse(corner, startAngle);
+  const end = pointOnEllipse(corner, endAngle);
+  pushPoint(points, start);
+  if (corner.rx <= 0 || corner.ry <= 0) {
+    pushPoint(points, end);
+    return;
+  }
+  const span = endAngle - startAngle;
+  const maxR = Math.max(corner.rx, corner.ry);
+  const steps = Math.max(1, Math.min(24, Math.ceil(Math.abs(span) * maxR / 8)));
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps;
+    const angle = startAngle + span * t;
+    pushPoint(points, pointOnEllipse(corner, angle));
+  }
+}
+function buildContourPoints(contour) {
+  const points = [];
+  pushPoint(points, { x: contour.tl.cx, y: contour.top });
+  pushPoint(points, { x: contour.tr.cx, y: contour.top });
+  appendEllipseArcPoints(points, contour.tr, -Math.PI / 2, 0);
+  pushPoint(points, { x: contour.right, y: contour.br.cy });
+  appendEllipseArcPoints(points, contour.br, 0, Math.PI / 2);
+  pushPoint(points, { x: contour.bl.cx, y: contour.bottom });
+  appendEllipseArcPoints(points, contour.bl, Math.PI / 2, Math.PI);
+  pushPoint(points, { x: contour.left, y: contour.tl.cy });
+  appendEllipseArcPoints(points, contour.tl, Math.PI, Math.PI * 1.5);
+  return points;
+}
+function traceClosedPath(ctx, points) {
+  if (points.length === 0) return;
+  if (points[0] === void 0) return;
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) {
+    const pt = points[i] ?? { x: 0, y: 0 };
+    ctx.lineTo(pt.x, pt.y);
+  }
+  ctx.closePath();
+}
+function drawSolidBorder(ctx, w, h, sides, corners, color, alpha, align) {
+  const offsets = resolveBorderOffsets(sides, align);
+  const outer = buildOuterContour(w, h, corners, offsets.outer);
+  const inner = buildInnerContour(w, h, corners, offsets.inner);
+  const outerPoints = buildContourPoints(outer);
+  const innerPoints = buildContourPoints(inner);
+  if (outerPoints.length < 3) return;
+  ctx.fillStyle(color, alpha);
+  ctx.beginPath();
+  traceClosedPath(ctx, outerPoints);
+  traceClosedPath(ctx, [...innerPoints].reverse());
+  ctx.fillPath();
+}
+function appendDashPoint(points, pt) {
+  const last = points[points.length - 1];
+  if (!last || Math.abs(last.x - pt.x) > 1e-3 || Math.abs(last.y - pt.y) > 1e-3) {
+    points.push(pt);
+  }
+}
+function strokeDashedPath(ctx, points, widths, color, alpha) {
+  if (points.length < 2 || widths.length === 0) return;
+  const width = widths.reduce((sum, value) => sum + value, 0) / widths.length;
+  if (width <= 0) return;
+  ctx.lineStyle(width, color, alpha);
+  ctx.beginPath();
+  if (points[0] === void 0) return;
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) {
+    const pt = points[i];
+    if (pt === void 0) continue;
+    ctx.lineTo(pt.x, pt.y);
+  }
+  ctx.strokePath();
+}
+function drawDashedBorder(ctx, w, h, sides, corners, border, color, alpha, align) {
+  const segs = buildPerimeterSegments(buildPerimeterPoints(w, h, sides, corners, align));
+  if (segs.length === 0) return;
+  const maxWidth = Math.max(sides.top, sides.right, sides.bottom, sides.left);
+  const dashArray = border.dash ?? [maxWidth * 3, maxWidth * 2];
+  const dashOffset = border.dashOffset ?? 0;
+  const pattern = dashArray.length % 2 === 0 ? dashArray : [...dashArray, ...dashArray];
+  const patternSum = pattern.reduce((a, b) => a + b, 0);
+  if (patternSum <= 0) return;
+  let patIdx = 0;
+  let drawing = true;
+  let accumulated = pattern[0] ?? 0;
+  let offset = dashOffset % patternSum;
+  if (offset < 0) offset += patternSum;
+  while (offset > 1e-3) {
+    const consume = Math.min(offset, accumulated);
+    offset -= consume;
+    accumulated -= consume;
+    if (accumulated <= 1e-3) {
+      patIdx = (patIdx + 1) % pattern.length;
+      drawing = !drawing;
+      accumulated = pattern[patIdx] ?? 0;
+    }
+  }
+  let dashPoints = [];
+  let dashWidths = [];
+  const flushDash = () => {
+    if (dashPoints.length > 1) {
+      strokeDashedPath(ctx, dashPoints, dashWidths, color, alpha);
+    }
+    dashPoints = [];
+    dashWidths = [];
+  };
+  for (const seg of segs) {
+    const sLen = seg.length;
+    if (sLen <= 0) continue;
+    let t = 0;
+    while (t < sLen) {
+      const consume = Math.min(accumulated, sLen - t);
+      const end = t + consume;
+      if (drawing && consume > 0) {
+        const p1 = pointAtDistance(seg, t);
+        const p2 = pointAtDistance(seg, end);
+        if (dashPoints.length === 0) {
+          appendDashPoint(dashPoints, p1);
+          dashWidths.push(p1.width);
+        }
+        appendDashPoint(dashPoints, p2);
+        dashWidths.push((p1.width + p2.width) / 2);
+      }
+      t += consume;
+      accumulated -= consume;
+      if (accumulated <= 1e-3) {
+        if (drawing) flushDash();
+        patIdx = (patIdx + 1) % pattern.length;
+        drawing = !drawing;
+        accumulated = pattern[patIdx] ?? 0;
+      }
+    }
+  }
+  if (drawing) flushDash();
+}
+function drawDottedBorder(ctx, w, h, sides, corners, border, color, alpha, align) {
+  const segs = buildPerimeterSegments(buildPerimeterPoints(w, h, sides, corners, align));
+  if (segs.length === 0) return;
+  const dotGap = border.dash?.[0] ?? Math.max(sides.top, sides.right, sides.bottom, sides.left);
+  const dotDiameterOverride = border.dash?.[1];
+  const totalLength = segs.reduce((sum, seg) => sum + seg.length, 0);
+  if (totalLength <= 0) return;
+  const fallbackDiameter = Math.max(sides.top, sides.right, sides.bottom, sides.left);
+  const baseDiameter = dotDiameterOverride ?? fallbackDiameter;
+  const step = baseDiameter + dotGap;
+  if (step <= 0) return;
+  let distance = step / 2 + (border.dashOffset ?? 0);
+  while (distance < 0) distance += step;
+  for (; distance < totalLength; distance += step) {
+    let remaining = distance;
+    for (const seg of segs) {
+      if (remaining <= seg.length) {
+        const pt = pointAtDistance(seg, remaining);
+        const dotDiameter = dotDiameterOverride ?? pt.width;
+        const dotRadius = dotDiameter / 2;
+        if (dotRadius > 0) {
+          ctx.fillCircleStyled(pt.x, pt.y, dotRadius, color, alpha);
+        }
+        break;
+      }
+      remaining -= seg.length;
+    }
+  }
+}
+function drawBorderGeometry(ctx, input, border) {
+  const { box, sides, corners } = input;
+  const { w, h } = box;
+  const color = border.color ?? 16777215;
+  const alpha = typeof border.alpha === "number" ? border.alpha : 1;
+  const maxSw = Math.max(sides.top, sides.right, sides.bottom, sides.left);
+  if (maxSw <= 0) return;
+  if (w <= 0 || h <= 0) return;
+  const align = border.align ?? "center";
+  const style = border.style ?? "solid";
+  switch (style) {
+    case "dotted":
+      drawDottedBorder(ctx, w, h, sides, corners, border, color, alpha, align);
+      break;
+    case "dashed":
+      drawDashedBorder(ctx, w, h, sides, corners, border, color, alpha, align);
+      break;
+    case "solid":
+    default:
+      drawSolidBorder(ctx, w, h, sides, corners, color, alpha, align);
+      break;
+  }
+}
+exports.drawBorderGeometry = drawBorderGeometry;
+exports.hasAnyCornerRadius = hasAnyCornerRadius;
+exports.isUniformBorder = isUniformBorder;
+exports.resolveBorderSides = resolveBorderSides;
+exports.resolveCornerRadii = resolveCornerRadii;
+exports.shouldUseCoreBorderGeometry = shouldUseCoreBorderGeometry;
+//# sourceMappingURL=border-geometry.cjs.map