@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.11

package/types/src/shape/_ShapeStyle.d.ts

@@ -0,0 +1,79 @@
+import { ITransaction } from '../transaction';
+import { IResource } from '../resource';
+import { IFill, IStroke } from '../fill';
+import { IStyleCollection } from '../style';
+import { ITheme } from '../theme';
+import { IMovable } from '../movable/IMovable';
+import { AnyFill } from '../fill/_Fills';
+import { IShape } from './IShape';
+import { IShapeStyle } from './IShapeStyle';
+import * as ShapeStyleUtils from './ShapeStyleUtils';
+/**
+ * What a shape's style reads and writes through: the shape's own JSON, the workbook it resolves
+ * colors and theme styles against, and the write that states a fill or line on the shape.
+ */
+export interface ShapeStyleHost {
+    getData(): IShape.JSON | null;
+    getStyles(): IStyleCollection | null;
+    getTheme(): ITheme.JSON | null;
+    getMovable(): IMovable | null;
+    getResource(resourceId: number): IResource | null;
+    /**
+     * Writes what the shape states: a key set to `undefined` is removed (back to the theme style),
+     * a key left out is untouched.
+     */
+    write(patch: Partial<Pick<IShape.JSON, 'fill' | 'stroke'>>, options: ITransaction.OperationOptions): void;
+    /**
+     * What the style resolves to over `data`, where it is not a shape's: a chart element's own
+     * default fill and line take the place of a theme style's. A shape's resolves through its theme.
+     */
+    resolve?(data: IShape.JSON | null): Pick<ShapeStyleUtils.ResolvedShapeStyle, 'fill' | 'stroke'>;
+    /** The undo message of a write, where it is not a shape's. */
+    describe?(key: 'fill' | 'stroke' | 'style' | 'clear'): string;
+}
+/**
+ * {@link IShapeStyle} for a shape: every read resolves from the shape's current JSON, and every
+ * write goes back to it. Nothing is cached, so the style can be held for the life of the shape.
+ */
+export declare class ShapeStyle implements IShapeStyle {
+    private readonly _h;
+    constructor(_h: ShapeStyleHost);
+    private _parseColor;
+    private _resolve;
+    private _describe;
+    /** The shape's JSON with one of its stated values left out: what the theme style alone gives. */
+    private _without;
+    private _fillHost;
+    private _strokeHost;
+    /** {@inheritDoc IShapeStyle.getFill} */
+    getFill(): AnyFill;
+    /** {@inheritDoc IShapeStyle.setFill} */
+    setFill(fill: IFill.Update, options?: ITransaction.OperationOptions): IShapeStyle;
+    /** {@inheritDoc IShapeStyle.setFillSolid} */
+    setFillSolid(options?: ITransaction.OperationOptions): IFill.ISolid;
+    /** {@inheritDoc IShapeStyle.setFillGradient} */
+    setFillGradient(options?: ITransaction.OperationOptions): IFill.IGradient;
+    /** {@inheritDoc IShapeStyle.setFillPattern} */
+    setFillPattern(options?: ITransaction.OperationOptions): IFill.IPattern;
+    /** {@inheritDoc IShapeStyle.setFillNone} */
+    setFillNone(options?: ITransaction.OperationOptions): IFill.INone;
+    /** {@inheritDoc IShapeStyle.getStroke} */
+    getStroke(): IStroke;
+    /** {@inheritDoc IShapeStyle.setStroke} */
+    setStroke(stroke: IStroke.Update, options?: ITransaction.OperationOptions): IShapeStyle;
+    /** {@inheritDoc IShapeStyle.setStrokeNone} */
+    setStrokeNone(options?: ITransaction.OperationOptions): IStroke;
+    /** {@inheritDoc IShapeStyle.update} */
+    update(update: IShapeStyle.Update, options?: ITransaction.OperationOptions): IShapeStyle;
+    /** {@inheritDoc IShapeStyle.clear} */
+    clear(options?: ITransaction.OperationOptions): IShapeStyle;
+    /** {@inheritDoc IShapeStyle.isThemed} */
+    isThemed(): boolean;
+    /** {@inheritDoc IShapeStyle.toJSON} */
+    toJSON(): IShapeStyle.JSON | null;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IShapeStyle.isIShapeStyle} */
+    get isIShapeStyle(): true;
+}
+//# sourceMappingURL=_ShapeStyle.d.ts.map

