@altpsyche/maths 0.9.4 → 0.10.0

package/README.md

@@ -212,23 +212,95 @@ When the pieces kept will not join into a loop, the operation stops and says how
 ends of the run it had are. That happens when an input crosses itself, which these do not take. A
 shape drawn with a gap in it and nothing said about it is the one failure a caller cannot see.
 
+## A turn about a point
+
+<img src="docs/rotate.svg" width="720" alt="Two panels side by side, each an L-shaped block turned part way round with a dot marking the point it turns about. In the left panel the dot sits at the middle of the block's own box. In the right it sits off to one side, so the block swings round it. A word rides with the block in both panels and stays upright.">
+
+`rotate(target, angle)` turns the marks a name reaches, over a span of the timeline. The point it
+turns about is the middle of the box round those marks unless a figure names one, and it is read off
+them as they arrive rather than after the turn has moved them. The box round a turned shape is not the
+turned box, so reading it back afterwards would let the pivot drift and the turn would stop being a
+turn.
+
+The left panel takes that default and spins where it stands. The right panel is given a point off to
+one side, so the same shape swings round it instead. The furthest corner of the left shape stays 1.00
+figure units from its pivot at every time and the right one's stays 2.34, which is what makes the two
+read as different motions rather than as the same one twice.
+
+A word rides with the shape in both panels and stays upright the whole way round. A mark carries no
+rotation of its own, so turning the words would be work in both painters for a label that is easier to
+read left as it is, which is the same reason a number line takes a direction rather than being turned
+on its side.
+
+A turn does not thicken a line. A stroke's width is multiplied by how much the transform stretches a
+length, and a rotation stretches nothing, where `scale` stretches by the factor it grew by.
+
+<img src="docs/rotate-strip.svg" width="820" alt="Four frames in two rows, each showing both panels, at nothing, a quarter, a half and three quarters of the way round.">
+
+The quarters of the turn. The whole turn is left off the strip because it draws the picture that
+nothing draws: this is the first figure here to declare itself a loop, and `loops(figure)` is the gate
+behind that flag, comparing the marks at the duration against the marks at zero.
+
+## A surface in space
+
+<img src="docs/surface.svg" width="720" alt="A saddle-shaped surface drawn as a grid of shaded cells, with a flat pane cutting through it at one height and the two branches of the curve where they meet drawn in orange along the surface. Three axes with their numbers stand behind it and the equation of the surface is typeset in the top left.">
+
+A figure's camera is a value the caller holds. `camera3({ eye, target, up, projection })` answers
+where a point in space lands in the figure's own units, how far off it is along the way the camera
+looks, and whether it is in front of the eye at all. `polyline3`, `dot3`, `text3` and `surface3` take
+points in space and hand back the same flat nodes everything else here draws, so `fadeIn` and `draw`
+reach a mark in space with no change to either of them. Nothing in the marks, the tree, the flattening
+or the two painters knows that space exists.
+
+`space(name, items, camera)` puts the pieces in the order they are painted, near over far. That is
+the painter's algorithm, and what it cannot do is worth knowing before it is used: two pieces that
+pass through each other have no one order at all. The answer for those is smaller pieces, which is why
+`surfaceCells` cuts a surface into a grid and why the saddle and the pane above are sorted together
+rather than one after the other.
+
+`sectionOf` finds the curve where a plane cuts a surface, by marching squares over the grid the
+surface is already drawn from. Every point it finds lies on the plane exactly, because signed distance
+to a plane changes evenly along a straight line. What it does not lie on exactly is the surface: it
+sits on the chord between two samples of it, 4.870e-4 of a unit off at the resolution the demo uses,
+and halving the cell size quarters that.
+
+The camera is driven by a track and never by an animation, which is the call the flat demo's walk
+already made: a span's eased fraction and a track's value are unrelated numbers, and a camera on one
+with a surface on the other would be two clocks free to disagree.
+
+<img src="docs/surface-strip.svg" width="820" alt="Four frames in two rows, showing the same saddle and pane from four points around one orbit of the eye.">
+
+The quarters of one orbit. The eye comes back to where it started, which the gate holds by comparing
+the marks at the end of the entrance against the marks one orbit later, mark for mark by name.
+
+## A view that follows
+
+`Extent` carries a `centre`, which is where the middle of the frame sits in figure units, and an
+extent may be a function of the shape of the surface and of the time. `viewAt(figure, seconds, width,
+height)` hands a painter its matrix at a time in one call, so a figure whose extent moves cannot be
+asked for its extent at one time and its marks at another.
+
+The flat demo's view follows its dot across. The dot stays within 1.2 figure units of the middle of
+the frame, where before it crossed 2.76. `fractionOf` reads the centre off the extent it is handed, so
+the reading and the typeset rule stay where they are on the surface while the grid slides under them:
+they drift 1.14e-15 figure units over the whole walk.
+
 ## The animations
 
 `fadeIn`, `fadeOut`, `fadeTo`, `draw`, `morph`, `morphEquation`, `countTo`, `moveBy`, `rotate`,
 `scale`, `growFrom`, `moveAlong`, `indicate`, `flash` and `circumscribe`. A `Timeline` plays them in order, plays several `together`, or
 `stagger`s a row so its parts arrive one after another.
 
