curvy 2.0.0-alpha.17 → 2.0.0-alpha.18

package/dist/arc/arc.d.ts

@@ -0,0 +1,277 @@
+import type { Closed } from '../interval/interval.ts';
+import type { Interval2d } from '../interval/interval2d.ts';
+import type { RationalCubicPath2d } from '../path/rationalCubic2d.ts';
+import type { Pipeable } from '../utils.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { ArcTypeId } from './arc.internal.ts';
+/**
+ * A circular arc: the points `center + radius * (cos(a), sin(a))` for `a`
+ * running from `startAngle` to `startAngle + sweep`.
+ *
+ * An authoring representation, like the spline modules: describe the arc
+ * here, query its closed-form geometry (`solve`, `length`, `boundingBox`),
+ * and lower it with `toPath` for curve math or `toPathData` for SVG. The
+ * description keeps answers the lowered form loses — arc length and
+ * point-at-parameter are exact one-liners here and numeric iterations
+ * there.
+ *
+ * Angles are in radians, measured from the `+x` direction, positive
+ * rotating `+x` toward `+y` — clockwise in an SVG viewport's y-down
+ * coordinates. Direction and multiplicity live in the sweep's sign and
+ * magnitude: a negative sweep runs the other way, and a magnitude past
+ * `2 * pi` keeps going around the circle.
+ *
+ * All fields are readonly. No operation mutates an arc.
+ *
+ * @since 2.0.0
+ */
+export interface Circular extends Pipeable {
+    readonly [ArcTypeId]: ArcTypeId;
+    readonly kind: 'circular';
+    /**
+     * The cartesian center of the circle the arc lies on.
+     */
+    readonly center: Vector2;
+    /**
+     * The circle's radius. Non-negative; `0` is a valid degenerate arc that
+     * never leaves `center`.
+     */
+    readonly radius: number;
+    /**
+     * The angle where the arc starts, in radians from the `+x` direction,
+     * positive rotating `+x` toward `+y`.
+     */
+    readonly startAngle: number;
+    /**
+     * The signed angular extent, in radians. Positive rotates `+x` toward
+     * `+y`; a magnitude past `2 * pi` traces the circle more than once.
+     */
+    readonly sweep: number;
+}
+/**
+ * Configuration for `circular`. Only `radius` is required; the defaults
+ * give a full circle around the origin.
+ *
+ * @since 2.0.0
+ */
+export interface CircularConfig {
+    /**
+     * The cartesian center of the circle. Defaults to the origin.
+     */
+    readonly center?: Vector2;
+    /**
+     * The circle's radius. Must be finite and non-negative.
+     */
+    readonly radius: number;
+    /**
+     * The angle where the arc starts, in radians from the `+x` direction,
+     * positive rotating `+x` toward `+y`. Defaults to `0` (3 o'clock on
+     * screen).
+     */
+    readonly startAngle?: number;
+    /**
+     * The signed angular extent, in radians. Defaults to `2 * pi`, a full
+     * circle.
+     */
+    readonly sweep?: number;
+}
+/**
+ * Checks if a value is a `Circular` arc.
+ *
+ * @param v - The value to check.
+ * @returns `true` if the value is a `Circular` arc, `false` otherwise.
+ * @since 2.0.0
+ */
+export declare const isCircular: (v: unknown) => v is Circular;
+/**
+ * Creates a `Circular` arc.
+ *
+ * @param config - Center, radius, start angle, and sweep. Only `radius` is
+ *   required; see `CircularConfig` for the defaults.
+ * @returns A new `Circular` arc.
+ * @throws `Error` when `radius` is negative, or when `radius`,
+ *   `startAngle`, or `sweep` is not finite.
+ * @since 2.0.0
+ * @example
+ * ```ts
+ * // A quarter circle of radius 100 from 3 o'clock to 6 o'clock:
+ * const quarter = Arc.circular({ radius: 100, sweep: Math.PI / 2 })
+ *
+ * // Omitting sweep gives the full circle:
+ * const dial = Arc.circular({ center: Vector2.make(200, 200), radius: 80 })
+ * ```
+ */
+export declare const circular: (config: CircularConfig) => Circular;
+export declare const equals: {
+    /**
+     * Checks two `Circular` arcs for equality, field by field. Numeric
+     * fields compare within the tolerance of `coincident` from
+     * `curvy/number`.
+     *
+     * Comparison is structural, not geometric: two arcs tracing the same
+     * points from different descriptions — a start angle shifted by
+     * `2 * pi`, or the reverse direction — compare unequal.
+     *
+     * @param a - The first arc.
+     * @param b - The second arc.
+     * @returns `true` if the arcs are equal, `false` otherwise.
+     * @since 2.0.0
+     */
+    (a: Circular, b: Circular): boolean;
+    /**
+     * Checks two `Circular` arcs for equality.
+     *
+     * @param b - The arc to compare against.
+     * @returns A function that takes an arc and returns whether the two are
+     *   equal.
+     * @since 2.0.0
+     */
+    (b: Circular): (a: Circular) => boolean;
+};
+/**
+ * Computes the point where the arc starts,
+ * `center + radius * (cos(startAngle), sin(startAngle))`.
+ *
+ * @param a - The arc.
+ * @returns The arc's first point.
+ * @since 2.0.0
+ */
+export declare const startPoint: (a: Circular) => Vector2;
+/**
+ * Computes the point where the arc ends, evaluated at
+ * `startAngle + sweep`.
+ *
+ * On a full-turn arc the result lands within rounding of `startPoint`,
+ * not bitwise on it — the trig re-evaluates a full period away. `toPathData`
+ * closes full circles on the exact starting coordinates instead.
+ *
+ * @param a - The arc.
+ * @returns The arc's last point.
+ * @since 2.0.0
+ */
+export declare const endPoint: (a: Circular) => Vector2;
+export declare const solve: {
+    /**
+     * Evaluates the arc at parameter `t`, the point at angle
+     * `startAngle + t * sweep`.
+     *
+     * The uniform parameter is also the arc-length parameter: equal steps
+     * in `t` cover equal distance along the arc, a property polynomial
+     * curves lack. `t` is not clamped — values outside `[0, 1]` continue
+     * around the circle.
+     *
+     * @param a - The arc to evaluate.
+     * @param t - The parameter. `0` is the start of the arc, `1` the end.
+     * @returns The point on the arc at parameter `t`.
+     * @since 2.0.0
+     * @example
+     * ```ts
+     * // The midpoint of a quarter arc sits at 45 degrees:
+     * Arc.solve(Arc.circular({ radius: 1, sweep: Math.PI / 2 }), 0.5)
+     * // (cos(pi / 4), sin(pi / 4))
+     * ```
+     */
+    (a: Circular, t: number): Vector2;
+    /**
+     * Evaluates the arc at parameter `t`.
+     *
+     * @param t - The parameter. `0` is the start of the arc, `1` the end.
+     * @returns A function that takes an arc and returns the point at `t`.
+     * @since 2.0.0
+     */
+    (t: number): (a: Circular) => Vector2;
+};
+/**
+ * Computes the arc's length, `radius * abs(sweep)`. Exact, in closed form
+ * — no tolerance parameter and no iteration, unlike arc length on a
+ * lowered path. A sweep past one full turn counts every traversal.
+ *
+ * @param a - The arc.
+ * @returns The length of the arc.
+ * @since 2.0.0
+ */
+export declare const length: (a: Circular) => number;
+/**
+ * Reverses the arc's direction: the same points traced the other way.
+ * The start angle moves to the far end and the sweep negates, so
+ * `solve(reverse(a), t)` is `solve(a, 1 - t)`.
+ *
+ * @param a - The arc.
+ * @returns A new `Circular` arc tracing the input backward.
+ * @since 2.0.0
+ */
+export declare const reverse: (a: Circular) => Circular;
+/**
+ * Computes the exact axis-aligned bounding box of the arc.
+ *
+ * Extremes occur only at the endpoints or where the arc crosses an axis
+ * direction (a multiple of `pi / 2`), so every side is evaluated in
+ * closed form — exact up to IEEE 754 rounding, with no tolerance
+ * parameter. Contrast `RationalCubicPath2d.boundingBox`, which is tight
+ * only to a tolerance you choose. A zero-radius arc's box collapses to
+ * `center`.
+ *
+ * @param a - The arc.
+ * @returns A closed `Interval2d` enclosing exactly the arc's points.
+ * @since 2.0.0
+ */
+export declare const boundingBox: (a: Circular) => Interval2d<Closed, Closed>;
+/**
+ * Constructs the arc as a `RationalCubicPath2d`, exact up to IEEE 754
+ * rounding — the same construction `CoordinateSystem.arc` uses: rational
+ * cubic segments of at most a quarter turn each, uniform in angle, with a
+ * sweep past one full turn tracing the circle more than once.
+ *
+ * The path is the form to transform: circles are not closed under affine
+ * maps, but rational cubics are, so lower first and apply
+ * `RationalCubicPath2d.transform` to the result.
+ *
+ * @param a - The arc.
+ * @returns The arc as a `RationalCubicPath2d`.
+ * @since 2.0.0
+ * @example
+ * ```ts
+ * // A quarter-turn fillet of radius 8 as one exact rational segment:
+ * const path = Arc.toPath(
+ *   Arc.circular({
+ *     center: Vector2.make(50, 50),
+ *     radius: 8,
+ *     startAngle: -Math.PI / 2,
+ *     sweep: Math.PI / 2,
+ *   }),
+ * )
+ * ```
+ */
+export declare const toPath: (a: Circular) => RationalCubicPath2d;
+/**
+ * Emits exact SVG path data for the arc, using `A` commands computed from
+ * the arc's description rather than recovered from curve coefficients.
+ * Pieces stay at or under a half turn, so the large-arc flag is always
+ * `0`; the sweep flag is `1` for a positive sweep, which renders
+ * clockwise in an SVG viewport's y-down coordinates.
+ *
+ * Degenerate contracts:
+ * - zero sweep, or radius `0`: an `M` command alone, which renders
+ *   nothing
+ * - a full-turn sweep: the circle as two half-turn `A` commands, closing
+ *   on the exact starting coordinates
+ * - a sweep past one full turn: clamped to one circle, where `toPath`
+ *   keeps going around — SVG path data cannot express multiple laps
+ *
+ * @param a - The arc.
+ * @returns The SVG path data string.
+ * @since 2.0.0
+ * @example
+ * ```ts
+ * // d attribute for a gauge tick at 12 o'clock, ready for <path d={...}>:
+ * const d = Arc.toPathData(
+ *   Arc.circular({
+ *     center: Vector2.make(200, 200),
+ *     radius: 120,
+ *     startAngle: -Math.PI / 2,
+ *     sweep: Math.PI / 6,
+ *   }),
+ * )
+ * ```
+ */
+export declare const toPathData: (a: Circular) => string;