package/types/src/shape/_builtIn/_BuiltInChunks.d.ts

@@ -0,0 +1,10 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** A chunk of built-in definitions. */
+export interface BuiltInChunk {
+    /** Connection-site lists shared by more than one shape in the chunk; `BuiltInDef.cxn` indexes into this. */
+    CXN_SHARED: readonly (readonly string[])[];
+    BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+}
+/** Each chunk's loader and the presets it holds. */
+export declare const BUILT_IN_CHUNKS: readonly (readonly [load: () => Promise<BuiltInChunk>, names: readonly string[]])[];
+//# sourceMappingURL=_BuiltInChunks.d.ts.map

package/types/src/shape/_builtIn/_BuiltInDef.d.ts

@@ -0,0 +1,9 @@
+import { IGeometry } from '../IGeometry';
+/**
+ * A definition as the built-in table stores it: connection sites may be an index into its
+ * chunk's shared lists, resolved to the lists themselves when the chunk loads.
+ */
+export interface BuiltInDef extends Omit<IGeometry.Def, 'cxn'> {
+    cxn?: readonly string[] | number;
+}
+//# sourceMappingURL=_BuiltInDef.d.ts.map

package/types/src/shape/_builtIn/arrows.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=arrows.d.ts.map

package/types/src/shape/_builtIn/basic.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=basic.d.ts.map

package/types/src/shape/_builtIn/callouts.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=callouts.d.ts.map

package/types/src/shape/_builtIn/flowchart.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=flowchart.d.ts.map

package/types/src/shape/_builtIn/lines.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=lines.d.ts.map

package/types/src/shape/_builtIn/math.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=math.d.ts.map

package/types/src/shape/_builtIn/other.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=other.d.ts.map

package/types/src/shape/_builtIn/rectangles.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=rectangles.d.ts.map

package/types/src/shape/_builtIn/starsBanners.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=starsBanners.d.ts.map

package/types/src/shape/geometry/_strokeEnds.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What a straight line needs to draw its ends without the rest of the engine: a chunk of its own,
+ * shared with the engine, so a sheet of arrows loads it and nothing else.
+ */
+export { decorateSubpaths } from './lineEnds';
+export { addSubpathsBounds, emptyBox, subpathsToSVG } from './segments';
+//# sourceMappingURL=_strokeEnds.d.ts.map

package/types/src/shape/geometry/format.d.ts

@@ -0,0 +1,3 @@
+/** Formats a coordinate: fixed decimals, trailing zeros dropped, negative zero canonicalized. */
+export declare function formatNumber(n: number, precision: number): string;
+//# sourceMappingURL=format.d.ts.map

package/types/src/shape/geometry/geometry.d.ts

