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

package/types/src/.generated/wasm/fonts.d.ts

@@ -0,0 +1,161 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A face's names and style (`sheetxl_text::identity::FaceIdentity`).
+ */
+export class FaceInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The `fsSelection` bold bit.
+     */
+    bold: boolean;
+    /**
+     * The family as GDI and Excel name it (`name` id 1).
+     */
+    family: string;
+    /**
+     * `name` id 4.
+     */
+    full_name: string;
+    /**
+     * The `fsSelection` italic bit.
+     */
+    italic: boolean;
+    /**
+     * `name` id 6.
+     */
+    postscript_name: string;
+    /**
+     * The style within `family` (`name` id 2).
+     */
+    subfamily: string;
+    /**
+     * The designer's family (`name` id 16), or `family`.
+     */
+    typographic_family: string;
+    /**
+     * `name` id 5, up to its first `;`.
+     */
+    version: string;
+    /**
+     * `usWeightClass`.
+     */
+    weight: number;
+}
+
+/**
+ * A face's tables, as the text of the files the sdk reads.
+ */
+export class FaceTables {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The `.hinted.json`, or `undefined` when no sizes were asked for.
+     */
+    get hinted(): string | undefined;
+    /**
+     * The `.hinted.json`, or `undefined` when no sizes were asked for.
+     */
+    set hinted(value: string | null | undefined);
+    /**
+     * The `.metrics.json`.
+     */
+    metrics: string;
+}
+
+/**
+ * The faces of one font file: one for a `.ttf` or `.otf`, each member of a `.ttc` or `.otc`.
+ */
+export class FontFile {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The tables of face `index`, recorded as `family`, with hinted widths at every ppem from
+     * `first_ppem` to `last_ppem` (none when `last_ppem < first_ppem`). `source_file`, when
+     * given, is recorded as the font file's name (`MetricsCapture::with_source_file`).
+     *
+     * The hinting is the slow part: about 1.2 s a face over 6-120 ppem; call per face so a host
+     * can report progress between them.
+     */
+    capture(index: number, family: string, first_ppem: number, last_ppem: number, source_file?: string | null): FaceTables;
+    /**
+     * The number of usable faces.
+     */
+    face_count(): number;
+    /**
+     * The names and style of face `index`.
+     */
+    identity(index: number): FaceInfo;
+    /**
+     * Opens a font file's bytes.
+     *
+     * Throws when the bytes are not a font. A collection member that is not a usable face is
+     * left out, so [`Self::face_count`] can be less than the file's own count.
+     */
+    constructor(bytes: Uint8Array);
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_faceinfo_free: (a: number, b: number) => void;
+    readonly __wbg_facetables_free: (a: number, b: number) => void;
+    readonly __wbg_fontfile_free: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_bold: (a: number) => number;
+    readonly __wbg_get_faceinfo_family: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_full_name: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_italic: (a: number) => number;
+    readonly __wbg_get_faceinfo_postscript_name: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_subfamily: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_typographic_family: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_version: (a: number, b: number) => void;
+    readonly __wbg_get_faceinfo_weight: (a: number) => number;
+    readonly __wbg_get_facetables_hinted: (a: number, b: number) => void;
+    readonly __wbg_get_facetables_metrics: (a: number, b: number) => void;
+    readonly __wbg_set_faceinfo_bold: (a: number, b: number) => void;
+    readonly __wbg_set_faceinfo_family: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_full_name: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_italic: (a: number, b: number) => void;
+    readonly __wbg_set_faceinfo_postscript_name: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_subfamily: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_typographic_family: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_version: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_faceinfo_weight: (a: number, b: number) => void;
+    readonly __wbg_set_facetables_hinted: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_facetables_metrics: (a: number, b: number, c: number) => void;
+    readonly fontfile_capture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly fontfile_face_count: (a: number) => number;
+    readonly fontfile_identity: (a: number, b: number, c: number) => void;
+    readonly fontfile_new: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/types/src/.generated/wasm/fonts_bg.inline.d.ts

@@ -0,0 +1,3 @@
+/** The WebAssembly binary `fonts_bg.wasm`, base64-encoded. */
+declare const wasmBase64: string;
+export default wasmBase64;

package/types/src/.generated/wasm/sdk.d.ts

@@ -0,0 +1,122 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A face's measures, filled once by the host from a shipped table or a canvas, then wrapped
+ * against any number of times (DESIGN-FONTS §6.2, shape C; DESIGN-FONTS §4).
+ */
+export class MetricsTable {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Records design-unit advances, `codepoints[i]` → `advances[i]`, in `units_per_em` units:
+     * what a `.metrics.json` lists, and what [`Self::fill_hinting`] rounds from.
+     */
+    fill(units_per_em: number, codepoints: Uint32Array, advances: Uint16Array): void;
+    /**
+     * Records hinted deltas at `ppem`, `codepoints[i]` → `deltas[i]`, from a `.hinted.json`;
+     * the table measures GDI's whole-pixel widths from then on.
+     */
+    fill_hinting(ppem: number, codepoints: Uint32Array, deltas: Int16Array): void;
+    /**
+     * Records per-em advances, `codepoints[i]` → `per_em[i]`: a canvas's measures, or
+     * characters measured on demand after [`Self::fill`].
+     */
+    fill_per_em(codepoints: Uint32Array, per_em: Float32Array): void;
+    /**
+     * Records Excel's row pitch at every integer ppem from `first_ppem`, from a `.rows.json`;
+     * `line_pitch` and `wrap` size lines by it from then on. `false` with fewer than two sizes.
+     */
+    fill_rows(first_ppem: number, pitches: Uint16Array): boolean;
+    /**
+     * Whether nothing has been recorded.
+     */
+    is_empty(): boolean;
+    /**
+     * The number of characters recorded.
+     */
+    len(): number;
+    /**
+     * Excel's row height for this face at `px` pixels per em.
+     */
+    line_pitch(px: number): number;
+    /**
+     * An empty table for a face with these vertical metrics per em (`usWinAscent / unitsPerEm`,
+     * `usWinDescent / unitsPerEm`): what the host's own table keeps, whether it came from a
+     * `.metrics.json` or a canvas.
+     */
+    constructor(ascent: number, descent: number);
+    /**
+     * The advance width of `text` at `px` pixels per em.
+     */
+    text_width(text: string, px: number, letter_spacing: number, super_sub: boolean): number;
+    /**
+     * Wraps `text`; `max_width` and `max_height` of zero or less mean none. Returns the lines
+     * flat, eight numbers each (`sheetxl_text::wrap::Wrapped::flatten`).
+     *
+     * Scalars rather than an options object, deliberately: each crosses for free, an object
+     * would be marshalled.
+     */
+    wrap(text: string, px: number, max_width: number, max_height: number, indent: number, letter_spacing: number, super_sub: boolean): Float32Array;
+}
+
+/**
+ * The alphabetic baseline's offset from the top of a line box of [`line_pitch`] height.
+ */
+export function baseline(ascent: number, descent: number): number;
+
+/**
+ * The number of Unicode scalar values in `text` (not `text.length`, which counts UTF-16 units).
+ */
+export function char_count(text: string): number;
+
+/**
+ * Excel's line pitch for a font: `ascent + descent + 2`, in whole pixels.
+ */
+export function line_pitch(ascent: number, descent: number): number;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_metricstable_free: (a: number, b: number) => void;
+    readonly baseline: (a: number, b: number) => number;
+    readonly char_count: (a: number, b: number) => number;
+    readonly line_pitch: (a: number, b: number) => number;
+    readonly metricstable_fill: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly metricstable_fill_hinting: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly metricstable_fill_per_em: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly metricstable_fill_rows: (a: number, b: number, c: number, d: number) => number;
+    readonly metricstable_is_empty: (a: number) => number;
+    readonly metricstable_len: (a: number) => number;
+    readonly metricstable_line_pitch: (a: number, b: number) => number;
+    readonly metricstable_new: (a: number, b: number) => number;
+    readonly metricstable_text_width: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly metricstable_wrap: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/types/src/.generated/wasm/sdk_bg.inline.d.ts

@@ -0,0 +1,3 @@
+/** The WebAssembly binary `sdk_bg.wasm`, base64-encoded. */
+declare const wasmBase64: string;
+export default wasmBase64;

package/types/src/address/AddressUtils.d.ts

@@ -71,6 +71,15 @@ export declare function stringToSheetRange(str: string, rangeDefault?: Readonly<
  * This doesn't fail but will return null if unable to parse.
  */
 export declare function stringToWorkbookRange(str: string, defaultRange?: Readonly<IRange.Coords>, allowR1C1?: boolean): Partial<IRange.FixableCoords> | null;
+/**
+ * Splits an address list at its `,` separators, skipping those inside a quoted sheet name
+ * (`'Q1, Q2'!A1`) or a structured reference's brackets (`Table1[[#Headers],[Qty]]`).
+ *
+ * @remarks
+ * Whitespace around a separator is dropped. Inside brackets a `'` escapes the character after it
+ * when that is `[`, `]`, `#` or `'`, as in a column specifier.
+ */
+export declare function splitAddressList(address: string): string[];
 /**
  * Parse a string into an array of coords.
  *
@@ -106,7 +115,7 @@ export declare function fasterStringToCell(address: string, _reuse: IRange.Fixab
 export declare function fastStringToCol(address: string): number;
 /**
  * `Fast` decode ranges but has no error checking.
- * If does not support fixed cells, sheets, or partials. Useful
+ * Absolute markers (`$A$1`) are read as relative. Does not support sheets or partials. Useful
  * for reading from save strings.
  */
 export declare function fastStringToRange(address: string, _reuse?: IRange.Coords): IRange.Coords;

package/types/src/address/_StructuredAddress.d.ts

@@ -0,0 +1,58 @@
+import { IRange } from '@sheetxl/primitives';
+import { INamed } from '../named';
+import { IWorksheet } from '../sheet';
+import { ITable } from '../table';
+/**
+ * A structured reference as an address spells it — `Table1[[#Headers],[Qty]:[Price]]` — by name.
+ *
+ * @remarks
+ * The same reading the formula parser gives the text, before linking turns names into ids: a
+ * well-formed reference reads identically through both. Where the formula parser lets a malformed
+ * one through as something else (`Table1[#Foo]` as the data body), this rejects it.
+ */
+export interface StructuredAddress {
+    /** The table's name; `''` for an unqualified reference (`[Qty]`). */
+    table: string;
+    /** The section, numbered as `StructuredReference.spec` numbers it. */
+    spec: number;
+    /** The first (or only) column's name, or `null` for every column. */
+    columnFrom: string | null;
+    /** The last column's name; the same as {@link columnFrom} for a single column. */
+    columnTo: string | null;
+    /** `@` / `#This Row`: only the row of the cell it is read from. */
+    isThisRow: boolean;
+}
+/**
+ * Reads `text` as a structured reference, or returns `null` when it is not one.
+ *
+ * @remarks
+ * Takes the canonical spelling: English section words and `,` between items. A reference into
+ * another workbook (`[1]!Table1[Col]`) is not read.
+ */
+export declare function parseStructuredAddress(text: string): StructuredAddress | null;
+/**
+ * What a structured-reference address is resolved against.
+ */
+export interface StructuredAddressContext {
+    /** The table a name designates. */
+    getTable(name: string): ITable | null;
+    /**
+     * The cell an address is read from — the active cell. An unqualified reference takes the table
+     * there, and `@` takes its row.
+     */
+    getAnchor(): {
+        sheet: IWorksheet;
+        coords: IRange.CellCoords;
+    } | null;
+}
+/** The table `named` designates, or `null` when it is not a table's name. */
+export declare function namedTable(named: INamed | null | undefined): ITable | null;
+/**
+ * The cells a structured-reference address designates, scoped by sheet name, or `null` when `text`
+ * is not a structured reference.
+ *
+ * @throws {@link ExpectedError} when `text` is a structured reference that designates no cells, or a
+ * reference into another workbook.
+ */
+export declare function resolveStructuredAddress(text: string, ctx: StructuredAddressContext): IRange.FixableCoords | null;
+//# sourceMappingURL=_StructuredAddress.d.ts.map

package/types/src/anchored/AbstractAnchored.d.ts

@@ -8,7 +8,7 @@ import { ListenerEmitter } from '../listener/ListenerEmitter';
 /**
  * Abstract implement of {@link IAnchorItem}.
  */
-export declare abstract class AbstractAnchored<STATE extends AbstractAnchored.State = AbstractAnchored.State, VIEW extends AbstractAnchored.CommitView = AbstractAnchored.CommitView, EVENTS extends IAnchored.Events = IAnchored.Events> implements IAnchored, ITransaction.ITransactional, IListener.ISource<IAnchored> {
+export declare abstract class AbstractAnchored<STATE extends AbstractAnchored.State = AbstractAnchored.State, EVENTS extends IAnchored.Events = IAnchored.Events> implements IAnchored, ITransaction.ITransactional, IListener.ISource<IAnchored> {
     protected _options: Anchored.ConstructorOptions;
     protected _emitter: ListenerEmitter<IAnchored, EVENTS>;
     private _transactions;
@@ -17,6 +17,8 @@ export declare abstract class AbstractAnchored<STATE extends AbstractAnchored.St
     private _closed;
     protected _range: ICellRange | null;
     protected _ranges: ICellRanges | null;
+    private _rangeAnchor;
+    private _rangesAnchor;
     constructor(options: Anchored.ConstructorOptions);
     protected _initializeOptions(options: Anchored.ConstructorOptions): Anchored.ConstructorOptions;
     protected _initialize(options: Anchored.ConstructorOptions): void;
@@ -107,11 +109,16 @@ export declare abstract class AbstractAnchored<STATE extends AbstractAnchored.St
     /** @internal */
     protected _processTransactionDone(_transaction: ITransaction): void;
     protected _getState(): Readonly<STATE>;
-    protected _beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
+    protected _beginCommit(options?: string | ITransaction.StoreOperationOptions): ITransaction;
     protected _getTransactions(): ITransaction.IStore;
     protected _updateState(updateState?: Partial<STATE>, //(prevState: STATE) => STATE,
     options?: string | ITransaction.OperationOptions | null, events?: (keyof EVENTS)[] | null, skipProtection?: boolean): this;
     protected _notify(events?: (keyof EVENTS)[] | keyof EVENTS): void;
+    /**
+     * Whether this model announces `onAnyChange` itself, once for every change of its state (undo and
+     * redo included), so that {@link _notify} must not add it to what a writer announces.
+     */
+    protected _isAnyChangeFromState(): boolean;
     /**
      * The authoritative anchor write for a shift.
      *
@@ -125,16 +132,21 @@ export declare abstract class AbstractAnchored<STATE extends AbstractAnchored.St
     /** @internal */
     protected _processContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;
     /** @internal */
-    protected _processBeforeCommitStart(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
-    /** @internal */
-    protected _processAfterStateChange(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
+    protected _processBeforeCommitStart(_state: STATE, _commit: ITransaction.ICommit): void;
+    /**
+     * Called after this item's state changed: by a commit, or by an undo (`isRevert`) or redo
+     * (`isRestore`) that landed on a different state for it. Items whose state the undo or redo
+     * left alone are not called.
+     * @internal
+     */
+    protected _processAfterStateChange(_state: STATE, _commit: ITransaction.ICommit, _isRevert?: boolean, _isRestore?: boolean): void;
     /**
      * Called before local commit
      * @internal
      */
     protected _processUpdateState(prevState: Partial<STATE>, newState: Partial<STATE>): void;
     /** @internal */
-    protected _processRestoreOrRevert(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
+    protected _processRestoreOrRevert(_state: STATE, _commit: ITransaction.ICommit): void;
     /** @internal */
     protected _processAnchorCoords(): void;
     /** @internal */
@@ -194,7 +206,5 @@ export declare namespace AbstractAnchored {
         anchorType: IAnchored.Type;
         isDeleted: boolean;
     }
-    interface CommitView {
-    }
 }
 //# sourceMappingURL=AbstractAnchored.d.ts.map

package/types/src/anchored/AnchoredMap.d.ts

@@ -108,6 +108,8 @@ export declare class AnchoredMap<T extends IAnchored, J, P = any> implements IAn
     has(range: Readonly<IRange.Coords>): boolean;
     /** {@inheritDoc IAnchoredMap.shift} */
     shift(options: IAnchoredMap.ShiftOptions): this;
+    /** {@inheritDoc IAnchoredMap.copyTo} */
+    copyTo(topLeft: IRange.CellCoords, from: IRange.Coords, move?: boolean): this;
     /**
      * Applies a per-model entry delta, then notifies each affected model **exactly once**.
      *

package/types/src/anchored/IAnchoredMap.d.ts

@@ -111,6 +111,37 @@ export interface IAnchoredMap<T extends IAnchored, J = any> extends ISpatialQuer
      * @param options The options for the shift.
      */
     shift(options: IAnchoredMap.ShiftOptions): this;
+    /**
+     * Copies every range the source rectangle carries to a destination, optionally removing the
+     * source - which is what a cut is.
+     *
+     * @param topLeft Where the source's top-left cell lands. The destination's extent is the
+     * source's, so naming the corner is the whole of it; a destination RANGE would carry a size
+     * nobody reads and could disagree with `from`.
+     * @param from The source rectangle.
+     * @param move Remove the source entries, making this a cut rather than a copy.
+     *
+     * @returns The map as the copy leaves it - `this` when nothing was carried.
+     *
+     * @remarks
+     * The spatial copy path ({@link ISpatialMap.createCopiedEntries}), so an anchored range is
+     * carried the way every other spatial value is: an entry the source encloses is carried whole;
+     * one that crosses the source boundary is split and its enclosed part carried - or, for a map
+     * whose entries cannot be split ({@link ConstructorOptions.isSplittable}), left behind whole.
+     * What the carried entry is comes from the value's own
+     * {@link ISpatialMap.IUpdatableValue.copyTo}; the default carries the value across untouched,
+     * so the model's identity survives, and a {@link CreateEntryOptions.createEntry} may supply
+     * another.
+     *
+     * The destination is this map. Copying into ANOTHER map - which is what a cut to another sheet
+     * needs - waits for a consumer: this map is copy-on-write, so a cross-map copy has to hand back
+     * both a source without the entries and a destination with them, and no caller wants that yet.
+     *
+     * A copy (`move` unset) leaves the source where it is and gives the same MODEL a second
+     * rectangle. Whether a copy should instead mint a new model is undecided; only the cut has a
+     * consumer today.
+     */
+    copyTo(topLeft: IRange.CellCoords, from: IRange.Coords, move?: boolean): this;
     /**
      * Remove all models at range.
      */
@@ -155,6 +186,25 @@ export declare namespace IAnchoredMap {
          * Get the entire range of the current model.
          */
         getEntireRange: () => ICellRange;
+        /**
+         * Whether this map's entries may be cut into pieces.
+         *
+         * @defaultValue `true`
+         *
+         * @remarks
+         * `false` says an entry is indivisible: on a partial shift the whole of it moves, the way a
+         * formula precedent does, rather than fragmenting into the part that moved and the part that
+         * did not. See {@link ISpatialMap.UpdateOptions.isSplittable}.
+         */
+        isSplittable?: boolean;
+        /**
+         * Shifts one entry of a model, in place of the map's own arithmetic.
+         *
+         * @remarks
+         * Returns the entry's new coords, `null` to remove it, or `undefined` to keep the map's answer.
+         * Called once per entry the shift reaches, with the map's own answer in `details.after`.
+         */
+        shiftEntry?: (model: IAnchored, details: ISpatialMap.ShiftDetails) => IRange.Coords | null | undefined;
     }
     interface CreateEntryOptions<T extends IAnchored> {
         /**
@@ -165,7 +215,8 @@ export declare namespace IAnchoredMap {
          * If provided then will allow for custom Anchored.Entry.
          *
          * @remarks
-         * Useful when the entries have custom merge/split or other spatial logic..
+         * Useful when the entries have custom merge/split or other spatial logic. A value without a
+         * `getSplit` or a `copyTo` is given the map's default for it.
          */
         createEntry?: (model: T, coords: IRange.Coords) => Anchored.Entry2<T>;
         /**
@@ -182,9 +233,6 @@ export declare namespace IAnchoredMap {
          */
         invalidate?: (coords?: IRange.Coords) => void;
     }
-    /**
-     * Options for the shift method on the Index.
-     */
     interface ShiftOptions {
         /**
          * The range to shift.