package/dist/arc/arc.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const ArcTypeId: unique symbol;
+export type ArcTypeId = typeof ArcTypeId;

package/dist/arc/index.d.ts

@@ -0,0 +1,2 @@
+import * as ArcNs from './arc.ts';
+export { ArcNs as Arc };

package/dist/arc/index.mjs

@@ -0,0 +1,165 @@
+import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
+import { _ as toPathData$1, c as equals$1, d as length$1, g as toPath$1, h as startPoint$1, i as circular$1, l as isCircular$1, m as solve$1, p as reverse$1, r as boundingBox$1, s as endPoint$1 } from "../shared/arc.internal-DBLPlj56.mjs";
+//#region src/arc/arc.ts
+var arc_exports = /* @__PURE__ */ __exportAll({
+	boundingBox: () => boundingBox,
+	circular: () => circular,
+	endPoint: () => endPoint,
+	equals: () => equals,
+	isCircular: () => isCircular,
+	length: () => length,
+	reverse: () => reverse,
+	solve: () => solve,
+	startPoint: () => startPoint,
+	toPath: () => toPath,
+	toPathData: () => toPathData
+});
+/**
+* Checks if a value is a `Circular` arc.
+*
+* @param v - The value to check.
+* @returns `true` if the value is a `Circular` arc, `false` otherwise.
+* @since 2.0.0
+*/
+const isCircular = isCircular$1;
+/**
+* Creates a `Circular` arc.
+*
+* @param config - Center, radius, start angle, and sweep. Only `radius` is
+*   required; see `CircularConfig` for the defaults.
+* @returns A new `Circular` arc.
+* @throws `Error` when `radius` is negative, or when `radius`,
+*   `startAngle`, or `sweep` is not finite.
+* @since 2.0.0
+* @example
+* ```ts
+* // A quarter circle of radius 100 from 3 o'clock to 6 o'clock:
+* const quarter = Arc.circular({ radius: 100, sweep: Math.PI / 2 })
+*
+* // Omitting sweep gives the full circle:
+* const dial = Arc.circular({ center: Vector2.make(200, 200), radius: 80 })
+* ```
+*/
+const circular = circular$1;
+const equals = equals$1;
+/**
+* Computes the point where the arc starts,
+* `center + radius * (cos(startAngle), sin(startAngle))`.
+*
+* @param a - The arc.
+* @returns The arc's first point.
+* @since 2.0.0
+*/
+const startPoint = startPoint$1;
+/**
+* Computes the point where the arc ends, evaluated at
+* `startAngle + sweep`.
+*
+* On a full-turn arc the result lands within rounding of `startPoint`,
+* not bitwise on it — the trig re-evaluates a full period away. `toPathData`
+* closes full circles on the exact starting coordinates instead.
+*
+* @param a - The arc.
+* @returns The arc's last point.
+* @since 2.0.0
+*/
+const endPoint = endPoint$1;
+const solve = solve$1;
+/**
+* Computes the arc's length, `radius * abs(sweep)`. Exact, in closed form
+* — no tolerance parameter and no iteration, unlike arc length on a
+* lowered path. A sweep past one full turn counts every traversal.
+*
+* @param a - The arc.
+* @returns The length of the arc.
+* @since 2.0.0
+*/
+const length = length$1;
+/**
+* Reverses the arc's direction: the same points traced the other way.
+* The start angle moves to the far end and the sweep negates, so
+* `solve(reverse(a), t)` is `solve(a, 1 - t)`.
+*
+* @param a - The arc.
+* @returns A new `Circular` arc tracing the input backward.
+* @since 2.0.0
+*/
+const reverse = reverse$1;
+/**
+* Computes the exact axis-aligned bounding box of the arc.
+*
+* Extremes occur only at the endpoints or where the arc crosses an axis
+* direction (a multiple of `pi / 2`), so every side is evaluated in
+* closed form — exact up to IEEE 754 rounding, with no tolerance
+* parameter. Contrast `RationalCubicPath2d.boundingBox`, which is tight
+* only to a tolerance you choose. A zero-radius arc's box collapses to
+* `center`.
+*
+* @param a - The arc.
+* @returns A closed `Interval2d` enclosing exactly the arc's points.
+* @since 2.0.0
+*/
+const boundingBox = boundingBox$1;
+/**
+* Constructs the arc as a `RationalCubicPath2d`, exact up to IEEE 754
+* rounding — the same construction `CoordinateSystem.arc` uses: rational
+* cubic segments of at most a quarter turn each, uniform in angle, with a
+* sweep past one full turn tracing the circle more than once.
+*
+* The path is the form to transform: circles are not closed under affine
+* maps, but rational cubics are, so lower first and apply
+* `RationalCubicPath2d.transform` to the result.
+*
+* @param a - The arc.
+* @returns The arc as a `RationalCubicPath2d`.
+* @since 2.0.0
+* @example
+* ```ts
+* // A quarter-turn fillet of radius 8 as one exact rational segment:
+* const path = Arc.toPath(
+*   Arc.circular({
+*     center: Vector2.make(50, 50),
+*     radius: 8,
+*     startAngle: -Math.PI / 2,
+*     sweep: Math.PI / 2,
+*   }),
+* )
+* ```
+*/
+const toPath = toPath$1;
+/**
+* Emits exact SVG path data for the arc, using `A` commands computed from
+* the arc's description rather than recovered from curve coefficients.
+* Pieces stay at or under a half turn, so the large-arc flag is always
+* `0`; the sweep flag is `1` for a positive sweep, which renders
+* clockwise in an SVG viewport's y-down coordinates.
+*
+* Degenerate contracts:
+* - zero sweep, or radius `0`: an `M` command alone, which renders
+*   nothing
+* - a full-turn sweep: the circle as two half-turn `A` commands, closing
+*   on the exact starting coordinates
+* - a sweep past one full turn: clamped to one circle, where `toPath`
+*   keeps going around — SVG path data cannot express multiple laps
+*
+* @param a - The arc.
+* @returns The SVG path data string.
+* @since 2.0.0
+* @example
+* ```ts
+* // d attribute for a gauge tick at 12 o'clock, ready for <path d={...}>:
+* const d = Arc.toPathData(
+*   Arc.circular({
+*     center: Vector2.make(200, 200),
+*     radius: 120,
+*     startAngle: -Math.PI / 2,
+*     sweep: Math.PI / 6,
+*   }),
+* )
+* ```
+*/
+const toPathData = toPathData$1;
+//#endregion
+export { arc_exports as Arc };
+
+//# sourceMappingURL=index.mjs.map