@@ -0,0 +1,85 @@
+import { Point } from '@sheetxl/utils';
+import { IGeometry } from '../IGeometry';
+import { LineOptions } from './lineEnds';
+import { FillMode } from './paths';
+export interface EvaluateOptions {
+    /** Decimal places in path data. @defaultValue `2` */
+    precision?: number;
+    /**
+     * The line the shape is stroked with, when it declares a head or tail. The head goes to the first
+     * stroked path no `Z` closes and the tail to the last, as Excel draws them; a subpath ending where
+     * it began takes its path's end without drawing it. Each is trimmed under its ends, which come
+     * back as `line`-filled paths (design §10). Absent, the paths are the definition's alone.
+     */
+    line?: LineOptions;
+}
+export interface GeometryPath {
+    /** SVG path data in output units. */
+    d: string;
+    fill: FillMode;
+    stroke: boolean;
+}
+export interface Rect {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+export interface XYHandle extends Point {
+    type: 'xy';
+    /** Adjust value the horizontal drag changes, with its allowed range. */
+    refX?: string;
+    minX?: number;
+    maxX?: number;
+    /** Adjust value the vertical drag changes, with its allowed range. */
+    refY?: string;
+    minY?: number;
+    maxY?: number;
+}
+export interface PolarHandle extends Point {
+    type: 'polar';
+    refR?: string;
+    minR?: number;
+    maxR?: number;
+    /** Angle bounds in degrees. */
+    refAng?: string;
+    minAng?: number;
+    maxAng?: number;
+}
+export type Handle = XYHandle | PolarHandle;
+export interface Connection extends Point {
+    /** Direction a connector leaves the site, in degrees clockwise from +x. */
+    ang: number;
+}
+/** What the engine evaluates a definition to; `IGeometry` is the public face of it. */
+export interface EvaluatedGeometry {
+    paths: GeometryPath[];
+    /** Text rectangle; the whole shape when the definition declares none. */
+    textRect: Rect;
+    /**
+     * The box of every path, line ends included, before the line's width: it can reach outside the
+     * shape. The whole shape when nothing is drawn.
+     */
+    pathBounds: Rect;
+    handles: Handle[];
+    connections: Connection[];
+    /** Effective adjust values after defaults and overrides. */
+    adjustments: Record<string, number>;
+}
+/**
+ * The adjust handles alone, at `width` by `height` with the given adjust values: what
+ * {@link evaluateGeometry} reports as `handles`, without compiling the paths. Cheap enough to call
+ * per step of a numeric search (see `adjustmentsFromHandle`).
+ */
+export declare function evaluateHandles(def: IGeometry.Def, width: number, height: number, adjustments?: Readonly<Record<string, number>>): Handle[];
+/**
+ * Evaluates a shape definition at `width` by `height` with optional adjust value overrides,
+ * producing SVG path data and the sites the editor needs.
+ *
+ * Every output coordinate is in the unit `width` and `height` are given in: the guide formulas
+ * are homogeneous in the extent, so a definition evaluates the same at any scale (the SDK passes
+ * pixels). Paths that declare their own coordinate space are evaluated against that space and
+ * scaled to the shape extent (design §6.1).
+ */
+export declare function evaluateGeometry(def: IGeometry.Def, width: number, height: number, adjustments?: Readonly<Record<string, number>>, options?: EvaluateOptions): EvaluatedGeometry;
+//# sourceMappingURL=geometry.d.ts.map

package/types/src/shape/geometry/guides.d.ts

@@ -0,0 +1,54 @@
+import { IGeometry } from '../IGeometry';
+/** DrawingML angles are in 60,000ths of a degree. */
+export declare const ANGLE_UNIT = 60000;
+/** A formula operand: a numeric literal or a guide name. */
+export type Operand = number | string;
+export interface CompiledGuide {
+    name: string;
+    op: string;
+    args: Operand[];
+}
+export interface CompiledGuides {
+    /** Adjust values with their default literal. */
+    av: {
+        name: string;
+        value: number;
+    }[];
+    gd: CompiledGuide[];
+}
+/** Parses one operand: an integer literal becomes a number, anything else is a guide name. */
+export declare const parseOperand: (token: string) => Operand;
+/** Tokenizes a definition's guides once; the result is cached per definition object. */
+export declare function compileGuides(def: IGeometry.Def): CompiledGuides;
+/**
+ * Guides every definition may use without declaring (ECMA-376 §20.1.9.11 plus the four the
+ * presets use but the list omits). `w`/`h` are the shape anchor extent; the anchor origin is 0,0.
+ */
+export declare function predefinedGuide(name: string, w: number, h: number): number | undefined;
+/**
+ * Evaluated guide values for one anchor extent. Lookups resolve literals, then bound guides,
+ * then the predefined set.
+ */
+export declare class GuideValues {
+    private readonly _values;
+    readonly w: number;
+    readonly h: number;
+    constructor(w: number, h: number);
+    /** The value of an operand. Throws on an unknown name; the generator guarantees presets never do. */
+    get(operand: Operand): number;
+    /** Whether a name is bound by the definition (not merely predefined). */
+    has(name: string): boolean;
+    set(name: string, value: number): void;
+}
+/**
+ * Applies one operator (design §5.2). Division by zero yields 0 rather than throwing, so a
+ * handle dragged through a degenerate size never breaks rendering.
+ */
+export declare function applyOp(op: string, x: number, y: number, z: number): number;
+/**
+ * Evaluates a definition's adjust values and guides against an anchor of `w` by `h` at 0,0.
+ * `adjustments` override adjust-value defaults by name; names the definition does not declare
+ * are ignored (a file may carry stale entries).
+ */
+export declare function evaluateGuides(def: IGeometry.Def, w: number, h: number, adjustments?: Readonly<Record<string, number>>): GuideValues;
+//# sourceMappingURL=guides.d.ts.map

package/types/src/shape/geometry/handles.d.ts

@@ -0,0 +1,14 @@
+import { IGeometry } from '../IGeometry';
+/**
+ * The adjust values a handle drag lands on: handle `index` of the shape at `width` by `height`
+ * moved to (`x`, `y`) in the shape's own frame, in the same unit as `width` and `height`.
+ *
+ * An `xy` handle solves its horizontal reference against `x` and its vertical one against `y`; a
+ * `polar` handle solves its angle reference against the direction of the point from the shape's
+ * center and its radius reference against the distance. Each value is clamped to the range the
+ * handle declares (or the spec's limit), and a reference the handle does not have is left alone.
+ *
+ * @returns `adjustments` with the solved values merged in, in the preset grammar's own units.
+ */
+export declare function adjustmentsFromHandle(def: IGeometry.Def, width: number, height: number, adjustments: Readonly<Record<string, number>> | undefined, index: number, x: number, y: number): Record<string, number>;
+//# sourceMappingURL=handles.d.ts.map

package/types/src/shape/geometry/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The geometry engine's lazily loaded entry: what the SDK's loader calls. Everything a dynamic
+ * import's module exports is kept by the bundler, so this exports only that.
+ */
+export { evaluateGeometry } from './geometry';
+export { adjustmentsFromHandle } from './handles';
+//# sourceMappingURL=index.d.ts.map

package/types/src/shape/geometry/lineEnds.d.ts

@@ -0,0 +1,54 @@
+import { Subpath } from './segments';
+/** DrawingML `ST_LineEndType`. */
+export type LineEndType = 'none' | 'triangle' | 'stealth' | 'diamond' | 'oval' | 'arrow';
+/** DrawingML `ST_LineEndWidth` / `ST_LineEndLength`. */
+export type LineEndSize = 'sm' | 'med' | 'lg';
+/** One end of a line: `headEnd` or `tailEnd`. */
+export interface LineEnd {
+    /** `'none'` and absent draw nothing. */
+    type?: LineEndType;
+    /** @defaultValue `'med'` */
+    width?: LineEndSize;
+    /** @defaultValue `'med'` */
+    length?: LineEndSize;
+}
+/** What a geometry's open paths are stroked with, as far as the line ends depend on it. */
+export interface LineOptions {
+    /** The stroke width, in px: the ends' sizes, like their 2pt floor, are in px too. */
+    width: number;
+    /** @defaultValue `'butt'` */
+    cap?: 'butt' | 'round' | 'square';
+    /** The end at a path's start. */
+    head?: LineEnd;
+    /** The end at a path's end. */
+    tail?: LineEnd;
+}
+/**
+ * A line end's shape, from rythan's `getLineDecoratorDrawInfo`: the outline with its tip at the
+ * origin and its body along +x, how much line it hides, and how far back along the line it is
+ * aimed. Sizes are in units of `lw' = max(lineWidth, MIN_END_BASE)` scaled by the declared size.
+ */
+interface EndOutline {
+    outline: Subpath[];
+    /** Arc length of line to trim under the end; none when not positive. */
+    clip: number;
+    /** Arc length back along the line to the point the end is aimed at; `0` aims it along the end's tangent. */
+    sample: number;
+}
+/** The outline of a line end at a line width, or `null` when it draws nothing. */
+export declare function lineEndOutline(end: LineEnd | undefined, lineWidth: number): EndOutline | null;
+/**
+ * A path's subpaths with the line's ends applied: every open subpath gets the head at its start
+ * and the tail at its end, each trimmed back under its end. Closed subpaths, and ones ending where
+ * they began, are left alone, as are all of them when the line declares no end. Which of a shape's
+ * paths take which end is the caller's choice (see `evaluateGeometry`).
+ *
+ * @returns The subpaths to stroke, and the ends to fill with the stroke's paint; `null` when
+ * nothing was decorated.
+ */
+export declare function decorateSubpaths(subpaths: readonly Subpath[], line: LineOptions): {
+    stroke: Subpath[];
+    ends: Subpath[];
+} | null;
+export {};
+//# sourceMappingURL=lineEnds.d.ts.map

package/types/src/shape/geometry/paths.d.ts

@@ -0,0 +1,35 @@
+import { IGeometry } from '../IGeometry';
+import { GuideValues, Operand } from './guides';
+import { Subpath } from './segments';
+export { formatNumber } from './segments';
+/**
+ * How a path is painted. The definitions declare `norm`, `none` and the four shaded modes; `line`
+ * is the geometry's own: a line end, filled with the stroke's paint (design §10).
+ */
+export type FillMode = 'norm' | 'none' | 'darken' | 'darkenLess' | 'lighten' | 'lightenLess' | 'line';
+export interface CompiledCommand {
+    c: 'M' | 'L' | 'Q' | 'C' | 'A' | 'Z';
+    args: Operand[];
+}
+export interface CompiledPath {
+    fill: FillMode;
+    stroke: boolean;
+    /** Path coordinate space, when the path declares one. */
+    w?: number;
+    h?: number;
+    cmds: CompiledCommand[];
+}
+export declare function compilePath(p: IGeometry.DefPath): CompiledPath;
+/** Tokenizes a definition's paths once; cached per definition object. */
+export declare function compilePaths(def: IGeometry.Def): CompiledPath[];
+/**
+ * Evaluates one path's commands into subpaths of segments in output space: guide-space points
+ * are scaled by `sx`,`sy`. `arcTo` follows design §6.3: DrawingML angles are visual, so the start
+ * angle is mapped to the ellipse's parametric angle to find the center, and the end point comes
+ * from the parametric end angle. A command right after `Z` continues from the closed subpath's
+ * start, as SVG does, in a subpath written without an `M`.
+ */
+export declare function evaluatePath(path: CompiledPath, values: GuideValues, sx: number, sy: number): Subpath[];
+/** Converts one path to SVG path data: {@link evaluatePath} written out. */
+export declare function pathToSVG(path: CompiledPath, values: GuideValues, sx: number, sy: number, precision: number): string;
+//# sourceMappingURL=paths.d.ts.map

package/types/src/shape/geometry/segments.d.ts

@@ -0,0 +1,114 @@
+import { Point } from '@sheetxl/utils';
+import { formatNumber } from './format';
+export interface LineSegment {
+    k: 'L';
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export interface QuadSegment {
+    k: 'Q';
+    x0: number;
+    y0: number;
+    cx: number;
+    cy: number;
+    x1: number;
+    y1: number;
+}
+export interface CubicSegment {
+    k: 'C';
+    x0: number;
+    y0: number;
+    c1x: number;
+    c1y: number;
+    c2x: number;
+    c2y: number;
+    x1: number;
+    y1: number;
+}
+/**
+ * An elliptical arc by center parameterization: `c + R(phi)·(rx·cos t, ry·sin t)` for `t` from
+ * `t0` over `dt` (radians; positive is clockwise on screen). A full turn is `|dt| = 2π`.
+ */
+export interface ArcSegment {
+    k: 'A';
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    phi: number;
+    t0: number;
+    dt: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export type Segment = LineSegment | QuadSegment | CubicSegment | ArcSegment;
+export interface Subpath {
+    /** The subpath's start: its `M`. */
+    x: number;
+    y: number;
+    segments: Segment[];
+    /** Ends with `Z`. */
+    closed: boolean;
+    /**
+     * Begun by a drawing command right after a `Z`, with no `M` of its own: SVG continues from the
+     * closed subpath's start, so no `M` is written for it.
+     */
+    implicit?: boolean;
+}
+export { formatNumber };
+export declare function arcPoint(a: ArcSegment, t: number): Point;
+/** The point at parameter `u` in `[0, 1]` along the segment. */
+export declare function pointAt(seg: Segment, u: number): Point;
+/** The direction of travel at parameter `u`: the derivative, not normalized. */
+export declare function tangentAt(seg: Segment, u: number): Point;
+export declare function segmentLength(seg: Segment): number;
+/** The parameter at arc length `s` from the segment's start, clamped to `[0, 1]`. */
+export declare function parameterAtLength(seg: Segment, s: number): number;
+/** The segment split at parameter `u`: the part before it and the part after. */
+export declare function splitSegment(seg: Segment, u: number): [Segment, Segment];
+export declare function subpathLength(sp: Subpath): number;
+/** The point at arc length `s` from the subpath's start, and the direction of travel there. Clamped to the ends. */
+export declare function pointAtLength(sp: Subpath, s: number): {
+    point: Point;
+    tangent: Point;
+};
+/** Whether the subpath is open: not closed by `Z`, and not ending where it began. */
+export declare function isOpen(sp: Subpath): boolean;
+/**
+ * The subpath shortened by `amount` of arc length from its start (`fromStart`) or its end, the
+ * way rythan's `adjustPathForDecorator` walks it: whole segments shorter than what is left to
+ * remove are dropped, the one the cut lands in is split there, and less than 0.26 left to remove
+ * is not removed at all.
+ */
+export declare function trimSubpath(sp: Subpath, amount: number, fromStart: boolean): Subpath;
+/**
+ * The subpath moved by a similarity transform: rotated by `angle` radians (clockwise on screen),
+ * after a reflection in y when `flipY`, then translated to (`x`, `y`).
+ */
+export declare function placeSubpath(sp: Subpath, x: number, y: number, angle: number, flipY?: boolean): Subpath;
+/** Edges of a box; empty while `l > r`. */
+export interface Box {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+/** A box that holds nothing yet. */
+export declare const emptyBox: () => Box;
+/**
+ * Grows `box` to hold the segment exactly: its ends and every point where it turns back along x
+ * or y (a curve's derivative roots, an arc's crossings of its ellipse's extremes).
+ */
+export declare function addSegmentBounds(box: Box, seg: Segment): void;
+/** Grows `box` to hold every subpath, starts included. */
+export declare function addSubpathsBounds(box: Box, subpaths: readonly Subpath[]): Box;
+/**
+ * SVG path data for subpaths. An arc of a full turn or more is written as two halves, because
+ * SVG draws nothing when an arc's end point equals its start.
+ */
+export declare function subpathsToSVG(subpaths: readonly Subpath[], precision: number): string;
+//# sourceMappingURL=segments.d.ts.map

package/types/src/shape/index.d.ts

@@ -1,2 +1,6 @@
 export * from './IShape';
+export * from './IShapeStyle';
+export * from './ITextBoxStyle';
+export * as ShapeStyleUtils from './ShapeStyleUtils';
+export * from './IGeometry';
 //# sourceMappingURL=index.d.ts.map

package/types/src/sheet/CellRegion.d.ts

@@ -1,7 +1,7 @@
 import { IRange } from '@sheetxl/primitives';
 import { ICell } from '../cell';
 import { ICellRange, ICellRegion, ICellRegions } from '../cellRange';
-import { ISheetInternal } from './Sheet';
+import { IWorksheetInternal } from './Worksheet';
 /**
  * Normalizes the requested features, ONCE, at the call.
  *
@@ -12,6 +12,12 @@ import { ISheetInternal } from './Sheet';
  * from a date-formatted blank. The three scalars were retired from the vocabulary entirely —
  * `getStats()` already answers "how many numbers" better — and `Date` was replaced by
  * `DateFormat`, a real, directly indexed feature that just means what it says.)
+ *
+ * A name that is not a feature throws, with the vocabulary. An untyped caller — a script, an
+ * agent's expression — is not stopped by the type, and a name the partition does not know matches
+ * no cells: `getRegions('NumberFormat')` came back empty, which reads as "this sheet has no number
+ * formats". Spelling is matched case-insensitively and the canonical value is what comes back, so
+ * the enum's key (`NumberFormat`) resolves the same as its value (`numberFormat`).
  * @internal
  */
 export declare const resolveRegionFeatures: (features?: ICellRange.Feature | readonly ICellRange.Feature[]) => readonly ICellRange.Feature[];
@@ -32,7 +38,9 @@ export declare class CellRegion implements ICellRegion {
     private _range;
     /** Memoized clip verdict: the probes are sheet reads, and a listing may ask twice. */
     private _clipped;
-    constructor(coords: Readonly<IRange.Coords>, internal: ISheetInternal, features: readonly ICellRange.Feature[], bounds: Readonly<IRange.Coords>);
+    /** Whether the address names its sheet: a listing across sheets. */
+    private readonly _qualified;
+    constructor(coords: Readonly<IRange.Coords>, internal: IWorksheetInternal, features: readonly ICellRange.Feature[], bounds: Readonly<IRange.Coords>, qualified?: boolean);
     /** {@inheritDoc ICellRegion.getFeatures} */
     getFeatures(): readonly ICellRange.Feature[];
     /** {@inheritDoc ICellRegion.getCoords} */
@@ -85,7 +93,7 @@ export declare class CellRegions implements ICellRegions {
     private _regions;
     /** The extent as a range, built on demand — a listing that never asks never pays. */
     private _range;
-    constructor(bounds: Readonly<IRange.Coords>, internal: ISheetInternal, features: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions);
+    constructor(bounds: Readonly<IRange.Coords>, internal: IWorksheetInternal, features: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions);
     /** {@inheritDoc ICellRegions.getFeatures} */
     getFeatures(): readonly ICellRange.Feature[];
     /** {@inheritDoc ICellRegions.getRange} */
@@ -103,4 +111,36 @@ export declare class CellRegions implements ICellRegions {
     /** {@inheritDoc ICellRegions.isICellRegions} */
     get isICellRegions(): true;
 }
+/** One sheet's part of an anomalies listing. @internal */
+export interface AnomalyExtent {
+    readonly bounds: Readonly<IRange.Coords>;
+    readonly internal: IWorksheetInternal;
+    /** Whether the addresses name the sheet: a listing across sheets. */
+    readonly qualified: boolean;
+}
+/** Validated eagerly, so a misspelled check throws at the call rather than at first iteration. */
+export declare const resolveAnomalyOptions: (options?: ICellRange.GetAnomaliesOptions) => Readonly<ICellRange.GetAnomaliesOptions>;
+/**
+ * The regions of the `anomalies` feature in reading order, windowed — what `getAnomalies`
+ * returns. The same regions and ranks as `getRegions('anomalies')`; lazily built and memoized.
+ */
+export declare class AnomalyRegions implements ICellRegions {
+    private readonly _extents;
+    private readonly _range;
+    private readonly _options;
+    private _listed;
+    constructor(extents: readonly AnomalyExtent[], range: () => ICellRange, options: Readonly<ICellRange.GetAnomaliesOptions>);
+    /** {@inheritDoc ICellRegions.getFeatures} */
+    getFeatures(): readonly ICellRange.Feature[];
+    /** {@inheritDoc ICellRegions.getRange} */
+    getRange(): ICellRange;
+    /** {@inheritDoc ICellRegions.getCount} */
+    getCount(): number;
+    /** {@inheritDoc ICellRegions.[Symbol.iterator]} */
+    [Symbol.iterator](): IterableIterator<ICellRegion>;
+    private _materialize;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc ICellRegions.isICellRegions} */
+    get isICellRegions(): true;
+}
 //# sourceMappingURL=CellRegion.d.ts.map