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

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

@@ -1,4 +1,7 @@
 export * from './IFill';
+export * from './IFillable';
 export * from './IStroke';
 export * from './IEffect';
+export * from './RectAlignment';
+export * as PaintUtils from './PaintUtils';
 //# sourceMappingURL=index.d.ts.map

package/types/src/filter/IFilter.d.ts

@@ -1,13 +1,20 @@
-import { IRange } from '@sheetxl/primitives';
+import { IRange, Scalar } from '@sheetxl/primitives';
+import { RunCoordValue } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { ICondition } from '../condition';
 import { ICellRange } from '../cellRange';
 /**
  * Filters are used to hide spans (rows or columns). that do not match a set of conditions.
+ *
+ * @remarks
+ * A column's filter ANDs with the other columns' (Excel's AutoFilter): setting one leaves the
+ * rest in place unless `replace` says otherwise. Every write returns a Promise that resolves once
+ * the rows are hidden; the criteria are written in the same transaction, so an `await` is what
+ * makes a read after the call see them.
  */
 export interface IFilter extends ICondition.Stateful, IFilter.IFilterable {
     /**
-     * Returns the range this filter applies to.
+     * Returns the range this filter applies to: the column's data rows, header and totals excluded.
      *
      * @remarks
      * A filter is exactly one column of its table, which is why the singular is declared here rather
@@ -15,9 +22,24 @@ export interface IFilter extends ICondition.Stateful, IFilter.IFilterable {
      */
     getRange(): ICellRange;
     /**
-     * Set the condition.
+     * Set the condition, `null` to clear this column's.
+     *
+     * @param condition The condition, or `null` to clear.
+     * @param replace If `true`, every other column's filter is dropped; omitted, they stay and this
+     * one ANDs with them. A column already filtered keeps its place in the level order.
+     * @param options Transaction options.
+     *
+     * @returns Resolves once the rows are hidden; one transaction, one undo step.
+     */
+    setCondition(condition: ICondition.Input | null, replace?: boolean, options?: ITransaction.OperationOptions): Promise<this>;
+    /**
+     * Re-runs every filter on the table with its current criteria.
+     */
+    apply(options?: ITransaction.OperationOptions): Promise<this>;
+    /**
+     * Clears this column's condition. The other columns' filters stay.
      */
-    setCondition(condition: ICondition.Input, append?: boolean, options?: ITransaction.OperationOptions): void;
+    delete(options?: ITransaction.OperationOptions): Promise<this>;
     /**
      * The offset index from the range
      *
@@ -25,6 +47,50 @@ export interface IFilter extends ICondition.Stateful, IFilter.IFilterable {
      * This is relative to the table.
      */
     getIndex(): number;
+    /**
+     * The column's distinct values, as a filter menu lists them.
+     *
+     * @param options See {@link IFilter.GetItemsOptions}.
+     *
+     * @remarks
+     * Under the default scope, which rows are read depends on the column:
+     * - With no condition on it, the rows that are showing. A row hidden by another column's filter,
+     *   or by hand, is not listed.
+     * - With a condition on it, the rows every *other* column's filter passes, so a value this
+     *   column's own condition hides is listed too, unchecked.
+     *
+     * An item is `checked` when at least one row holding it passes the filters, so a column filtered
+     * by any condition (`> 5`, say) lists the passing values checked. A row hidden by hand does not
+     * uncheck its value.
+     *
+     * Under the `'column'` scope every row is read, and each item also says whether it passes the
+     * other columns' filters ({@link IFilter.Item.passesOthers}).
+     *
+     * Reads the stored values in one pass; the cost follows the column's content, not its extent.
+     *
+     * @example
+     * ```ts
+     * const filter = table.getColumnAt(1).getFilter();
+     * const { items } = await filter.getItems();
+     * // keep the first two values
+     * await filter.setCondition({
+     *   operator: ICondition.BuiltInOperatorNames.InSet,
+     *   param: { items: items.slice(0, 2).map((item) => item.text) }
+     * });
+     * ```
+     */
+    getItems(options?: IFilter.GetItemsOptions): Promise<IFilter.Items>;
+    /**
+     * The texts `values` show as in this column's data rows, each once, in column order: what a
+     * list by displayed text would hold for them, and what the xlsx writer spells a value list as,
+     * since OOXML's list holds displayed text. A value no cell holds contributes nothing.
+     *
+     * @remarks
+     * Synchronous: it reads the number-format runs and the column's statistics, not its cells.
+     */
+    getDisplayTexts(values: readonly Scalar[]): readonly string[];
+    /** For runtime type checking. */
+    readonly isIFilter: true;
 }
 /**
  * {@inheritDoc IFilter}
@@ -38,6 +104,121 @@ export declare namespace IFilter {
         conditions?: ICondition.JSON[];
         axis?: IRange.Axis;
     }
+    /**
+     * Options for {@link IFilter.getItems}.
+     */
+    interface GetItemsOptions {
+        /**
+         * The distinct values to stop at.
+         *
+         * @defaultValue `10000`
+         */
+        limit?: number;
+        /**
+         * The selector the column is read under, as the condition's will be. Under
+         * {@link ICondition.BuiltInSelectorNames.Display} the column is grouped by the text its cells
+         * SHOW, as a spreadsheet's filter list does: `1` under `$0` and under `0%` are two items, and
+         * a string of only spaces is a blank. The items are then the texts an `inSet` under Display
+         * holds. Any other selector lists the distinct values.
+         *
+         * @defaultValue `null` — by value, the identity {@link ICondition.InSetOption.items} has
+         * under no selector.
+         */
+        selector?: string | ICondition.ISelector | null;
+        /**
+         * Which rows are listed.
+         *
+         * - `'visible'`: as a filter menu lists them (see {@link IFilter.getItems}).
+         * - `'column'`: every row of the column, hidden or not, so a value every row of which another
+         *   column's filter hides is listed too, with {@link Item.passesOthers} saying so. What a
+         *   slicer lists.
+         *
+         * @defaultValue `'visible'`
+         */
+        scope?: 'visible' | 'column';
+    }
+    /**
+     * One distinct value of a filtered column.
+     */
+    interface Item {
+        /**
+         * The item's label: by value, the value as `General` shows it (a date as its date format
+         * does); under Display, the text the cells show, which is then the item an `inSet` under
+         * Display holds.
+         */
+        text: string;
+        /** The value, or by display the value of the first cell showing `text`; the item's place in the order. */
+        value: Scalar;
+        /** The rows holding the value. */
+        count: number;
+        /** Whether at least one row holding the value passes the filters. */
+        checked: boolean;
+        /**
+         * Whether at least one row holding the value passes every *other* column's filter: a slicer's
+         * "has data". Read under {@link GetItemsOptions.scope} `'column'` only.
+         */
+        passesOthers?: boolean;
+        /** The sheet row of the first listed row holding the value. */
+        firstRow: number;
+    }
+    /**
+     * One level of the date tree {@link Items.dates}: the nodes, each the run of items it spans,
+     * in the order the items are listed.
+     */
+    interface DateLevel {
+        /** The part this level groups by. */
+        group: ICondition.DateItemGroupingType;
+        /**
+         * The nodes. A run's `value` is the group item selecting exactly its items: the parts down
+         * to this level (`{ group: 'month', year: 1995, month: 10 }`).
+         */
+        runs: readonly RunCoordValue<ICondition.DateGroupItem>[];
+    }
+    /**
+     * What {@link IFilter.getItems} answers.
+     */
+    interface Items {
+        /**
+         * The distinct values, or the distinct texts under Display. The dates come first (the tree in {@link dates}), newest year first
+         * and ascending within a year, as Excel's date tree lists them; the rest follow, ascending
+         * by the workbook's comparison of their values. Values that show alike are one item. Blanks
+         * are not an item.
+         */
+        items: readonly Item[];
+        /**
+         * The date tree over the leading items, one level per entry: year, month and day, then hour,
+         * minute and second when a date carries a time. Absent when the column shows no date.
+         *
+         * @remarks
+         * A date is a number shown under a date format; a time-only format is a number. Every level
+         * covers the same items, `0` to the last date, and a finer level's runs nest inside the
+         * coarser's. A node's checkbox is the state of its items; a checked node is written as its
+         * run's value, in {@link ICondition.InSetOption.dateGroups}.
+         */
+        dates?: readonly DateLevel[];
+        /**
+         * Whether a listed row is blank: empty, or showing nothing (a `""` result, a string of only
+         * spaces). The same rows `includeBlanks` keeps.
+         */
+        hasBlanks: boolean;
+        /** Whether at least one blank row passes the filters. */
+        blanksChecked: boolean;
+        /**
+         * Whether at least one blank row passes every other column's filter. Read under
+         * {@link GetItemsOptions.scope} `'column'` only.
+         */
+        blanksPassOthers?: boolean;
+        /** Whether the column has more distinct values than `limit`; the rest are not listed. */
+        truncated: boolean;
+        /** The rows read. */
+        total: number;
+        /**
+         * The selector the list was read under, so a caller writes the items back under the same
+         * one: `{ selector, operator: 'inSet', param: { items } }`. A list read by value fed back as
+         * texts under Display would match nothing for a number.
+         */
+        selector: string | null;
+    }
     /**
      * Interface indicating the ability to filter data.
      */