package/dist/arc/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["internal.isCircular","internal.circular","internal.equals","internal.startPoint","internal.endPoint","internal.solve","internal.length","internal.reverse","internal.boundingBox","internal.toPath","internal.toPathData"],"sources":["../../src/arc/arc.ts"],"sourcesContent":["import type { Closed } from '../interval/interval.ts'\nimport type { Interval2d } from '../interval/interval2d.ts'\nimport type { RationalCubicPath2d } from '../path/rationalCubic2d.ts'\nimport type { Pipeable } from '../utils.ts'\nimport type { Vector2 } from '../vector/vector2.ts'\nimport type { ArcTypeId } from './arc.internal.ts'\nimport * as internal from './arc.internal.ts'\n\n/**\n * A circular arc: the points `center + radius * (cos(a), sin(a))` for `a`\n * running from `startAngle` to `startAngle + sweep`.\n *\n * An authoring representation, like the spline modules: describe the arc\n * here, query its closed-form geometry (`solve`, `length`, `boundingBox`),\n * and lower it with `toPath` for curve math or `toPathData` for SVG. The\n * description keeps answers the lowered form loses — arc length and\n * point-at-parameter are exact one-liners here and numeric iterations\n * there.\n *\n * Angles are in radians, measured from the `+x` direction, positive\n * rotating `+x` toward `+y` — clockwise in an SVG viewport's y-down\n * coordinates. Direction and multiplicity live in the sweep's sign and\n * magnitude: a negative sweep runs the other way, and a magnitude past\n * `2 * pi` keeps going around the circle.\n *\n * All fields are readonly. No operation mutates an arc.\n *\n * @since 2.0.0\n */\nexport interface Circular extends Pipeable {\n  readonly [ArcTypeId]: ArcTypeId\n  readonly kind: 'circular'\n  /**\n   * The cartesian center of the circle the arc lies on.\n   */\n  readonly center: Vector2\n  /**\n   * The circle's radius. Non-negative; `0` is a valid degenerate arc that\n   * never leaves `center`.\n   */\n  readonly radius: number\n  /**\n   * The angle where the arc starts, in radians from the `+x` direction,\n   * positive rotating `+x` toward `+y`.\n   */\n  readonly startAngle: number\n  /**\n   * The signed angular extent, in radians. Positive rotates `+x` toward\n   * `+y`; a magnitude past `2 * pi` traces the circle more than once.\n   */\n  readonly sweep: number\n}\n\n/**\n * Configuration for `circular`. Only `radius` is required; the defaults\n * give a full circle around the origin.\n *\n * @since 2.0.0\n */\nexport interface CircularConfig {\n  /**\n   * The cartesian center of the circle. Defaults to the origin.\n   */\n  readonly center?: Vector2\n  /**\n   * The circle's radius. Must be finite and non-negative.\n   */\n  readonly radius: number\n  /**\n   * The angle where the arc starts, in radians from the `+x` direction,\n   * positive rotating `+x` toward `+y`. Defaults to `0` (3 o'clock on\n   * screen).\n   */\n  readonly startAngle?: number\n  /**\n   * The signed angular extent, in radians. Defaults to `2 * pi`, a full\n   * circle.\n   */\n  readonly sweep?: number\n}\n\n/**\n * Checks if a value is a `Circular` arc.\n *\n * @param v - The value to check.\n * @returns `true` if the value is a `Circular` arc, `false` otherwise.\n * @since 2.0.0\n */\nexport const isCircular: (v: unknown) => v is Circular = internal.isCircular\n\n/**\n * Creates a `Circular` arc.\n *\n * @param config - Center, radius, start angle, and sweep. Only `radius` is\n *   required; see `CircularConfig` for the defaults.\n * @returns A new `Circular` arc.\n * @throws `Error` when `radius` is negative, or when `radius`,\n *   `startAngle`, or `sweep` is not finite.\n * @since 2.0.0\n * @example\n * ```ts\n * // A quarter circle of radius 100 from 3 o'clock to 6 o'clock:\n * const quarter = Arc.circular({ radius: 100, sweep: Math.PI / 2 })\n *\n * // Omitting sweep gives the full circle:\n * const dial = Arc.circular({ center: Vector2.make(200, 200), radius: 80 })\n * ```\n */\nexport const circular: (config: CircularConfig) => Circular = internal.circular\n\nexport const equals: {\n  /**\n   * Checks two `Circular` arcs for equality, field by field. Numeric\n   * fields compare within the tolerance of `coincident` from\n   * `curvy/number`.\n   *\n   * Comparison is structural, not geometric: two arcs tracing the same\n   * points from different descriptions — a start angle shifted by\n   * `2 * pi`, or the reverse direction — compare unequal.\n   *\n   * @param a - The first arc.\n   * @param b - The second arc.\n   * @returns `true` if the arcs are equal, `false` otherwise.\n   * @since 2.0.0\n   */\n  (a: Circular, b: Circular): boolean\n  /**\n   * Checks two `Circular` arcs for equality.\n   *\n   * @param b - The arc to compare against.\n   * @returns A function that takes an arc and returns whether the two are\n   *   equal.\n   * @since 2.0.0\n   */\n  (b: Circular): (a: Circular) => boolean\n} = internal.equals\n\n/**\n * Computes the point where the arc starts,\n * `center + radius * (cos(startAngle), sin(startAngle))`.\n *\n * @param a - The arc.\n * @returns The arc's first point.\n * @since 2.0.0\n */\nexport const startPoint: (a: Circular) => Vector2 = internal.startPoint\n\n/**\n * Computes the point where the arc ends, evaluated at\n * `startAngle + sweep`.\n *\n * On a full-turn arc the result lands within rounding of `startPoint`,\n * not bitwise on it — the trig re-evaluates a full period away. `toPathData`\n * closes full circles on the exact starting coordinates instead.\n *\n * @param a - The arc.\n * @returns The arc's last point.\n * @since 2.0.0\n */\nexport const endPoint: (a: Circular) => Vector2 = internal.endPoint\n\nexport const solve: {\n  /**\n   * Evaluates the arc at parameter `t`, the point at angle\n   * `startAngle + t * sweep`.\n   *\n   * The uniform parameter is also the arc-length parameter: equal steps\n   * in `t` cover equal distance along the arc, a property polynomial\n   * curves lack. `t` is not clamped — values outside `[0, 1]` continue\n   * around the circle.\n   *\n   * @param a - The arc to evaluate.\n   * @param t - The parameter. `0` is the start of the arc, `1` the end.\n   * @returns The point on the arc at parameter `t`.\n   * @since 2.0.0\n   * @example\n   * ```ts\n   * // The midpoint of a quarter arc sits at 45 degrees:\n   * Arc.solve(Arc.circular({ radius: 1, sweep: Math.PI / 2 }), 0.5)\n   * // (cos(pi / 4), sin(pi / 4))\n   * ```\n   */\n  (a: Circular, t: number): Vector2\n  /**\n   * Evaluates the arc at parameter `t`.\n   *\n   * @param t - The parameter. `0` is the start of the arc, `1` the end.\n   * @returns A function that takes an arc and returns the point at `t`.\n   * @since 2.0.0\n   */\n  (t: number): (a: Circular) => Vector2\n} = internal.solve\n\n/**\n * Computes the arc's length, `radius * abs(sweep)`. Exact, in closed form\n * — no tolerance parameter and no iteration, unlike arc length on a\n * lowered path. A sweep past one full turn counts every traversal.\n *\n * @param a - The arc.\n * @returns The length of the arc.\n * @since 2.0.0\n */\nexport const length: (a: Circular) => number = internal.length\n\n/**\n * Reverses the arc's direction: the same points traced the other way.\n * The start angle moves to the far end and the sweep negates, so\n * `solve(reverse(a), t)` is `solve(a, 1 - t)`.\n *\n * @param a - The arc.\n * @returns A new `Circular` arc tracing the input backward.\n * @since 2.0.0\n */\nexport const reverse: (a: Circular) => Circular = internal.reverse\n\n/**\n * Computes the exact axis-aligned bounding box of the arc.\n *\n * Extremes occur only at the endpoints or where the arc crosses an axis\n * direction (a multiple of `pi / 2`), so every side is evaluated in\n * closed form — exact up to IEEE 754 rounding, with no tolerance\n * parameter. Contrast `RationalCubicPath2d.boundingBox`, which is tight\n * only to a tolerance you choose. A zero-radius arc's box collapses to\n * `center`.\n *\n * @param a - The arc.\n * @returns A closed `Interval2d` enclosing exactly the arc's points.\n * @since 2.0.0\n */\nexport const boundingBox: (a: Circular) => Interval2d<Closed, Closed> = internal.boundingBox\n\n/**\n * Constructs the arc as a `RationalCubicPath2d`, exact up to IEEE 754\n * rounding — the same construction `CoordinateSystem.arc` uses: rational\n * cubic segments of at most a quarter turn each, uniform in angle, with a\n * sweep past one full turn tracing the circle more than once.\n *\n * The path is the form to transform: circles are not closed under affine\n * maps, but rational cubics are, so lower first and apply\n * `RationalCubicPath2d.transform` to the result.\n *\n * @param a - The arc.\n * @returns The arc as a `RationalCubicPath2d`.\n * @since 2.0.0\n * @example\n * ```ts\n * // A quarter-turn fillet of radius 8 as one exact rational segment:\n * const path = Arc.toPath(\n *   Arc.circular({\n *     center: Vector2.make(50, 50),\n *     radius: 8,\n *     startAngle: -Math.PI / 2,\n *     sweep: Math.PI / 2,\n *   }),\n * )\n * ```\n */\nexport const toPath: (a: Circular) => RationalCubicPath2d = internal.toPath\n\n/**\n * Emits exact SVG path data for the arc, using `A` commands computed from\n * the arc's description rather than recovered from curve coefficients.\n * Pieces stay at or under a half turn, so the large-arc flag is always\n * `0`; the sweep flag is `1` for a positive sweep, which renders\n * clockwise in an SVG viewport's y-down coordinates.\n *\n * Degenerate contracts:\n * - zero sweep, or radius `0`: an `M` command alone, which renders\n *   nothing\n * - a full-turn sweep: the circle as two half-turn `A` commands, closing\n *   on the exact starting coordinates\n * - a sweep past one full turn: clamped to one circle, where `toPath`\n *   keeps going around — SVG path data cannot express multiple laps\n *\n * @param a - The arc.\n * @returns The SVG path data string.\n * @since 2.0.0\n * @example\n * ```ts\n * // d attribute for a gauge tick at 12 o'clock, ready for <path d={...}>:\n * const d = Arc.toPathData(\n *   Arc.circular({\n *     center: Vector2.make(200, 200),\n *     radius: 120,\n *     startAngle: -Math.PI / 2,\n *     sweep: Math.PI / 6,\n *   }),\n * )\n * ```\n */\nexport const toPathData: (a: Circular) => string = internal.toPathData\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwFA,MAAa,aAA4CA;;;;;;;;;;;;;;;;;;;AAoBzD,MAAa,WAAiDC;AAE9D,MAAa,SAyBTC;;;;;;;;;AAUJ,MAAa,aAAuCC;;;;;;;;;;;;;AAcpD,MAAa,WAAqCC;AAElD,MAAa,QA8BTC;;;;;;;;;;AAWJ,MAAa,SAAkCC;;;;;;;;;;AAW/C,MAAa,UAAqCC;;;;;;;;;;;;;;;AAgBlD,MAAa,cAA2DC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BxE,MAAa,SAA+CC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiC5D,MAAa,aAAsCC"}

package/dist/characteristic/index.mjs

@@ -1,2 +1,2 @@
-import { n as characteristic_exports } from "../shared/characteristic-CL3bnjgJ.mjs";
+import { n as characteristic_exports } from "../shared/characteristic-OjEkAZBA.mjs";
 export { characteristic_exports as Characteristic };