pixel-react 1.4.4 → 1.4.5

package/lib/components/ExcelFile/ExcelFile/Excel/actions.d.ts

@@ -0,0 +1,130 @@
+import { Matrix } from "./matrix";
+import { Point } from "./point";
+import { CellBase, Dimensions, CommitChanges, CreateFormulaParser } from "./types";
+import { Selection } from "./selection";
+export declare const SET_DATA = "SET_DATA";
+export declare const SET_CREATE_FORMULA_PARSER = "SET_CREATE_FORMULA_PARSER";
+export declare const SELECT_ENTIRE_ROW = "SELECT_ENTIRE_ROW";
+export declare const SELECT_ENTIRE_COLUMN = "SELECT_ENTIRE_COLUMN";
+export declare const SELECT_ENTIRE_WORKSHEET = "SELECT_ENTIRE_WORKSHEET";
+export declare const SET_SELECTION = "SET_SELECTION";
+export declare const SELECT = "SELECT";
+export declare const ACTIVATE = "ACTIVATE";
+export declare const SET_CELL_DATA = "SET_CELL_DATA";
+export declare const SET_CELL_DIMENSIONS = "SET_CELL_DIMENSIONS";
+export declare const COPY = "COPY";
+export declare const CUT = "CUT";
+export declare const PASTE = "PASTE";
+export declare const EDIT = "EDIT";
+export declare const VIEW = "VIEW";
+export declare const CLEAR = "CLEAR";
+export declare const BLUR = "BLUR";
+export declare const KEY_PRESS = "KEY_PRESS";
+export declare const KEY_DOWN = "KEY_DOWN";
+export declare const DRAG_START = "DRAG_START";
+export declare const DRAG_END = "DRAG_END";
+export declare const COMMIT = "COMMIT";
+export type BaseAction<T extends string> = {
+    type: T;
+};
+export type SetDataAction = BaseAction<typeof SET_DATA> & {
+    payload: {
+        data: Matrix<CellBase>;
+    };
+};
+export declare function setData(data: Matrix<CellBase>): SetDataAction;
+export type SetCreateFormulaParserAction = BaseAction<typeof SET_CREATE_FORMULA_PARSER> & {
+    payload: {
+        createFormulaParser: CreateFormulaParser;
+    };
+};
+export declare function setCreateFormulaParser(createFormulaParser: CreateFormulaParser): SetCreateFormulaParserAction;
+export type SelectEntireRowAction = BaseAction<typeof SELECT_ENTIRE_ROW> & {
+    payload: {
+        row: number;
+        extend: boolean;
+    };
+};
+export declare function selectEntireRow(row: number, extend: boolean): SelectEntireRowAction;
+export type SelectEntireColumnAction = BaseAction<typeof SELECT_ENTIRE_COLUMN> & {
+    payload: {
+        column: number;
+        extend: boolean;
+    };
+};
+export declare function selectEntireColumn(column: number, extend: boolean): SelectEntireColumnAction;
+export type SelectEntireWorksheetAction = BaseAction<typeof SELECT_ENTIRE_WORKSHEET>;
+export declare function selectEntireWorksheet(): SelectEntireWorksheetAction;
+export type SetSelectionAction = BaseAction<typeof SET_SELECTION> & {
+    payload: {
+        selection: Selection;
+    };
+};
+export declare function setSelection(selection: Selection): SetSelectionAction;
+export type SelectAction = BaseAction<typeof SELECT> & {
+    payload: {
+        point: Point;
+    };
+};
+export declare function select(point: Point): SelectAction;
+export type ActivateAction = BaseAction<typeof ACTIVATE> & {
+    payload: {
+        point: Point;
+    };
+};
+export declare function activate(point: Point): ActivateAction;
+export type SetCellDataAction = BaseAction<typeof SET_CELL_DATA> & {
+    payload: {
+        active: Point;
+        data: CellBase;
+    };
+};
+export declare function setCellData(active: Point, data: CellBase): SetCellDataAction;
+export type SetCellDimensionsAction = BaseAction<typeof SET_CELL_DIMENSIONS> & {
+    payload: {
+        point: Point;
+        dimensions: Dimensions;
+    };
+};
+export declare function setCellDimensions(point: Point, dimensions: Dimensions): SetCellDimensionsAction;
+export type PasteAction = BaseAction<typeof PASTE> & {
+    payload: {
+        data: string;
+    };
+};
+export declare function paste(data: string): PasteAction;
+export type KeyPressAction = BaseAction<typeof KEY_PRESS> & {
+    payload: {
+        event: React.KeyboardEvent;
+    };
+};
+export declare function keyPress(event: React.KeyboardEvent): KeyPressAction;
+export type KeyDownAction = BaseAction<typeof KEY_DOWN> & {
+    payload: {
+        event: React.KeyboardEvent;
+    };
+};
+export declare function keyDown(event: React.KeyboardEvent): KeyDownAction;
+export type DragStartAction = BaseAction<typeof DRAG_START>;
+export declare function dragStart(): DragStartAction;
+export type DragEndAction = BaseAction<typeof DRAG_END>;
+export declare function dragEnd(): DragEndAction;
+export type CommitAction = BaseAction<typeof COMMIT> & {
+    payload: {
+        changes: CommitChanges;
+    };
+};
+export declare function commit(changes: CommitChanges): CommitAction;
+export type CopyAction = BaseAction<typeof COPY>;
+export declare function copy(): CopyAction;
+export type CutAction = BaseAction<typeof CUT>;
+export declare function cut(): CutAction;
+export type EditAction = BaseAction<typeof EDIT>;
+export declare function edit(): EditAction;
+export type ViewAction = BaseAction<typeof VIEW>;
+export declare function view(): ViewAction;
+export type ClearAction = BaseAction<typeof CLEAR>;
+export declare function clear(): ClearAction;
+export type BlurAction = BaseAction<typeof BLUR>;
+export declare function blur(): BlurAction;
+export type Action = SetDataAction | SetCreateFormulaParserAction | SelectEntireRowAction | SelectEntireColumnAction | SelectEntireWorksheetAction | SetSelectionAction | SelectAction | ActivateAction | SetCellDataAction | SetCellDimensionsAction | PasteAction | KeyPressAction | KeyDownAction | DragStartAction | DragEndAction | CommitAction | CopyAction | CutAction | EditAction | ViewAction | ClearAction | BlurAction;

