@gridsheet/react-core 0.12.3 → 0.12.4-rc.1

package/dist/lib/table.js

@@ -1,299 +1,251 @@
-import { defaultParser } from "../parsers/core";
-import { defaultRenderer } from "../renderers/core";
-import { areaShape, createMatrix, matrixShape, putMatrix } from "./structs";
-import { a2p, x2c, p2a, y2r, grantAddressAbsolute } from "./converters";
-import { functions as functionsDefault } from "../formula/mapping";
-import { convertFormulaAbsolute, Lexer } from "../formula/evaluator";
-import { solveFormula } from "../formula/solver";
-import { DEFAULT_HEIGHT, DEFAULT_WIDTH, HISTORY_LIMIT } from "../constants";
-import { shouldTracking } from "../store/helpers";
-const cellFilter = (cell) => true;
-export class Table {
-    constructor({ numRows = 0, numCols = 0, cells = {}, parsers = {}, renderers = {}, labelers = {}, useBigInt = false, historyLimit: historyLimit = HISTORY_LIMIT, minNumRows = 1, maxNumRows = -1, minNumCols = 1, maxNumCols = -1, headerWidth = -1, headerHeight = -1, functions = functionsDefault, }) {
-        this.totalWidth = 0;
-        this.totalHeight = 0;
-        this.headerWidth = 0;
-        this.headerHeight = 0;
-        this.functions = {};
-        this.head = useBigInt ? BigInt(0) : 0;
-        this.data = {};
-        this.area = { top: 0, left: 0, bottom: numRows, right: numCols };
-        this.parsers = parsers;
-        this.renderers = renderers;
-        this.labelers = labelers;
-        this.idMatrix = [];
-        this.histories = [];
-        this.historyIndex = -1;
-        this.addressesById = {};
-        this.historyLimit = historyLimit;
-        this.changedAt = new Date();
-        this.minNumRows = minNumRows;
-        this.maxNumRows = maxNumRows;
-        this.minNumCols = minNumCols;
-        this.maxNumCols = maxNumCols;
-        this.solvedCaches = {};
-        this.headerHeight = headerHeight;
-        this.headerWidth = headerWidth;
-        this.functions = functions;
-        const common = cells.default;
-        // make idMatrix beforehand
-        for (let y = 0; y < numRows + 1; y++) {
-            const ids = [];
-            this.idMatrix.push(ids);
-            for (let x = 0; x < numCols + 1; x++) {
-                const id = this.generateId();
-                ids.push(id);
-                const address = p2a({ y, x });
-                this.addressesById[id] = address;
-            }
-        }
-        for (let y = 0; y < numRows + 1; y++) {
-            const rowId = y2r(y);
-            const rowDefault = cells[rowId];
-            for (let x = 0; x < numCols + 1; x++) {
-                const id = this.getId({ y, x });
-                const address = p2a({ y, x });
-                const colId = x2c(x);
-                const colDefault = cells[colId];
-                const cell = cells[address];
-                const stacked = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, common), rowDefault), colDefault), cell), { style: Object.assign(Object.assign(Object.assign(Object.assign({}, common === null || common === void 0 ? void 0 : common.style), rowDefault === null || rowDefault === void 0 ? void 0 : rowDefault.style), colDefault === null || colDefault === void 0 ? void 0 : colDefault.style), cell === null || cell === void 0 ? void 0 : cell.style) });
-                stacked.value = convertFormulaAbsolute({
-                    value: stacked === null || stacked === void 0 ? void 0 : stacked.value,
-                    table: this,
-                });
-                if (y === 0) {
-                    if (stacked.width == null) {
-                        stacked.width = DEFAULT_WIDTH;
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../parsers/core", "../renderers/core", "./structs", "./converters", "../formula/mapping", "../formula/evaluator", "../formula/solver", "../constants", "../store/helpers"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ReadonlyTable = exports.Table = void 0;
+    const core_1 = require("../parsers/core");
+    const core_2 = require("../renderers/core");
+    const structs_1 = require("./structs");
+    const converters_1 = require("./converters");
+    const mapping_1 = require("../formula/mapping");
+    const evaluator_1 = require("../formula/evaluator");
+    const solver_1 = require("../formula/solver");
+    const constants_1 = require("../constants");
+    const helpers_1 = require("../store/helpers");
+    const cellFilter = (cell) => true;
+    class Table {
+        constructor({ numRows = 0, numCols = 0, cells = {}, parsers = {}, renderers = {}, labelers = {}, useBigInt = false, historyLimit: historyLimit = constants_1.HISTORY_LIMIT, minNumRows = 1, maxNumRows = -1, minNumCols = 1, maxNumCols = -1, headerWidth = -1, headerHeight = -1, functions = mapping_1.functions, }) {
+            this.totalWidth = 0;
+            this.totalHeight = 0;
+            this.headerWidth = 0;
+            this.headerHeight = 0;
+            this.functions = {};
+            this.head = useBigInt ? BigInt(0) : 0;
+            this.data = {};
+            this.area = { top: 0, left: 0, bottom: numRows, right: numCols };
+            this.parsers = parsers;
+            this.renderers = renderers;
+            this.labelers = labelers;
+            this.idMatrix = [];
+            this.histories = [];
+            this.historyIndex = -1;
+            this.addressesById = {};
+            this.historyLimit = historyLimit;
+            this.changedAt = new Date();
+            this.minNumRows = minNumRows;
+            this.maxNumRows = maxNumRows;
+            this.minNumCols = minNumCols;
+            this.maxNumCols = maxNumCols;
+            this.solvedCaches = {};
+            this.headerHeight = headerHeight;
+            this.headerWidth = headerWidth;
+            this.functions = functions;
+            const common = cells.default;
+            // make idMatrix beforehand
+            for (let y = 0; y < numRows + 1; y++) {
+                const ids = [];
+                this.idMatrix.push(ids);
+                for (let x = 0; x < numCols + 1; x++) {
+                    const id = this.generateId();
+                    ids.push(id);
+                    const address = (0, converters_1.p2a)({ y, x });
+                    this.addressesById[id] = address;
+                }
+            }
+            for (let y = 0; y < numRows + 1; y++) {
+                const rowId = (0, converters_1.y2r)(y);
+                const rowDefault = cells[rowId];
+                for (let x = 0; x < numCols + 1; x++) {
+                    const id = this.getId({ y, x });
+                    const address = (0, converters_1.p2a)({ y, x });
+                    const colId = (0, converters_1.x2c)(x);
+                    const colDefault = cells[colId];
+                    const cell = cells[address];
+                    const stacked = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, common), rowDefault), colDefault), cell), { style: Object.assign(Object.assign(Object.assign(Object.assign({}, common === null || common === void 0 ? void 0 : common.style), rowDefault === null || rowDefault === void 0 ? void 0 : rowDefault.style), colDefault === null || colDefault === void 0 ? void 0 : colDefault.style), cell === null || cell === void 0 ? void 0 : cell.style) });
+                    stacked.value = (0, evaluator_1.convertFormulaAbsolute)({
+                        value: stacked === null || stacked === void 0 ? void 0 : stacked.value,
+                        table: this,
+                    });
+                    if (y === 0) {
+                        if (stacked.width == null) {
+                            stacked.width = constants_1.DEFAULT_WIDTH;
+                        }
+                    }
+                    else if (x === 0) {
+                        if (stacked.height == null) {
+                            stacked.height = constants_1.DEFAULT_HEIGHT;
+                        }
                     }
+                    else {
+                        delete stacked.height;
+                        delete stacked.width;
+                        delete stacked.labeler;
+                    }
+                    this.data[id] = stacked;
                 }
