@gridsheet/react-core 0.12.4-rc.0 → 0.12.4

package/dist/lib/table.js

@@ -1,250 +1,301 @@
-(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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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, 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 || 0, right: numCols || 0 };
+        this.parsers = parsers || {};
+        this.renderers = renderers || {};
+        this.labelers = labelers || {};
+        this.idMatrix = [];
+        this.histories = [];
+        this.historyIndex = -1;
+        this.addressesById = {};
+        this.historyLimit = historyLimit || constants_1.HISTORY_LIMIT;
+        this.changedAt = new Date();
+        this.minNumRows = minNumRows || 0;
+        this.maxNumRows = maxNumRows || 0;
+        this.minNumCols = minNumCols || 0;
+        this.maxNumCols = maxNumCols || 0;
+        this.solvedCaches = {};
+        this.headerHeight = headerHeight || 0;
+        this.headerWidth = headerWidth || 0;
+        this.functions = functions;
+        const common = cells === null || cells === void 0 ? void 0 : 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 === null || cells === void 0 ? void 0 : 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 === null || cells === void 0 ? void 0 : cells[colId];
+                const cell = cells === null || cells === void 0 ? void 0 : 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;
                     }
-                    this.data[id] = stacked;
                 }
-            }
-            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 if (x === 0) {
+                    if (stacked.height == null) {
+                        stacked.height = constants_1.DEFAULT_HEIGHT;
                     }
                 }
-            }
-        }
-        getAddressesByIds(ids) {
-            const addresses = {};
-            Object.keys(ids).forEach((id) => {
-                const cell = ids[id];
-                const address = this.getAddressById(id);
-                if (cell && address) {
-                    addresses[address] = cell;
+                else {
+                    delete stacked.height;
+                    delete stacked.width;
+                    delete stacked.labeler;
                 }
-            });
-            return addresses;
-        }
-        getPointById(id) {
-            const address = this.getAddressById(id);
-            if (address) {
-                return (0, converters_1.a2p)(address);
+                this.data[id] = stacked;
             }
-            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];
+        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;
         }
-        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;
+        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;
         }
-        getById(id) {
-            return this.data[id];
+        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;
         }
-        getNumRows(base = 0) {
-            const { top, left, bottom, right } = this.area;
-            return base + bottom - top;
+        else {
+            // force reset
+            this.addressesById = {};
         }
-        getNumCols(base = 0) {
-            const { top, left, bottom, right } = this.area;
-            return base + right - left;
+        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);
+                }
+            }
         }
-        get top() {
-            return this.area.top;
+    }
+    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 (0, converters_1.a2p)(address);
         }
-        get left() {
-            return this.area.left;
+        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 = (0, structs_1.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
+                    ? (0, solver_1.solveFormula)({
+                        value: cell[key],
+                        table: this,
+                        raise,
+                    })
+                    : cell[key];
+            }
         }
-        get bottom() {
-            return this.area.bottom;
+        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[(0, converters_1.p2a)({ y, x })] = evaluates
+                        ? (0, solver_1.solveFormula)({
+                            value: cell[key],
+                            table: this,
+                            raise,
+                        })
+                        : cell[key];
+                }
+            }
         }
-        get right() {
-            return this.area.right;
+        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[(0, converters_1.x2c)(x) || (0, converters_1.y2r)(y)] = evaluates
+                        ? (0, solver_1.solveFormula)({
+                            value: cell[key],
+                            table: this,
+                            raise,
+                        })
+                        : cell[key];
+                }
+            }
         }
-        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);
+        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);
             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
+                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,
@@ -253,752 +304,687 @@
                         : cell[key];
                 }
             }
-            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[(0, converters_1.p2a)({ y, x })] = evaluates
+        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 = (0, structs_1.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
                             ? (0, solver_1.solveFormula)({
-                                value: cell[key],
+                                value: cell === null || cell === void 0 ? void 0 : cell.value,
                                 table: this,
                                 raise,
                             })
-                            : cell[key];
-                    }
+                            : cell === null || cell === void 0 ? void 0 : cell.value });
                 }
             }
-            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[(0, converters_1.x2c)(x) || (0, converters_1.y2r)(y)] = evaluates
+        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[(0, converters_1.p2a)({ y, x })] = Object.assign(Object.assign({}, cell), { value: evaluates
                             ? (0, solver_1.solveFormula)({
-                                value: cell[key],
+                                value: cell === null || cell === void 0 ? void 0 : cell.value,
                                 table: this,
                                 raise,
                             })
-                            : cell[key];
-                    }
+                            : cell === null || cell === void 0 ? void 0 : cell.value });
                 }
             }
-            return result;
         }
-        getColsFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
-            const result = [];
-            const { top, left, bottom, right } = this.area;
+        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);
             for (let x = left; x <= right; x++) {
-                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
+                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[key],
+                                value: cell === null || cell === void 0 ? void 0 : cell.value,
                                 table: this,
                                 raise,
                             })
-                            : cell[key];
-                    }
+                            : cell === null || cell === void 0 ? void 0 : cell.value });
                 }
             }
-            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 = (0, structs_1.createMatrix)(bottom - top + 1, right - left + 1);
+        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);
             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
-                                ? (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 });
-                    }
+                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 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[(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;
+        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++;
         }
-        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 });
-                    }
-                }
+    }
+    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];
+                });
+            });
+        }
+    }
+    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 result;
         }