package/lib/components/ExcelFile/ExcelFile/Excel/areModelsEqual.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/ExcelFile/ExcelFile/Excel/context.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import reducer from "./reducer";
+import { Action } from "./actions";
+export type ReducerState = React.ReducerState<typeof reducer>;
+export type Dispatch = React.Dispatch<Action>;
+export type Value = [ReducerState, Dispatch];
+declare const context: import("use-context-selector").Context<Value>;
+export default context;

package/lib/components/ExcelFile/ExcelFile/Excel/engine/engine.d.ts

@@ -0,0 +1,22 @@
+import FormulaParser, { Value } from "fast-formula-parser";
+import * as Matrix from "../matrix";
+import { Point } from "../point";
+import { CellBase, CreateFormulaParser } from "../types";
+import { PointGraph } from "./point-graph";
+export declare class Model<Cell extends CellBase> {
+    readonly data: Matrix.Matrix<Cell>;
+    readonly evaluatedData: Matrix.Matrix<Cell>;
+    readonly referenceGraph: PointGraph;
+    readonly createFormulaParser: CreateFormulaParser;
+    constructor(createFormulaParser: CreateFormulaParser, data: Matrix.Matrix<Cell>, referenceGraph?: PointGraph, evaluatedData?: Matrix.Matrix<Cell>);
+}
+export declare function updateCellValue<Cell extends CellBase>(model: Model<Cell>, point: Point, cell: Cell): Model<Cell>;
+/**
+ *
+ * @param data - the spreadsheet data
+ * @returns the spreadsheet reference graph
+ */
+export declare function createReferenceGraph(data: Matrix.Matrix<CellBase>): PointGraph;
+export declare function createEvaluatedData<Cell extends CellBase>(data: Matrix.Matrix<Cell>, referenceGraph: PointGraph, createFormulaParser: CreateFormulaParser): Matrix.Matrix<Cell>;
+/** Get the computed value of a formula cell */
+export declare function getFormulaComputedValue(value: string, point: Point, formulaParser: FormulaParser): Value;