-A turn and a growth happen about a point the marks decide for themselves, which is the middle of the
-box round them. `boundsOf` is that box, worked out from where each piece of the curve turns back on
-itself rather than from the points the curve is written from.
+`boundsOf` is the box a turn and a growth are worked about, found from where each piece of the curve
+turns back on itself rather than from the points the curve is written from.
 
 `moveAlong` carries a mark along a path at one speed, measured by the path's length. Even steps in a
 curve's own parameter are uneven steps along the curve: a step covers more of it where the curve is
 moving fast, which on a quarter circle is a 6.9% difference between the longest step and the shortest
 and on the demo's own walk is 82%.
 
-Both pictures are written by `svgMarkup`, which needs no browser, so `npm run demos` regenerates
-them and a test compares the bytes against the committed files.
+Every picture here is written by `svgMarkup`, which needs no browser, so `npm run demos` regenerates
+all eight and a test compares the bytes against the committed files.
 
 ## What it is built on
 

package/dist/figure/axis3.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Three number lines in space, with a tick at each of their numbers and the
+ * numbers written beside them.
+ *
+ * A tick reaches along the next axis round, x along y, y along z and z along x,
+ * so every tick lies in a plane the axis is part of and no tick needs the camera
+ * to decide which way to point. A label is flat text at the projected tick,
+ * standing off it in the direction that leads away from the projected origin, so
+ * labels fall outside the picture at every pose rather than over it.
+ */
+import { type Interval } from '../values/interval.js';
+import { type GroupNode } from './node.js';
+import type { Camera3 } from './camera.js';
+import type { Fill, Stroke } from './mark.js';
+export interface Axes3Options {
+    /** The run of each axis in world units, minus one to one unless named. */
+    x?: Interval;
+    y?: Interval;
+    z?: Interval;
+    /** The lines and their ticks. */
+    stroke: Stroke;
+    /** The labels. Nothing is written where this is missing. */
+    fill?: Fill;
+    /** How big the labels are, in figure units. Nothing is written where this is
+     * missing. */
+    size?: number;
+    /** About how many ticks are wanted on each axis. The step is a round number,
+     * so the count that comes back is near this rather than equal to it. */
+    ticks?: number;
+    /** How far a tick reaches across its axis in world units, half either side. */
+    tickLength?: number;
+    /** From the projected tick to the label's own anchor, in figure units. */
+    gap?: number;
+    family?: string;
+    weight?: number;
+}
+/**
+ * The three axes as a group, one child per axis, each holding its line under
+ * `line`, its ticks under `ticks` and its labels under `labels`.
+ *
+ * Each tick and each label is named after the number it shows rather than by its
+ * place in the list, so an animation naming a tick follows that number when the
+ * axes are rebuilt over a different range.
+ */
+export declare function axes3(name: string, camera: Camera3, options: Axes3Options): GroupNode;

package/dist/figure/axis3.js

