@b9g/revise 0.1.2 → 0.1.4

package/edit.cjs

@@ -1,618 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-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");
-    }
-    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");
-            }
-            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;
-        }
-        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 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);
-    }
-    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;
-            }
-        }
-    }
-    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++) {
-            if (typeof this.parts[i] === "string") {
-                text += this.parts[i];
-            }
-        }
-        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;
-        let index = 0;
-        let deleteStart = 0;
-        for (let i = 0; i < this.parts.length; i++) {
-            const part = this.parts[i];
-            if (typeof part === "number") {
-                if (part < index) {
-                    throw new TypeError("Malformed edit");
-                }
-                else if (part > index) {
-                    if (retaining) {
-                        operations.push({ type: "retain", start: index, end: part });
-                    }
-                    else {
-                        const value = typeof this.deleted === "undefined"
-                            ? undefined
-                            : this.deleted.slice(deleteStart, part);
-                        operations.push({
-                            type: "delete",
-                            start: index,
-                            end: part,
-                            value,
-                        });
-                        deleteStart = part;
-                    }
-                }
-                index = part;
-                retaining = !retaining;
-            }
-            else {
-                operations.push({ type: "insert", start: index, value: part });
-            }
-        }
-        return operations;
-    }
-    apply(text) {
-        let text1 = "";
-        const operations = this.operations();
-        for (let i = 0; i < operations.length; i++) {
-            const op = operations[i];
-            switch (op.type) {
-                case "retain":
-                    text1 += text.slice(op.start, op.end);
-                    break;
-                case "insert":
-                    text1 += op.value;
-                    break;
-            }
-        }
-        return text1;
-    }
-    /** 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 = 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("Edit is not normalizable");
-        }
-        const insertSeq = [];
-        const deleteSeq = [];
-        let inserted = "";
-        let deleted = "";
-        let insertion;
-        const operations = this.operations();
-        for (let i = 0; i < operations.length; i++) {
-            const op = operations[i];
-            switch (op.type) {
-                case "insert": {
-                    insertion = op.value;
-                    break;
-                }
-                case "retain": {
-                    if (insertion !== undefined) {
-                        pushSegment(insertSeq, insertion.length, true);
-                        inserted += insertion;
-                        insertion = undefined;
-                    }
-                    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;
-                    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 += 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;
-                }
-            }
-        }
-        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;
-                }
-            }
-        }
-        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);
-            },
-        };
-    }
-    /**
-     * 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.
-     */
-    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));
-        }
-        return Edit.builder(text1)
-            .retain(prefix)
-            .insert(text2.slice(prefix, text2.length - suffix))
-            .delete(text1.length - prefix - suffix)
-            .retain(suffix)
-            .build();
-    }
-}
-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;
-        }
-    }
-    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 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 [length, included1, included2] of align(subseq1, subseq2)) {
-        if (included1 && included2) {
-            throw new Error("Overlapping subseqs");
-        }
-        else if (included1) {
-            result += text1.slice(i1, i1 + length);
-            i1 += length;
-        }
-        else if (included2) {
-            result += text2.slice(i2, i2 + length);
-            i2 += length;
-        }
-    }
-    return result;
-}
-/**
- * Given two subseqs as well a string which is represented by the included
- * 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 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 [length, included1, included2] of align(subseq1, subseq2)) {
-        if (included1) {
-            if (!included2) {
-                result += str.slice(i, i + length);
-            }
-            i += length;
-        }
-        else if (included2) {
-            throw new Error("Non-overlapping subseqs");
-        }
-    }
-    return result;
-}
-/** @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++) {
-        if (text1[i] !== text2[i]) {
-            return i;
-        }
-    }
-    return length;
-}
-/** @returns The length of the common suffix between two strings. */
-function commonSuffixLength(text1, text2) {
-    const length1 = text1.length;
-    const length2 = text2.length;
-    const length = Math.min(length1, length2);
-    for (let i = 0; i < length; i++) {
-        if (text1[length1 - i - 1] !== text2[length2 - i - 1]) {
-            return i;
-        }
-    }
-    return length;
-}
-
-exports.Edit = Edit;
-//# sourceMappingURL=edit.cjs.map