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

package/dist/lib/autofill.js

@@ -1,389 +1,403 @@
-import { isEqual } from 'date-fns';
-import { areaShape, areaToZone, complementSelectingArea, concatAreas, zoneToArea } from "./structs";
-import { p2a } from "./converters";
-import { convertFormulaAbsolute } from "../formula/evaluator";
-import { TimeDelta } from "./time";
-const BORDER_AUTOFILL_DRAGGING = "dashed 1px #000000";
-const DirectionMapping = {
-    left: ["horizontal", -1],
-    right: ["horizontal", 1],
-    up: ["vertical", -1],
-    down: ["vertical", 1],
-};
-export class Autofill {
-    constructor(store, draggingTo) {
-        const { table, choosing, selectingZone } = store;
-        this.src = complementSelectingArea(zoneToArea(selectingZone), choosing);
-        this.direction = this.suggestDirection(draggingTo);
-        this.dst = this.getDestinationArea(draggingTo);
-        this.table = table;
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
     }
-    get applied() {
-        const [orientation, sign] = DirectionMapping[this.direction];
-        const matrix = this.table.getMatrix({ area: this.src, evaluates: false });
-        const srcShape = areaShape(Object.assign(Object.assign({}, this.src), { base: 1 }));
-        const dstShape = areaShape(Object.assign(Object.assign({}, this.dst), { base: 1 }));
-        const diff = {};
-        if (orientation === "horizontal") {
-            for (let i = 0; i < dstShape.height; i++) {
-                const patterns = this.getChangePatterns(matrix[i]);
-                for (let j = 0; j < dstShape.width; j++) {
-                    const baseCell = matrix[i % srcShape.height][j % srcShape.width];
-                    const x = sign > 0 ? this.dst.left + j : this.dst.right - j;
-                    const px = sign > 0 ? j % srcShape.width : (srcShape.width - 1 - (j % srcShape.width)) % srcShape.width;
-                    diff[p2a({ y: this.dst.top + i, x })] = Object.assign(Object.assign({}, baseCell), { value: patterns[px].next().value });
-                }
-            }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "date-fns", "./structs", "./converters", "../formula/evaluator", "./time"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Autofill = void 0;
+    const date_fns_1 = require("date-fns");
+    const structs_1 = require("./structs");
+    const converters_1 = require("./converters");
+    const evaluator_1 = require("../formula/evaluator");
+    const time_1 = require("./time");
+    const BORDER_AUTOFILL_DRAGGING = "dashed 1px #000000";
+    const DirectionMapping = {
+        left: ["horizontal", -1],
+        right: ["horizontal", 1],
+        up: ["vertical", -1],
+        down: ["vertical", 1],
+    };
+    class Autofill {
+        constructor(store, draggingTo) {
+            const { table, choosing, selectingZone } = store;
+            this.src = (0, structs_1.complementSelectingArea)((0, structs_1.zoneToArea)(selectingZone), choosing);
+            this.direction = this.suggestDirection(draggingTo);
+            this.dst = this.getDestinationArea(draggingTo);
+            this.table = table;
         }
-        else {
-            for (let i = 0; i < dstShape.width; i++) {
-                const patterns = this.getChangePatterns(matrix.map((row) => row[i]));
-                for (let j = 0; j < dstShape.height; j++) {
-                    const baseCell = matrix[i % srcShape.height][j % srcShape.width];
-                    const y = sign > 0 ? this.dst.top + j : this.dst.bottom - j;
-                    const py = sign > 0 ? j % srcShape.height : (srcShape.height - 1 - (j % srcShape.height)) % srcShape.height;
-                    diff[p2a({ y, x: this.dst.left + i })] = Object.assign(Object.assign({}, baseCell), { value: patterns[py].next().value });
+        get applied() {
+            const [orientation, sign] = DirectionMapping[this.direction];
+            const matrix = this.table.getMatrix({ area: this.src, evaluates: false });
+            const srcShape = (0, structs_1.areaShape)(Object.assign(Object.assign({}, this.src), { base: 1 }));
+            const dstShape = (0, structs_1.areaShape)(Object.assign(Object.assign({}, this.dst), { base: 1 }));
+            const diff = {};
+            if (orientation === "horizontal") {
+                for (let i = 0; i < dstShape.height; i++) {
+                    const patterns = this.getChangePatterns(matrix[i]);
+                    for (let j = 0; j < dstShape.width; j++) {
+                        const baseCell = matrix[i % srcShape.height][j % srcShape.width];
+                        const x = sign > 0 ? this.dst.left + j : this.dst.right - j;
+                        const px = sign > 0 ? j % srcShape.width : (srcShape.width - 1 - (j % srcShape.width)) % srcShape.width;
+                        diff[(0, converters_1.p2a)({ y: this.dst.top + i, x })] = Object.assign(Object.assign({}, baseCell), { value: patterns[px].next().value });
+                    }
                 }
             }
-        }
-        const table = this.table.update({
-            diff,
-            reflection: {
-                selectingZone: areaToZone(this.src),
-            }
-        });
-        return table;
-    }
-    get wholeArea() {
-        return concatAreas(this.src, this.dst);
-    }
-    getCellStyle(target) {
-        const { x, y } = target;
-        const style = {};
-        const { top, left, bottom, right } = this.src;
-        switch (this.direction) {
-            case "left": {
-                if (this.dst.left <= x && x <= this.dst.right) {
-                    if (top === y) {
-                        style.borderTop = BORDER_AUTOFILL_DRAGGING;
-                    }
-                    if (bottom === y - 1) {
-                        style.borderTop = BORDER_AUTOFILL_DRAGGING;
+            else {
+                for (let i = 0; i < dstShape.width; i++) {
+                    const patterns = this.getChangePatterns(matrix.map((row) => row[i]));
+                    for (let j = 0; j < dstShape.height; j++) {
+                        const baseCell = matrix[i % srcShape.height][j % srcShape.width];
+                        const y = sign > 0 ? this.dst.top + j : this.dst.bottom - j;
+                        const py = sign > 0 ? j % srcShape.height : (srcShape.height - 1 - (j % srcShape.height)) % srcShape.height;
+                        diff[(0, converters_1.p2a)({ y, x: this.dst.left + i })] = Object.assign(Object.assign({}, baseCell), { value: patterns[py].next().value });
                     }
                 }
-                if (this.dst.left === x && top <= y && y <= bottom) {
-                    style.borderLeft = BORDER_AUTOFILL_DRAGGING;
-                }
-                break;
             }
-            case "right": {
-                if (this.dst.left <= x && x <= this.dst.right) {
-                    if (top === y) {
-                        style.borderTop = BORDER_AUTOFILL_DRAGGING;
+            const table = this.table.update({
+                diff,
+                reflection: {
+                    selectingZone: (0, structs_1.areaToZone)(this.src),
+                }
+            });
+            return table;
+        }
+        get wholeArea() {
+            return (0, structs_1.concatAreas)(this.src, this.dst);
+        }
+        getCellStyle(target) {
+            const { x, y } = target;
+            const style = {};
+            const { top, left, bottom, right } = this.src;
+            switch (this.direction) {
+                case "left": {
+                    if (this.dst.left <= x && x <= this.dst.right) {
+                        if (top === y) {
+                            style.borderTop = BORDER_AUTOFILL_DRAGGING;
+                        }
+                        if (bottom === y - 1) {
+                            style.borderTop = BORDER_AUTOFILL_DRAGGING;
+                        }
                     }
-                    if (bottom === y - 1) {
-                        style.borderTop = BORDER_AUTOFILL_DRAGGING;
+                    if (this.dst.left === x && top <= y && y <= bottom) {
+                        style.borderLeft = BORDER_AUTOFILL_DRAGGING;
                     }
+                    break;
                 }
-                if (this.dst.right === x - 1 && top <= y && y <= bottom) {
-                    style.borderLeft = BORDER_AUTOFILL_DRAGGING;
-                }
-                break;
-            }
-            case "up": {
-                if (this.dst.top <= y && y <= this.dst.bottom) {
-                    if (left === x) {
-                        style.borderLeft = BORDER_AUTOFILL_DRAGGING;
+                case "right": {
+                    if (this.dst.left <= x && x <= this.dst.right) {
+                        if (top === y) {
+                            style.borderTop = BORDER_AUTOFILL_DRAGGING;
+                        }
+                        if (bottom === y - 1) {
+                            style.borderTop = BORDER_AUTOFILL_DRAGGING;
+                        }
                     }
-                    if (right === x - 1) {
+                    if (this.dst.right === x - 1 && top <= y && y <= bottom) {
                         style.borderLeft = BORDER_AUTOFILL_DRAGGING;
                     }
+                    break;
                 }
-                if (this.dst.top === y && left <= x && x <= right) {
-                    style.borderTop = BORDER_AUTOFILL_DRAGGING;
-                }
-                break;
-            }
-            case "down": {
-                if (this.dst.top <= y && y <= this.dst.bottom) {
-                    if (left === x) {
-                        style.borderLeft = BORDER_AUTOFILL_DRAGGING;
+                case "up": {
+                    if (this.dst.top <= y && y <= this.dst.bottom) {
+                        if (left === x) {
+                            style.borderLeft = BORDER_AUTOFILL_DRAGGING;
+                        }
+                        if (right === x - 1) {
+                            style.borderLeft = BORDER_AUTOFILL_DRAGGING;
+                        }
                     }
-                    if (right === x - 1) {
-                        style.borderLeft = BORDER_AUTOFILL_DRAGGING;
+                    if (this.dst.top === y && left <= x && x <= right) {
+                        style.borderTop = BORDER_AUTOFILL_DRAGGING;
                     }
+                    break;
                 }
-                if (this.dst.bottom === y - 1 && left <= x && x <= right) {
-                    style.borderTop = BORDER_AUTOFILL_DRAGGING;
+                case "down": {
+                    if (this.dst.top <= y && y <= this.dst.bottom) {
+                        if (left === x) {
+                            style.borderLeft = BORDER_AUTOFILL_DRAGGING;
+                        }
+                        if (right === x - 1) {
+                            style.borderLeft = BORDER_AUTOFILL_DRAGGING;
+                        }
+                    }
+                    if (this.dst.bottom === y - 1 && left <= x && x <= right) {
+                        style.borderTop = BORDER_AUTOFILL_DRAGGING;
+                    }
+                    break;
                 }
-                break;
             }
+            return style;
         }
-        return style;
-    }
-    getDestinationArea(autofillDraggingTo) {
-        const { x, y } = autofillDraggingTo;
-        const { top, left, bottom, right } = this.src;
-        switch (this.direction) {
-            case "left":
-                return { top, bottom, left: x, right: left - 1 };
-            case "right":
-                return { top, bottom, left: right + 1, right: x };
-            case "up":
-                return { left, right, top: y, bottom: top - 1 };
-            case "down":
-                return { left, right, top: bottom + 1, bottom: y };
-        }
-        return this.src;
-    }
-    suggestDirection(draggingTo) {
-        const { top, left, bottom, right } = this.src;
-        let horizontal = 0, vertical = 0;
-        if (draggingTo.x < left) {
-            horizontal = draggingTo.x - left;
-        }
-        else if (draggingTo.x > right) {
-            horizontal = draggingTo.x - right;
-        }
-        if (draggingTo.y < top) {
-            vertical = draggingTo.y - top;
-        }
-        else if (draggingTo.y > bottom) {
-            vertical = draggingTo.y - bottom;
+        getDestinationArea(autofillDraggingTo) {
+            const { x, y } = autofillDraggingTo;
+            const { top, left, bottom, right } = this.src;
+            switch (this.direction) {
+                case "left":
+                    return { top, bottom, left: x, right: left - 1 };
+                case "right":
+                    return { top, bottom, left: right + 1, right: x };
+                case "up":
+                    return { left, right, top: y, bottom: top - 1 };
+                case "down":
+                    return { left, right, top: bottom + 1, bottom: y };
+            }
+            return this.src;
         }
-        // diagonal
-        if (Math.abs(horizontal) > 0 && Math.abs(vertical) > 0) {
-            if (Math.abs(horizontal) > Math.abs(vertical)) {
+        suggestDirection(draggingTo) {
+            const { top, left, bottom, right } = this.src;
+            let horizontal = 0, vertical = 0;
+            if (draggingTo.x < left) {
+                horizontal = draggingTo.x - left;
+            }
+            else if (draggingTo.x > right) {
+                horizontal = draggingTo.x - right;
+            }
+            if (draggingTo.y < top) {
+                vertical = draggingTo.y - top;
+            }
+            else if (draggingTo.y > bottom) {
+                vertical = draggingTo.y - bottom;
+            }
+            // diagonal
+            if (Math.abs(horizontal) > 0 && Math.abs(vertical) > 0) {
+                if (Math.abs(horizontal) > Math.abs(vertical)) {
+                    return horizontal < 0 ? "left" : "right";
+                }
+                return vertical < 0 ? "up" : "down";
+            }
+            if (horizontal !== 0) {
                 return horizontal < 0 ? "left" : "right";
             }
-            return vertical < 0 ? "up" : "down";
-        }
-        if (horizontal !== 0) {
-            return horizontal < 0 ? "left" : "right";
-        }
-        if (vertical !== 0) {
-            return vertical < 0 ? "up" : "down";
+            if (vertical !== 0) {
+                return vertical < 0 ? "up" : "down";
+            }
+            return "down";
         }
-        return "down";
-    }
-    ;
-    getChangePatterns(cells) {
-        const result = [];
-        const groups = groupByType(cells);
-        const [orientation, sign] = DirectionMapping[this.direction];
-        groups.forEach((group) => {
-            const lastValue = sign > 0 ? group.last : group.first;
-            switch (group.kind) {
-                case "other": {
-                    result.push(pass(group.first));
-                    return;
-                }
-                case "formula": {
-                    const value = group.first;
-                    const table = this.table;
-                    function* generateFormula() {
-                        let slide = 0;
-                        const skip = cells.length * sign;
-                        while (true) {
-                            slide += skip;
-                            yield convertFormulaAbsolute({
-                                value,
-                                table,
-                                slideY: orientation === "vertical" ? slide : 0,
-                                slideX: orientation === "horizontal" ? slide : 0,
-                            });
-                        }
-                    }
-                    result.push(generateFormula());
-                    return;
-                }
-                case "number": {
-                    if (!group.equidistant) {
-                        result.push(pass(group.first), ...group.nexts.map((v) => pass(v)));
+        ;
+        getChangePatterns(cells) {
+            const result = [];
+            const groups = groupByType(cells);
+            const [orientation, sign] = DirectionMapping[this.direction];
+            groups.forEach((group) => {
+                const lastValue = sign > 0 ? group.last : group.first;
+                switch (group.kind) {
+                    case "other": {
+                        result.push(pass(group.first));
                         return;
                     }
-                    function* generateNumber() {
-                        let value = lastValue;
-                        const skip = group.numericDelta * sign;
-                        while (true) {
-                            value += skip;
-                            yield value;
+                    case "formula": {
+                        const value = group.first;
+                        const table = this.table;
+                        function* generateFormula() {
+                            let slide = 0;
+                            const skip = cells.length * sign;
+                            while (true) {
+                                slide += skip;
+                                yield (0, evaluator_1.convertFormulaAbsolute)({
+                                    value,
+                                    table,
+                                    slideY: orientation === "vertical" ? slide : 0,
+                                    slideX: orientation === "horizontal" ? slide : 0,
+                                });
+                            }
                         }
-                    }
-                    const g = generateNumber();
-                    result.push(g, ...group.nexts.map(() => g));
-                    return;
-                }
-                case "date": {
-                    const next = (d) => {
-                        return sign > 0 ? group.timeDelta.add(d) : group.timeDelta.sub(d);
-                    };
-                    if (!group.equidistant) {
-                        result.push(pass(group.first), ...group.nexts.map((v) => pass(v)));
+                        result.push(generateFormula());
                         return;
                     }
-                    function* generateDate() {
-                        let value = lastValue;
-                        while (true) {
-                            value = next(value);
-                            yield new Date(value);
+                    case "number": {
+                        if (!group.equidistant) {
+                            result.push(pass(group.first), ...group.nexts.map((v) => pass(v)));
+                            return;
                         }
+                        function* generateNumber() {
+                            let value = lastValue;
+                            const skip = group.numericDelta * sign;
+                            while (true) {
+                                value += skip;
+                                yield value;
+                            }
+                        }
+                        const g = generateNumber();
+                        result.push(g, ...group.nexts.map(() => g));
+                        return;
                     }
-                    const g = generateDate();
-                    result.push(g, ...group.nexts.map(() => g));
-                    return;
-                }
-                case "string+number": {
-                    if (!group.equidistant) {
-                        result.push(pass(group.first), ...group.nexts.map((v) => pass(v)));
+                    case "date": {
+                        const next = (d) => {
+                            return sign > 0 ? group.timeDelta.add(d) : group.timeDelta.sub(d);
+                        };
+                        if (!group.equidistant) {
+                            result.push(pass(group.first), ...group.nexts.map((v) => pass(v)));
+                            return;
+                        }
+                        function* generateDate() {
+                            let value = lastValue;
+                            while (true) {
+                                value = next(value);
+                                yield new Date(value);
+                            }
+                        }
+                        const g = generateDate();
+                        result.push(g, ...group.nexts.map(() => g));
                         return;
                     }
-                    function* generateStringNumber() {
-                        const { prefix } = extractStringNumber(group.first);
-                        const { number: lastNumber } = extractStringNumber(lastValue);
-                        let value = lastNumber;
-                        const skip = group.numericDelta * sign;
-                        while (true) {
-                            value += skip;
-                            yield `${prefix}${Math.abs(value)}`;
+                    case "string+number": {
+                        if (!group.equidistant) {
+                            result.push(pass(group.first), ...group.nexts.map((v) => pass(v)));
+                            return;
+                        }
+                        function* generateStringNumber() {
+                            const { prefix } = extractStringNumber(group.first);
+                            const { number: lastNumber } = extractStringNumber(lastValue);
+                            let value = lastNumber;
+                            const skip = group.numericDelta * sign;
+                            while (true) {
+                                value += skip;
+                                yield `${prefix}${Math.abs(value)}`;
+                            }
                         }
+                        const g = generateStringNumber();
+                        result.push(g, ...group.nexts.map(() => g));
+                        return;
                     }
-                    const g = generateStringNumber();
-                    result.push(g, ...group.nexts.map(() => g));
-                    return;
                 }
-            }
-        });
-        return result;
-    }
-}
-function* pass(value) {
-    while (true) {
-        yield value;
-    }
-}
-const StringNumberPattern = new RegExp('(.+?)(\\d+)$');
-const extractStringNumber = (value) => {
-    const match = value.match(StringNumberPattern);
-    if (match) {
-        const [, prefix, n] = match;
-        return { prefix, number: Number(n) };
+            });
+            return result;
+        }
     }
-    return { prefix: "", number: 0 };
-};
-class TypedGroup {
-    constructor(value) {
-        this.timeDelta = TimeDelta.create();
-        this.numericDelta = 0;
-        this.equidistant = true;
-        this.first = value;
-        this.nexts = [];
-        this.kind = this.discriminate(value);
+    exports.Autofill = Autofill;
+    function* pass(value) {
+        while (true) {
+            yield value;
+        }
     }
-    discriminate(value) {
-        let kind = value instanceof Date ? "date" : typeof value;
-        if (kind === "number" || kind === "date") {
-            return kind;
+    const StringNumberPattern = new RegExp('(.+?)(\\d+)$');
+    const extractStringNumber = (value) => {
+        const match = value.match(StringNumberPattern);
+        if (match) {
+            const [, prefix, n] = match;
+            return { prefix, number: Number(n) };
         }
-        if (kind === "string" && value[0] === "=") {
-            return "formula";
+        return { prefix: "", number: 0 };
+    };
+    class TypedGroup {
+        constructor(value) {
+            this.timeDelta = time_1.TimeDelta.create();
+            this.numericDelta = 0;
+            this.equidistant = true;
+            this.first = value;
+            this.nexts = [];
+            this.kind = this.discriminate(value);
         }
-        else if (kind === "string" && value.match(StringNumberPattern)) {
-            return "string+number";
+        discriminate(value) {
+            let kind = value instanceof Date ? "date" : typeof value;
+            if (kind === "number" || kind === "date") {
+                return kind;
+            }
+            if (kind === "string" && value[0] === "=") {
+                return "formula";
+            }
+            else if (kind === "string" && value.match(StringNumberPattern)) {
+                return "string+number";
+            }
+            return "other";
         }
-        return "other";
-    }
-    get last() {
-        if (this.nexts.length === 0) {
-            return this.first;
+        get last() {
+            if (this.nexts.length === 0) {
+                return this.first;
+            }
+            return this.nexts[this.nexts.length - 1];
         }
-        return this.nexts[this.nexts.length - 1];
-    }
-    add(value) {
-        const kind = this.discriminate(value);
-        if (this.kind !== kind || kind === "other" || kind === "formula") {
-            return new TypedGroup(value);
+        add(value) {
+            const kind = this.discriminate(value);
+            if (this.kind !== kind || kind === "other" || kind === "formula") {
+                return new TypedGroup(value);
+            }
+            if (this.nexts.length === 0) {
+                switch (kind) {
+                    case "date": {
+                        this.timeDelta = new time_1.TimeDelta(value, this.first);
+                        break;
+                    }
+                    case "number": {
+                        this.numericDelta = value - this.first;
+                        break;
+                    }
+                    case "string+number": {
+                        const { prefix: prefix1, number: number1 } = extractStringNumber(this.first);
+                        const { prefix: prefix2, number: number2 } = extractStringNumber(value);
+                        if (prefix1 === prefix2) {
+                            this.numericDelta = number2 - number1;
+                        }
+                        break;
+                    }
+                }
+            }
+            this.nexts.push(value);
         }
-        if (this.nexts.length === 0) {
-            switch (kind) {
+        subdivide() {
+            if (this.nexts.length === 0) {
+                return [];
+            }
+            const news = [];
+            let lastGroup = this;
+            switch (this.kind) {
                 case "date": {
-                    this.timeDelta = new TimeDelta(value, this.first);
-                    break;
+                    const eq = this.nexts.every((v, i) => i === 0 || (0, date_fns_1.isEqual)(v, this.timeDelta.add(this.nexts[i - 1])));
+                    this.equidistant = eq;
+                    return [];
                 }
                 case "number": {
-                    this.numericDelta = value - this.first;
-                    break;
+                    const eq = this.nexts.every((v, i) => i === 0 || v === this.first + this.numericDelta * (i + 1));
+                    this.equidistant = eq;
+                    return [];
                 }
                 case "string+number": {
-                    const { prefix: prefix1, number: number1 } = extractStringNumber(this.first);
-                    const { prefix: prefix2, number: number2 } = extractStringNumber(value);
-                    if (prefix1 === prefix2) {
-                        this.numericDelta = number2 - number1;
+                    let { prefix: basePrefix, number: baseNumber } = extractStringNumber(this.first);
+                    for (let i = 0; i < lastGroup.nexts.length; i++) {
+                        const next = lastGroup.nexts[i];
+                        const { prefix, number } = extractStringNumber(next);
+                        if (basePrefix !== prefix) {
+                            const nexts = this.nexts.splice(i, this.nexts.length);
+                            lastGroup = new TypedGroup(nexts.splice(0, 1)[0]);
+                            nexts.forEach(lastGroup.add.bind(lastGroup));
+                            news.push(lastGroup, ...lastGroup.subdivide());
+                            break;
+                        }
+                        else {
+                            const { number: firstNumber } = extractStringNumber(lastGroup.first);
+                            if (number !== firstNumber + (i + 1) * lastGroup.numericDelta) {
+                                lastGroup.equidistant = false;
+                            }
+                        }
                     }
                     break;
                 }
             }
+            return news;
         }
-        this.nexts.push(value);
     }
-    subdivide() {
-        if (this.nexts.length === 0) {
-            return [];
-        }
-        const news = [];
-        let lastGroup = this;
-        switch (this.kind) {
-            case "date": {
-                const eq = this.nexts.every((v, i) => i === 0 || isEqual(v, this.timeDelta.add(this.nexts[i - 1])));
-                this.equidistant = eq;
-                return [];
-            }
-            case "number": {
-                const eq = this.nexts.every((v, i) => i === 0 || v === this.first + this.numericDelta * (i + 1));
-                this.equidistant = eq;
-                return [];
-            }
-            case "string+number": {
-                let { prefix: basePrefix, number: baseNumber } = extractStringNumber(this.first);
-                for (let i = 0; i < lastGroup.nexts.length; i++) {
-                    const next = lastGroup.nexts[i];
-                    const { prefix, number } = extractStringNumber(next);
-                    if (basePrefix !== prefix) {
-                        const nexts = this.nexts.splice(i, this.nexts.length);
-                        lastGroup = new TypedGroup(nexts.splice(0, 1)[0]);
-                        nexts.forEach(lastGroup.add.bind(lastGroup));
-                        news.push(lastGroup, ...lastGroup.subdivide());
-                        break;
-                    }
-                    else {
-                        const { number: firstNumber } = extractStringNumber(lastGroup.first);
-                        if (number !== firstNumber + (i + 1) * lastGroup.numericDelta) {
-                            lastGroup.equidistant = false;
-                        }
-                    }
-                }
-                break;
+    function groupByType(cells) {
+        var _a, _b;
+        let group = new TypedGroup((_a = cells[0]) === null || _a === void 0 ? void 0 : _a.value);
+        const groups = [group];
+        for (let i = 1; i < cells.length; i++) {
+            const value = (_b = cells[i]) === null || _b === void 0 ? void 0 : _b.value;
+            const nextGroup = group.add(value);
+            if (nextGroup) {
+                groups.push(nextGroup);
+                group = nextGroup;
             }
         }
-        return news;
-    }
-}
-function groupByType(cells) {
-    var _a, _b;
-    let group = new TypedGroup((_a = cells[0]) === null || _a === void 0 ? void 0 : _a.value);
-    const groups = [group];
-    for (let i = 1; i < cells.length; i++) {
-        const value = (_b = cells[i]) === null || _b === void 0 ? void 0 : _b.value;
-        const nextGroup = group.add(value);
-        if (nextGroup) {
-            groups.push(nextGroup);
-            group = nextGroup;
+        for (let i = groups.length - 1; i >= 0; i--) {
+            const group = groups[i];
+            groups.splice(i + 1, 0, ...group.subdivide());
         }
+        return groups;
     }
-    for (let i = groups.length - 1; i >= 0; i--) {
-        const group = groups[i];
-        groups.splice(i + 1, 0, ...group.subdivide());
-    }
-    return groups;
-}
+});
 //# sourceMappingURL=autofill.js.map