package/lib/components/ExcelFile/ExcelFile/Excel/engine/formula.d.ts

@@ -0,0 +1,17 @@
+import FormulaParser, { FormulaParserConfig, Value } from "fast-formula-parser";
+import { Point } from "../point";
+import * as Matrix from "../matrix";
+import { CellBase } from "../types";
+import { PointSet } from "./point-set";
+export declare const FORMULA_VALUE_PREFIX = "=";
+/** Returns whether given value is a formula */
+export declare function isFormulaValue(value: unknown): value is string;
+/** Extracts formula from value  */
+export declare function extractFormula(value: string): string;
+export declare function createFormulaParser(data: Matrix.Matrix<CellBase>, config?: Omit<FormulaParserConfig, "onCell" | "onRange">): FormulaParser;
+/**
+ * For given formula returns the cell references
+ * @param formula - formula to get references for
+ */
+export declare function getReferences(formula: string, point: Point, data: Matrix.Matrix<CellBase>): PointSet;
+export declare function evaluate(formula: string, point: Point, formulaParser: FormulaParser): Value;

package/lib/components/ExcelFile/ExcelFile/Excel/engine/index.d.ts

@@ -0,0 +1,2 @@
+export { Model, updateCellValue } from "./engine";
+export { createFormulaParser } from "./formula";

package/lib/components/ExcelFile/ExcelFile/Excel/engine/point-graph.d.ts

@@ -0,0 +1,21 @@
+import { Point } from "../point";
+import { PointSet } from "./point-set";
+/**
+ * Immutable directed graph of points, where each point can have multiple
+ * edges to other points.
+ */
+export declare class PointGraph {
+    private forwards;
+    private constructor();
+    /** Creates a new PointGraph instance from an array-like or iterable object */
+    static from(pairs: Iterable<[Point, PointSet]>): PointGraph;
+    set(node: Point, edges: PointSet): PointGraph;
+    get(node: Point): PointSet;
+    getBackwards(node: Point): PointSet;
+    getBackwardsRecursive(node: Point, visited?: PointSet): PointSet;
+    /** Determine whether the graph has a circular dependency, starting from given start point */
+    hasCircularDependency(startPoint: Point): boolean;
+    [Symbol.iterator](): Iterator<[Point, PointSet]>;
+    /** Get the points in the graph in a breadth-first order */
+    traverseBFSBackwards(): Generator<Point>;
+}

package/lib/components/ExcelFile/ExcelFile/Excel/engine/point-hash.d.ts

@@ -0,0 +1,3 @@
+import { Point } from "../point";
+export declare function toString(point: Point): string;
+export declare function fromString(point: string): Point;

package/lib/components/ExcelFile/ExcelFile/Excel/engine/point-set.d.ts

@@ -0,0 +1,24 @@
+import * as Point from "../point";
+/**
+ * Immutable Set like interface of points
+ */
+export declare class PointSet {
+    private set;
+    private constructor();
+    /** Creates a new PointSet instance from an array-like or iterable object */
+    static from(points: Iterable<Point.Point>): PointSet;
+    /** Returns a boolean asserting whether an point is present with the given value in the Set object or not */
+    has(point: Point.Point): boolean;
+    /** Returns the number of points in a PointSet object */
+    get size(): number;
+    /** Add the given point to given set */
+    add(point: Point.Point): PointSet;
+    /** Remove the given point from the given set */
+    delete(point: Point.Point): PointSet;
+    /** Returns a new PointSet with points common to the set and other */
+    difference(other: PointSet): PointSet;
+    /** Returns a new PointSet with all points in both sets */
+    union(other: PointSet): PointSet;
+    /** Creates an iterator of points in the set */
+    [Symbol.iterator](): Iterator<Point.Point>;
+}

package/lib/components/ExcelFile/ExcelFile/Excel/index.d.ts