@@ -76,8 +257,10 @@ export declare namespace IFilter {
          * ``` ts
          * sheet.getRange('E:E').filter('>= 30');
          * ```
+         *
+         * @returns Resolves once the rows are hidden.
          */
-        filter(condition?: ICondition.Input, options?: ITransaction.OperationOptions): this;
+        filter(condition?: ICondition.Input, options?: ITransaction.OperationOptions): Promise<this>;
     }
 }
 //# sourceMappingURL=IFilter.d.ts.map

package/types/src/font/AdvanceBuilder.d.ts

@@ -0,0 +1,59 @@
+import { AdvanceTable } from './AdvanceTable';
+/**
+ * Makes the {@link AdvanceTable} for a face from one source: a shipped `.metrics.json`, a canvas,
+ * a font's bytes.
+ *
+ * @remarks
+ * A platform has several, tried in order; the first that answers wins. One build serves every size
+ * of the face, so a builder runs once per family, weight and style.
+ */
+export interface AdvanceBuilder {
+    /** The builder's name, for diagnostics. */
+    readonly name: string;
+    /**
+     * `'table'` when the advances were captured ahead of time (possibly from a metric-compatible
+     * twin), `'exact'` when they are read from the face itself as installed.
+     */
+    readonly kind: 'table' | 'exact';
+    /**
+     * The table for `face`, or `null` when this builder has no source for it.
+     *
+     * @throws when a source exists but cannot be read as a table.
+     */
+    build(face: AdvanceTable.Face): Promise<AdvanceTable | null>;
+    /**
+     * Gives a table built elsewhere (a built-in one) the hinted widths this builder has for its
+     * face, when it has them.
+     *
+     * @returns Whether the table is hinted now.
+     */
+    hint?(table: AdvanceTable): Promise<boolean>;
+    /**
+     * The table of what the platform PAINTS `face` with when a cell names `families` (the face's
+     * family and the style's fallbacks, in order): a browser's own advances for that CSS stack,
+     * substitutes included. Only a builder that can see the platform's paint has one; the
+     * collection uses it to reconcile paint to the measure
+     * (`IFont.ExtendedMetrics.renderLetterSpacing`).
+     *
+     * @returns `null` when this builder cannot say.
+     */
+    paint?(face: AdvanceTable.Face, families: readonly string[]): Promise<AdvanceTable | null>;
+    /**
+     * How the platform measures a character that a captured table for `face` lacks: its advance
+     * per em as the platform paints it, its font fallback included (a symbol or emoji that the
+     * face does not have). The collection gives it to every captured table
+     * ({@link AdvanceTable.setMeasureMissing}), so such a character takes up room instead of
+     * measuring as nothing. Only a builder that can measure on the platform has one.
+     *
+     * @returns `null` when this builder cannot measure.
+     */
+    measureMissing?(face: AdvanceTable.Face): ((text: string) => number | undefined) | null;
+    /**
+     * Whether the platform has `family` installed, so paints it as itself: what a font menu shows a
+     * missing family differently by. Only a builder that can see the platform's fonts has one.
+     *
+     * @returns `undefined` when this builder cannot tell.
+     */
+    isInstalled?(family: string): boolean | undefined;
+}
+//# sourceMappingURL=AdvanceBuilder.d.ts.map