@@ -0,0 +1,75 @@
+/**
+ * Three number lines in space, with a tick at each of their numbers and the
+ * numbers written beside them.
+ *
+ * A tick reaches along the next axis round, x along y, y along z and z along x,
+ * so every tick lies in a plane the axis is part of and no tick needs the camera
+ * to decide which way to point. A label is flat text at the projected tick,
+ * standing off it in the direction that leads away from the projected origin, so
+ * labels fall outside the picture at every pose rather than over it.
+ */
+import { interval } from '../values/interval.js';
+import { vec2 } from '../values/vec2.js';
+import { vec3 } from '../values/vec3.js';
+import { group } from './node.js';
+import { ticksOn } from './ticks.js';
+import { polyline3, text3 } from './space.js';
+const ALONG = {
+    x: vec3(1, 0, 0),
+    y: vec3(0, 1, 0),
+    z: vec3(0, 0, 1),
+};
+const ACROSS = { x: ALONG.y, y: ALONG.z, z: ALONG.x };
+/** Which way a label leans away from where the three lines cross, or straight
+ * down where the tick lands on that crossing and there is no direction to lean
+ * in. */
+function leaning(from, to, gap) {
+    const away = vec2.sub(to, from);
+    if (vec2.magnitude(away) < 1e-12)
+        return vec2(0, -gap);
+    return vec2.scale(vec2.normalize(away), gap);
+}
+function oneAxis(which, bounds, camera, options) {
+    const along = ALONG[which];
+    const across = ACROSS[which];
+    const size = options.size ?? 0;
+    const tickLength = options.tickLength ?? options.stroke.width * 8;
+    const gap = options.gap ?? size * 0.35;
+    const { from: low, to: high } = interval.ordered(bounds);
+    const at = (value) => vec3.scale(along, value);
+    const marked = ticksOn(bounds, options.ticks);
+    const half = tickLength / 2;
+    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 }))));
+    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.
+        const written = marked.filter((tick) => which === 'x' || tick.value !== 0);
+        parts.push(group('labels', written.map((tick) => text3(tick.label, at(tick.value), tick.label, size, camera, {
+            fill: options.fill,
+            family: options.family,
+            weight: options.weight,
+            align: 'middle',
+            baseline: 'middle',
+            offset: leaning(origin, camera.project(at(tick.value)).at, gap),
+        }))));
+    }
+    return group(which, parts);
+}
+/**
+ * The three axes as a group, one child per axis, each holding its line under
+ * `line`, its ticks under `ticks` and its labels under `labels`.
+ *
+ * Each tick and each label is named after the number it shows rather than by its
+ * place in the list, so an animation naming a tick follows that number when the
+ * axes are rebuilt over a different range.
+ */
+export function axes3(name, camera, options) {
+    const span = interval(-1, 1);
+    return group(name, [
+        oneAxis('x', options.x ?? span, camera, options),
+        oneAxis('y', options.y ?? span, camera, options),
+        oneAxis('z', options.z ?? span, camera, options),
+    ]);
+}

package/dist/figure/camera.d.ts

