@b9g/revise 0.1.1 → 0.1.2

package/edit.cjs

@@ -2,87 +2,190 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var subseq = require('./subseq.cjs');
-
-/**
- * A data structure which represents edits to strings.
- */
-class Edit {
-    constructor(parts, deleted) {
-        this.parts = parts;
-        this.deleted = deleted;
+function measure(subseq) {
+    let length = 0, includedLength = 0, excludedLength = 0;
+    for (let i = 0; i < subseq.length; i++) {
+        const s = subseq[i];
+        length += s;
+        if (i % 2 === 0) {
+            excludedLength += s;
+        }
+        else {
+            includedLength += s;
+        }
+    }
+    return { length, includedLength, excludedLength };
+}
+function pushSegment(subseq, length, included) {
+    if (length < 0) {
+        throw new RangeError("Negative length");
+    }
+    else if (length === 0) {
+        return;
+    }
+    else if (!subseq.length) {
+        if (included) {
+            subseq.push(0, length);
+        }
+        else {
+            subseq.push(length);
+        }
+    }
+    else {
+        const included1 = subseq.length % 2 === 0;
+        if (included === included1) {
+            subseq[subseq.length - 1] += length;
+        }
+        else {
+            subseq.push(length);
+        }
+    }
+}
+function align(subseq1, subseq2) {
+    if (measure(subseq1).length !== measure(subseq2).length) {
+        throw new Error("Length mismatch");
     }
-    static synthesize(insertSeq, inserted, deleteSeq, deleted) {
-        if (insertSeq.includedSize !== inserted.length) {
-            throw new Error("insertSeq and inserted string do not match in length");
-        }
-        else if (deleted !== undefined &&
-            deleteSeq.includedSize !== deleted.length) {
-            throw new Error("deleteSeq and deleted string do not match in length");
-        }
-        else if (deleteSeq.size !== insertSeq.excludedSize) {
-            throw new Error("deleteSeq and insertSeq do not match in length");
-        }
-        const parts = [];
-        let insertIndex = 0;
-        let retainIndex = 0;
-        let needsLength = true;
-        for (const [length, deleting, inserting] of deleteSeq
-            .expand(insertSeq)
-            .align(insertSeq)) {
-            if (inserting) {
-                parts.push(inserted.slice(insertIndex, insertIndex + length));
-                insertIndex += length;
+    const result = [];
+    for (let i1 = 0, i2 = 0, length1 = 0, length2 = 0, included1 = true, included2 = true; i1 < subseq1.length || i2 < subseq2.length;) {
+        if (length1 === 0) {
+            if (i1 >= subseq1.length) {
+                throw new Error("Length mismatch");
             }
-            else {
-                if (!deleting) {
-                    parts.push(retainIndex, retainIndex + length);
-                }
-                retainIndex += length;
-                needsLength = deleting;
+            length1 = subseq1[i1++];
+            included1 = !included1;
+        }
+        if (length2 === 0) {
+            if (i2 >= subseq2.length) {
+                throw new Error("Size mismatch");
+            }
+            length2 = subseq2[i2++];
+            included2 = !included2;
+        }
+        if (length1 < length2) {
+            if (length1) {
+                result.push([length1, included1, included2]);
             }
+            length2 = length2 - length1;
+            length1 = 0;
         }
-        if (needsLength) {
-            parts.push(retainIndex);
+        else if (length1 > length2) {
+            if (length2) {
+                result.push([length2, included1, included2]);
+            }
+            length1 = length1 - length2;
+            length2 = 0;
+        }
+        else {
+            if (length1) {
+                result.push([length1, included1, included2]);
+            }
+            length1 = length2 = 0;
         }
-        return new Edit(parts, deleted);
     }
-    static build(text, inserted, from, to = from) {
-        const insertSizes = [];
-        subseq.Subseq.pushSegment(insertSizes, from, false);
-        subseq.Subseq.pushSegment(insertSizes, inserted.length, true);
-        subseq.Subseq.pushSegment(insertSizes, to - from, false);
-        subseq.Subseq.pushSegment(insertSizes, text.length - to, false);
-        const deleteSizes = [];
-        subseq.Subseq.pushSegment(deleteSizes, from, false);
-        subseq.Subseq.pushSegment(deleteSizes, to - from, true);
-        subseq.Subseq.pushSegment(deleteSizes, text.length - to, false);
-        const deleted = text.slice(from, to);
-        return Edit.synthesize(new subseq.Subseq(insertSizes), inserted, new subseq.Subseq(deleteSizes), deleted);
+    return result;
+}
+function union(subseq1, subseq2) {
+    const result = [];
+    for (const [length, included1, included2] of align(subseq1, subseq2)) {
+        pushSegment(result, length, included1 || included2);
+    }
+    return result;
+}
+function intersection(subseq1, subseq2) {
+    const result = [];
+    for (const [length, included1, included2] of align(subseq1, subseq2)) {
+        pushSegment(result, length, included1 && included2);
     }
-    /**
-     * Given two strings, this method finds an edit which can be applied to the
-     * first string to result in the second.
-     * An optional hint can be provided to disambiguate edits when they are made
-     * to overlapping characters.
-     */
-    static diff(text1, text2, hint) {
-        let prefix = commonPrefixLength(text1, text2);
-        let suffix = commonSuffixLength(text1, text2);
-        // prefix and suffix overlap when edits are runs of the same character.
-        if (prefix + suffix > Math.min(text1.length, text2.length)) {
-            if (hint !== undefined && hint > -1) {
-                prefix = Math.min(prefix, hint);
+    return result;
+}
+function shrink(subseq1, subseq2) {
+    if (measure(subseq1).length !== measure(subseq2).length) {
+        throw new Error("Length mismatch");
+    }
+    const result = [];
+    for (const [length, included1, included2] of align(subseq1, subseq2)) {
+        if (!included2) {
+            pushSegment(result, length, included1);
+        }
+    }
+    return result;
+}
+function expand(subseq1, subseq2) {
+    if (measure(subseq1).length !== measure(subseq2).excludedLength) {
+        throw new Error("Length mismatch");
+    }
+    const result = [];
+    for (let i1 = 0, i2 = 0, length1 = 0, included1 = true, included2 = true; i2 < subseq2.length; i2++) {
+        let length2 = subseq2[i2];
+        included2 = !included2;
+        if (included2) {
+            pushSegment(result, length2, false);
+        }
+        else {
+            while (length2) {
+                if (length1 === 0) {
+                    length1 = subseq1[i1++];
+                    included1 = !included1;
+                }
+                const minLength = Math.min(length1, length2);
+                pushSegment(result, minLength, included1);
+                length1 -= minLength;
+                length2 -= minLength;
             }
-            // TODO: We can probably avoid the commonSuffixLength() call here in
-            // favor of arithmetic but I’m too dumb to figure it out.
-            suffix = commonSuffixLength(text1.slice(prefix), text2.slice(prefix));
         }
-        return Edit.build(text1, text2.slice(prefix, text2.length - suffix), prefix, text1.length - suffix);
     }
-    /**
-     * A string which represents a concatenation of all insertions.
-     */
+    return result;
+}
+function interleave(subseq1, subseq2) {
+    if (measure(subseq1).excludedLength !== measure(subseq2).excludedLength) {
+        throw new Error("Length mismatch");
+    }
+    const result1 = [];
+    const result2 = [];
+    for (let i1 = 0, i2 = 0, length1 = 0, length2 = 0, included1 = true, included2 = true; i1 < subseq1.length || i2 < subseq2.length;) {
+        if (length1 === 0 && i1 < subseq1.length) {
+            length1 = subseq1[i1++];
+            included1 = !included1;
+        }
+        if (length2 === 0 && i2 < subseq2.length) {
+            length2 = subseq2[i2++];
+            included2 = !included2;
+        }
+        if (included1 && included2) {
+            pushSegment(result1, length1, true);
+            pushSegment(result1, length2, false);
+            pushSegment(result2, length1, false);
+            pushSegment(result2, length2, true);
+            length1 = length2 = 0;
+        }
+        else if (included1) {
+            pushSegment(result1, length1, true);
+            pushSegment(result2, length1, false);
+            length1 = 0;
+        }
+        else if (included2) {
+            pushSegment(result1, length2, false);
+            pushSegment(result2, length2, true);
+            length2 = 0;
+        }
+        else {
+            const minLength = Math.min(length1, length2);
+            pushSegment(result1, minLength, false);
+            pushSegment(result2, minLength, false);
+            length1 -= minLength;
+            length2 -= minLength;
+        }
+    }
+    return [result1, result2];
+}
+
+/** A compact data structure for representing changes to strings. */
+class Edit {
+    constructor(parts, deleted) {
+        this.parts = parts;
+        this.deleted = deleted;
+    }
+    /** A string which represents a concatenation of all insertions. */
     get inserted() {
         let text = "";
         for (let i = 0; i < this.parts.length; i++) {
@@ -92,6 +195,20 @@ class Edit {
         }
         return text;
     }
+    /**
+     * Returns an array of operations, which is more readable than the parts
+     * array.
+     *
+     *   new Edit([0, 1, " ", 2], "x").operations();
+     *   [
+     *     {type: "retain", start: 0, end: 1},
+     *     {type: "insert", start: 1, value: " "},
+     *     {type: "delete", start: 1, end: 2, value: "x"},
+     *   ]
+     *
+     * When insertions and deletions happen at the same index, insertions will
+     * always appear before deletions in the operations array.
+     */
     operations() {
         const operations = [];
         let retaining = false;
@@ -129,8 +246,6 @@ class Edit {
         }
         return operations;
     }
-    // TODO: I’m not too happy about the name of this method, insofar as it might
-    // imply that this object is callable.
     apply(text) {
         let text1 = "";
         const operations = this.operations();
@@ -147,158 +262,307 @@ class Edit {
         }
         return text1;
     }
-    factor() {
-        const insertSizes = [];
-        const deleteSizes = [];
-        let inserted = "";
-        const operations = this.operations();
-        for (let i = 0; i < operations.length; i++) {
-            const op = operations[i];
-            switch (op.type) {
-                case "retain": {
-                    const length = op.end - op.start;
-                    subseq.Subseq.pushSegment(insertSizes, length, false);
-                    subseq.Subseq.pushSegment(deleteSizes, length, false);
-                    break;
-                }
-                case "delete": {
-                    const length = op.end - op.start;
-                    subseq.Subseq.pushSegment(insertSizes, length, false);
-                    subseq.Subseq.pushSegment(deleteSizes, length, true);
-                    break;
-                }
-                case "insert":
-                    subseq.Subseq.pushSegment(insertSizes, op.value.length, true);
-                    inserted += op.value;
-                    break;
-                default:
-                    throw new TypeError("Invalid operation type");
+    /** Composes two consecutive edits. */
+    compose(that) {
+        let [insertSeq1, inserted1, deleteSeq1, deleted1] = factor(this);
+        let [insertSeq2, inserted2, deleteSeq2, deleted2] = factor(that);
+        // Expand all subseqs so that they share the same coordinate space.
+        deleteSeq1 = expand(deleteSeq1, insertSeq1);
+        deleteSeq2 = expand(deleteSeq2, deleteSeq1);
+        [deleteSeq1, insertSeq2] = interleave(deleteSeq1, insertSeq2);
+        deleteSeq2 = expand(deleteSeq2, insertSeq2);
+        insertSeq1 = expand(insertSeq1, insertSeq2);
+        {
+            // Find insertions which have been deleted and remove them.
+            const toggleSeq = intersection(insertSeq1, deleteSeq2);
+            if (measure(toggleSeq).includedLength) {
+                deleteSeq1 = shrink(deleteSeq1, toggleSeq);
+                inserted1 = erase(insertSeq1, inserted1, toggleSeq);
+                insertSeq1 = shrink(insertSeq1, toggleSeq);
+                deleteSeq2 = shrink(deleteSeq2, toggleSeq);
+                insertSeq2 = shrink(insertSeq2, toggleSeq);
             }
         }
-        const insertSeq = new subseq.Subseq(insertSizes);
-        const deleteSeq = new subseq.Subseq(deleteSizes);
-        return [insertSeq, inserted, deleteSeq, this.deleted];
+        const insertSeq = union(insertSeq1, insertSeq2);
+        const inserted = consolidate(insertSeq1, inserted1, insertSeq2, inserted2);
+        const deleteSeq = shrink(union(deleteSeq1, deleteSeq2), insertSeq);
+        const deleted = deleted1 != null && deleted2 != null
+            ? consolidate(deleteSeq1, deleted1, deleteSeq2, deleted2)
+            : undefined;
+        return synthesize(insertSeq, inserted, deleteSeq, deleted).normalize();
+    }
+    invert() {
+        if (typeof this.deleted === "undefined") {
+            throw new Error("Edit is not invertible");
+        }
+        let [insertSeq, inserted, deleteSeq, deleted] = factor(this);
+        deleteSeq = expand(deleteSeq, insertSeq);
+        insertSeq = shrink(insertSeq, deleteSeq);
+        return synthesize(deleteSeq, deleted, insertSeq, inserted);
     }
     normalize() {
         if (typeof this.deleted === "undefined") {
-            throw new Error("Missing deleted property");
+            throw new Error("Edit is not normalizable");
         }
-        const insertSizes = [];
-        const deleteSizes = [];
+        const insertSeq = [];
+        const deleteSeq = [];
         let inserted = "";
         let deleted = "";
-        let prevInserted;
+        let insertion;
         const operations = this.operations();
         for (let i = 0; i < operations.length; i++) {
             const op = operations[i];
             switch (op.type) {
                 case "insert": {
-                    prevInserted = op.value;
+                    insertion = op.value;
                     break;
                 }
                 case "retain": {
-                    if (prevInserted !== undefined) {
-                        subseq.Subseq.pushSegment(insertSizes, prevInserted.length, true);
-                        inserted += prevInserted;
-                        prevInserted = undefined;
+                    if (insertion !== undefined) {
+                        pushSegment(insertSeq, insertion.length, true);
+                        inserted += insertion;
+                        insertion = undefined;
                     }
-                    subseq.Subseq.pushSegment(insertSizes, op.end - op.start, false);
-                    subseq.Subseq.pushSegment(deleteSizes, op.end - op.start, false);
+                    pushSegment(insertSeq, op.end - op.start, false);
+                    pushSegment(deleteSeq, op.end - op.start, false);
                     break;
                 }
                 case "delete": {
                     const length = op.end - op.start;
+                    const deletion = op.value;
                     let prefix = 0;
-                    if (prevInserted !== undefined) {
-                        prefix = commonPrefixLength(prevInserted, op.value);
-                        subseq.Subseq.pushSegment(insertSizes, prefix, false);
-                        subseq.Subseq.pushSegment(insertSizes, prevInserted.length - prefix, true);
-                        inserted += prevInserted.slice(prefix);
-                        prevInserted = undefined;
+                    let suffix = 0;
+                    if (insertion !== undefined) {
+                        if (insertion === deletion) {
+                            prefix = deletion.length;
+                        }
+                        else {
+                            prefix = commonPrefixLength(insertion, deletion);
+                            suffix = commonSuffixLength(insertion.slice(prefix), deletion.slice(prefix));
+                        }
+                        pushSegment(insertSeq, prefix, false);
+                        pushSegment(insertSeq, insertion.length - prefix - suffix, true);
+                        inserted += insertion.slice(prefix, insertion.length - suffix);
                     }
-                    deleted += op.value.slice(prefix);
-                    subseq.Subseq.pushSegment(deleteSizes, prefix, false);
-                    subseq.Subseq.pushSegment(deleteSizes, length - prefix, true);
-                    subseq.Subseq.pushSegment(insertSizes, length - prefix, false);
+                    deleted += deletion.slice(prefix, deletion.length - suffix);
+                    pushSegment(deleteSeq, prefix, false);
+                    // TODO: This line is throwing for some reason
+                    pushSegment(deleteSeq, length - prefix - suffix, true);
+                    pushSegment(deleteSeq, suffix, false);
+                    pushSegment(insertSeq, length - prefix - suffix, false);
+                    pushSegment(insertSeq, suffix, false);
+                    insertion = undefined;
                     break;
                 }
-                default: {
-                    throw new TypeError("Invalid operation type");
-                }
             }
         }
-        if (prevInserted !== undefined) {
-            subseq.Subseq.pushSegment(insertSizes, prevInserted.length, true);
-            inserted += prevInserted;
+        if (insertion !== undefined) {
+            pushSegment(insertSeq, insertion.length, true);
+            inserted += insertion;
+        }
+        return synthesize(insertSeq, inserted, deleteSeq, deleted);
+    }
+    hasChangesBetween(start, end) {
+        const ops = this.operations();
+        for (const op of ops) {
+            switch (op.type) {
+                case "delete": {
+                    if ((start <= op.start && op.start <= end) ||
+                        (start <= op.end && op.end <= end)) {
+                        return true;
+                    }
+                    break;
+                }
+                case "insert": {
+                    if (start <= op.start && op.start <= end) {
+                        return true;
+                    }
+                    break;
+                }
+            }
         }
-        const insertSeq = new subseq.Subseq(insertSizes);
-        const deleteSeq = new subseq.Subseq(deleteSizes);
-        return Edit.synthesize(insertSeq, inserted, deleteSeq, deleted);
+        return false;
+    }
+    static builder(value) {
+        let index = 0;
+        let inserted = "";
+        let deleted = undefined;
+        const insertSeq = [];
+        const deleteSeq = [];
+        return {
+            retain(length) {
+                if (value != null) {
+                    length = Math.min(value.length - index, length);
+                }
+                index += length;
+                pushSegment(insertSeq, length, false);
+                pushSegment(deleteSeq, length, false);
+                return this;
+            },
+            delete(length) {
+                if (value != null) {
+                    length = Math.min(value.length - index, length);
+                    deleted = (deleted || "") + value.slice(index, index + length);
+                }
+                index += length;
+                pushSegment(insertSeq, length, false);
+                pushSegment(deleteSeq, length, true);
+                return this;
+            },
+            insert(value) {
+                pushSegment(insertSeq, value.length, true);
+                inserted += value;
+                return this;
+            },
+            concat(edit) {
+                const ops = edit.operations();
+                for (const op of ops) {
+                    switch (op.type) {
+                        case "delete":
+                            this.delete(op.end - op.start);
+                            break;
+                        case "insert":
+                            this.insert(op.value);
+                            break;
+                        case "retain":
+                            this.retain(op.end - op.start);
+                            break;
+                    }
+                }
+                if (value != null && index > value.length) {
+                    throw new RangeError("Edit is longer than original value");
+                }
+                return this;
+            },
+            build() {
+                if (value != null) {
+                    deleted = deleted || "";
+                    if (index < value.length) {
+                        pushSegment(insertSeq, value.length - index, false);
+                        pushSegment(deleteSeq, value.length - index, false);
+                    }
+                }
+                return synthesize(insertSeq, inserted, deleteSeq, deleted);
+            },
+        };
     }
     /**
-     * Composes two consecutive edits.
+     * Given two strings, this method finds an edit which can be applied to the
+     * first string to result in the second.
+     *
+     * @param startHint - An optional hint can be provided to disambiguate edits
+     * which cannot be inferred by comparing the text alone. For example,
+     * inserting "a" into the string "aaaa" to make it "aaaaa" could be an
+     * insertion at any index in the string. This value should be the smaller of
+     * the start indices of the selection from before and after the edit.
      */
-    compose(that) {
-        let [insertSeq1, inserted1, deleteSeq1, deleted1] = this.factor();
-        let [insertSeq2, inserted2, deleteSeq2, deleted2] = that.factor();
-        // Expand all subseqs so that they share the same coordinate space.
-        deleteSeq1 = deleteSeq1.expand(insertSeq1);
-        deleteSeq2 = deleteSeq2.expand(deleteSeq1);
-        [deleteSeq1, insertSeq2] = deleteSeq1.interleave(insertSeq2);
-        deleteSeq2 = deleteSeq2.expand(insertSeq2);
-        insertSeq1 = insertSeq1.expand(insertSeq2);
-        // Find insertions which have been deleted and remove them.
-        {
-            const toggleSeq = insertSeq1.intersection(deleteSeq2);
-            if (toggleSeq.includedSize) {
-                deleteSeq1 = deleteSeq1.shrink(toggleSeq);
-                inserted1 = erase(insertSeq1, inserted1, toggleSeq);
-                insertSeq1 = insertSeq1.shrink(toggleSeq);
-                deleteSeq2 = deleteSeq2.shrink(toggleSeq);
-                insertSeq2 = insertSeq2.shrink(toggleSeq);
+    static diff(text1, text2, startHint) {
+        let prefix = commonPrefixLength(text1, text2);
+        let suffix = commonSuffixLength(text1, text2);
+        // prefix and suffix overlap when edits are in runs of the same character.
+        if (prefix + suffix > Math.min(text1.length, text2.length)) {
+            if (startHint != null && startHint >= 0) {
+                prefix = Math.min(prefix, startHint);
             }
+            // TODO: We can probably avoid the commonSuffixLength() call here in
+            // favor of arithmetic but I’m too dumb to figure it out.
+            suffix = commonSuffixLength(text1.slice(prefix), text2.slice(prefix));
         }
-        const insertSeq = insertSeq1.union(insertSeq2);
-        const inserted = consolidate(insertSeq1, inserted1, insertSeq2, inserted2);
-        const deleteSeq = deleteSeq1.union(deleteSeq2).shrink(insertSeq);
-        const deleted = deleted1 != null && deleted2 != null
-            ? consolidate(deleteSeq1, deleted1, deleteSeq2, deleted2)
-            : undefined;
-        return Edit.synthesize(insertSeq, inserted, deleteSeq, deleted).normalize();
+        return Edit.builder(text1)
+            .retain(prefix)
+            .insert(text2.slice(prefix, text2.length - suffix))
+            .delete(text1.length - prefix - suffix)
+            .retain(suffix)
+            .build();
     }
-    invert() {
-        if (typeof this.deleted === "undefined") {
-            throw new Error("Missing deleted property");
+}
+function synthesize(insertSeq, inserted, deleteSeq, deleted) {
+    if (measure(insertSeq).includedLength !== inserted.length) {
+        throw new Error("insertSeq and inserted string do not match in length");
+    }
+    else if (deleted !== undefined &&
+        measure(deleteSeq).includedLength !== deleted.length) {
+        throw new Error("deleteSeq and deleted string do not match in length");
+    }
+    const parts = [];
+    let insertIndex = 0;
+    let retainIndex = 0;
+    let needsLength = true;
+    for (const [length, deleting, inserting] of align(expand(deleteSeq, insertSeq), insertSeq)) {
+        if (inserting) {
+            const insertion = inserted.slice(insertIndex, insertIndex + length);
+            if (parts.length && typeof parts[parts.length - 1] === "string") {
+                parts[parts.length - 1] += insertion;
+            }
+            else {
+                parts.push(insertion);
+            }
+            insertIndex += length;
+        }
+        else {
+            if (!deleting) {
+                parts.push(retainIndex, retainIndex + length);
+            }
+            retainIndex += length;
+            needsLength = deleting;
         }
-        let [insertSeq, inserted, deleteSeq, deleted] = this.factor();
-        deleteSeq = deleteSeq.expand(insertSeq);
-        insertSeq = insertSeq.shrink(deleteSeq);
-        return Edit.synthesize(deleteSeq, deleted, insertSeq, inserted);
     }
+    if (needsLength) {
+        parts.push(retainIndex);
+    }
+    return new Edit(parts, deleted);
+}
+function factor(edit) {
+    const insertSeq = [];
+    const deleteSeq = [];
+    let inserted = "";
+    const operations = edit.operations();
+    for (let i = 0; i < operations.length; i++) {
+        const op = operations[i];
+        switch (op.type) {
+            case "retain": {
+                const length = op.end - op.start;
+                pushSegment(insertSeq, length, false);
+                pushSegment(deleteSeq, length, false);
+                break;
+            }
+            case "delete": {
+                const length = op.end - op.start;
+                pushSegment(insertSeq, length, false);
+                pushSegment(deleteSeq, length, true);
+                break;
+            }
+            case "insert":
+                pushSegment(insertSeq, op.value.length, true);
+                inserted += op.value;
+                break;
+        }
+    }
+    return [insertSeq, inserted, deleteSeq, edit.deleted];
 }
 /**
  * Given two subseqs and strings which are represented by the included segments
  * of the subseqs, this function combines the two strings so that they overlap
  * according to the positions of the included segments of subseqs.
  *
- * The subseqs must have the same size, and the included segments of these
+ * The subseqs must have the same length, and the included segments of these
  * subseqs may not overlap.
  */
 function consolidate(subseq1, text1, subseq2, text2) {
     let i1 = 0;
     let i2 = 0;
     let result = "";
-    for (const [size, flag1, flag2] of subseq1.align(subseq2)) {
-        if (flag1 && flag2) {
+    for (const [length, included1, included2] of align(subseq1, subseq2)) {
+        if (included1 && included2) {
             throw new Error("Overlapping subseqs");
         }
-        else if (flag1) {
-            result += text1.slice(i1, i1 + size);
-            i1 += size;
+        else if (included1) {
+            result += text1.slice(i1, i1 + length);
+            i1 += length;
         }
-        else if (flag2) {
-            result += text2.slice(i2, i2 + size);
-            i2 += size;
+        else if (included2) {
+            result += text2.slice(i2, i2 + length);
+            i2 += length;
         }
     }
     return result;
@@ -308,28 +572,26 @@ function consolidate(subseq1, text1, subseq2, text2) {
  * segments of the first subseq, this function returns the result of removing
  * the included segments of the second subseq from the first subseq.
  *
- * The subseqs must have the same size, and the included segments of the second
+ * The subseqs must have the same length, and the included segments of the second
  * subseq must overlap with the first subseq’s included segments.
  */
 function erase(subseq1, str, subseq2) {
     let i = 0;
     let result = "";
-    for (const [size, flag1, flag2] of subseq1.align(subseq2)) {
-        if (flag1) {
-            if (!flag2) {
-                result += str.slice(i, i + size);
+    for (const [length, included1, included2] of align(subseq1, subseq2)) {
+        if (included1) {
+            if (!included2) {
+                result += str.slice(i, i + length);
             }
-            i += size;
+            i += length;
         }
-        else if (flag2) {
+        else if (included2) {
             throw new Error("Non-overlapping subseqs");
         }
     }
     return result;
 }
-/**
- * @returns The length of the common prefix between two strings.
- */
+/** @returns The length of the common prefix between two strings. */
 function commonPrefixLength(text1, text2) {
     const length = Math.min(text1.length, text2.length);
     for (let i = 0; i < length; i++) {
@@ -339,9 +601,7 @@ function commonPrefixLength(text1, text2) {
     }
     return length;
 }
-/**
- * @returns The length of the common suffix between two strings.
- */
+/** @returns The length of the common suffix between two strings. */
 function commonSuffixLength(text1, text2) {
     const length1 = text1.length;
     const length2 = text2.length;