-        getCols({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
-            const result = [];
-            const { top, left, bottom, right } = this.area;
+        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);
             for (let x = left; x <= right; x++) {
-                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 });
-                    }
+                const id = (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
+                if (id) {
+                    ids.push(id);
                 }
             }
-            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++;
-            }
+        return matrix;
+    }
+    setChangedAt(cell, changedAt) {
+        if (cell == null) {
+            return null;
         }
-        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];
-                    }));
-                });
-            }
+        cell.changedAt = changedAt || new Date();
+        return cell;
+    }
+    copyCellLayout(cell) {
+        if (cell == null) {
+            return undefined;
         }
-        cleanStrayed(history) {
-            if (history.operation === "ADD_ROWS" || history.operation === "ADD_COLS") {
-                history.idMatrix.forEach((ids) => {
-                    ids.forEach((id) => {
-                        delete this.data[id];
-                    });
-                });
-            }
+        const newCell = {};
+        if (cell.style != null) {
+            newCell.style = cell.style;
         }
-        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.justifyContent != null) {
+            newCell.justifyContent = cell.justifyContent;
         }
-        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.alignItems != null) {
+            newCell.alignItems = cell.alignItems;
         }
-        setChangedAt(cell, changedAt) {
-            if (cell == null) {
-                return null;
-            }
-            cell.changedAt = changedAt || new Date();
-            return cell;
+        if (cell.renderer != null) {
+            newCell.renderer = cell.renderer;
         }
-        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;
+        if (cell.parser != null) {
+            newCell.parser = cell.parser;
         }
-        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;
-                }
-                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 });
+        if (cell.width != null) {
+            newCell.width = cell.width;
         }
-        _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);
+        if (cell.height != null) {
+            newCell.height = cell.height;
+        }
+        if (cell.labeler != null) {
+            newCell.labeler = cell.labeler;
+        }
+        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);
+        (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;
+            }
+            for (let j = 0; j <= rightTo - leftTo; j++) {
+                const toX = leftTo + j;
+                if (toX > this.getNumCols()) {
+                    continue;
                 }
-                cell.value = (0, evaluator_1.convertFormulaAbsolute)({
-                    value: cell.value,
+                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,
                 });
-                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;
-                }
-            });
-            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) {
-                        return;
-                    }
-                    const cell = this.parse({ y, x }, value);
-                    diff[(0, converters_1.p2a)({ y, x })] = cell;
-                });
-            });
-            return this.update({
-                diff,
-                partial: true,
-                updateChangedAt,
-                reflection,
-            });
-        }
-        write({ point, value, updateChangedAt = true, reflection = {}, }) {
-            return this.writeMatrix({
-                point,
-                matrix: [[value]],
-                updateChangedAt,
-                reflection,
-            });
+                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 });
+            }
         }
-        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,
+        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 = (0, evaluator_1.convertFormulaAbsolute)({
+                value: cell.value,
+                table: this,
             });
-            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 });
+            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;
+            }
+        });
+        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) {
+                    return;
                 }
-                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,
+                const cell = this.parse({ y, x }, value);
+                diff[(0, converters_1.p2a)({ y, x })] = cell;
             });
-            return this.shallowCopy({ copyCache: false });
-        }
-        getHistories() {
-            return [...this.histories];
-        }
-        getHistoryIndex() {
-            return this.historyIndex;
-        }
-        getHistorySize() {
-            return this.histories.length;
-        }
-        getHistoryLimit() {
-            return this.historyLimit;
+        });
+        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;
         }
-        setFunctions(additionalFunctions) {
-            this.functions = Object.assign(Object.assign({}, mapping_1.functions), additionalFunctions);
+        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;
         }
-        getArea() {
-            return Object.assign({}, this.area);
+        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;
         }
-        parse(point, value) {
-            const cell = this.getByPoint(point) || {};
-            const parser = this.parsers[cell.parser || ""] || core_1.defaultParser;
-            return parser.call(value, cell);
+        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;
         }
-        render(point, writer) {
-            const cell = this.getByPoint(point) || {};
-            const renderer = this.renderers[cell.renderer || ""] || core_2.defaultRenderer;
-            return renderer.call(this, point, writer);
+        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({}, 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 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 ? "$" : ""}`;
         }
-        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 }));
+    }
+    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);
                 }
-                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 ? "$" : ""}`;
+                const { height } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+                this.idMatrix.splice(history.y, height);
+                this.area.bottom -= height;
+                break;
             }
-        }
-        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)
+            case "ADD_COLS": {
+                if (history.diffBefore) {
                     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 } = (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;
             }
-            return {
-                history,
-                newTable: this.shallowCopy({
-                    copyCache: !(0, helpers_1.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":
+        return {
+            history,
+            newTable: this.shallowCopy({
+                copyCache: !(0, helpers_1.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);
-                    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 { 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,
+                });
             }
-            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: !(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];
     }
-    exports.Table = Table;
-    // just using as a type
-    class ReadonlyTable extends Table {
+    setSolvedCache(key, value) {
+        this.solvedCaches[key] = value;
     }
-    exports.ReadonlyTable = ReadonlyTable;
-});
+}
+exports.Table = Table;
 //# sourceMappingURL=table.js.map