@@ -0,0 +1,100 @@
+/**
+ * A figure's own camera: where an eye is, what it looks at, and how a point in
+ * space becomes a point in the figure's units.
+ *
+ * A camera is a value the caller holds, the way a `Scale` is, and nothing inside
+ * a figure owns one. That is what keeps the seam: `at(figure, seconds)` gives
+ * back marks measured in the figure's own units, so a point in space has to
+ * become a point in those units before it is a mark at all. A camera inside the
+ * flattening would make every animation say whether it acts on the shape in
+ * space or on the picture of it, which is a question `fadeIn` should never be
+ * asked.
+ *
+ * So a camera moves by being rebuilt from values a track samples, and never by an
+ * animation. A span's eased fraction and a track's value are unrelated numbers,
+ * and a camera on one with a surface on the other is two clocks free to disagree.
+ */
+import { type Mat4 } from '../values/mat4.js';
+import { type Vec3 } from '../values/vec3.js';
+import type { Vec2 } from '../values/vec2.js';
+/**
+ * How a point that the eye has already lined up becomes a point on the page.
+ *
+ * `place` takes a point in view space, where the eye is at the origin looking
+ * down the negative z axis, and gives its place in figure units measured from the
+ * middle of the frame. `near` is how close to the eye a point may come before it
+ * has no place on the page at all.
+ */
+export type Projection = {
+    near: number;
+    place: (view: Vec3) => Vec2;
+};
+export type OrthographicChoice = {
+    /** How many figure units across the frame one world unit becomes. */
+    scale?: number;
+};
+/**
+ * An eye that sees everything at the size it is, however far off it is.
+ *
+ * A parallel projection is a multiplication rather than a divide, so there is no
+ * matrix here and no clip box: near and far planes are what a divide needs, and
+ * this has none. Nothing shrinks with distance, so a point behind the eye lands
+ * where the point in front of it that it lines up with lands, and the near plane
+ * is at negative infinity to say that nothing is ever cut away.
+ */
+export declare function orthographic({ scale }?: OrthographicChoice): Projection;
+export type PerspectiveChoice = {
+    /** The angle the frame covers up and down, in radians. */
+    fov?: number;
+    /** How tall the frame is in figure units, so handing this the extent's own
+     * height makes the picture fill the frame. */
+    height?: number;
+    near?: number;
+    far?: number;
+};
+/**
+ * An eye that sees things smaller the further off they are.
+ *
+ * The matrix is built at an aspect of one and only its x and y are read, so the
+ * same shrinking factor is used across and up and a circle facing the eye stays a
+ * circle at every shape of surface. How wide the frame is comes from the extent,
+ * and how deep a point is comes from view space, where it is a distance rather
+ * than the squeezed value a projection writes into z.
+ */
+export declare function perspective({ fov, height, near, far, }?: PerspectiveChoice): Projection;
+export type Camera3Choice = {
+    eye: Vec3;
+    target: Vec3;
+    up?: Vec3;
+    projection?: Projection;
+};
+/** Where a point in space landed, how far off it is, and whether the eye can see
+ * it at all. */
+export type Projected = {
+    /** The place in the figure's own units, measured from the middle of the frame. */
+    at: Vec2;
+    /** How far the point is from the eye along the way the camera looks, which is
+     * what a depth sort orders by and not the straight-line distance to the eye. */
+    depth: number;
+    /** Whether the point is further off than the near plane. A point that is not is
+     * still given a place, and that place is meaningless. */
+    inFront: boolean;
+};
+export type Camera3 = {
+    eye: Vec3;
+    target: Vec3;
+    up: Vec3;
+    projection: Projection;
+    /** The matrix that lines the world up with the eye, kept so a caller that has
+     * many points to place does not rebuild it per point. */
+    view: Mat4;
+    project: (point: Vec3) => Projected;
+};
+/**
+ * An eye at `eye` looking at `target`, with `up` saying which way is up.
+ *
+ * An `up` lying along the line of sight has no sideways direction in it and gives
+ * a camera that places every point at the middle of the frame, which is a pose
+ * the caller has to avoid rather than one this can fix.
+ */
+export declare function camera3({ eye, target, up, projection, }: Camera3Choice): Camera3;

package/dist/figure/camera.js

