@gridsheet/preact-core 2.0.0-rc.0

package/dist/lib/autofill.d.ts

@@ -0,0 +1,17 @@
+import { AreaType, PointType, StoreType } from '../types';
+import { Table } from './table';
+import { CSSProperties } from 'react';
+export declare class Autofill {
+    private readonly src;
+    private readonly dst;
+    private readonly direction;
+    private readonly table;
+    constructor(store: StoreType, draggingTo: PointType);
+    get applied(): Table;
+    get wholeArea(): AreaType;
+    getCellStyle(target: PointType): CSSProperties;
+    private getDestinationArea;
+    private suggestDirection;
+    private getChangePatterns;
+}
+//# sourceMappingURL=autofill.d.ts.map

package/dist/lib/clipboard.d.ts

@@ -0,0 +1,3 @@
+import { StoreType, AreaType } from '../types';
+export declare const clip: (store: StoreType) => AreaType;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/lib/converters.d.ts

@@ -0,0 +1,10 @@
+import { Address, ExtraPointType } from '../types';
+export declare const x2c: (x: number) => string;
+export declare const c2x: (col: string, absolute?: boolean) => number;
+export declare const y2r: (y: number) => string;
+export declare const r2y: (row: number | string, absolute?: boolean) => number;
+export declare const p2a: ({ y, x, absX, absY }: ExtraPointType) => string;
+export declare const a2p: (address: Address) => ExtraPointType;
+export declare const grantAddressAbsolute: (address: Address, absCol: boolean, absRow: boolean) => string | undefined;
+export declare const stripAddressAbsolute: (address: Address) => string;
+//# sourceMappingURL=converters.d.ts.map

package/dist/lib/events.d.ts

@@ -0,0 +1,6 @@
+export declare const isTouching: (e: React.TouchEvent | React.MouseEvent) => boolean;
+/**
+ * Safely call preventDefault to avoid errors on touch events
+ */
+export declare const safePreventDefault: (e: React.MouseEvent | React.TouchEvent) => void;
+//# sourceMappingURL=events.d.ts.map

package/dist/lib/hub.d.ts

@@ -0,0 +1,39 @@
+import { HistoryType, RefPaletteType, SheetIdsByName, ContextsBySheetId, ZoneType, HubPatchType, CellsByIdType, Id } from '../types';
+export type HubProps = {
+    historyLimit?: number;
+};
+export declare class Hub {
+    sheetHead: number;
+    cellHead: number;
+    data: CellsByIdType;
+    sheetIdsByName: SheetIdsByName;
+    contextsBySheetId: ContextsBySheetId;
+    choosingSheetId: number;
+    choosingAddress: string;
+    editingSheetId: number;
+    editingAddress: string;
+    paletteBySheetName: {
+        [sheetName: string]: RefPaletteType;
+    };
+    lastFocused: HTMLTextAreaElement | null;
+    solvedCaches: Map<Id, any>;
+    copyingSheetId: number;
+    copyingZone: ZoneType;
+    cutting: boolean;
+    histories: HistoryType[];
+    historyIndex: number;
+    historyLimit: number;
+    lastHistory?: HistoryType;
+    currentHistory?: HistoryType;
+    ready: boolean;
+    reflect: (newHub?: HubPatchType) => void;
+    identifyFormula(): void;
+    constructor({ historyLimit }?: HubProps);
+}
+export declare const createHub: (historyLimit?: number) => Hub;
+export type HubReactiveType = {
+    hub: Hub;
+};
+export declare const createHubReactive: (historyLimit?: number) => HubReactiveType;
+export declare const useHubReactive: (historyLimit?: number) => HubReactiveType;
+//# sourceMappingURL=hub.d.ts.map

package/dist/lib/input.d.ts