package/types/src/font/AdvanceTable.d.ts

@@ -0,0 +1,228 @@
+import { IFont } from './IFont';
+import { SdkWasmExports } from '../wasm';
+/**
+ * One face's advances and vertical metrics, per em: one table per family, weight and style that
+ * serves every size.
+ *
+ * @remarks
+ * The TypeScript twin of `AdvanceTable` in the `sheetxl-text` crate, with the same rules, so a
+ * table measures alike before the wasm loads and after it. Advances are per em
+ * (`advance / unitsPerEm` from a font, `advance / px` from a canvas). A character with no advance
+ * measures as a space when it is white space and as nothing otherwise.
+ *
+ * Vertical metrics follow GDI: the font is realized at a whole-pixel em (`round(px)`), and the
+ * OS/2 `winAscent` and `winDescent` are scaled to it and rounded.
+ *
+ * A table given its `.hinted.json` ({@link applyHinting}) measures widths as GDI does too, and so
+ * as Excel does: each character's design-unit advance rounded at that whole-pixel em, plus the
+ * delta the original font's hinting moves it by there. Without one, widths are fractional.
+ */
+export declare class AdvanceTable implements IFont.AdvanceTable {
+    /** The family the table measures, as a style names it (`Calibri`, not its twin `Carlito`). */
+    readonly family: string;
+    /** The CSS weight, 400 regular and 700 bold. */
+    readonly weight: number;
+    readonly italic: boolean;
+    private readonly _vertical;
+    private readonly _perEm;
+    /** Design-unit advances, kept from a `.metrics.json`: what hinted widths round from. */
+    private readonly _units;
+    private _unitsPerEm;
+    /** Hinted deltas by ppem, then by codepoint; set once {@link applyHinting} has run. */
+    private _hinting;
+    /** Measures a character the table lacks, per em; see {@link setMeasureMissing}. */
+    private _measureMissing;
+    /** Excel's row pitch per integer ppem from `first`; set once {@link applyRows} has run. */
+    private _rows;
+    /** The table in the wasm, built on first ask from this table's data; see {@link native}. */
+    private _native;
+    /** Per-em advances recorded since the twin was built, written to it on the next ask. */
+    private _nativePending;
+    constructor(face: AdvanceTable.Face, vertical: AdvanceTable.VerticalPerEm);
+    /**
+     * A table from a captured `.metrics.json` (format `sheetxl-font-metrics/1`).
+     *
+     * @throws when the format is not one this reads.
+     */
+    static fromJSON(json: AdvanceTable.JSON): AdvanceTable;
+    /**
+     * Makes this a hinted table: widths from now on are GDI's whole pixels, from the companion
+     * `.hinted.json` (format `sheetxl-font-hinting/1`) captured from the original font.
+     *
+     * @throws when the format is not one this reads, or the file is for another face.
+     */
+    applyHinting(json: AdvanceTable.HintedJSON): void;
+    /** Whether widths are GDI's hinted whole pixels ({@link applyHinting}). */
+    get isHinted(): boolean;
+    /**
+     * Gives the table Excel's own row heights, from the companion `.rows.json` (format
+     * `sheetxl-font-rows/1`) captured from Excel: {@link metrics} then reports the pitch Excel
+     * autofits a row of this face to at each size. GDI's box plus 2 is Excel's up to about 22 pt
+     * and runs under it from there, by a per-font amount no table predicts.
+     *
+     * @throws when the format is not one this reads, or fewer than two sizes are listed.
+     */
+    applyRows(json: AdvanceTable.RowsJSON): void;
+    /** Whether row heights are Excel's captured ones ({@link applyRows}). */
+    get hasRows(): boolean;
+    /** The number of characters with an advance. */
+    get size(): number;
+    /** The advance of `codepoint` per em, or `undefined` when the table has none. */
+    advance(codepoint: number): number | undefined;
+    /**
+     * Records advances per em by codepoint, replacing earlier values: how a builder that measures
+     * (a canvas) fills a table.
+     */
+    set(entries: Iterable<readonly [codepoint: number, perEm: number]>): void;
+    /** Records one per-em advance, and queues it for the wasm twin when there is one. */
+    private _record;
+    /**
+     * This table in the wasm (the binding's `MetricsTable`), for the Rust wrapper to measure from:
+     * filled once from the same advances, hinted deltas and row pitches, and kept in step with them
+     * afterwards, so the wrapper measures exactly what {@link width} and {@link metrics} do. The
+     * table stays the owner; the twin is its view, freed by {@link release}.
+     *
+     * @param text Measured in first, character by character, when the table grows on demand
+     *   ({@link setMeasureMissing}): the twin cannot ask back across the boundary.
+     */
+    native(wasm: SdkWasmExports, text?: string): AdvanceTable.Native;
+    /** Whether {@link native} has built the wasm twin. */
+    get hasNative(): boolean;
+    /**
+     * Frees the wasm twin, if there is one; the next {@link native} builds it again. The wasm has
+     * no garbage collector, so a table that changes what it would answer ({@link applyHinting},
+     * {@link applyRows}) or goes out of use lets its twin go here.
+     */
+    release(): void;
+    private _buildNative;
+    /**
+     * Makes the table grow on demand: a character it lacks is measured by `measure` (its advance per
+     * em, or `undefined` when it cannot say) the first time it is asked for, and remembered. How a
+     * canvas fills a table, since no table built from one can list every character up front.
+     */
+    setMeasureMissing(measure: ((text: string) => number | undefined) | null): void;
+    /** The characters of `text` with no advance, each once, in first-seen order. */
+    missing(text: string): string[];
+    /**
+     * The advance width of `text` in px at `px` pixels per em: the advances summed, then the
+     * super/subscript scale, then `letterSpacing` between characters.
+     */
+    width(text: string, px: number, options?: AdvanceTable.WidthOptions): number;
+    /** One character's advance in px: hinted whole pixels when the table is hinted. */
+    private _advancePx;
+    /** The face's whole-px vertical metrics at `px` pixels per em. */
+    metrics(px: number): IFont.Metrics;
+    /**
+     * The underline at `px`: its center's offset above the baseline (negative below) and its
+     * thickness, in px; `null` when the source did not record one.
+     */
+    underline(px: number): AdvanceTable.LineRule | null;
+    /** The strikeout at `px`, as {@link underline}. */
+    strikeout(px: number): AdvanceTable.LineRule | null;
+    /**
+     * {@link width} and {@link metrics} together, with the underline and strikeout thickness in
+     * whole px as they are drawn (at least 1).
+     */
+    measure(text: string, px: number, options?: AdvanceTable.MeasureOptions): IFont.ExtendedMetrics;
+    /**
+     * The letter-spacing that paints `text` at `width` when the platform paints it with
+     * `options.paint`'s advances: the difference spread between the characters (CSS spacing is
+     * added after each character but the last, as {@link width} counts it).
+     */
+    private _renderLetterSpacing;
+}
+export declare namespace AdvanceTable {
+    /** The `format` of a `.metrics.json` this version reads. */
+    const FORMAT = "sheetxl-font-metrics/1";
+    /** The `format` of a `.hinted.json` this version reads. */
+    const HINTED_FORMAT = "sheetxl-font-hinting/1";
+    /**
+     * A captured `.hinted.json`, the companion of a `.metrics.json`: where the original font's
+     * hinting moves an advance off its rounded value, by size.
+     */
+    interface HintedJSON {
+        format: typeof HINTED_FORMAT;
+        family: string;
+        weight: number;
+        italic: boolean;
+        /** The original font the hinting programs were run from. */
+        source?: {
+            family: string;
+            version?: string;
+        };
+        /** The units the table's advances are in; must match the table's. */
+        unitsPerEm: number;
+        /**
+         * `[ppem, [codepoint, delta, codepoint, delta, ...]]`: whole px over the advance rounded at
+         * that ppem. A size not listed moves no advance.
+         */
+        sizes: [number, number[]][];
+    }
+    /** The `format` of a `.rows.json` this version reads. */
+    const ROWS_FORMAT = "sheetxl-font-rows/1";
+    /**
+     * A captured `.rows.json`, the companion of a `.metrics.json`: Excel's autofit row height for
+     * the face, in px at 96 dpi, at every integer ppem from `firstPpem` up to where the row reaches
+     * Excel's 409 pt cap (`private-assets/design/rust/tools/capture-excel-row-heights.ps1`).
+     */
+    interface RowsJSON {
+        format: typeof ROWS_FORMAT;
+        family: string;
+        weight: number;
+        italic: boolean;
+        source?: {
+            application?: string;
+            dpi?: number;
+        };
+        firstPpem: number;
+        /** `pitches[i]` is the pitch at `firstPpem + i`. */
+        pitches: number[];
+    }
+    /** Excel's row pitch per integer ppem, from `first` on. */
+    interface RowPitches {
+        readonly first: number;
+        readonly pitches: readonly number[];
+    }
+    /** A table's twin in the wasm: the binding's `MetricsTable` (`crates/sheetxl-wasm-sdk`). */
+    type Native = InstanceType<SdkWasmExports['MetricsTable']>;
+    type Face = IFont.AdvanceTable.Face;
+    type WidthOptions = IFont.AdvanceTable.WidthOptions;
+    type MeasureOptions = IFont.AdvanceTable.MeasureOptions;
+    type LineRule = IFont.AdvanceTable.LineRule;
+    /** Vertical metrics per em. */
+    interface VerticalPerEm {
+        /** OS/2 `winAscent` per em. */
+        ascent: number;
+        /** OS/2 `winDescent` per em, positive below the baseline. */
+        descent: number;
+        underline?: LineRule | null;
+        strikeout?: LineRule | null;
+    }
+    /**
+     * A captured `.metrics.json`: the advances and vertical metrics of one face, in design units,
+     * with the font it was captured from.
+     */
+    interface JSON {
+        format: typeof FORMAT;
+        family: string;
+        weight: number;
+        italic: boolean;
+        /** The font measured, when it is a metric-compatible twin of `family`, and its license. */
+        source?: {
+            family: string;
+            version?: string;
+            license?: string;
+            notice?: string;
+        };
+        unitsPerEm: number;
+        winAscent: number;
+        winDescent: number;
+        /** `[position, thickness]` in design units. */
+        underline?: [number, number];
+        /** `[position, thickness]` in design units. */
+        strikeout?: [number, number];
+        /** Runs of consecutive codepoints: `[first codepoint, advances in design units]`. */
+        advances: [number, number[]][];
+    }
+}
+//# sourceMappingURL=AdvanceTable.d.ts.map