@@ -0,0 +1,13 @@
+import Spreadsheet from "./Spreadsheet";
+import DataEditor from "./DataEditor";
+import DataViewer from "./DataViewer";
+export default Spreadsheet;
+export { Spreadsheet, DataEditor, DataViewer };
+export type { Props } from "./Spreadsheet";
+export { createEmpty as createEmptyMatrix } from "./matrix";
+export type { Matrix } from "./matrix";
+export { Selection, EmptySelection, EntireAxisSelection, EntireColumnsSelection, EntireRowsSelection, EntireSelection, EntireWorksheetSelection, InvalidIndexError, RangeSelection, } from "./selection";
+export { PointRange } from "./point-range";
+export type { Point } from "./point";
+export type { CellBase, CellDescriptor, Mode, Dimensions, CellChange, CellComponentProps, CellComponent, DataViewerProps, DataViewerComponent, DataEditorProps, DataEditorComponent, ColumnIndicatorComponent, ColumnIndicatorProps, RowIndicatorComponent, RowIndicatorProps, CornerIndicatorComponent, CornerIndicatorProps, RowComponent, RowProps, TableComponent, TableProps, HeaderRowProps, HeaderRowComponent, } from "./types";
+export { createFormulaParser, Model } from "./engine";

package/lib/components/ExcelFile/ExcelFile/Excel/matrix.d.ts

@@ -0,0 +1,67 @@
+import * as Point from "./point";
+/** A two-dimensional array of given type T in rows and columns */
+export type Matrix<T> = Array<Array<T | undefined>>;
+/**
+ * Creates an empty matrix with given rows and columns
+ * @param rows - integer, the amount of rows the matrix should have
+ * @param columns - integer, the amount of columns the matrix should have
+ * @returns an empty matrix with given rows and columns
+ */
+export declare function createEmpty<T>(rows: number, columns: number): Matrix<T>;
+/** Gets the value at row and column of matrix. */
+export declare function get<T>(point: Point.Point, matrix: Matrix<T>): T | undefined;
+/** Creates a slice of matrix from startPoint up to, but not including, endPoint. */
+export declare function slice<T>(startPoint: Point.Point, endPoint: Point.Point, matrix: Matrix<T>): Matrix<T>;
+/** Sets the value at row and column of matrix. If a row doesn't exist, it's created. */
+export declare function set<T>(point: Point.Point, value: T, matrix: Matrix<T>): Matrix<T>;
+/** Like Matrix.set() but mutates the matrix */
+export declare function mutableSet<T>(point: Point.Point, value: T, matrix: Matrix<T>): void;
+/** Removes the coordinate of matrix */
+export declare function unset<T>(point: Point.Point, matrix: Matrix<T>): Matrix<T>;
+/** Creates an array of values by running each element in collection thru iteratee. */
+export declare function map<T, T2>(func: (value: T | undefined, point: Point.Point) => T2, matrix: Matrix<T>): Matrix<T2>;
+/** Create an iterator over the cells in the matrix */
+export declare function entries<T>(matrix: Matrix<T>): IterableIterator<[Point.Point, T | undefined]>;
+/**
+ * Converts all elements in row into a string separated by horizontalSeparator and each row string
+ * to string separated by verticalSeparator
+ */
+export declare function join(matrix: Matrix<unknown>, horizontalSeparator?: string, verticalSeparator?: string): string;
+/**
+ * Parses a CSV separated by a horizontalSeparator and verticalSeparator into a
+ * Matrix using a transform function
+ */
+export declare function split<T>(csv: string, transform: (value: string) => T, horizontalSeparator?: string, verticalSeparator?: string | RegExp): Matrix<T>;
+/** Returns whether the point exists in the matrix or not. */
+export declare function has(point: Point.Point, matrix: Matrix<unknown>): boolean;
+/** Counts of the rows and column in a matrix */
+export type Size = {
+    /** Count of the rows in the matrix */
+    rows: number;
+    /** Count of the columns in the matrix */
+    columns: number;
+};
+/** Gets the count of rows and columns of given matrix */
+export declare function getSize(matrix: Matrix<unknown>): Size;
+/** Gets the count of rows of given matrix */
+export declare function getRowsCount(matrix: Matrix<unknown>): number;
+/** Gets the count of columns of given matrix */
+export declare function getColumnsCount(matrix: Matrix<unknown>): number;
+/**
+ * Pads matrix with empty rows to match given total rows
+ * @param matrix - matrix to pad
+ * @param totalRows - number of rows the matrix should have
+ * @returns the updated matrix
+ */
+export declare function padRows<T>(matrix: Matrix<T>, totalRows: number): Matrix<T>;
+/**
+ * Pads matrix with empty columns to match given total columns
+ * @param matrix - matrix to pad
+ * @param size - minimum size of the matrix after padding.
+ * @returns the updated matrix
+ */
+export declare function pad<T>(matrix: Matrix<T>, size: Size): Matrix<T>;
+export declare function toArray<T>(matrix: Matrix<T>): T[];
+export declare function toArray<T1, T2>(matrix: Matrix<T1>, transform: (cell: T1 | undefined, coords: Point.Point) => T2): T2[];
+/** Returns the maximum point in the matrix */
+export declare function maxPoint(matrix: Matrix<unknown>): Point.Point;