@@ -0,0 +1,74 @@
+/**
+ * A figure's own camera: where an eye is, what it looks at, and how a point in
+ * space becomes a point in the figure's units.
+ *
+ * A camera is a value the caller holds, the way a `Scale` is, and nothing inside
+ * a figure owns one. That is what keeps the seam: `at(figure, seconds)` gives
+ * back marks measured in the figure's own units, so a point in space has to
+ * become a point in those units before it is a mark at all. A camera inside the
+ * flattening would make every animation say whether it acts on the shape in
+ * space or on the picture of it, which is a question `fadeIn` should never be
+ * asked.
+ *
+ * So a camera moves by being rebuilt from values a track samples, and never by an
+ * animation. A span's eased fraction and a track's value are unrelated numbers,
+ * and a camera on one with a surface on the other is two clocks free to disagree.
+ */
+import { mat4 } from '../values/mat4.js';
+import { vec3 } from '../values/vec3.js';
+/**
+ * An eye that sees everything at the size it is, however far off it is.
+ *
+ * A parallel projection is a multiplication rather than a divide, so there is no
+ * matrix here and no clip box: near and far planes are what a divide needs, and
+ * this has none. Nothing shrinks with distance, so a point behind the eye lands
+ * where the point in front of it that it lines up with lands, and the near plane
+ * is at negative infinity to say that nothing is ever cut away.
+ */
+export function orthographic({ scale = 1 } = {}) {
+    return {
+        near: -Infinity,
+        place: (view) => ({ x: view.x * scale, y: view.y * scale }),
+    };
+}
+/**
+ * An eye that sees things smaller the further off they are.
+ *
+ * The matrix is built at an aspect of one and only its x and y are read, so the
+ * same shrinking factor is used across and up and a circle facing the eye stays a
+ * circle at every shape of surface. How wide the frame is comes from the extent,
+ * and how deep a point is comes from view space, where it is a distance rather
+ * than the squeezed value a projection writes into z.
+ */
+export function perspective({ fov = Math.PI / 4, height = 2, near = 0.01, far = 1000, } = {}) {
+    const matrix = mat4.perspective({ fov, aspect: 1, near, far });
+    return {
+        near,
+        place: (view) => {
+            const clip = mat4.transformPoint(matrix, view);
+            return { x: (clip.x * height) / 2, y: (clip.y * height) / 2 };
+        },
+    };
+}
+/**
+ * An eye at `eye` looking at `target`, with `up` saying which way is up.
+ *
+ * An `up` lying along the line of sight has no sideways direction in it and gives
+ * a camera that places every point at the middle of the frame, which is a pose
+ * the caller has to avoid rather than one this can fix.
+ */
+export function camera3({ eye, target, up = vec3(0, 1, 0), projection = perspective(), }) {
+    const view = mat4.lookAt(eye, target, up);
+    return {
+        eye,
+        target,
+        up,
+        projection,
+        view,
+        project: (point) => {
+            const seen = mat4.transformPoint(view, point);
+            const depth = -seen.z;
+            return { at: projection.place(seen), depth, inFront: depth > projection.near };
+        },
+    };
+}

package/dist/figure/extent.d.ts

@@ -10,14 +10,18 @@ import { type Vec2 } from '../values/vec2.js';
 export interface Extent {
     width: number;
     height: number;
+    /** Where the middle of the frame sits in the figure's own units, the origin
+     * unless named. A figure whose view follows something moves this rather than
+     * moving everything it draws. */
+    centre?: Vec2;
 }
 /** Whether the extent is held inside the surface, leaving margins where the
  * shapes differ, or fills it and runs off two edges. */
 export type Fit = 'contain' | 'cover';
 /** An extent that never changes, or one chosen from the shape of the surface it
- * is about to be drawn on. */
-export type ExtentChoice = Extent | ((aspect: number) => Extent);
-export declare function resolveExtent(choice: ExtentChoice, aspect: number): Extent;
+ * is about to be drawn on and the time it is drawn at. */
+export type ExtentChoice = Extent | ((aspect: number, seconds: number) => Extent);
+export declare function resolveExtent(choice: ExtentChoice, aspect: number, seconds?: number): Extent;
 /**
  * An extent per shape, for a figure whose composition does not survive being
  * reframed.

package/dist/figure/extent.js

@@ -7,8 +7,8 @@
  */
 import { mat3 } from '../values/mat3.js';
 import { vec2 } from '../values/vec2.js';
