@altpsyche/maths 0.11.0 → 0.13.0

package/dist/figure/annotate.js

@@ -2,10 +2,11 @@
  * The shapes an annotation is made of, composed from marks rather than being
  * marks of their own.
  *
- * Each one hands back a group, so an arrow is a shaft and a head with ids of
+ * A builder hands back a group, so an arrow is a shaft and a head with ids of
  * their own and an animation naming the arrow reaches both. Making an arrow a
  * single mark instead would mean one path that is stroked along its shaft and
- * filled at its head, and no mark can be both.
+ * filled at its head, and no mark can be both. `bracePath` is the one call here
+ * that hands back a path, for a figure that wants the outline and not the group.
  */
 import { vec2 } from '../values/vec2.js';
 import { circle, line, polygon, straight } from './path.js';

package/dist/figure/axis.js

@@ -12,7 +12,7 @@ import { vec2 } from '../values/vec2.js';
 import { line, polygon } from './path.js';
 import { group, shape, text } from './node.js';
 import { multiplesOn, tickStep, ticksOn } from './ticks.js';
-import { scaled } from './scale.js';
+import { toUnits } from './scale.js';
 /** A head pointing along the line, apex at the end and base back along it. */
 function head(apex, back, spread) {
     const along = vec2.normalize(vec2.sub(apex, back));
@@ -37,11 +37,8 @@ export function numberLine(name, scale, options) {
     const gap = options.gap ?? size * 0.35;
     const { from: low, to: high } = interval.ordered(scale.units);
     const at = (along, off) => (across ? vec2(along, seat + off) : vec2(seat + off, along));
-    // The line runs the whole of the axis and each head stands beyond its end,
-    // rather than the heads eating into the line. Eating in leaves the outermost
-    // tick standing under a head instead of on the line, and the line still stops
-    // where a head begins, so a head that is not fully opaque has nothing showing
-    // through it.
+    // Each head stands beyond the line's end, or the outermost tick stands under a head instead of on
+    // the line. The line stops where a head begins, so a head that is not opaque shows nothing through.
     const parts = [shape('line', line(at(low, 0), at(high, 0)), { stroke: options.stroke })];
     if (tip > 0 && options.fill) {
         const spread = options.spread ?? 0.6;
@@ -91,7 +88,7 @@ export function numberLine(name, scale, options) {
  */
 export function axes(name, coords, options) {
     const holdsOrigin = interval.holds(coords.x.graph, 0) && interval.holds(coords.y.graph, 0);
-    const seat = (scale) => scaled(scale, interval.clampTo(scale.graph, 0));
+    const seat = (scale) => toUnits(scale, interval.clampTo(scale.graph, 0));
     return group(name, [
         numberLine('x', coords.x, {
             ...options,
@@ -116,7 +113,7 @@ function gridLines(coords, step, along, skipping) {
     return multiplesOn(scale.graph, step)
         .filter((value) => !(skipping && onStep(value, skipping)))
         .map((value) => {
-        const [from, to] = ends(scaled(scale, value));
+        const [from, to] = ends(toUnits(scale, value));
         return shape(String(value), line(from, to), {});
     });
 }

package/dist/figure/axis3.d.ts

@@ -31,6 +31,14 @@ export interface Axes3Options {
     tickLength?: number;
     /** From the projected tick to the label's own anchor, in figure units. */
     gap?: number;
+    /** What each axis is called, written past its far end. An axis this does not
+     * name carries no name, and nothing is written at all without a `fill` and a
+     * `size`. */
+    names?: {
+        x?: string;
+        y?: string;
+        z?: string;
+    };
     family?: string;
     weight?: number;
 }

package/dist/figure/axis3.js

@@ -42,6 +42,19 @@ function oneAxis(which, bounds, camera, options) {
     const origin = camera.project(vec3.ZERO).at;
     const parts = [polyline3('line', [at(low), at(high)], camera, { stroke: options.stroke })];
     parts.push(group('ticks', marked.map((tick) => polyline3(tick.label, [vec3.sub(at(tick.value), vec3.scale(across, half)), vec3.add(at(tick.value), vec3.scale(across, half))], camera, { stroke: options.stroke }))));
+    const name = options.names?.[which];
+    if (options.fill && size > 0 && name !== undefined) {
+        // Set beyond the label of the last tick, which stands at the same point and
+        // leans the same way, so the two would be written over each other.
+        parts.push(text3('name', at(high), name, size, camera, {
+            fill: options.fill,
+            family: options.family,
+            weight: options.weight,
+            align: 'middle',
+            baseline: 'middle',
+            offset: leaning(origin, camera.project(at(high)).at, gap + size),
+        }));
+    }
     if (options.fill && size > 0) {
         // The three lines cross at the origin, so only one of them writes the number
         // there and the other two would write it again in the same place.

package/dist/figure/boolean.js

@@ -20,7 +20,7 @@
  * outside an overlap, and a difference keeps the first path's copy of it.
  */
 import { vec2 } from '../values/vec2.js';
-import { pointOn, slopeOn } from './path.js';
+import { pointOn, tangentOn } from './path.js';
 import { cutPath } from './cut.js';
 import { curveCrossings } from './intersect.js';
 import { flattenPath, nearestEdge, windingAt } from './inside.js';
@@ -160,7 +160,7 @@ function sidesAgainst(pieces, other, tolerance) {
         const middle = pointOn(piece.from, piece.curve, 0.5);
         const edge = nearestEdge(other, middle);
         if (edge && edge.gap <= tolerance) {
-            return vec2.dot(slopeOn(piece.from, piece.curve, 0.5), edge.heading) >= 0 ? 'along' : 'against';
+            return vec2.dot(tangentOn(piece.from, piece.curve, 0.5), edge.heading) >= 0 ? 'along' : 'against';
         }
         return windingAt(other, middle) !== 0 ? 'inside' : 'outside';
     });

package/dist/figure/equation.d.ts

@@ -14,7 +14,7 @@ export interface Equation {
     readonly marks: readonly PathMark[];
     readonly box: EquationBox;
 }
-export declare function equationMarks(root: EquationElement): Equation;
+export declare function equationOf(root: EquationElement): Equation;
 /** One expression typeset and read, which is the two halves above in the order
  * they are always used in. */
 export declare function equationFromTex(tex: string): Promise<Equation>;

package/dist/figure/equation.js

@@ -125,7 +125,7 @@ function boxOf(svg) {
     const [x = 0, y = 0, width = 0, height = 0] = numbers;
     return { x, y: -(y + height), width, height };
 }
-export function equationMarks(root) {
+export function equationOf(root) {
     const svg = svgOf(root);
     const marks = [];
     const mark = (path, stack, suffix) => {
@@ -157,7 +157,7 @@ export function equationMarks(root) {
 /** One expression typeset and read, which is the two halves above in the order
  * they are always used in. */
 export async function equationFromTex(tex) {
-    return equationMarks(await typesetElement(tex));
+    return equationOf(await typesetElement(tex));
 }
 /**
  * A typeset expression placed in a figure: one shape per glyph, fitted inside a

package/dist/figure/field.d.ts

@@ -31,12 +31,12 @@ export interface VectorFieldOptions {
         x: number;
         y: number;
     };
-    /** The run of x sampled, which is the whole width of the graph where it is
-     * left out. */
-    overX?: Interval;
-    /** The run of y sampled, which is the whole height of the graph where it is
-     * left out. */
-    overY?: Interval;
+    /** The runs sampled, each the whole of the graph that way where it is left
+     * out. */
+    over?: {
+        x?: Interval;
+        y?: Interval;
+    };
     /** How long a head is, in figure units. Four times the shaft's width unless
      * named, which is what an arrow takes when nothing says. */
     head?: number;

package/dist/figure/field.js

@@ -16,11 +16,9 @@
 import { interval } from '../values/interval.js';
 import { vec2 } from '../values/vec2.js';
 import { pointOf } from './scale.js';
+import { stepsOf } from './grid.js';
 import { group } from './node.js';
 import { arrow } from './annotate.js';
-function stepsOf(resolution) {
-    return typeof resolution === 'number' ? { x: resolution, y: resolution } : resolution;
-}
 /**
  * The arrows of a field over a graph, one group per sample, named by its column
  * and row so a stagger can reach them one at a time.
@@ -40,9 +38,10 @@ function stepsOf(resolution) {
  * pointing the other, at the same magnitude.
  */
 export function vectorField(name, coords, of, options) {
-    const steps = stepsOf(options.resolution ?? 12);
-    const overX = interval.ordered(options.overX ?? coords.x.graph);
-    const overY = interval.ordered(options.overY ?? coords.y.graph);
+    const steps = stepsOf(options.resolution ?? 12, 'x', 'y');
+    const over = options.over ?? {};
+    const overX = interval.ordered(over.x ?? coords.x.graph);
+    const overY = interval.ordered(over.y ?? coords.y.graph);
     const children = [];
     for (let column = 0; column < steps.x; column += 1) {
         for (let row = 0; row < steps.y; row += 1) {

package/dist/figure/field3.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A field of vectors in space, drawn as an arrow at every sample.
+ *
+ * An arrow is measured in the world's own units rather than the figure's, unlike
+ * the arrows of a flat field, because a length in space is what perspective is
+ * for. Its head stays in figure units, since the head is drawn on the page.
+ */
+import { type Interval } from '../values/interval.js';
+import { type Vec3 } from '../values/vec3.js';
+import type { Colour } from './mark.js';
+import type { ArrowOptions } from './annotate.js';
+import type { Camera3 } from './camera.js';
+import { type SpaceItem } from './space.js';
+import type { GroupNode } from './node.js';
+export type VectorField3Options = ArrowOptions & {
+    /** The box the samples are taken in, nothing to one each way unless named. */
+    over?: {
+        x?: Interval;
+        y?: Interval;
+        z?: Interval;
+    };
+    /** How many samples each way. One number is all three. */
+    resolution?: number | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** How long an arrow is, in the world's own units, from the magnitude of the
+     * vector at its own sample. */
+    lengthOf: (magnitude: number) => number;
+    /** What colour an arrow is, from that same magnitude. */
+    colourFor: (magnitude: number) => Colour;
+};
+/**
+ * The arrows of a field sampled over a box in space, and the points each was
+ * drawn from, for a figure that sorts them among pieces of its own.
+ *
+ * An arrow is measured in the world's own units rather than the figure's, unlike
+ * the arrows of a flat field, because a length in space is what perspective is
+ * for: a far arrow drawing shorter than a near one of the same magnitude is what
+ * says which is far. Its head is still in figure units, since the head is drawn
+ * on the page.
+ *
+ * A sample sits at the middle of its cell and the count is fixed by the
+ * resolution, so a gate can hold it as the eye moves. A sample whose vector is
+ * nothing draws no arrow there.
+ */
+export declare function fieldArrows3(name: string, of: (at: Vec3) => Vec3, camera: Camera3, options: VectorField3Options): SpaceItem[];
+/** A field of vectors in space, drawn as arrows ordered back to front. */
+export declare function vectorField3(name: string, of: (at: Vec3) => Vec3, camera: Camera3, options: VectorField3Options): GroupNode;

package/dist/figure/field3.js

@@ -0,0 +1,60 @@
+/**
+ * A field of vectors in space, drawn as an arrow at every sample.
+ *
+ * An arrow is measured in the world's own units rather than the figure's, unlike
+ * the arrows of a flat field, because a length in space is what perspective is
+ * for. Its head stays in figure units, since the head is drawn on the page.
+ */
+import { interval } from '../values/interval.js';
+import { vec3 } from '../values/vec3.js';
+import { stepsOf } from './grid.js';
+import { arrow3, scene3 } from './space.js';
+/**
+ * The arrows of a field sampled over a box in space, and the points each was
+ * drawn from, for a figure that sorts them among pieces of its own.
+ *
+ * An arrow is measured in the world's own units rather than the figure's, unlike
+ * the arrows of a flat field, because a length in space is what perspective is
+ * for: a far arrow drawing shorter than a near one of the same magnitude is what
+ * says which is far. Its head is still in figure units, since the head is drawn
+ * on the page.
+ *
+ * A sample sits at the middle of its cell and the count is fixed by the
+ * resolution, so a gate can hold it as the eye moves. A sample whose vector is
+ * nothing draws no arrow there.
+ */
+export function fieldArrows3(name, of, camera, options) {
+    const { over = {}, resolution = 6, lengthOf, colourFor, ...rest } = options;
+    const box = {
+        x: interval.ordered(over.x ?? interval(0, 1)),
+        y: interval.ordered(over.y ?? interval(0, 1)),
+        z: interval.ordered(over.z ?? interval(0, 1)),
+    };
+    const steps = stepsOf(resolution, 'x', 'y', 'z');
+    const items = [];
+    for (let i = 0; i < steps.x; i += 1) {
+        for (let j = 0; j < steps.y; j += 1) {
+            for (let k = 0; k < steps.z; k += 1) {
+                const from = vec3(interval.at(box.x, (i + 0.5) / steps.x), interval.at(box.y, (j + 0.5) / steps.y), interval.at(box.z, (k + 0.5) / steps.z));
+                const vector = of(from);
+                const magnitude = vec3.magnitude(vector);
+                const length = lengthOf(magnitude);
+                if (!(magnitude > 0) || !Number.isFinite(length) || !(length > 0))
+                    continue;
+                const to = vec3.add(from, vec3.scale(vector, length / magnitude));
+                items.push({
+                    points: [from, to],
+                    node: arrow3(`${name}/${i}-${j}-${k}`, from, to, camera, {
+                        ...rest,
+                        stroke: { ...rest.stroke, colour: colourFor(magnitude) },
+                    }),
+                });
+            }
+        }
+    }
+    return items;
+}
+/** A field of vectors in space, drawn as arrows ordered back to front. */
+export function vectorField3(name, of, camera, options) {
+    return scene3(name, fieldArrows3('arrow', of, camera, options), camera);
+}

package/dist/figure/figure.d.ts

@@ -19,13 +19,13 @@ import type { Mark } from './mark.js';
  * is what lets geometry follow a number rather than only be moved about: a
  * radius that is keyed makes a circle that is genuinely a different circle each
  * frame. */
-export type Values = Record<string, TrackValue>;
+export type TrackValues = Record<string, TrackValue>;
 export interface Figure {
     /** How much of the world the figure shows, in its own units. */
     extent: ExtentChoice;
     fit?: Fit;
     /** The tree, either fixed or rebuilt from the clock and the sampled values. */
-    scene: Node | ((seconds: number, values: Values) => Node);
+    scene: Node | ((seconds: number, values: TrackValues) => Node);
     tracks?: Tracks;
     timeline?: Timeline;
     /** Overrides the timeline's own length, for a figure that should hold after
@@ -44,7 +44,7 @@ export interface Figure {
 }
 export declare function durationOf(figure: Figure): number;
 /** The marks a figure shows at a time. */
-export declare function at(figure: Figure, seconds: number): readonly Mark[];
+export declare function marksAt(figure: Figure, seconds: number): readonly Mark[];
 /**
  * The matrix a painter needs at a time, in one call.
  *
@@ -58,6 +58,6 @@ export declare function viewAt(figure: Figure, seconds: number, width: number, h
  * behind that flag. The comparison is by tolerance rather than exactly, because
  * the sine and cosine a figure is built from are not specified to the last bit
  * and differ between engines. */
-export declare function loops(figure: Figure, tolerance?: number): boolean;
+export declare function isLoop(figure: Figure, tolerance?: number): boolean;
 /** Two lists holding the same marks in the same order, to a tolerance. */
 export declare function sameMarks(one: readonly Mark[], two: readonly Mark[], tolerance?: number): boolean;

package/dist/figure/figure.js

@@ -16,7 +16,7 @@ export function durationOf(figure) {
     return figure.duration ?? figure.timeline?.duration ?? 0;
 }
 /** The marks a figure shows at a time. */
-export function at(figure, seconds) {
+export function marksAt(figure, seconds) {
     const values = figure.tracks ? sampleTracks(figure.tracks, seconds) : {};
     const tree = typeof figure.scene === 'function' ? figure.scene(seconds, values) : figure.scene;
     const marks = flatten(tree);
@@ -38,9 +38,9 @@ export function viewAt(figure, seconds, width, height) {
  * behind that flag. The comparison is by tolerance rather than exactly, because
  * the sine and cosine a figure is built from are not specified to the last bit
  * and differ between engines. */
-export function loops(figure, tolerance = 1e-6) {
-    const start = at(figure, 0);
-    const end = at(figure, durationOf(figure));
+export function isLoop(figure, tolerance = 1e-6) {
+    const start = marksAt(figure, 0);
+    const end = marksAt(figure, durationOf(figure));
     return sameMarks(start, end, tolerance);
 }
 /** Two lists holding the same marks in the same order, to a tolerance. */

package/dist/figure/frames.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A figure walked at a fixed step, a frame at a time.
+ *
+ * A frame is the marks and the view read at one time, handed over together. A
+ * consumer that asked for them separately holds two calls it can pass different
+ * times, and a figure whose view moves then paints its marks through the matrix
+ * of some other moment.
+ *
+ * Frames come back one at a time rather than as a list. A ten second figure at
+ * sixty frames a second is six hundred frames of every mark it draws, and a
+ * recorder encodes a frame and throws it away.
+ */
+import { type Figure } from './figure.js';
+import type { Mark } from './mark.js';
+import type { Mat3 } from '../values/mat3.js';
+export interface Frame {
+    /** Its place in the walk, counting from nothing. */
+    index: number;
+    /** The time it was read at, in seconds. */
+    seconds: number;
+    marks: readonly Mark[];
+    /** The matrix a painter needs for these marks, built at this frame's own
+     * time. */
+    view: Mat3;
+}
+/**
+ * How the walk is stepped, as a rate or as a count.
+ *
+ * The two are different questions. A recorder knows how fast the frames play and
+ * needs a step of exactly one over that, or the encoded video drifts from the
+ * figure's own clock. A strip knows how many pictures fit across a page and wants
+ * them spread over the whole figure.
+ */
+export type FrameStep = {
+    fps: number;
+    frames?: never;
+} | {
+    frames: number;
+    fps?: never;
+};
+export type FramesOptions = FrameStep & {
+    /** The surface the view is built for, in whatever units a painter counts in. */
+    width: number;
+    height: number;
+};
+/**
+ * The times a walk reads, which a recorder needs before it has drawn anything to
+ * say how far along it is.
+ *
+ * A walk stops strictly before the duration. The frame at the duration of a
+ * figure that loops is its own first frame, and a recording would show it twice.
+ * A figure with no duration is one frame, since a picture that never moves still
+ * has a picture.
+ */
+export declare function frameTimesOf(figure: Figure, step: FrameStep): number[];
+/** A figure walked at a fixed step, a frame at a time. */
+export declare function framesOf(figure: Figure, options: FramesOptions): Generator<Frame>;

package/dist/figure/frames.js

@@ -0,0 +1,43 @@
+/**
+ * A figure walked at a fixed step, a frame at a time.
+ *
+ * A frame is the marks and the view read at one time, handed over together. A
+ * consumer that asked for them separately holds two calls it can pass different
+ * times, and a figure whose view moves then paints its marks through the matrix
+ * of some other moment.
+ *
+ * Frames come back one at a time rather than as a list. A ten second figure at
+ * sixty frames a second is six hundred frames of every mark it draws, and a
+ * recorder encodes a frame and throws it away.
+ */
+import { marksAt, durationOf, viewAt } from './figure.js';
+/**
+ * The times a walk reads, which a recorder needs before it has drawn anything to
+ * say how far along it is.
+ *
+ * A walk stops strictly before the duration. The frame at the duration of a
+ * figure that loops is its own first frame, and a recording would show it twice.
+ * A figure with no duration is one frame, since a picture that never moves still
+ * has a picture.
+ */
+export function frameTimesOf(figure, step) {
+    const duration = durationOf(figure);
+    const count = step.fps === undefined
+        ? Math.max(1, Math.round(step.frames))
+        : Math.max(1, Math.round(duration * step.fps));
+    const gap = step.fps === undefined ? duration / count : 1 / step.fps;
+    return Array.from({ length: count }, (_, index) => index * gap);
+}
+/** A figure walked at a fixed step, a frame at a time. */
+export function* framesOf(figure, options) {
+    const times = frameTimesOf(figure, options);
+    for (let index = 0; index < times.length; index += 1) {
+        const seconds = times[index];
+        yield {
+            index,
+            seconds,
+            marks: marksAt(figure, seconds),
+            view: viewAt(figure, seconds, options.width, options.height),
+        };
+    }
+}

package/dist/figure/grid.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The sampling a surface and a section share: how many steps a resolution asks
+ * for, and where the corners of that grid land.
+ *
+ * A cell reads its four corners out of the grid rather than working each of them
+ * out again. Four cells meet at every inside corner, so computing them per cell
+ * asks the surface for the same point four times, and the surface is the
+ * caller's own function with no promise about what it costs.
+ */
+import { type Interval } from '../values/interval.js';
+import type { Vec3 } from '../values/vec3.js';
+/** A resolution given as one number is that many steps along every named way. */
+export declare function stepsOf<K extends string>(resolution: number | Record<K, number>, ...ways: readonly K[]): Record<K, number>;
+/** The corners of a grid over a surface, taking both edges of each run, so a
+ * grid of n by m cells is n + 1 by m + 1 corners. */
+export declare function cornersOf(of: (u: number, v: number) => Vec3, u: Interval, v: Interval, steps: {
+    u: number;
+    v: number;
+}): Vec3[][];

package/dist/figure/grid.js

@@ -0,0 +1,32 @@
+/**
+ * The sampling a surface and a section share: how many steps a resolution asks
+ * for, and where the corners of that grid land.
+ *
+ * A cell reads its four corners out of the grid rather than working each of them
+ * out again. Four cells meet at every inside corner, so computing them per cell
+ * asks the surface for the same point four times, and the surface is the
+ * caller's own function with no promise about what it costs.
+ */
+import { interval } from '../values/interval.js';
+/** A resolution given as one number is that many steps along every named way. */
+export function stepsOf(resolution, ...ways) {
+    if (typeof resolution !== 'number')
+        return resolution;
+    const steps = {};
+    for (const way of ways)
+        steps[way] = resolution;
+    return steps;
+}
+/** The corners of a grid over a surface, taking both edges of each run, so a
+ * grid of n by m cells is n + 1 by m + 1 corners. */
+export function cornersOf(of, u, v, steps) {
+    const grid = [];
+    for (let i = 0; i <= steps.u; i += 1) {
+        const column = [];
+        for (let j = 0; j <= steps.v; j += 1) {
+            column.push(of(interval.at(u, i / steps.u), interval.at(v, j / steps.v)));
+        }
+        grid.push(column);
+    }
+    return grid;
+}

package/dist/figure/inside.d.ts

@@ -32,7 +32,7 @@ export declare function flattenPath(path: Path, options?: FlattenOptions): Vec2[
 export declare function windingAt(loops: readonly (readonly Vec2[])[], point: Vec2): number;
 /** The nearest straight run of a flattening to a point: how far off it is, and
  * which way that run goes. */
-export interface Edge {
+export interface FlatEdge {
     readonly gap: number;
     readonly heading: Vec2;
 }
@@ -43,7 +43,7 @@ export interface Edge {
  * near it, which the winding count cannot answer because a point on the edge
  * itself is the one place the count has no answer for.
  */
-export declare function nearestEdge(loops: readonly (readonly Vec2[])[], point: Vec2): Edge | null;
+export declare function nearestEdge(loops: readonly (readonly Vec2[])[], point: Vec2): FlatEdge | null;
 /**
  * Whether a path holds a point, under the nonzero rule.
  *

package/dist/figure/inside.js

@@ -21,10 +21,9 @@ const DEPTH = 24;
 /**
  * How many points a whole flattening may hold before it is refused.
  *
- * Halving is the only bound the depth gives, and sixteen million points for one
- * piece is a machine out of memory rather than a fine flattening. A circle of
- * radius 1 wants 4096 of these at a tolerance of a millionth, so the room here
- * is a thousandfold.
+ * Halving is the only bound the depth gives, so with no ceiling on the count a
+ * fine tolerance is a machine out of memory rather than a fine flattening. The
+ * ceiling sits far above what the finest tolerance a figure asks for reaches.
  */
 const POINTS = 1_000_000;
 /** How far the two controls sit from the straight run between the ends.

package/dist/figure/length.d.ts

@@ -33,9 +33,7 @@ export declare function measurePath(path: Path): Measure;
  * Reading the fraction of the length as the parameter is exact only where the
  * curve moves at one rate, which is a straight line. Walking the table instead
  * and interpolating inside the one sample the length lands in makes a cut by
- * length even along a curve as well: measured on a quarter circle, cutting at
- * twenty even fractions of its length was 4.7e-3 of the whole out at the worst
- * of them and is 1.4e-4 out now.
+ * length even along a curve as well.
  */
 export declare function parameterAt(measured: Measured, wanted: number): number;
 /** How long a path is, in figure units, across every subpath it holds. It reads

package/dist/figure/length.js

@@ -16,13 +16,12 @@ import { clamp } from '../values/scalar.js';
 /**
  * How many samples measure one piece.
  *
- * Sixteen chords read a quarter circle 4 parts in ten thousand short of its true
- * length, since a chord cuts the corner off the arc it spans. What the count is
- * chosen for is the evenness of a walk rather than the total, and a share of the
- * length is a ratio the shortfall largely cancels out of: measured, twenty steps
- * along a quarter circle vary by 0.36% in size at this count. Doubling it costs
- * twice the work in every cut and every walk and buys a total four times closer,
- * which nothing here has asked for.
+ * A chord cuts the corner off the arc it spans, so a total read this way is
+ * short of the true one. What the count is chosen for is the evenness of a walk
+ * rather than the total, and a share of the length is a ratio the shortfall
+ * largely cancels out of. Doubling it costs twice the work in every cut and
+ * every walk and buys a total four times closer, which nothing here has asked
+ * for.
  */
 const SAMPLES = 16;
 function measureCurve(from, curve) {
@@ -58,9 +57,7 @@ export function measurePath(path) {
  * Reading the fraction of the length as the parameter is exact only where the
  * curve moves at one rate, which is a straight line. Walking the table instead
  * and interpolating inside the one sample the length lands in makes a cut by
- * length even along a curve as well: measured on a quarter circle, cutting at
- * twenty even fractions of its length was 4.7e-3 of the whole out at the worst
- * of them and is 1.4e-4 out now.
+ * length even along a curve as well.
  */
 export function parameterAt(measured, wanted) {
     const { upTo, total } = measured;

package/dist/figure/mark.d.ts

@@ -6,8 +6,13 @@
  * two-dimensional canvas can both do, rather than the union. A figure reaching
  * for something only one of them has would look right on the page and lose it
  * without a word in a recording, which is the worst way to find out. So there
- * are no filters, no blend modes, no clipping and no gradients here, and adding
- * one means adding it to both painters in the same change.
+ * are no filters, no blend modes and no clipping here, and adding one means
+ * adding it to both painters in the same change.
+ *
+ * A gradient is refused for a different reason, since both painters draw one.
+ * SVG names a gradient with an element carrying an id and a canvas names it with
+ * an object built from the context, and a colour here is text that both take as
+ * it stands.
  */
 import type { Vec2 } from '../values/vec2.js';
 import type { Path } from './path.js';

package/dist/figure/node.js

@@ -57,9 +57,8 @@ function walk(node, prefix, transform, style, into) {
     }
     const settled = inherited(style, node);
     const opacity = settled.opacity ?? 1;
-    // A group that scales makes the lines inside it thicker, the way it makes
-    // everything else bigger, so the width travels through the same transform the
-    // geometry did rather than staying at the number the author typed.
+    // A group that scales makes the lines inside it thicker, the way it makes everything else bigger,
+    // so the width goes through the transform the geometry did rather than staying as it was typed.
     const scale = mat3.scaleFactor(transform);
     if (node.kind === 'shape') {
         if (!settled.fill && !settled.stroke)

package/dist/figure/path-data.js

@@ -139,9 +139,8 @@ export function pathFromData(d) {
     let moved = false;
     let command = '';
     let index = 0;
-    // Held per kind because an S reflects a cubic's second control and a T a
-    // quadratic's only one, and either falls back to the current point when the
-    // segment before it was neither.
+    // Held per kind because an S reflects a cubic's second control and a T a quadratic's only one, and
+    // either falls back to the current point when the segment before it was neither.
     let lastCubic;
     let lastQuadratic;
     const take = (count) => {

package/dist/figure/path.d.ts

@@ -50,7 +50,7 @@ export declare function arc(centre: Vec2, radius: number, fromAngle: number, toA
 export declare function pointOn(from: Vec2, curve: Cubic, along: number): Vec2;
 /** Which way a piece is heading at a fraction along it, which is the derivative
  * of a cubic and so a quadratic over the gaps between neighbouring points. */
-export declare function slopeOn(from: Vec2, curve: Cubic, along: number): Vec2;
+export declare function tangentOn(from: Vec2, curve: Cubic, along: number): Vec2;
 /**
  * One piece cut into two at a fraction, both pieces drawing what the whole
  * drew, by de Casteljau's construction.