package/lib/components/ExcelFile/ExcelFile/Excel/point-range.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Interface for ranges between two points
+ */
+import * as Point from "./point";
+/** Range between two points. Creates a normalized range between two given points */
+export declare class PointRange {
+    /** The top-left point */
+    start: Point.Point;
+    /** The bottom-right point */
+    end: Point.Point;
+    constructor(source: Point.Point, target: Point.Point);
+    /** Iterates through all the existing points in given range */
+    [Symbol.iterator](): Iterator<Point.Point>;
+    /** Returns the size (rows x columns) of the given range */
+    size(): number;
+    /** Returns whether given point exists in given range */
+    has(point: Point.Point): boolean;
+    /** Limits given masked range with given mask */
+    mask(mask: PointRange): PointRange;
+    /** Returns whether given range is equal to this range */
+    equals(range: PointRange): boolean;
+}

package/lib/components/ExcelFile/ExcelFile/Excel/point.d.ts

@@ -0,0 +1,11 @@
+/** A cell coordinates in the spreadsheet */
+export type Point = {
+    /** The cell's column */
+    column: number;
+    /** The cell's row */
+    row: number;
+};
+/** Return whether two given points are the equal */
+export declare function isEqual(source: Point, target: Point): boolean;
+/** The origin point in matrices */
+export declare const ORIGIN: Point;

package/lib/components/ExcelFile/ExcelFile/Excel/reducer.d.ts

@@ -0,0 +1,27 @@
+import * as Matrix from "./matrix";
+import * as Types from "./types";
+import * as Point from "./point";
+import { Selection, RangeSelection, EntireColumnsSelection, EntireRowsSelection } from "./selection";
+import * as Actions from "./actions";
+export declare const INITIAL_STATE: Types.StoreState;
+export default function reducer(state: Types.StoreState, action: Actions.Action): Types.StoreState;
+export declare const go: (rowDelta: number, columnDelta: number) => KeyDownHandler;
+export type KeyDownHandler = (state: Types.StoreState, event: React.KeyboardEvent) => Types.StoreState | void;
+export declare enum Direction {
+    Left = "Left",
+    Right = "Right",
+    Top = "Top",
+    Bottom = "Bottom"
+}
+export declare function getKeyDownHandler(state: Types.StoreState, event: React.KeyboardEvent): KeyDownHandler | undefined;
+/** Returns whether the reducer has a handler for the given keydown event */
+export declare function hasKeyDownHandler(state: Types.StoreState, event: React.KeyboardEvent): boolean;
+/** Returns whether the active cell is read only */
+export declare function isActiveReadOnly(state: Types.StoreState): boolean;
+/** Gets active cell from given state */
+export declare function getActive(state: Types.StoreState): Types.CellBase | null;
+/** Modify given edge according to given active point and data */
+export declare function modifyEdge<T extends Selection>(selection: T, active: Point.Point | null, data: Matrix.Matrix<unknown>, direction: Direction): T;
+export declare function modifyRangeSelectionEdge(rangeSelection: RangeSelection, active: Point.Point, data: Matrix.Matrix<unknown>, edge: Direction): RangeSelection;
+export declare function modifyEntireRowsSelection(selection: EntireRowsSelection, active: Point.Point, data: Matrix.Matrix<unknown>, edge: Direction): EntireRowsSelection;
+export declare function modifyEntireColumnsSelection(selection: EntireColumnsSelection, active: Point.Point, data: Matrix.Matrix<unknown>, edge: Direction): EntireColumnsSelection;