-export function resolveExtent(choice, aspect) {
-    return typeof choice === 'function' ? choice(aspect) : choice;
+export function resolveExtent(choice, aspect, seconds = 0) {
+    return typeof choice === 'function' ? choice(aspect, seconds) : choice;
 }
 /**
  * An extent per shape, for a figure whose composition does not survive being
@@ -49,7 +49,8 @@ export function matchingAspect(height = 2) {
  * is drawing would need the shader's camera, and nothing can read one.
  */
 export function fractionOf(extent, across, up) {
-    return vec2((across - 0.5) * extent.width, (up - 0.5) * extent.height);
+    const centre = extent.centre ?? vec2(0, 0);
+    return vec2(centre.x + (across - 0.5) * extent.width, centre.y + (up - 0.5) * extent.height);
 }
 /**
  * The one matrix taking figure units onto a surface, with the extent centred.
@@ -63,7 +64,9 @@ export function viewMatrix(extent, fit, surfaceWidth, surfaceHeight) {
     const byWidth = surfaceWidth / extent.width;
     const byHeight = surfaceHeight / extent.height;
     const scale = fit === 'cover' ? Math.max(byWidth, byHeight) : Math.min(byWidth, byHeight);
-    const centre = mat3.translation(vec2(surfaceWidth / 2, surfaceHeight / 2));
+    const middle = mat3.translation(vec2(surfaceWidth / 2, surfaceHeight / 2));
     const flip = mat3.scaling(vec2(scale, -scale));
-    return mat3.multiply(centre, flip);
+    const seen = extent.centre ?? vec2(0, 0);
+    const follow = mat3.translation(vec2(-seen.x, -seen.y));
+    return mat3.multiply(mat3.multiply(middle, flip), follow);
 }

package/dist/figure/figure.d.ts

@@ -12,7 +12,8 @@
 import { type TrackValue, type Tracks } from '../timing/track.js';
 import { type Node } from './node.js';
 import { Timeline } from './timeline.js';
-import type { ExtentChoice, Fit } from './extent.js';
+import { type ExtentChoice, type Fit } from './extent.js';
+import type { Mat3 } from '../values/mat3.js';
 import type { Mark } from './mark.js';
 /** The values a scene is rebuilt from, sampled out of the figure's tracks. This
  * is what lets geometry follow a number rather than only be moved about: a
@@ -44,6 +45,15 @@ 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[];
+/**
+ * The matrix a painter needs at a time, in one call.
+ *
+ * A figure whose extent is a function of the clock has to be asked for its
+ * extent at the same time its marks were asked for, and a consumer writing that
+ * as two calls has two chances to pass different times. What the painter is
+ * handed is the matrix, so the extent and the centring stay in here.
+ */
+export declare function viewAt(figure: Figure, seconds: number, width: number, height: number): Mat3;
 /** Whether a figure declaring itself a loop actually is one, which is the gate
  * 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

package/dist/figure/figure.js

@@ -11,6 +11,7 @@
  */
 import { sampleTracks } from '../timing/track.js';
 import { flatten } from './node.js';
+import { resolveExtent, viewMatrix } from './extent.js';
 export function durationOf(figure) {
     return figure.duration ?? figure.timeline?.duration ?? 0;
 }
@@ -21,6 +22,18 @@ export function at(figure, seconds) {
     const marks = flatten(tree);
     return figure.timeline ? figure.timeline.at(marks, seconds) : marks;
 }
+/**
+ * The matrix a painter needs at a time, in one call.
+ *
+ * A figure whose extent is a function of the clock has to be asked for its
+ * extent at the same time its marks were asked for, and a consumer writing that
+ * as two calls has two chances to pass different times. What the painter is
+ * handed is the matrix, so the extent and the centring stay in here.
+ */
+export function viewAt(figure, seconds, width, height) {
+    const extent = resolveExtent(figure.extent, width / height, seconds);
+    return viewMatrix(extent, figure.fit ?? 'contain', width, height);
+}
 /** Whether a figure declaring itself a loop actually is one, which is the gate
  * 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

package/dist/figure/section.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The curve where a plane cuts a surface, found on the grid the surface is
+ * already drawn from.
+ *
+ * This is marching squares, with the plane's signed distance as the value at each
+ * grid point. A crossing point is found by walking along a cell edge to where
+ * that distance reaches nothing, and because signed distance to a plane changes
+ * evenly along a straight line, every point this finds lies on the plane exactly.
+ * It lies on the chord between two samples of the surface rather than on the
+ * surface itself, which is the whole of the error and is why halving the cell
+ * size quarters it.
+ */
+import { type Interval } from '../values/interval.js';
+import { type Vec3 } from '../values/vec3.js';
+export interface Plane {
+    /** A point the plane passes through. */
+    point: Vec3;
+    /** Which way the plane faces. Its length does not matter. */
+    normal: Vec3;
+}
+export interface SectionOptions {
+    u?: Interval;
+    v?: Interval;
+    resolution?: number | {
+        u: number;
+        v: number;
+    };
+    /** How close two ends come before they are read as the same place. */
+    tolerance?: number;
+}
+/**
+ * The runs of points where a plane cuts a surface, in space.
+ *
+ * A run whose two ends meet comes back with its first point repeated at the end,
+ * so drawing the points as they are given draws the loop closed.
+ */
+export declare function sectionOf(of: (u: number, v: number) => Vec3, plane: Plane, options?: SectionOptions): Vec3[][];