package/types/src/font/CanvasAdvanceBuilder.d.ts

@@ -0,0 +1,54 @@
+import { AdvanceBuilder } from './AdvanceBuilder';
+import { AdvanceTable } from './AdvanceTable';
+/** The part of a 2D context the builder uses. */
+export interface MeasureContext {
+    font: string;
+    measureText(text: string): {
+        width: number;
+        fontBoundingBoxAscent?: number;
+        fontBoundingBoxDescent?: number;
+    };
+}
+/**
+ * Builds tables in a browser for families we have no captured table for, by
+ * measuring with a canvas: each character once, at one size, stored per em, so the table serves
+ * every size. Characters beyond printable ASCII are measured the first time text uses them.
+ *
+ * @remarks
+ * Advances are the browser's own (unhinted, fractional), which is what it paints with. The vertical
+ * metrics come from the canvas's font box and are the only approximate numbers: a canvas does not
+ * expose the OS/2 `win` metrics Excel sizes rows with.
+ *
+ * A family the browser does not have gets no table. Cells are painted by the style's family list,
+ * so the browser paints such a family as the first fallback it has, while the bare name measures
+ * as the browser's default face (Michael's `testing_b`: measured as Times New Roman, painted as
+ * Arial, clipped). The collection measures the fallbacks instead, in the browser's order, and a
+ * CSS generic name among them is built here as the face the browser paints for it.
+ */
+export declare class CanvasAdvanceBuilder implements AdvanceBuilder {
+    readonly name = "canvas";
+    readonly kind = "exact";
+    private readonly _createContext;
+    private _context;
+    /**
+     * @param createContext Where to measure; a 2D context of an offscreen canvas by default.
+     */
+    constructor(createContext?: () => MeasureContext | null);
+    build(face: AdvanceTable.Face): Promise<AdvanceTable | null>;
+    /**
+     * What the browser paints `face` with when a cell names `families`: the same canvas measure, of
+     * the whole CSS stack, with no question asked about which face answers. Where the cell's own
+     * table is Excel's hinted one, this is what the hinted widths are reconciled to.
+     */
+    paint(face: AdvanceTable.Face, families: readonly string[]): Promise<AdvanceTable | null>;
+    /**
+     * Measures a character a captured table lacks as the browser paints it in `face`: the face
+     * itself when installed, or the browser's fallback for that character.
+     */
+    measureMissing(face: AdvanceTable.Face): ((text: string) => number | undefined) | null;
+    /** Whether the browser has `family`, by the same telltale {@link build} uses; a CSS generic always. */
+    isInstalled(family: string): boolean | undefined;
+    private _measure;
+    private _ctx;
+}
+//# sourceMappingURL=CanvasAdvanceBuilder.d.ts.map

package/types/src/font/FontCapture.d.ts

@@ -0,0 +1,4 @@
+import { IFont } from './IFont';
+/** {@inheritDoc IFont.captureTables} */
+export declare function captureTables(bytes: Uint8Array, options?: IFont.CaptureOptions): Promise<IFont.CapturedFace[]>;
+//# sourceMappingURL=FontCapture.d.ts.map