package/lib/components/ExcelFile/ExcelFile/Excel/selection.d.ts

@@ -0,0 +1,95 @@
+import { PointRange } from "./point-range";
+import * as Point from "./point";
+import * as Matrix from "./matrix";
+/** Selection from a spreadsheet */
+export declare abstract class Selection {
+    /** Get concrete range of the selection in the given data */
+    abstract toRange(data: Matrix.Matrix<unknown>): PointRange | null;
+    /** Normalize the selection according to the given data */
+    abstract normalizeTo(data: Matrix.Matrix<unknown>): this;
+    /** Determines whether the given row is entirely selected in given selection */
+    abstract hasEntireRow(row: number): boolean;
+    /** Determines whether the given column is entirely selected in given selection */
+    abstract hasEntireColumn(column: number): boolean;
+    /** Get the number of selected points according to given data */
+    abstract size(data: Matrix.Matrix<unknown>): number;
+    /** Determines whether the given point is within the selection */
+    abstract has(data: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+    /** Determines whether the given selection is equal to this selection */
+    abstract equals(selection: Selection): boolean;
+}
+/** Selection of no cells */
+export declare class EmptySelection extends Selection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange | null;
+    normalizeTo(_: Matrix.Matrix<unknown>): this;
+    hasEntireRow(): boolean;
+    hasEntireColumn(): boolean;
+    size(): number;
+    has(): boolean;
+    equals(selection: Selection): boolean;
+}
+/** Selection of a range of cells */
+export declare class RangeSelection extends Selection {
+    range: PointRange;
+    constructor(range: PointRange);
+    toRange(_: Matrix.Matrix<unknown>): PointRange | null;
+    normalizeTo(data: Matrix.Matrix<unknown>): this;
+    hasEntireRow(): boolean;
+    hasEntireColumn(): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(data: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+    equals(selection: Selection): boolean;
+}
+/** Selection of an entire part of the spreadsheet */
+export declare abstract class EntireSelection extends Selection {
+}
+/** Selection of the entire worksheet */
+export declare class EntireWorksheetSelection extends EntireSelection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange;
+    normalizeTo(): this;
+    hasEntireColumn(): boolean;
+    hasEntireRow(): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(): boolean;
+    equals(selection: Selection): boolean;
+}
+/** Selection of an entire axis in the spreadsheet */
+export declare abstract class EntireAxisSelection extends EntireSelection {
+    /** Selection start index, integer */
+    readonly start: number;
+    /** Selection end index, integer */
+    readonly end: number;
+    /**
+     * @param start - row index where the selection starts, integer
+     * @param end - row index where the selection ends, integer
+     * @throws {@link InvalidIndexError}
+     */
+    constructor(start: number, end: number);
+    equals(selection: Selection): boolean;
+}
+/** Selection of entire rows in the spreadsheet */
+export declare class EntireRowsSelection extends EntireAxisSelection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange;
+    normalizeTo(data: Matrix.Matrix<unknown>): this;
+    hasEntireRow(row: number): boolean;
+    hasEntireColumn(): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(_: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+}
+/** Selection of entire columns in the spreadsheet */
+export declare class EntireColumnsSelection extends EntireAxisSelection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange;
+    normalizeTo(data: Matrix.Matrix<unknown>): this;
+    hasEntireRow(): boolean;
+    hasEntireColumn(column: number): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(_: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+}
+/** Get the point range of given matrix */
+export declare function getMatrixRange(data: Matrix.Matrix<unknown>): PointRange;
+/** Determines whether the given value is a valid index */
+export declare function isIndex(value: number): boolean;
+/** Error thrown when passing a non-index value where an index value is expected */
+export declare class InvalidIndexError extends Error {
+    constructor(name: string);
+}