@@ -0,0 +1,15 @@
+import { PointType } from '../types';
+import { Table } from './table';
+export declare const insertTextAtCursor: (input: HTMLTextAreaElement, text: string) => void;
+type InsertRefProps = {
+    input: HTMLTextAreaElement | null;
+    ref: string;
+    dryRun?: boolean;
+};
+export declare const insertRef: ({ input, ref, dryRun }: InsertRefProps) => boolean;
+export declare const isRefInsertable: (input: HTMLTextAreaElement | null) => boolean;
+export declare const expandInput: (input: HTMLTextAreaElement | null) => void;
+export declare const resetInput: (input: HTMLTextAreaElement | null, table: Table, point: PointType) => void;
+export declare const isFocus: (input: HTMLTextAreaElement | null) => boolean;
+export {};
+//# sourceMappingURL=input.d.ts.map

package/dist/lib/operation.d.ts

@@ -0,0 +1,27 @@
+import { OperationType as operations } from '../types';
+export declare const RemoveRows: operations;
+export declare const RemoveCols: operations;
+export declare const InsertRowsAbove: operations;
+export declare const InsertRowsBelow: operations;
+export declare const InsertColsLeft: operations;
+export declare const InsertColsRight: operations;
+export declare const MoveFrom: operations;
+export declare const MoveTo: operations;
+export declare const Write: operations;
+export declare const Style: operations;
+export declare const Copy: operations;
+export declare const Resize: operations;
+export declare const SetRenderer: operations;
+export declare const SetParser: operations;
+export declare const SetPolicy: operations;
+export declare const NoOperation: operations;
+export declare const Move: operations;
+export declare const Update: operations;
+export declare const InsertRows: operations;
+export declare const InsertCols: operations;
+export declare const Add: operations;
+export declare const Delete: operations;
+export declare const ReadOnly: operations;
+export declare const hasOperation: (operation: operations | undefined, flag: operations) => boolean;
+export declare const debugOperations: (prevention: operations | undefined) => string[];
+//# sourceMappingURL=operation.d.ts.map

package/dist/lib/palette.d.ts

@@ -0,0 +1,2 @@
+export declare const COLOR_PALETTE: string[];
+//# sourceMappingURL=palette.d.ts.map

package/dist/lib/paste.d.ts

@@ -0,0 +1,4 @@
+import { RawCellType } from '../types';
+export declare const parseHTML: (html: string, onlyValue?: boolean) => RawCellType[][];
+export declare const parseText: (tsv: string, sep?: string) => RawCellType[][];
+//# sourceMappingURL=paste.d.ts.map

package/dist/lib/sheet.d.ts

@@ -0,0 +1,3 @@
+export declare const escapeSheetName: (name: string) => string;
+export declare const getSheetPrefix: (name?: string) => string;
+//# sourceMappingURL=sheet.d.ts.map

package/dist/lib/structs.d.ts