-                else if (x === 0) {
-                    if (stacked.height == null) {
-                        stacked.height = DEFAULT_HEIGHT;
+            }
+            this.setTotalSize();
+        }
+        generateId() {
+            return (this.head++).toString(36);
+        }
+        getRectSize({ top, left, bottom, right }) {
+            var _a, _b;
+            let width = 0, height = 0;
+            for (let x = left || 1; x < right; x++) {
+                width += ((_a = this.getByPoint({ y: 0, x })) === null || _a === void 0 ? void 0 : _a.width) || constants_1.DEFAULT_WIDTH;
+            }
+            for (let y = top || 1; y < bottom; y++) {
+                height += ((_b = this.getByPoint({ y, x: 0 })) === null || _b === void 0 ? void 0 : _b.height) || constants_1.DEFAULT_HEIGHT;
+            }
+            return { width, height };
+        }
+        setTotalSize() {
+            const { bottom, right } = this.area;
+            const { width, height } = this.getRectSize({ top: 1, left: 1, bottom: bottom + 1, right: right + 1 });
+            this.totalWidth = width + this.headerWidth;
+            this.totalHeight = height + this.headerHeight;
+        }
+        shallowCopy({ copyCache = true } = {}) {
+            const copied = new Table({});
+            copied.changedAt = new Date();
+            copied.lastChangedAt = this.changedAt;
+            copied.head = this.head;
+            copied.idMatrix = this.idMatrix;
+            copied.data = this.data;
+            copied.area = this.area;
+            copied.parsers = this.parsers;
+            copied.renderers = this.renderers;
+            copied.labelers = this.labelers;
+            copied.functions = this.functions;
+            copied.histories = this.histories;
+            copied.historyLimit = this.historyLimit;
+            copied.historyIndex = this.historyIndex;
+            copied.minNumRows = this.minNumRows;
+            copied.maxNumRows = this.maxNumRows;
+            copied.minNumCols = this.minNumCols;
+            copied.maxNumCols = this.maxNumCols;
+            copied.headerHeight = this.headerHeight;
+            copied.headerWidth = this.headerWidth;
+            copied.setTotalSize();
+            if (copyCache) {
+                copied.addressesById = this.addressesById;
+            }
+            else {
+                // force reset
+                this.addressesById = {};
+            }
+            return copied;
+        }
+        getAddressById(id, slideY = 0, slideX = 0) {
+            const absCol = id.startsWith("$");
+            if (absCol) {
+                id = id.slice(1);
+                slideX = 0;
+            }
+            const absRow = id.endsWith("$");
+            if (absRow) {
+                id = id.slice(0, -1);
+                slideY = 0;
+            }
+            for (let y = 0; y < this.idMatrix.length; y++) {
+                const ids = this.idMatrix[y];
+                for (let x = 0; x < ids.length; x++) {
+                    const existing = ids[x];
+                    const address = (0, converters_1.p2a)({ y, x });
+                    this.addressesById[existing] = address;
+                    if (existing === id) {
+                        const slidedAddress = (0, converters_1.p2a)({
+                            y: y + slideY,
+                            x: x + slideX,
+                        });
+                        return (0, converters_1.grantAddressAbsolute)(slidedAddress, absCol, absRow);
                     }
                 }
-                else {
-                    delete stacked.height;
-                    delete stacked.width;
-                    delete stacked.labeler;
+            }
+        }
+        getAddressesByIds(ids) {
+            const addresses = {};
+            Object.keys(ids).forEach((id) => {
+                const cell = ids[id];
+                const address = this.getAddressById(id);
+                if (cell && address) {
+                    addresses[address] = cell;
                 }
-                this.data[id] = stacked;
+            });
+            return addresses;
+        }
+        getPointById(id) {
+            const address = this.getAddressById(id);
+            if (address) {
+                return (0, converters_1.a2p)(address);
             }
+            return { y: 0, x: 0 };
         }
-        this.setTotalSize();
-    }
-    generateId() {
-        return (this.head++).toString(36);
-    }
-    getRectSize({ top, left, bottom, right }) {
-        var _a, _b;
-        let width = 0, height = 0;
-        for (let x = left || 1; x < right; x++) {
-            width += ((_a = this.getByPoint({ y: 0, x })) === null || _a === void 0 ? void 0 : _a.width) || DEFAULT_WIDTH;
+        getId(point) {
+            var _a;
+            const { y, x } = point;
+            return (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
         }
-        for (let y = top || 1; y < bottom; y++) {
-            height += ((_b = this.getByPoint({ y, x: 0 })) === null || _b === void 0 ? void 0 : _b.height) || DEFAULT_HEIGHT;
+        getByPoint(point) {
+            var _a;
+            const { y, x } = point;
+            if (y === -1 || x === -1) {
+                return undefined;
+            }
+            const id = (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
+            if (id == null) {
+                return undefined;
+            }
+            const value = this.data[id];
+            return value;
         }
-        return { width, height };
-    }
-    setTotalSize() {
-        const { bottom, right } = this.area;
-        const { width, height } = this.getRectSize({ top: 1, left: 1, bottom: bottom + 1, right: right + 1 });
-        this.totalWidth = width + this.headerWidth;
-        this.totalHeight = height + this.headerHeight;
-    }
-    shallowCopy({ copyCache = true } = {}) {
-        const copied = new Table({});
-        copied.changedAt = new Date();
-        copied.lastChangedAt = this.changedAt;
-        copied.head = this.head;
-        copied.idMatrix = this.idMatrix;
-        copied.data = this.data;
-        copied.area = this.area;
-        copied.parsers = this.parsers;
-        copied.renderers = this.renderers;
-        copied.labelers = this.labelers;
-        copied.functions = this.functions;
-        copied.histories = this.histories;
-        copied.historyLimit = this.historyLimit;
-        copied.historyIndex = this.historyIndex;
-        copied.minNumRows = this.minNumRows;
-        copied.maxNumRows = this.maxNumRows;
-        copied.minNumCols = this.minNumCols;
-        copied.maxNumCols = this.maxNumCols;
-        copied.headerHeight = this.headerHeight;
-        copied.headerWidth = this.headerWidth;
-        copied.setTotalSize();
-        if (copyCache) {
-            copied.addressesById = this.addressesById;
+        getById(id) {
+            return this.data[id];
         }
-        else {
-            // force reset
-            this.addressesById = {};
+        getNumRows(base = 0) {
+            const { top, left, bottom, right } = this.area;
+            return base + bottom - top;
         }
-        return copied;
-    }
-    getAddressById(id, slideY = 0, slideX = 0) {
-        const absCol = id.startsWith("$");
-        if (absCol) {
-            id = id.slice(1);
-            slideX = 0;
-        }
-        const absRow = id.endsWith("$");
-        if (absRow) {
-            id = id.slice(0, -1);
-            slideY = 0;
-        }
-        for (let y = 0; y < this.idMatrix.length; y++) {
-            const ids = this.idMatrix[y];
-            for (let x = 0; x < ids.length; x++) {
-                const existing = ids[x];
-                const address = p2a({ y, x });
-                this.addressesById[existing] = address;
-                if (existing === id) {
-                    const slidedAddress = p2a({
-                        y: y + slideY,
-                        x: x + slideX,
-                    });
-                    return grantAddressAbsolute(slidedAddress, absCol, absRow);
-                }
-            }
+        getNumCols(base = 0) {
+            const { top, left, bottom, right } = this.area;
+            return base + right - left;
         }
-    }
-    getAddressesByIds(ids) {
-        const addresses = {};
-        Object.keys(ids).forEach((id) => {
-            const cell = ids[id];
-            const address = this.getAddressById(id);
-            if (cell && address) {
-                addresses[address] = cell;
-            }
-        });
-        return addresses;
-    }
-    getPointById(id) {
-        const address = this.getAddressById(id);
-        if (address) {
-            return a2p(address);
+        get top() {
+            return this.area.top;
         }
-        return { y: 0, x: 0 };
-    }
-    getId(point) {
-        var _a;
-        const { y, x } = point;
-        return (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
-    }
-    getByPoint(point) {
-        var _a;
-        const { y, x } = point;
-        if (y === -1 || x === -1) {
-            return undefined;
-        }
-        const id = (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
-        if (id == null) {
-            return undefined;
-        }
-        const value = this.data[id];
-        return value;
-    }
-    getById(id) {
-        return this.data[id];
-    }
-    getNumRows(base = 0) {
-        const { top, left, bottom, right } = this.area;
-        return base + bottom - top;
-    }
-    getNumCols(base = 0) {
-        const { top, left, bottom, right } = this.area;
-        return base + right - left;
-    }
-    get top() {
-        return this.area.top;
-    }
-    get left() {
-        return this.area.left;
-    }
-    get bottom() {
-        return this.area.bottom;
-    }
-    get right() {
-        return this.area.right;
-    }
-    getMatrixFlatten({ area, key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const { top, left, bottom, right } = area || {
-            top: 1,
-            left: 1,
-            bottom: this.area.bottom,
-            right: this.area.right,
-        };
-        const matrix = createMatrix(bottom - top + 1, right - left + 1);
-        for (let y = top; y <= bottom; y++) {
-            for (let x = left; x <= right; x++) {
-                const cell = this.getByPoint({ y, x }) || {};
-                if (!filter(cell)) {
-                    continue;
-                }
-                matrix[y - top][x - left] = evaluates
-                    ? solveFormula({
-                        value: cell[key],
-                        table: this,
-                        raise,
-                    })
-                    : cell[key];
-            }
+        get left() {
+            return this.area.left;
         }
-        return matrix;
-    }
-    getObjectFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const result = {};
-        const { top, left, bottom, right } = this.area;
-        for (let y = top; y <= bottom; y++) {
-            for (let x = left; x <= right; x++) {
-                const cell = this.getByPoint({ y: y - top, x: x - left });
-                if (cell != null && filter(cell)) {
-                    result[p2a({ y, x })] = evaluates
-                        ? solveFormula({
-                            value: cell[key],
-                            table: this,
-                            raise,
-                        })
-                        : cell[key];
-                }
-            }
+        get bottom() {
+            return this.area.bottom;
         }
-        return result;
-    }
-    getRowsFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const result = [];
-        const { top, left, bottom, right } = this.area;
-        for (let y = top; y <= bottom; y++) {
-            const row = {};
-            result.push(row);
-            for (let x = left; x <= right; x++) {
-                const cell = this.getByPoint({ y: y - top, x: x - left });
-                if (cell != null && filter(cell)) {
-                    row[x2c(x) || y2r(y)] = evaluates
-                        ? solveFormula({
-                            value: cell[key],
-                            table: this,
-                            raise,
-                        })
-                        : cell[key];
-                }
-            }
+        get right() {
+            return this.area.right;
         }
-        return result;
-    }
-    getColsFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const result = [];
-        const { top, left, bottom, right } = this.area;
-        for (let x = left; x <= right; x++) {
-            const col = {};
-            result.push(col);
+        getMatrixFlatten({ area, key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const { top, left, bottom, right } = area || {
+                top: 1,
+                left: 1,
+                bottom: this.area.bottom,
+                right: this.area.right,
+            };
+            const matrix = (0, structs_1.createMatrix)(bottom - top + 1, right - left + 1);
             for (let y = top; y <= bottom; y++) {
-                const cell = this.getByPoint({ y: y - top, x: x - left });
-                if (cell != null && filter(cell)) {
-                    col[y2r(y) || x2c(x)] = evaluates
-                        ? solveFormula({
+                for (let x = left; x <= right; x++) {
+                    const cell = this.getByPoint({ y, x }) || {};
+                    if (!filter(cell)) {
+                        continue;
+                    }
+                    matrix[y - top][x - left] = evaluates
+                        ? (0, solver_1.solveFormula)({
                             value: cell[key],
                             table: this,
                             raise,
@@ -301,689 +253,752 @@ export class Table {
                         : cell[key];
                 }
             }
+            return matrix;
         }
-        return result;
-    }
-    getMatrix({ area, evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const { top, left, bottom, right } = area || {
-            top: 1,
-            left: 1,
-            bottom: this.area.bottom,
-            right: this.area.right,
-        };
-        const matrix = createMatrix(bottom - top + 1, right - left + 1);
-        for (let y = top; y <= bottom; y++) {
-            for (let x = left; x <= right; x++) {
-                const cell = this.getByPoint({ y, x });
-                if (cell != null && filter(cell)) {
-                    matrix[y - top][x - left] = Object.assign(Object.assign({}, cell), { value: evaluates
-                            ? solveFormula({
-                                value: cell === null || cell === void 0 ? void 0 : cell.value,
+        getObjectFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const result = {};
+            const { top, left, bottom, right } = this.area;
+            for (let y = top; y <= bottom; y++) {
+                for (let x = left; x <= right; x++) {
+                    const cell = this.getByPoint({ y: y - top, x: x - left });
+                    if (cell != null && filter(cell)) {
+                        result[(0, converters_1.p2a)({ y, x })] = evaluates
+                            ? (0, solver_1.solveFormula)({
+                                value: cell[key],
                                 table: this,
                                 raise,
                             })
-                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                            : cell[key];
+                    }
                 }
             }
+            return result;
         }
-        return matrix;
-    }
-    getObject({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const result = {};
-        const { top, left, bottom, right } = this.area;
-        for (let y = top; y <= bottom; y++) {
-            for (let x = left; x <= right; x++) {
-                const cell = this.getByPoint({ y: y - top, x: x - left });
-                if (cell != null && filter(cell)) {
-                    result[p2a({ y, x })] = Object.assign(Object.assign({}, cell), { value: evaluates
-                            ? solveFormula({
-                                value: cell === null || cell === void 0 ? void 0 : cell.value,
+        getRowsFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const result = [];
+            const { top, left, bottom, right } = this.area;
+            for (let y = top; y <= bottom; y++) {
+                const row = {};
+                result.push(row);
+                for (let x = left; x <= right; x++) {
+                    const cell = this.getByPoint({ y: y - top, x: x - left });
+                    if (cell != null && filter(cell)) {
+                        row[(0, converters_1.x2c)(x) || (0, converters_1.y2r)(y)] = evaluates
+                            ? (0, solver_1.solveFormula)({
+                                value: cell[key],
                                 table: this,
                                 raise,
                             })
-                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                            : cell[key];
+                    }
                 }
             }
+            return result;
         }
-        return result;
-    }
-    getRows({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const result = [];
-        const { top, left, bottom, right } = this.area;
-        for (let y = top; y <= bottom; y++) {
-            const row = {};
-            result.push(row);
+        getColsFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const result = [];
+            const { top, left, bottom, right } = this.area;
             for (let x = left; x <= right; x++) {
-                const cell = this.getByPoint({ y: y - top, x: x - left });
-                if (cell != null && filter(cell)) {
-                    row[x2c(x) || y2r(y)] = Object.assign(Object.assign({}, cell), { value: evaluates
-                            ? solveFormula({
-                                value: cell === null || cell === void 0 ? void 0 : cell.value,
+                const col = {};
+                result.push(col);
+                for (let y = top; y <= bottom; y++) {
+                    const cell = this.getByPoint({ y: y - top, x: x - left });
+                    if (cell != null && filter(cell)) {
+                        col[(0, converters_1.y2r)(y) || (0, converters_1.x2c)(x)] = evaluates
+                            ? (0, solver_1.solveFormula)({
+                                value: cell[key],
                                 table: this,
                                 raise,
                             })
-                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                            : cell[key];
+                    }
                 }
             }
+            return result;
         }
-        return result;
-    }
-    getCols({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
-        const result = [];
-        const { top, left, bottom, right } = this.area;
-        for (let x = left; x <= right; x++) {
-            const col = {};
-            result.push(col);
+        getMatrix({ area, evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const { top, left, bottom, right } = area || {
+                top: 1,
+                left: 1,
+                bottom: this.area.bottom,
+                right: this.area.right,
+            };
+            const matrix = (0, structs_1.createMatrix)(bottom - top + 1, right - left + 1);
             for (let y = top; y <= bottom; y++) {
-                const cell = this.getByPoint({ y: y - top, x: x - left });
-                if (cell != null && filter(cell)) {
-                    col[y2r(y) || x2c(x)] = Object.assign(Object.assign({}, cell), { value: evaluates
-                            ? solveFormula({
-                                value: cell === null || cell === void 0 ? void 0 : cell.value,
-                                table: this,
-                                raise,
-                            })
-                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                for (let x = left; x <= right; x++) {
+                    const cell = this.getByPoint({ y, x });
+                    if (cell != null && filter(cell)) {
+                        matrix[y - top][x - left] = Object.assign(Object.assign({}, cell), { value: evaluates
+                                ? (0, solver_1.solveFormula)({
+                                    value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                    table: this,
+                                    raise,
+                                })
+                                : cell === null || cell === void 0 ? void 0 : cell.value });
+                    }
                 }
             }
+            return matrix;
         }
-        return result;
-    }
-    pushHistory(history) {
-        const strayedHistories = this.histories.splice(this.historyIndex + 1, this.histories.length);
-        strayedHistories.forEach(this.cleanStrayed.bind(this));
-        this.histories.push(history);
-        this.lastHistory = history;
-        if (this.histories.length > this.historyLimit) {
-            const kickedOut = this.histories.splice(0, 1)[0];
-            this.cleanObsolete(kickedOut);
-        }
-        else {
-            this.historyIndex++;
-        }
-    }
-    cleanObsolete(history) {
-        if (history.operation === "REMOVE_ROWS" ||
-            history.operation === "REMOVE_COLS") {
-            history.idMatrix.forEach((ids) => {
-                ids.forEach((id) => {
-                    delete this.data[id];
-                });
-            });
-        }
-        if (history.operation === "MOVE") {
-            Object.keys(history.lostRows).forEach((address) => {
-                const idMatrix = history.lostRows[address];
-                idMatrix.map((ids) => ids.forEach((id) => {
-                    delete this.data[id];
-                }));
-            });
-        }
-    }
-    cleanStrayed(history) {
-        if (history.operation === "ADD_ROWS" || history.operation === "ADD_COLS") {
-            history.idMatrix.forEach((ids) => {
-                ids.forEach((id) => {
-                    delete this.data[id];
-                });
-            });
+        getObject({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const result = {};
+            const { top, left, bottom, right } = this.area;
+            for (let y = top; y <= bottom; y++) {
+                for (let x = left; x <= right; x++) {
+                    const cell = this.getByPoint({ y: y - top, x: x - left });
+                    if (cell != null && filter(cell)) {
+                        result[(0, converters_1.p2a)({ y, x })] = Object.assign(Object.assign({}, cell), { value: evaluates
+                                ? (0, solver_1.solveFormula)({
+                                    value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                    table: this,
+                                    raise,
+                                })
+                                : cell === null || cell === void 0 ? void 0 : cell.value });
+                    }
+                }
+            }
+            return result;
         }
-    }
-    getNewIdMatrix(area) {
-        const matrix = [];
-        const { top, left, bottom, right } = area;
-        for (let y = top; y <= bottom; y++) {
-            const ids = [];
-            matrix.push(ids);
-            for (let x = left; x <= right; x++) {
-                ids.push(this.generateId());
+        getRows({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const result = [];
+            const { top, left, bottom, right } = this.area;
+            for (let y = top; y <= bottom; y++) {
+                const row = {};
+                result.push(row);
+                for (let x = left; x <= right; x++) {
+                    const cell = this.getByPoint({ y: y - top, x: x - left });
+                    if (cell != null && filter(cell)) {
+                        row[(0, converters_1.x2c)(x) || (0, converters_1.y2r)(y)] = Object.assign(Object.assign({}, cell), { value: evaluates
+                                ? (0, solver_1.solveFormula)({
+                                    value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                    table: this,
+                                    raise,
+                                })
+                                : cell === null || cell === void 0 ? void 0 : cell.value });
+                    }
+                }
             }
+            return result;
         }
-        return matrix;
-    }
-    getIdMatrixFromArea(area) {
-        var _a;
-        const matrix = [];
-        const { top, left, bottom, right } = area;
-        for (let y = top; y <= bottom; y++) {
-            const ids = [];
-            matrix.push(ids);
+        getCols({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
+            const result = [];
+            const { top, left, bottom, right } = this.area;
             for (let x = left; x <= right; x++) {
-                const id = (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
-                if (id) {
-                    ids.push(id);
+                const col = {};
+                result.push(col);
+                for (let y = top; y <= bottom; y++) {
+                    const cell = this.getByPoint({ y: y - top, x: x - left });
+                    if (cell != null && filter(cell)) {
+                        col[(0, converters_1.y2r)(y) || (0, converters_1.x2c)(x)] = Object.assign(Object.assign({}, cell), { value: evaluates
+                                ? (0, solver_1.solveFormula)({
+                                    value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                    table: this,
+                                    raise,
+                                })
+                                : cell === null || cell === void 0 ? void 0 : cell.value });
+                    }
                 }
             }
+            return result;
         }
-        return matrix;
-    }
-    setChangedAt(cell, changedAt) {
-        if (cell == null) {
-            return null;
-        }
-        cell.changedAt = changedAt || new Date();
-        return cell;
-    }
-    copyCellLayout(cell) {
-        if (cell == null) {
-            return undefined;
-        }
-        const newCell = {};
-        if (cell.style != null) {
-            newCell.style = cell.style;
-        }
-        if (cell.justifyContent != null) {
-            newCell.justifyContent = cell.justifyContent;
+        pushHistory(history) {
+            const strayedHistories = this.histories.splice(this.historyIndex + 1, this.histories.length);
+            strayedHistories.forEach(this.cleanStrayed.bind(this));
+            this.histories.push(history);
+            this.lastHistory = history;
+            if (this.histories.length > this.historyLimit) {
+                const kickedOut = this.histories.splice(0, 1)[0];
+                this.cleanObsolete(kickedOut);
+            }
+            else {
+                this.historyIndex++;
+            }
         }
-        if (cell.alignItems != null) {
-            newCell.alignItems = cell.alignItems;
+        cleanObsolete(history) {
+            if (history.operation === "REMOVE_ROWS" ||
+                history.operation === "REMOVE_COLS") {
+                history.idMatrix.forEach((ids) => {
+                    ids.forEach((id) => {
+                        delete this.data[id];
+                    });
+                });
+            }
+            if (history.operation === "MOVE") {
+                Object.keys(history.lostRows).forEach((address) => {
+                    const idMatrix = history.lostRows[address];
+                    idMatrix.map((ids) => ids.forEach((id) => {
+                        delete this.data[id];
+                    }));
+                });
+            }
         }
-        if (cell.renderer != null) {
-            newCell.renderer = cell.renderer;
+        cleanStrayed(history) {
+            if (history.operation === "ADD_ROWS" || history.operation === "ADD_COLS") {
+                history.idMatrix.forEach((ids) => {
+                    ids.forEach((id) => {
+                        delete this.data[id];
+                    });
+                });
+            }
         }
-        if (cell.parser != null) {
-            newCell.parser = cell.parser;
+        getNewIdMatrix(area) {
+            const matrix = [];
+            const { top, left, bottom, right } = area;
+            for (let y = top; y <= bottom; y++) {
+                const ids = [];
+                matrix.push(ids);
+                for (let x = left; x <= right; x++) {
+                    ids.push(this.generateId());
+                }
+            }
+            return matrix;
         }
-        if (cell.width != null) {
-            newCell.width = cell.width;
+        getIdMatrixFromArea(area) {
+            var _a;
+            const matrix = [];
+            const { top, left, bottom, right } = area;
+            for (let y = top; y <= bottom; y++) {
+                const ids = [];
+                matrix.push(ids);
+                for (let x = left; x <= right; x++) {
+                    const id = (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
+                    if (id) {
+                        ids.push(id);
+                    }
+                }
+            }
+            return matrix;
         }
-        if (cell.height != null) {
-            newCell.height = cell.height;
+        setChangedAt(cell, changedAt) {
+            if (cell == null) {
+                return null;
+            }
+            cell.changedAt = changedAt || new Date();
+            return cell;
         }
-        if (cell.labeler != null) {
-            newCell.labeler = cell.labeler;
+        copyCellLayout(cell) {
+            if (cell == null) {
+                return undefined;
+            }
+            const newCell = {};
+            if (cell.style != null) {
+                newCell.style = cell.style;
+            }
+            if (cell.justifyContent != null) {
+                newCell.justifyContent = cell.justifyContent;
+            }
+            if (cell.alignItems != null) {
+                newCell.alignItems = cell.alignItems;
+            }
+            if (cell.renderer != null) {
+                newCell.renderer = cell.renderer;
+            }
+            if (cell.parser != null) {
+                newCell.parser = cell.parser;
+            }
+            if (cell.width != null) {
+                newCell.width = cell.width;
+            }
+            if (cell.height != null) {
+                newCell.height = cell.height;
+            }
+            if (cell.labeler != null) {
+                newCell.labeler = cell.labeler;
+            }
+            return newCell;
         }
-        return newCell;
-    }
-    move({ src, dst, reflection = {}, }) {
-        const changedAt = new Date();
-        const matrixFrom = this.getIdMatrixFromArea(src);
-        const matrixTo = this.getIdMatrixFromArea(dst);
-        const matrixNew = this.getNewIdMatrix(src);
-        putMatrix(this.idMatrix, matrixNew, src);
-        matrixFrom.forEach((ids) => {
-            ids
-                .map(this.getById.bind(this))
-                .filter((c) => c)
-                .forEach((cell) => this.setChangedAt(cell, changedAt));
-        });
-        const lostRows = putMatrix(this.idMatrix, matrixFrom, dst);
-        this.pushHistory({
-            operation: "MOVE",
-            reflection,
-            matrixFrom,
-            matrixTo,
-            matrixNew,
-            pointFrom: { y: src.top, x: src.left },
-            pointTo: { y: dst.top, x: dst.left },
-            lostRows,
-        });
-        return this.shallowCopy({ copyCache: false });
-    }
-    copy({ src, dst, reflection = {}, }) {
-        const { height: maxHeight, width: maxWidth } = areaShape(Object.assign(Object.assign({}, src), { base: 1 }));
-        const { top: topFrom, left: leftFrom } = src;
-        const { top: topTo, left: leftTo, bottom: bottomTo, right: rightTo } = dst;
-        const diff = {};
-        const changedAt = new Date();
-        for (let i = 0; i <= bottomTo - topTo; i++) {
-            const toY = topTo + i;
-            if (toY > this.getNumRows()) {
-                continue;
-            }
-            for (let j = 0; j <= rightTo - leftTo; j++) {
-                const toX = leftTo + j;
-                if (toX > this.getNumCols()) {
+        move({ src, dst, reflection = {}, }) {
+            const changedAt = new Date();
+            const matrixFrom = this.getIdMatrixFromArea(src);
+            const matrixTo = this.getIdMatrixFromArea(dst);
+            const matrixNew = this.getNewIdMatrix(src);
+            (0, structs_1.putMatrix)(this.idMatrix, matrixNew, src);
+            matrixFrom.forEach((ids) => {
+                ids
+                    .map(this.getById.bind(this))
+                    .filter((c) => c)
+                    .forEach((cell) => this.setChangedAt(cell, changedAt));
+            });
+            const lostRows = (0, structs_1.putMatrix)(this.idMatrix, matrixFrom, dst);
+            this.pushHistory({
+                operation: "MOVE",
+                reflection,
+                matrixFrom,
+                matrixTo,
+                matrixNew,
+                pointFrom: { y: src.top, x: src.left },
+                pointTo: { y: dst.top, x: dst.left },
+                lostRows,
+            });
+            return this.shallowCopy({ copyCache: false });
+        }
+        copy({ src, dst, reflection = {}, }) {
+            const { height: maxHeight, width: maxWidth } = (0, structs_1.areaShape)(Object.assign(Object.assign({}, src), { base: 1 }));
+            const { top: topFrom, left: leftFrom } = src;
+            const { top: topTo, left: leftTo, bottom: bottomTo, right: rightTo } = dst;
+            const diff = {};
+            const changedAt = new Date();
+            for (let i = 0; i <= bottomTo - topTo; i++) {
+                const toY = topTo + i;
+                if (toY > this.getNumRows()) {
                     continue;
                 }
-                const fromY = topFrom + (i % maxHeight);
-                const fromX = leftFrom + (j % maxWidth);
-                const slideY = toY - fromY;
-                const slideX = toX - fromX;
-                const cell = Object.assign({}, this.getByPoint({
-                    y: topFrom + (i % maxHeight),
-                    x: leftFrom + (j % maxWidth),
-                }));
-                const value = convertFormulaAbsolute({
-                    value: cell === null || cell === void 0 ? void 0 : cell.value,
-                    table: this,
-                    slideY,
-                    slideX,
-                });
-                this.setChangedAt(cell, changedAt);
-                diff[p2a({ y: toY, x: toX })] = Object.assign(Object.assign({}, cell), { style: Object.assign({}, cell === null || cell === void 0 ? void 0 : cell.style), value });
+                for (let j = 0; j <= rightTo - leftTo; j++) {
+                    const toX = leftTo + j;
+                    if (toX > this.getNumCols()) {
+                        continue;
+                    }
+                    const fromY = topFrom + (i % maxHeight);
+                    const fromX = leftFrom + (j % maxWidth);
+                    const slideY = toY - fromY;
+                    const slideX = toX - fromX;
+                    const cell = Object.assign({}, this.getByPoint({
+                        y: topFrom + (i % maxHeight),
+                        x: leftFrom + (j % maxWidth),
+                    }));
+                    const value = (0, evaluator_1.convertFormulaAbsolute)({
+                        value: cell === null || cell === void 0 ? void 0 : cell.value,
+                        table: this,
+                        slideY,
+                        slideX,
+                    });
+                    this.setChangedAt(cell, changedAt);
+                    diff[(0, converters_1.p2a)({ y: toY, x: toX })] = Object.assign(Object.assign({}, cell), { style: Object.assign({}, cell === null || cell === void 0 ? void 0 : cell.style), value });
+                }
             }
+            return this.update({ diff, partial: false, reflection });
         }
-        return this.update({ diff, partial: false, reflection });
-    }
-    _update({ diff, partial = true, updateChangedAt = true, }) {
-        const diffBefore = {};
-        const diffAfter = {};
-        const changedAt = new Date();
-        Object.keys(diff).forEach((address) => {
-            const cell = Object.assign({}, diff[address]);
-            if (updateChangedAt) {
-                this.setChangedAt(cell, changedAt);
-            }
-            cell.value = convertFormulaAbsolute({
-                value: cell.value,
-                table: this,
+        _update({ diff, partial = true, updateChangedAt = true, }) {
+            const diffBefore = {};
+            const diffAfter = {};
+            const changedAt = new Date();
+            Object.keys(diff).forEach((address) => {
+                const cell = Object.assign({}, diff[address]);
+                if (updateChangedAt) {
+                    this.setChangedAt(cell, changedAt);
+                }
+                cell.value = (0, evaluator_1.convertFormulaAbsolute)({
+                    value: cell.value,
+                    table: this,
+                });
+                const point = (0, converters_1.a2p)(address);
+                const id = this.getId(point);
+                // must not partial
+                diffBefore[id] = this.getByPoint(point);
+                diffAfter[id] = cell;
+                if (partial) {
+                    this.data[id] = Object.assign(Object.assign({}, this.data[id]), cell);
+                }
+                else {
+                    this.data[id] = cell;
+                }
             });
-            const point = a2p(address);
-            const id = this.getId(point);
-            // must not partial
-            diffBefore[id] = this.getByPoint(point);
-            diffAfter[id] = cell;
-            if (partial) {
-                this.data[id] = Object.assign(Object.assign({}, this.data[id]), cell);
-            }
-            else {
-                this.data[id] = cell;
-            }
-        });
-        this.solvedCaches = {};
-        return {
-            diffBefore,
-            diffAfter,
-        };
-    }
-    update({ diff, partial = true, updateChangedAt = true, reflection = {}, }) {
-        const { diffBefore, diffAfter } = this._update({
-            diff,
-            partial,
-            updateChangedAt,
-        });
-        this.pushHistory({
-            operation: "UPDATE",
-            reflection,
-            diffBefore,
-            diffAfter,
-            partial,
-        });
-        return this.shallowCopy({ copyCache: true });
-    }
-    writeMatrix({ point, matrix, updateChangedAt = true, reflection = {}, }) {
-        const { y: baseY, x: baseX } = point;
-        const diff = {};
-        matrix.forEach((cols, i) => {
-            const y = baseY + i;
-            if (y > this.bottom) {
-                return;
-            }
-            cols.forEach((value, j) => {
-                const x = baseX + j;
-                if (x > this.right) {
+            this.solvedCaches = {};
+            return {
+                diffBefore,
+                diffAfter,
+            };
+        }
+        update({ diff, partial = true, updateChangedAt = true, reflection = {}, }) {
+            const { diffBefore, diffAfter } = this._update({
+                diff,
+                partial,
+                updateChangedAt,
+            });
+            this.pushHistory({
+                operation: "UPDATE",
+                reflection,
+                diffBefore,
+                diffAfter,
+                partial,
+            });
+            return this.shallowCopy({ copyCache: true });
+        }
+        writeMatrix({ point, matrix, updateChangedAt = true, reflection = {}, }) {
+            const { y: baseY, x: baseX } = point;
+            const diff = {};
+            matrix.forEach((cols, i) => {
+                const y = baseY + i;
+                if (y > this.bottom) {
                     return;
                 }
-                const cell = this.parse({ y, x }, value);
-                diff[p2a({ y, x })] = cell;
+                cols.forEach((value, j) => {
+                    const x = baseX + j;
+                    if (x > this.right) {
+                        return;
+                    }
+                    const cell = this.parse({ y, x }, value);
+                    diff[(0, converters_1.p2a)({ y, x })] = cell;
+                });
+            });
+            return this.update({
+                diff,
+                partial: true,
+                updateChangedAt,
+                reflection,
             });
-        });
-        return this.update({
-            diff,
-            partial: true,
-            updateChangedAt,
-            reflection,
-        });
-    }
-    write({ point, value, updateChangedAt = true, reflection = {}, }) {
-        return this.writeMatrix({
-            point,
-            matrix: [[value]],
-            updateChangedAt,
-            reflection,
-        });
-    }
-    addRowsAndUpdate({ y, numRows, baseY, diff, partial, updateChangedAt, reflection = {}, }) {
-        const returned = this.addRows({
-            y,
-            numRows,
-            baseY,
-            reflection,
-        });
-        Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt }), { partial });
-        return returned;
-    }
-    addRows({ y, numRows, baseY, reflection = {}, }) {
-        if (this.maxNumRows !== -1 &&
-            this.getNumRows() + numRows > this.maxNumRows) {
-            console.error(`Rows are limited to ${this.maxNumRows}.`);
-            return this;
         }
-        const numCols = this.getNumCols(1);
-        const rows = [];
-        const changedAt = new Date();
-        for (let i = 0; i < numRows; i++) {
-            const row = [];
-            for (let j = 0; j < numCols; j++) {
-                const id = this.generateId();
-                row.push(id);
-                const cell = this.getByPoint({ y: baseY, x: j });
-                const copied = this.copyCellLayout(cell);
-                this.data[id] = Object.assign(Object.assign({}, copied), { changedAt });
-            }
-            rows.push(row);
-        }
-        this.idMatrix.splice(y, 0, ...rows);
-        this.area.bottom += numRows;
-        this.pushHistory({
-            operation: "ADD_ROWS",
-            reflection,
-            y,
-            idMatrix: rows,
-        });
-        return this.shallowCopy({ copyCache: false });
-    }
-    removeRows({ y, numRows, reflection = {}, }) {
-        if (this.minNumRows !== -1 &&
-            this.getNumRows() - numRows < this.minNumRows) {
-            console.error(`At least ${this.minNumRows} row(s) are required.`);
-            return this;
+        write({ point, value, updateChangedAt = true, reflection = {}, }) {
+            return this.writeMatrix({
+                point,
+                matrix: [[value]],
+                updateChangedAt,
+                reflection,
+            });
         }
-        const rows = this.idMatrix.splice(y, numRows);
-        this.area.bottom -= numRows;
-        this.pushHistory({
-            operation: "REMOVE_ROWS",
-            reflection,
-            y,
-            idMatrix: rows,
-        });
-        return this.shallowCopy({ copyCache: false });
-    }
-    addColsAndUpdate({ x, numCols, baseX, diff, partial, updateChangedAt, reflection = {}, }) {
-        const returned = this.addCols({
-            x,
-            numCols,
-            baseX,
-            reflection,
-        });
-        Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt }), { partial });
-        return returned;
-    }
-    addCols({ x, numCols, baseX, reflection = {}, }) {
-        if (this.maxNumCols !== -1 &&
-            this.getNumCols() + numCols > this.maxNumCols) {
-            console.error(`Columns are limited to ${this.maxNumCols}.`);
-            return this;
+        addRowsAndUpdate({ y, numRows, baseY, diff, partial, updateChangedAt, reflection = {}, }) {
+            const returned = this.addRows({
+                y,
+                numRows,
+                baseY,
+                reflection,
+            });
+            Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt }), { partial });
+            return returned;
+        }
+        addRows({ y, numRows, baseY, reflection = {}, }) {
+            if (this.maxNumRows !== -1 &&
+                this.getNumRows() + numRows > this.maxNumRows) {
+                console.error(`Rows are limited to ${this.maxNumRows}.`);
+                return this;
+            }
+            const numCols = this.getNumCols(1);
+            const rows = [];
+            const changedAt = new Date();
+            for (let i = 0; i < numRows; i++) {
+                const row = [];
+                for (let j = 0; j < numCols; j++) {
+                    const id = this.generateId();
+                    row.push(id);
+                    const cell = this.getByPoint({ y: baseY, x: j });
+                    const copied = this.copyCellLayout(cell);
+                    this.data[id] = Object.assign(Object.assign({}, copied), { changedAt });
+                }
+                rows.push(row);
+            }
+            this.idMatrix.splice(y, 0, ...rows);
+            this.area.bottom += numRows;
+            this.pushHistory({
+                operation: "ADD_ROWS",
+                reflection,
+                y,
+                idMatrix: rows,
+            });
+            return this.shallowCopy({ copyCache: false });
+        }
+        removeRows({ y, numRows, reflection = {}, }) {
+            if (this.minNumRows !== -1 &&
+                this.getNumRows() - numRows < this.minNumRows) {
+                console.error(`At least ${this.minNumRows} row(s) are required.`);
+                return this;
+            }
+            const rows = this.idMatrix.splice(y, numRows);
+            this.area.bottom -= numRows;
+            this.pushHistory({
+                operation: "REMOVE_ROWS",
+                reflection,
+                y,
+                idMatrix: rows,
+            });
+            return this.shallowCopy({ copyCache: false });
+        }
+        addColsAndUpdate({ x, numCols, baseX, diff, partial, updateChangedAt, reflection = {}, }) {
+            const returned = this.addCols({
+                x,
+                numCols,
+                baseX,
+                reflection,
+            });
+            Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt }), { partial });
+            return returned;
+        }
+        addCols({ x, numCols, baseX, reflection = {}, }) {
+            if (this.maxNumCols !== -1 &&
+                this.getNumCols() + numCols > this.maxNumCols) {
+                console.error(`Columns are limited to ${this.maxNumCols}.`);
+                return this;
+            }
+            const numRows = this.getNumRows(1);
+            const rows = [];
+            const changedAt = new Date();
+            for (let i = 0; i < numRows; i++) {
+                const row = [];
+                for (let j = 0; j < numCols; j++) {
+                    const id = this.generateId();
+                    row.push(id);
+                    const cell = this.getByPoint({ y: i, x: baseX });
+                    const copied = this.copyCellLayout(cell);
+                    this.idMatrix[i].splice(x, 0, id);
+                    this.data[id] = Object.assign(Object.assign({}, copied), { changedAt });
+                }
+                rows.push(row);
+            }
+            this.area.right += numCols;
+            this.pushHistory({
+                operation: "ADD_COLS",
+                reflection,
+                x,
+                idMatrix: rows,
+            });
+            return this.shallowCopy({ copyCache: false });
+        }
+        removeCols({ x, numCols, reflection = {}, }) {
+            if (this.minNumCols !== -1 &&
+                this.getNumCols() - numCols < this.minNumCols) {
+                console.error(`At least ${this.minNumCols} column(s) are required.`);
+                return this;
+            }
+            const rows = [];
+            this.idMatrix.forEach((row) => {
+                const deleted = row.splice(x, numCols);
+                rows.push(deleted);
+            });
+            this.area.right -= numCols;
+            this.pushHistory({
+                operation: "REMOVE_COLS",
+                reflection,
+                x,
+                idMatrix: rows,
+            });
+            return this.shallowCopy({ copyCache: false });
         }
-        const numRows = this.getNumRows(1);
-        const rows = [];
-        const changedAt = new Date();
-        for (let i = 0; i < numRows; i++) {
-            const row = [];
-            for (let j = 0; j < numCols; j++) {
-                const id = this.generateId();
-                row.push(id);
-                const cell = this.getByPoint({ y: i, x: baseX });
-                const copied = this.copyCellLayout(cell);
-                this.idMatrix[i].splice(x, 0, id);
-                this.data[id] = Object.assign(Object.assign({}, copied), { changedAt });
-            }
-            rows.push(row);
-        }
-        this.area.right += numCols;
-        this.pushHistory({
-            operation: "ADD_COLS",
-            reflection,
-            x,
-            idMatrix: rows,
-        });
-        return this.shallowCopy({ copyCache: false });
-    }
-    removeCols({ x, numCols, reflection = {}, }) {
-        if (this.minNumCols !== -1 &&
-            this.getNumCols() - numCols < this.minNumCols) {
-            console.error(`At least ${this.minNumCols} column(s) are required.`);
-            return this;
+        getHistories() {
+            return [...this.histories];
         }
-        const rows = [];
-        this.idMatrix.forEach((row) => {
-            const deleted = row.splice(x, numCols);
-            rows.push(deleted);
-        });
-        this.area.right -= numCols;
-        this.pushHistory({
-            operation: "REMOVE_COLS",
-            reflection,
-            x,
-            idMatrix: rows,
-        });
-        return this.shallowCopy({ copyCache: false });
-    }
-    getHistories() {
-        return [...this.histories];
-    }
-    getHistoryIndex() {
-        return this.historyIndex;
-    }
-    getHistorySize() {
-        return this.histories.length;
-    }
-    getHistoryLimit() {
-        return this.historyLimit;
-    }
-    setFunctions(additionalFunctions) {
-        this.functions = Object.assign(Object.assign({}, functionsDefault), additionalFunctions);
-    }
-    getArea() {
-        return Object.assign({}, this.area);
-    }
-    parse(point, value) {
-        const cell = this.getByPoint(point) || {};
-        const parser = this.parsers[cell.parser || ""] || defaultParser;
-        return parser.call(value, cell);
-    }
-    render(point, writer) {
-        const cell = this.getByPoint(point) || {};
-        const renderer = this.renderers[cell.renderer || ""] || defaultRenderer;
-        return renderer.call(this, point, writer);
-    }
-    stringify(point, value, evaluates = false) {
-        const cell = this.getByPoint(point);
-        const renderer = this.renderers[(cell === null || cell === void 0 ? void 0 : cell.renderer) || ""] || defaultRenderer;
-        const s = renderer.stringify(typeof value === "undefined" ? Object.assign({}, cell) : Object.assign(Object.assign({}, cell), { value }));
-        if (s[0] === "=") {
-            if (evaluates) {
-                return String(solveFormula({ value: s, table: this, raise: false }));
-            }
-            const lexer = new Lexer(s.substring(1));
-            lexer.tokenize();
-            return "=" + lexer.stringifyToRef(this);
-        }
-        return s;
-    }
-    trim(area) {
-        const copied = new Table({});
-        copied.area = area;
-        copied.idMatrix = this.idMatrix;
-        copied.data = this.data;
-        copied.parsers = this.parsers;
-        copied.renderers = this.renderers;
-        copied.labelers = this.labelers;
-        copied.functions = this.functions;
-        copied.addressesById = this.addressesById;
-        copied.solvedCaches = this.solvedCaches;
-        return copied;
-    }
-    getIdByAddress(address) {
-        const { y, x } = a2p(address);
-        const id = this.getId({ y: Math.abs(y), x: Math.abs(x) });
-        if (id) {
-            return `#${x < 0 ? "$" : ""}${id}${y < 0 ? "$" : ""}`;
+        getHistoryIndex() {
+            return this.historyIndex;
         }
-    }
-    applyDiff(diff, partial = true) {
-        if (!partial) {
-            Object.assign(this.data, diff);
-            return;
-        }
-        Object.keys(diff).map((id) => {
-            const cell = diff[id];
-            this.data[id] = Object.assign(Object.assign({}, this.getById(id)), cell);
-        });
-    }
-    undo() {
-        if (this.historyIndex < 0) {
-            return { history: null, newTable: this };
-        }
-        const history = this.histories[this.historyIndex--];
-        switch (history.operation) {
-            case "UPDATE":
-                // diffBefore is guaranteed as total of cell (not partial)
-                this.applyDiff(history.diffBefore, false);
-                break;
-            case "ADD_ROWS": {
-                if (history.diffBefore) {
-                    this.applyDiff(history.diffBefore, false);
+        getHistorySize() {
+            return this.histories.length;
+        }
+        getHistoryLimit() {
+            return this.historyLimit;
+        }
+        setFunctions(additionalFunctions) {
+            this.functions = Object.assign(Object.assign({}, mapping_1.functions), additionalFunctions);
+        }
+        getArea() {
+            return Object.assign({}, this.area);
+        }
+        parse(point, value) {
+            const cell = this.getByPoint(point) || {};
+            const parser = this.parsers[cell.parser || ""] || core_1.defaultParser;
+            return parser.call(value, cell);
+        }
+        render(point, writer) {
+            const cell = this.getByPoint(point) || {};
+            const renderer = this.renderers[cell.renderer || ""] || core_2.defaultRenderer;
+            return renderer.call(this, point, writer);
+        }
+        stringify(point, value, evaluates = false) {
+            const cell = this.getByPoint(point);
+            const renderer = this.renderers[(cell === null || cell === void 0 ? void 0 : cell.renderer) || ""] || core_2.defaultRenderer;
+            const s = renderer.stringify(typeof value === "undefined" ? Object.assign({}, cell) : Object.assign(Object.assign({}, cell), { value }));
+            if (s[0] === "=") {
+                if (evaluates) {
+                    return String((0, solver_1.solveFormula)({ value: s, table: this, raise: false }));
                 }
-                const { height } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.splice(history.y, height);
-                this.area.bottom -= height;
-                break;
+                const lexer = new evaluator_1.Lexer(s.substring(1));
+                lexer.tokenize();
+                return "=" + lexer.stringifyToRef(this);
+            }
+            return s;
+        }
+        trim(area) {
+            const copied = new Table({});
+            copied.area = area;
+            copied.idMatrix = this.idMatrix;
+            copied.data = this.data;
+            copied.parsers = this.parsers;
+            copied.renderers = this.renderers;
+            copied.labelers = this.labelers;
+            copied.functions = this.functions;
+            copied.addressesById = this.addressesById;
+            copied.solvedCaches = this.solvedCaches;
+            return copied;
+        }
+        getIdByAddress(address) {
+            const { y, x } = (0, converters_1.a2p)(address);
+            const id = this.getId({ y: Math.abs(y), x: Math.abs(x) });
+            if (id) {
+                return `#${x < 0 ? "$" : ""}${id}${y < 0 ? "$" : ""}`;
+            }
+        }
+        applyDiff(diff, partial = true) {
+            if (!partial) {
+                Object.assign(this.data, diff);
+                return;
             }
-            case "ADD_COLS": {
-                if (history.diffBefore) {
+            Object.keys(diff).map((id) => {
+                const cell = diff[id];
+                this.data[id] = Object.assign(Object.assign({}, this.getById(id)), cell);
+            });
+        }
+        undo() {
+            if (this.historyIndex < 0) {
+                return { history: null, newTable: this };
+            }
+            const history = this.histories[this.historyIndex--];
+            switch (history.operation) {
+                case "UPDATE":
+                    // diffBefore is guaranteed as total of cell (not partial)
                     this.applyDiff(history.diffBefore, false);
+                    break;
+                case "ADD_ROWS": {
+                    if (history.diffBefore) {
+                        this.applyDiff(history.diffBefore, false);
+                    }
+                    const { height } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.splice(history.y, height);
+                    this.area.bottom -= height;
+                    break;
+                }
+                case "ADD_COLS": {
+                    if (history.diffBefore) {
+                        this.applyDiff(history.diffBefore, false);
+                    }
+                    const { width } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.forEach((row) => {
+                        row.splice(history.x, width);
+                    });
+                    this.area.right -= width;
+                    break;
+                }
+                case "REMOVE_ROWS": {
+                    const { height } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.splice(history.y, 0, ...history.idMatrix);
+                    this.area.bottom += height;
+                    break;
+                }
+                case "REMOVE_COLS": {
+                    const { width } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.forEach((row, i) => {
+                        row.splice(history.x, 0, ...history.idMatrix[i]);
+                    });
+                    this.area.right += width;
+                    break;
+                }
+                case "MOVE": {
+                    const { y: yFrom, x: xFrom } = history.pointFrom;
+                    const { y: yTo, x: xTo } = history.pointTo;
+                    const { height: rows, width: cols } = (0, structs_1.matrixShape)({
+                        matrix: history.matrixFrom,
+                        base: -1,
+                    });
+                    (0, structs_1.putMatrix)(this.idMatrix, history.matrixFrom, {
+                        top: yFrom,
+                        left: xFrom,
+                        bottom: yFrom + rows,
+                        right: xFrom + cols,
+                    });
+                    (0, structs_1.putMatrix)(this.idMatrix, history.matrixTo, {
+                        top: yTo,
+                        left: xTo,
+                        bottom: yTo + rows,
+                        right: xTo + cols,
+                    });
+                    break;
                 }
-                const { width } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.forEach((row) => {
-                    row.splice(history.x, width);
-                });
-                this.area.right -= width;
-                break;
-            }
-            case "REMOVE_ROWS": {
-                const { height } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.splice(history.y, 0, ...history.idMatrix);
-                this.area.bottom += height;
-                break;
-            }
-            case "REMOVE_COLS": {
-                const { width } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.forEach((row, i) => {
-                    row.splice(history.x, 0, ...history.idMatrix[i]);
-                });
-                this.area.right += width;
-                break;
-            }
-            case "MOVE": {
-                const { y: yFrom, x: xFrom } = history.pointFrom;
-                const { y: yTo, x: xTo } = history.pointTo;
-                const { height: rows, width: cols } = matrixShape({
-                    matrix: history.matrixFrom,
-                    base: -1,
-                });
-                putMatrix(this.idMatrix, history.matrixFrom, {
-                    top: yFrom,
-                    left: xFrom,
-                    bottom: yFrom + rows,
-                    right: xFrom + cols,
-                });
-                putMatrix(this.idMatrix, history.matrixTo, {
-                    top: yTo,
-                    left: xTo,
-                    bottom: yTo + rows,
-                    right: xTo + cols,
-                });
-                break;
             }
+            return {
+                history,
+                newTable: this.shallowCopy({
+                    copyCache: !(0, helpers_1.shouldTracking)(history.operation),
+                }),
+            };
         }
-        return {
-            history,
-            newTable: this.shallowCopy({
-                copyCache: !shouldTracking(history.operation),
-            }),
-        };
-    }
-    redo() {
-        if (this.historyIndex + 1 >= this.histories.length) {
-            return { history: null, newTable: this };
-        }
-        const history = this.histories[++this.historyIndex];
-        switch (history.operation) {
-            case "UPDATE":
-                this.applyDiff(history.diffAfter, history.partial);
-                break;
-            case "ADD_ROWS": {
-                if (history.diffAfter) {
-                    this.applyDiff(history.diffAfter, history.partial);
-                }
-                const { height } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.splice(history.y, 0, ...history.idMatrix);
-                this.area.bottom += height;
-                break;
+        redo() {
+            if (this.historyIndex + 1 >= this.histories.length) {
+                return { history: null, newTable: this };
             }
-            case "ADD_COLS": {
-                if (history.diffAfter) {
+            const history = this.histories[++this.historyIndex];
+            switch (history.operation) {
+                case "UPDATE":
                     this.applyDiff(history.diffAfter, history.partial);
+                    break;
+                case "ADD_ROWS": {
+                    if (history.diffAfter) {
+                        this.applyDiff(history.diffAfter, history.partial);
+                    }
+                    const { height } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.splice(history.y, 0, ...history.idMatrix);
+                    this.area.bottom += height;
+                    break;
+                }
+                case "ADD_COLS": {
+                    if (history.diffAfter) {
+                        this.applyDiff(history.diffAfter, history.partial);
+                    }
+                    const { width } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.map((row, i) => {
+                        row.splice(history.x, 0, ...history.idMatrix[i]);
+                    });
+                    this.area.right += width;
+                    break;
+                }
+                case "REMOVE_ROWS": {
+                    const { height } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.splice(history.y, height);
+                    this.area.bottom -= height;
+                    break;
+                }
+                case "REMOVE_COLS": {
+                    const { width } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                    this.idMatrix.forEach((row) => {
+                        row.splice(history.x, width);
+                    });
+                    this.area.right -= width;
+                    break;
+                }
+                case "MOVE": {
+                    const { y: yFrom, x: xFrom } = history.pointFrom;
+                    const { y: yTo, x: xTo } = history.pointTo;
+                    const { height: rows, width: cols } = (0, structs_1.matrixShape)({
+                        matrix: history.matrixFrom,
+                        base: -1,
+                    });
+                    (0, structs_1.putMatrix)(this.idMatrix, history.matrixNew, {
+                        top: yFrom,
+                        left: xFrom,
+                        bottom: yFrom + rows,
+                        right: xFrom + cols,
+                    });
+                    (0, structs_1.putMatrix)(this.idMatrix, history.matrixFrom, {
+                        top: yTo,
+                        left: xTo,
+                        bottom: yTo + rows,
+                        right: xTo + cols,
+                    });
                 }
-                const { width } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.map((row, i) => {
-                    row.splice(history.x, 0, ...history.idMatrix[i]);
-                });
-                this.area.right += width;
-                break;
-            }
-            case "REMOVE_ROWS": {
-                const { height } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.splice(history.y, height);
-                this.area.bottom -= height;
-                break;
-            }
-            case "REMOVE_COLS": {
-                const { width } = matrixShape({ matrix: history.idMatrix });
-                this.idMatrix.forEach((row) => {
-                    row.splice(history.x, width);
-                });
-                this.area.right -= width;
-                break;
-            }
-            case "MOVE": {
-                const { y: yFrom, x: xFrom } = history.pointFrom;
-                const { y: yTo, x: xTo } = history.pointTo;
-                const { height: rows, width: cols } = matrixShape({
-                    matrix: history.matrixFrom,
-                    base: -1,
-                });
-                putMatrix(this.idMatrix, history.matrixNew, {
-                    top: yFrom,
-                    left: xFrom,
-                    bottom: yFrom + rows,
-                    right: xFrom + cols,
-                });
-                putMatrix(this.idMatrix, history.matrixFrom, {
-                    top: yTo,
-                    left: xTo,
-                    bottom: yTo + rows,
-                    right: xTo + cols,
-                });
             }
+            return {
+                history,
+                newTable: this.shallowCopy({
+                    copyCache: !(0, helpers_1.shouldTracking)(history.operation),
+                }),
+            };
+        }
+        getFunction(name) {
+            return this.functions[name];
+        }
+        getLabel(key, n) {
+            const labeler = this.labelers[key];
+            return labeler === null || labeler === void 0 ? void 0 : labeler(n);
+        }
+        getBase() {
+            return this;
+        }
+        getSolvedCache(key) {
+            return this.solvedCaches[key];
+        }
+        setSolvedCache(key, value) {
+            this.solvedCaches[key] = value;
         }
-        return {
-            history,
-            newTable: this.shallowCopy({
-                copyCache: !shouldTracking(history.operation),
-            }),
-        };
-    }
-    getFunction(name) {
-        return this.functions[name];
-    }
-    getLabel(key, n) {
-        const labeler = this.labelers[key];
-        return labeler === null || labeler === void 0 ? void 0 : labeler(n);
-    }
-    getBase() {
-        return this;
-    }
-    getSolvedCache(key) {
-        return this.solvedCaches[key];
     }
-    setSolvedCache(key, value) {
-        this.solvedCaches[key] = value;
+    exports.Table = Table;
+    // just using as a type
+    class ReadonlyTable extends Table {
     }
-}
-// just using as a type
-export class ReadonlyTable extends Table {
-}
+    exports.ReadonlyTable = ReadonlyTable;
+});
 //# sourceMappingURL=table.js.map