@@ -0,0 +1,64 @@
+import { MatrixType, AreaType, ZoneType, RangeType, PointType, Y, X, CellsByAddressType, ShapeType, MatricesByAddress, CellType, Address } from '../types';
+export declare const slideArea: (area: AreaType, y: Y, x: X) => AreaType;
+export declare const superposeArea: (srcArea: AreaType, dstArea: AreaType) => ShapeType;
+export declare const concatAreas: (area1: AreaType, area2: AreaType) => AreaType;
+export declare const zoneToArea: (zone: ZoneType) => AreaType;
+export declare const areaToZone: (area: AreaType) => ZoneType;
+export declare const areaToRange: (area: AreaType) => string;
+export declare const between: (range: RangeType, index: number) => boolean;
+export declare const among: (area: AreaType, point: PointType) => boolean;
+type ShapeExtension = {
+    base?: number;
+};
+export declare const zoneShape: ({ base, ...zone }: ZoneType & ShapeExtension) => ShapeType;
+export declare const areaShape: ({ base, ...area }: AreaType & ShapeExtension) => ShapeType;
+export declare const matrixShape: ({ base, matrix }: {
+    matrix: MatrixType;
+} & ShapeExtension) => ShapeType;
+export declare const makeSequence: (start: number, stop: number, step?: number) => number[];
+export declare const oa2aa: (oa: {
+    [s: string]: any;
+}[], fields: string[]) => MatrixType;
+export declare const aa2oa: (aa: MatrixType, fields: string[]) => {
+    [s: string]: any;
+}[];
+export declare const putMatrix: <T = any>(dst: T[][], src: T[][], dstArea: AreaType, filter?: (srcValue: T, dstValue: T) => boolean) => MatricesByAddress<T>;
+export declare const createMatrix: <T = any>(numRows: number, numCols: number, fill?: T) => T[][];
+export declare const cropMatrix: <T = any>(matrix: T[][], area: AreaType) => T[][];
+export declare const buildInitialCellsOrigin: ({ cells, ensured, matrix, flattenAs, }: {
+    cells?: CellsByAddressType;
+    ensured?: {
+        numRows?: number;
+        numCols?: number;
+    };
+    flattenAs?: keyof CellType;
+    matrix?: MatrixType;
+}) => CellsByAddressType;
+export declare const buildInitialCells: ({ cells, ensured, matrices, flattenAs, }?: {
+    cells?: CellsByAddressType;
+    ensured?: {
+        numRows?: number;
+        numCols?: number;
+    };
+    flattenAs?: keyof CellType;
+    matrices?: MatricesByAddress<any>;
+}) => CellsByAddressType;
+export declare const upsert: <T>({ cells, matrices, flattenAs, }: {
+    cells?: CellsByAddressType;
+    flattenAs?: keyof CellType;
+    matrices?: MatricesByAddress<T>;
+}) => CellsByAddressType;
+export declare const getMaxSizesFromCells: (cells?: CellsByAddressType) => {
+    numRows: number;
+    numCols: number;
+};
+export declare const range: (start: number, end: number) => number[];
+export declare const complementSelectingArea: (selectingArea: AreaType, choosing: PointType) => AreaType;
+export declare const isSameArea: (area1: AreaType, area2: AreaType) => boolean;
+export declare const expandRange: (range: string) => Address[];
+export declare const restrictZone: (zone: ZoneType) => ZoneType;
+export type BinarySearchPredicate = (mid: number) => boolean;
+export declare const binarySearch: (low: number, high: number, predicate: BinarySearchPredicate, lessThan: boolean) => number;
+export declare const moveKey: (obj: any, keyFrom: string, keyTo: string) => void;
+export {};
+//# sourceMappingURL=structs.d.ts.map

package/dist/lib/table.d.ts

@@ -0,0 +1,388 @@
+import { RendererCallProps } from '../renderers/core';
+import { Id, AreaType, CellsByIdType, CellsByAddressType, PointType, Address, CellFilter, Labelers, MatrixType, CellType, Parsers, Renderers, HistoryType, StorePatchType, ShapeType, OperatorType, OperationType, Policies, RawCellType, ExtraPointType, StoreType } from '../types';
+import { FunctionMapping } from '../formula/functions/__base';
+import { Hub } from './hub';
+import { PolicyType } from '../policy/core';
+type Props = {
+    parsers?: Parsers;
+    renderers?: Renderers;
+    labelers?: Labelers;
+    policies?: Policies;
+    historyLimit?: number;
+    minNumRows?: number;
+    maxNumRows?: number;
+    minNumCols?: number;
+    maxNumCols?: number;
+    headerHeight?: number;
+    headerWidth?: number;
+    functions?: FunctionMapping;
+    sheetName?: string;
+    hub?: Hub;
+};
+type GetProps = {
+    evaluates?: boolean | null;
+    raise?: boolean;
+    filter?: CellFilter;
+};
+type MoveProps = {
+    srcTable?: UserTable;
+    src: AreaType;
+    dst: AreaType;
+    operator?: OperatorType;
+    undoReflection?: StorePatchType;
+    redoReflection?: StorePatchType;
+    historicize?: boolean;
+};
+type GetFieldProps = GetProps & {
+    key?: keyof CellType;
+};
+type GetPropsWithArea = GetProps & {
+    area?: AreaType;
+};
+type GetFieldPropsWithArea = GetFieldProps & {
+    area?: AreaType;
+};
+export interface UserTable {
+    changedAt: Date;
+    lastChangedAt?: Date;
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    minNumRows: number;
+    maxNumRows: number;
+    minNumCols: number;
+    maxNumCols: number;
+    totalWidth: number;
+    totalHeight: number;
+    headerWidth: number;
+    headerHeight: number;
+    currentHistory?: HistoryType;
+    /**
+     * Returns the raw table object, which is used for internal operations.
+     * This is not intended for public use and may change in future versions.
+     */
+    __raw__: Table;
+    getRectSize(area: AreaType): ShapeType;
+    getAddressById(id: Id, slideY: number, slideX: number): string | undefined;
+    getAddressesByIds(ids: CellsByIdType): CellsByAddressType;
+    getPointById(id: Id): PointType;
+    getByPoint(point: PointType): CellType | undefined;
+    getId(point: PointType): Id;
+    getById(id: Id): CellType | undefined;
+    getNumRows(base?: number): number;
+    getNumCols(base?: number): number;
+    getFieldMatrix(args?: GetFieldPropsWithArea): any[][];
+    getFieldObject(args?: GetFieldProps): CellsByAddressType;
+    getFieldRows(args?: GetFieldProps): CellsByAddressType[];
+    getFieldCols(args?: GetFieldProps): CellsByAddressType[];
+    getMatrix(args?: GetPropsWithArea): (CellType | null)[][];
+    getObject(args?: GetProps): CellsByAddressType;
+    getRows(args?: GetProps): CellsByAddressType[];
+    getCols(args?: GetProps): CellsByAddressType[];
+    getTableBySheetName(sheetName: string): UserTable;
+    getSheetId(): number;
+    getHistories(): HistoryType[];
+    move(args: MoveProps): UserTable;
+    copy(args: MoveProps & {
+        onlyValue?: boolean;
+    }): UserTable;
+    update(args: {
+        diff: CellsByAddressType;
+        partial?: boolean;
+        updateChangedAt?: boolean;
+        reflection?: StorePatchType;
+    }): UserTable;
+    writeMatrix(args: {
+        point: PointType;
+        matrix: MatrixType<string>;
+        updateChangedAt?: boolean;
+        reflection?: StorePatchType;
+    }): UserTable;
+    write(args: {
+        point: PointType;
+        value: string;
+        updateChangedAt?: boolean;
+        reflection?: StorePatchType;
+    }): UserTable;
+    insertRowsAndUpdate(args: {
+        y: number;
+        numRows: number;
+        baseY: number;
+        diff: CellsByAddressType;
+        partial?: boolean;
+        updateChangedAt?: boolean;
+        reflection?: StorePatchType;
+    }): UserTable;
+    insertRows(args: {
+        y: number;
+        numRows: number;
+        baseY: number;
+        reflection?: StorePatchType;
+    }): UserTable;
+    removeRows(args: {
+        y: number;
+        numRows: number;
+        reflection?: StorePatchType;
+    }): UserTable;
+    insertColsAndUpdate(args: {
+        x: number;
+        numCols: number;
+        baseX: number;
+        diff: CellsByAddressType;
+        partial?: boolean;
+        updateChangedAt?: boolean;
+        reflection?: StorePatchType;
+    }): UserTable;
+    insertCols(args: {
+        x: number;
+        numCols: number;
+        baseX: number;
+        reflection?: StorePatchType;
+    }): UserTable;
+    removeCols(args: {
+        x: number;
+        numCols: number;
+        reflection?: StorePatchType;
+    }): UserTable;
+    undo(): {
+        history: HistoryType | null;
+        newTable: UserTable;
+    };
+    redo(): {
+        history: HistoryType | null;
+        newTable: UserTable;
+    };
+    getHistories(): HistoryType[];
+    getHistoryIndex(): number;
+    getHistorySize(): number;
+    stringify(props: {
+        point: PointType;
+        cell?: CellType;
+        evaluates?: boolean;
+    }): string;
+}
+export declare class Table implements UserTable {
+    changedAt: Date;
+    lastChangedAt?: Date;
+    minNumRows: number;
+    maxNumRows: number;
+    minNumCols: number;
+    maxNumCols: number;
+    totalWidth: number;
+    totalHeight: number;
+    headerWidth: number;
+    headerHeight: number;
+    sheetId: number;
+    sheetName: string;
+    prevSheetName: string;
+    status: 0 | 1 | 2;
+    hub: Hub;
+    idsToBeAbsoluted: Id[];
+    private version;
+    private idMatrix;
+    private area;
+    private parsers;
+    private renderers;
+    private labelers;
+    private policies;
+    private functions;
+    private addressCaches;
+    constructor({ parsers, renderers, labelers, policies, minNumRows, maxNumRows, minNumCols, maxNumCols, headerWidth, headerHeight, functions, sheetName, hub, }: Props);
+    get isInitialized(): boolean;
+    identifyFormula(): void;
+    getSheetId(): number;
+    getTableBySheetName(sheetName: string): Table;
+    getTableBySheetId(sheetId: number): Table;
+    initialize(cells: CellsByAddressType): void;
+    incrementVersion(): void;
+    private generateId;
+    getRectSize({ top, left, bottom, right }: AreaType): {
+        width: number;
+        height: number;
+    };
+    private setTotalSize;
+    clone(keepAddressCache?: boolean): Table;
+    getPointById(id: Id, slideY?: number, slideX?: number): PointType & {
+        absCol: boolean;
+        absRow: boolean;
+    };
+    getAddressById(id: Id, slideY?: number, slideX?: number): string | undefined;
+    getAddressesByIds(ids: CellsByIdType): CellsByAddressType;
+    clearAddressCaches(): void;
+    getId(point: PointType): string;
+    getIdFormula(point: ExtraPointType): {
+        id: Id | null;
+        formula: string | null;
+    };
+    getByPoint(point: PointType): CellType<any, any> | undefined;
+    getById(id: Id): CellType<any, any> | undefined;
+    getPathById(id: Id): string;
+    getByPath(path: string): CellType<any, any>;
+    getNumRows(base?: number): number;
+    getNumCols(base?: number): number;
+    get top(): number;
+    get left(): number;
+    get bottom(): number;
+    get right(): number;
+    getFullRef(ref: Address): string;
+    getFieldMatrix({ area, key, evaluates, raise, filter, }?: GetFieldPropsWithArea): any[][];
+    getFieldObject({ key, evaluates, raise, filter }?: GetFieldProps): CellsByAddressType;
+    getFieldRows({ key, evaluates, raise, filter }?: GetFieldProps): CellsByAddressType[];
+    getFieldCols({ key, evaluates, raise, filter }?: GetFieldProps): CellsByAddressType[];
+    getMatrix({ area, evaluates, raise, filter, }?: GetPropsWithArea): (CellType | null)[][];
+    getObject({ evaluates, raise, filter }?: GetProps): CellsByAddressType;
+    getRows({ evaluates, raise, filter }?: GetProps): CellsByAddressType[];
+    getCols({ evaluates, raise, filter }?: GetProps): CellsByAddressType[];
+    private pushHistory;
+    private cleanObsolete;
+    private cleanStrayed;
+    private getNewIdMatrix;
+    private getIdMatrixFromArea;
+    private setChangedAt;
+    private copyCellLayout;
+    move({ srcTable, src, dst, historicize, operator, undoReflection, redoReflection, }: MoveProps): Table;
+    copy({ srcTable, src, dst, onlyValue, operator, undoReflection, redoReflection, }: MoveProps & {
+        onlyValue?: boolean;
+    }): Table;
+    getPolicyByPoint(point: PointType): PolicyType;
+    private _update;
+    update({ diff, partial, updateChangedAt, historicize, operator, operation: op, undoReflection, redoReflection, }: {
+        diff: CellsByAddressType;
+        partial?: boolean;
+        updateChangedAt?: boolean;
+        historicize?: boolean;
+        operator?: OperatorType;
+        operation?: OperationType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    writeRawCellMatrix({ point, matrix, updateChangedAt, historicize, onlyValue, operator, undoReflection, redoReflection, }: {
+        point: PointType;
+        matrix: MatrixType<RawCellType>;
+        updateChangedAt?: boolean;
+        historicize?: boolean;
+        onlyValue?: boolean;
+        operator?: OperatorType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    writeMatrix(props: {
+        point: PointType;
+        matrix: MatrixType<string>;
+        updateChangedAt?: boolean;
+        historicize?: boolean;
+        operator?: OperatorType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    write(props: {
+        point: PointType;
+        value: string;
+        updateChangedAt?: boolean;
+        historicize?: boolean;
+        operator?: OperatorType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    insertRowsAndUpdate({ y, numRows, baseY, diff, partial, updateChangedAt, operator, undoReflection, redoReflection, }: {
+        y: number;
+        numRows: number;
+        baseY: number;
+        diff: CellsByAddressType;
+        partial?: boolean;
+        updateChangedAt?: boolean;
+        operator?: OperatorType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    insertRows({ y, numRows, baseY, undoReflection, redoReflection, }: {
+        y: number;
+        numRows: number;
+        baseY: number;
+        operator?: OperatorType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    removeRows({ y, numRows, operator, undoReflection, redoReflection, }: {
+        y: number;
+        numRows: number;
+        operator?: OperatorType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    insertColsAndUpdate({ x, numCols, baseX, diff, partial, updateChangedAt, undoReflection, redoReflection, }: {
+        x: number;
+        numCols: number;
+        baseX: number;
+        diff: CellsByAddressType;
+        partial?: boolean;
+        updateChangedAt?: boolean;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    insertCols({ x, numCols, baseX, undoReflection, redoReflection, }: {
+        x: number;
+        numCols: number;
+        baseX: number;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    removeCols({ x, numCols, operator, undoReflection, redoReflection, }: {
+        x: number;
+        numCols: number;
+        operator?: OperatorType;
+        undoReflection?: StorePatchType;
+        redoReflection?: StorePatchType;
+    }): Table;
+    getHistories(): HistoryType[];
+    getHistoryIndex(): number;
+    getHistorySize(): number;
+    getHistoryLimit(): number;
+    setFunctions(additionalFunctions: FunctionMapping): void;
+    getArea(): AreaType;
+    parse(point: PointType, value: string): CellType;
+    render(props: RendererCallProps): any;
+    stringify({ point, cell, evaluates }: {
+        point: PointType;
+        cell?: CellType;
+        evaluates?: boolean;
+    }): string;
+    trim(area: AreaType): Table;
+    private applyDiff;
+    undo(): {
+        history: null;
+        newTable: Table;
+        callback?: undefined;
+    } | {
+        history: HistoryType;
+        newTable: Table;
+        callback: ({ table: { hub } }: StoreType) => void;
+    };
+    redo(): {
+        history: null;
+        newTable: Table;
+        callback?: undefined;
+    } | {
+        history: HistoryType;
+        newTable: Table;
+        callback: ({ table: { hub } }: StoreType) => void;
+    };
+    getFunction(name: string): typeof import('../formula/functions/__base').BaseFunction;
+    getLabel(key: string, n: number): string;
+    getBase(): this;
+    getSolvedCache(point: PointType): any;
+    setSolvedCache(point: PointType, value: any): void;
+    clearSolvedCaches(): void;
+    sheetPrefix(omit?: boolean): string;
+    rangeToArea(range: string): {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    };
+    updatePolicies(policies: Policies | undefined): void;
+    get __raw__(): Table;
+}
+export {};
+//# sourceMappingURL=table.d.ts.map

package/dist/lib/time.d.ts

@@ -0,0 +1,24 @@
+export declare const defaultTimeDeltaFormat = "HH:mm:ss";
+export declare const BASE_DATE: Date;
+type Diff = [number, number, number, number, number, number, number];
+export declare class TimeDelta {
+    gsType: string;
+    protected diff: Diff;
+    private date1;
+    private date2;
+    format: string;
+    constructor(date1: Date, date2: Date, format?: string);
+    add(date: Date): Date;
+    sub(date: Date): Date;
+    stringify(format?: string): string;
+    toJSON(): string;
+    toString(): string;
+    static create(hours?: number, minutes?: number, seconds?: number, milliseconds?: number): TimeDelta;
+    static is(obj: any): boolean;
+    static ensure(obj: any): TimeDelta;
+    static fromObject(obj: any): TimeDelta;
+    static parse(value: string, format?: string, strict?: boolean): TimeDelta | undefined;
+}
+export declare const safeQueueMicrotask: typeof queueMicrotask;
+export {};
+//# sourceMappingURL=time.d.ts.map

package/dist/lib/virtualization.d.ts

@@ -0,0 +1,22 @@
+import { Table } from './table';
+import { AreaType, PointType, Virtualization } from '../types';
+export declare const getCellRectPositions: (table: Table, { y, x }: PointType) => {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    width: number;
+    height: number;
+};
+export declare const getScreenRect: (e: HTMLDivElement) => {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    height: number;
+    width: number;
+};
+export declare const virtualize: (table: Table, e: HTMLDivElement | null) => Virtualization | null;
+export declare const smartScroll: (table: Table, e: HTMLDivElement | null, targetPoint: PointType, behavior?: ScrollBehavior) => void;
+export declare const getAreaInTabular: (tabularElement: HTMLDivElement) => AreaType;
+//# sourceMappingURL=virtualization.d.ts.map

package/dist/parsers/core.d.ts

@@ -0,0 +1,36 @@
+import { CellType } from '../types';
+import { TimeDelta } from '../lib/time';
+type Condition = (value: string) => boolean;
+type Stringify = (value: string) => any;
+type Props = {
+    condition?: Condition;
+    complement?: Stringify;
+    mixins?: ParserMixinType[];
+};
+export interface ParserMixinType {
+    functions?: ((value: string, cell?: CellType) => any)[];
+    callback?(parsed: any, cell?: CellType): CellType;
+    parse?(value: string, cell: CellType): any;
+    bool?(value: string, cell?: CellType): boolean | undefined;
+    number?(value: string, cell?: CellType): number | undefined;
+    timedelta?(value: string, cell?: CellType): TimeDelta | undefined;
+    date?(value: string, cell?: CellType): Date | undefined;
+}
+export declare class Parser implements ParserMixinType {
+    functions: ((value: string, cell?: CellType) => any)[];
+    private condition?;
+    private complement?;
+    constructor(props?: Props);
+    private applyMixins;
+    call(value: string, cell: CellType): CellType;
+    callback(parsed: any, cell?: CellType): CellType;
+    parse(value: string, cell?: CellType): any;
+    bool(value: string, cell?: CellType): boolean | undefined;
+    number(value: string, cell?: CellType): number | undefined;
+    timedelta(value: string, cell?: CellType): TimeDelta | undefined;
+    date(value: string, cell?: CellType): Date | undefined;
+}
+export type ParserType = Parser;
+export declare const defaultParser: Parser;
+export {};
+//# sourceMappingURL=core.d.ts.map