muggle-string 0.4.1 → 1.0.0-alpha.0

package/out/sourceRewrite.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSourceRewrite = createSourceRewrite;
+function createSourceRewrite(source, text) {
+    return new Rewrite(source, text);
+}
+const coreRank = 0x7fffffff;
+// Before: outermost (highest rank) first; Slot and After: innermost first
+function compareEdits(a, b) {
+    if (a.at !== b.at) {
+        return a.at - b.at;
+    }
+    if (a.side !== b.side) {
+        return a.side - b.side;
+    }
+    if (a.rank !== b.rank) {
+        return a.side === 0 /* Side.Before */ ? b.rank - a.rank : a.rank - b.rank;
+    }
+    if (a.order !== b.order) {
+        return a.order < b.order ? -1 : 1;
+    }
+    return a.seq - b.seq;
+}
+class Edits {
+    constructor() {
+        this.records = [];
+        // the sorted records by column, filled when frozen
+        this.at = new Int32Array(0);
+        this.side = new Uint8Array(0);
+        this.code = [];
+    }
+    push(at, side, rank, order, code) {
+        this.records.push({ at, side, rank, order, seq: this.records.length, code });
+    }
+    freeze() {
+        const records = this.records;
+        // every writer's edits usually arrive in order; the sort is linear on such runs
+        for (let i = 1; i < records.length; i++) {
+            if (compareEdits(records[i - 1], records[i]) > 0) {
+                records.sort(compareEdits);
+                break;
+            }
+        }
+        const size = records.length;
+        this.at = new Int32Array(size);
+        this.side = new Uint8Array(size);
+        this.code = new Array(size);
+        for (let i = 0; i < size; i++) {
+            const record = records[i];
+            this.at[i] = record.at;
+            this.side[i] = record.side;
+            this.code[i] = record.code;
+        }
+    }
+    /** The first index from `low` whose anchor is at or after `offset`. */
+    lowerBound(offset, low) {
+        let high = this.at.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (this.at[mid] < offset) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return low;
+    }
+}
+class Rewrite {
+    constructor(source, text) {
+        this.source = source;
+        this.text = text;
+        this.edits = new Edits();
+        /** `insertAfter(0)`: before all text. */
+        this.head = new Edits();
+        /** `insertBefore(length)`: after all text. */
+        this.tail = new Edits();
+        /** Removed ranges as flat start, end pairs; merged when frozen. */
+        this.removals = [];
+        /** The top-level cuts, sorted and disjoint. */
+        this.roots = [];
+        this.frozen = false;
+        const core = this.createWriter(coreRank);
+        core.cut = (start, end, { data, placeholder }) => {
+            this.check(start, end);
+            const cut = new Cut(this, start, end, data, placeholder);
+            if (start === end) {
+                if (placeholder !== undefined) {
+                    throw new RangeError(`The empty cut ${start}..${end} cannot have a placeholder.`);
+                }
+                if (!this.text.length) {
+                    this.firstEmpty ??= cut;
+                }
+            }
+            else {
+                this.insertCut(cut);
+            }
+            return cut;
+        };
+        this.core = core;
+    }
+    writer(rank) {
+        if (!Number.isInteger(rank) || rank < 0 || rank >= coreRank) {
+            throw new RangeError(`The rank ${rank} is not a non-negative integer below the rank of core.`);
+        }
+        return this.createWriter(rank);
+    }
+    createWriter(rank) {
+        return {
+            insertBefore: (offset, code, options) => {
+                this.check(offset, offset);
+                const order = getOrder(options);
+                if (offset === this.text.length) {
+                    this.tail.push(offset, 2 /* Side.After */, rank, order, code);
+                }
+                else {
+                    this.edits.push(offset, 0 /* Side.Before */, rank, order, code);
+                }
+            },
+            insertAfter: (offset, code, options) => {
+                this.check(offset, offset);
+                const order = getOrder(options);
+                if (offset === 0) {
+                    this.head.push(0, 0 /* Side.Before */, rank, order, code);
+                }
+                else {
+                    this.edits.push(offset - 1, 2 /* Side.After */, rank, order, code);
+                }
+            },
+            replace: (start, end, code, options) => {
+                this.check(start, end);
+                if (start === end) {
+                    throw new RangeError(`The replace at ${start}..${end} removes no char.`);
+                }
+                this.edits.push(start, 1 /* Side.Slot */, rank, getOrder(options), code);
+                this.removals.push(start, end);
+            },
+        };
+    }
+    check(start, end) {
+        if (this.frozen) {
+            throw new Error('The rewrite is already rendered.');
+        }
+        if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || start > end || end > this.text.length) {
+            throw new RangeError(`${start}..${end} is out of 0..${this.text.length}.`);
+        }
+    }
+    // A cut that crosses `cut` intersects it, so it lies inside every cut that contains `cut`: the descent only checks
+    // the siblings that `cut` intersects, of the innermost cut that contains it.
+    insertCut(cut) {
+        const { start, end } = cut;
+        const last = this.lastCut;
+        let siblings = last && last.start <= start && end <= last.end ? last.children : this.roots;
+        while (true) {
+            let first = 0;
+            let after = siblings.length;
+            for (let high = after; first < high;) {
+                const mid = (first + high) >>> 1;
+                if (siblings[mid].end <= start) {
+                    first = mid + 1;
+                }
+                else {
+                    high = mid;
+                }
+            }
+            for (let low = first; low < after;) {
+                const mid = (low + after) >>> 1;
+                if (siblings[mid].start < end) {
+                    low = mid + 1;
+                }
+                else {
+                    after = mid;
+                }
+            }
+            if (after - first === 1 && siblings[first].start <= start && end <= siblings[first].end) {
+                siblings = siblings[first].children;
+                continue;
+            }
+            if (after > first) {
+                // the siblings in between lie strictly inside `cut`
+                for (const sibling of [siblings[first], siblings[after - 1]]) {
+                    if (sibling.start < start || sibling.end > end) {
+                        throw new RangeError(`The cut ${start}..${end} crosses the cut ${sibling.start}..${sibling.end}; cuts are nested or disjoint.`);
+                    }
+                }
+                cut.children = siblings.splice(first, after - first, cut);
+            }
+            else {
+                siblings.splice(first, 0, cut);
+            }
+            this.lastCut = cut;
+            return;
+        }
+    }
+    freeze() {
+        if (this.frozen) {
+            return;
+        }
+        this.frozen = true;
+        this.edits.freeze();
+        this.head.freeze();
+        this.tail.freeze();
+        const removals = this.removals;
+        const pairs = removals.length >> 1;
+        for (let pair = 1; pair < pairs; pair++) {
+            if (removals[2 * pair - 2] > removals[2 * pair]) {
+                const sorted = Array.from({ length: pairs }, (_, index) => [removals[2 * index], removals[2 * index + 1]])
+                    .sort((a, b) => a[0] - b[0]);
+                for (let index = 0; index < pairs; index++) {
+                    removals[2 * index] = sorted[index][0];
+                    removals[2 * index + 1] = sorted[index][1];
+                }
+                break;
+            }
+        }
+        let merged = 0;
+        for (let pair = 0; pair < pairs; pair++) {
+            const start = removals[2 * pair];
+            const end = removals[2 * pair + 1];
+            if (merged && start <= removals[merged - 1]) {
+                if (end > removals[merged - 1]) {
+                    removals[merged - 1] = end;
+                }
+            }
+            else {
+                removals[merged++] = start;
+                removals[merged++] = end;
+            }
+        }
+        removals.length = merged;
+        for (const root of this.roots) {
+            root.isRoot = true;
+        }
+    }
+}
+function getOrder(options) {
+    const order = options?.order ?? 0;
+    if (typeof order !== 'number' || Number.isNaN(order)) {
+        throw new TypeError(`The order ${order} is not a number.`);
+    }
+    return order;
+}
+class Cut {
+    constructor(rewrite, start, end, data, placeholder) {
+        this.rewrite = rewrite;
+        this.start = start;
+        this.end = end;
+        this.data = data;
+        this.placeholder = placeholder;
+        /** The cuts directly inside, sorted and disjoint. */
+        this.children = [];
+        this.isRoot = false;
+        this.placed = false;
+    }
+    render(sink) {
+        if (this.placed) {
+            throw new Error(`The cut ${this.start}..${this.end} is placed twice.`);
+        }
+        this.placed = true;
+        const rewrite = this.rewrite;
+        rewrite.freeze();
+        const { edits, removals, head, tail } = rewrite;
+        const { start, end, children, data } = this;
+        if (start === end) {
+            if (this === rewrite.firstEmpty) {
+                renderAll(head, sink);
+                renderAll(tail, sink);
+            }
+            return;
+        }
+        if (this.isRoot && start === 0) {
+            renderAll(head, sink);
+        }
+        const removalsEnd = removals.length;
+        let pos = start;
+        let removal = 0;
+        // the first removal that ends after `pos`, from `removal` on
+        const seekRemoval = () => {
+            let low = removal >> 1;
+            let high = removalsEnd >> 1;
+            while (low < high) {
+                const mid = (low + high) >>> 1;
+                if (removals[2 * mid + 1] <= pos) {
+                    low = mid + 1;
+                }
+                else {
+                    high = mid;
+                }
+            }
+            removal = low * 2;
+        };
+        // the kept chars from `pos` to `to`, as runs between the removals
+        const renderText = (to) => {
+            while (pos < to) {
+                while (removal < removalsEnd && removals[removal + 1] <= pos) {
+                    removal += 2;
+                }
+                if (removal < removalsEnd && removals[removal] <= pos) {
+                    pos = Math.min(removals[removal + 1], to);
+                    continue;
+                }
+                const stop = removal < removalsEnd ? Math.min(removals[removal], to) : to;
+                sink.source(rewrite, pos, stop, data);
+                pos = stop;
+            }
+        };
+        seekRemoval();
+        const { at, side, code } = edits;
+        const size = at.length;
+        let edit = edits.lowerBound(start, 0);
+        for (let index = 0;; index++) {
+            const child = children[index];
+            const until = child ? child.start : end;
+            for (; edit < size && at[edit] < until; edit++) {
+                renderText(side[edit] === 2 /* Side.After */ ? at[edit] + 1 : at[edit]);
+                renderCode(code[edit], sink);
+            }
+            if (!child) {
+                break;
+            }
+            renderText(child.start);
+            if (child.placeholder !== undefined) {
+                renderCode(child.placeholder, sink);
+            }
+            pos = child.end;
+            seekRemoval();
+            edit = edits.lowerBound(child.end, edit);
+        }
+        renderText(end);
+        if (this.isRoot && end === rewrite.text.length) {
+            renderAll(tail, sink);
+        }
+    }
+}
+function renderAll(edits, sink) {
+    for (const code of edits.code) {
+        renderCode(code, sink);
+    }
+}
+function renderCode(code, sink) {
+    if (typeof code === 'string') {
+        if (code) {
+            sink.text(code);
+        }
+        return;
+    }
+    for (const item of code()) {
+        if (typeof item === 'string') {
+            if (item) {
+                sink.text(item);
+            }
+        }
+        else if (Array.isArray(item)) {
+            sink.segment(item);
+        }
+        else {
+            item.render(sink);
+        }
+    }
+}
+//# sourceMappingURL=sourceRewrite.js.map

package/out/types.d.ts

@@ -1,16 +1,4 @@
-declare const NO_DATA_SYMBOL: unique symbol;
-export type Segment<T = typeof NO_DATA_SYMBOL> = string | (T extends typeof NO_DATA_SYMBOL ? [
-    text: string,
-    source: string | undefined,
-    sourceOffset: number
-] : [
-    text: string,
-    source: string | undefined,
-    sourceOffset: number,
-    data: T
-]);
-export interface StackNode {
-    length: number;
-    stack: string;
-}
-export {};
+/** Generated code: plain text, or text that maps to `sourceOffset` of `source`. */
+export type Segment<Source, Data> = string | [text: string, source: Source, sourceOffset: number, data: Data];
+/** A segment of generated code that maps to a source. */
+export type MappedSegment<Source, Data> = Exclude<Segment<Source, Data>, string>;

package/package.json

@@ -1,7 +1,9 @@
 {
 	"name": "muggle-string",
-	"version": "0.4.1",
+	"version": "1.0.0-alpha.0",
+	"description": "Ranked, conflict-free rewrites of a source text, rendered as format-neutral segments",
 	"main": "out/index.js",
+	"types": "out/index.d.ts",
 	"license": "MIT",
 	"files": [
 		"out/**/*.js",
@@ -12,11 +14,12 @@
 		"url": "https://github.com/johnsoncodehk/muggle-string.git"
 	},
 	"scripts": {
+		"build": "tsc",
 		"test": "vitest run"
 	},
 	"devDependencies": {
-		"typescript": "latest",
-		"vitest": "latest",
-		"vite": "latest"
+		"@types/node": "^26.0.1",
+		"typescript": "7.1.0-beta",
+		"vitest": "latest"
 	}
 }

package/out/base.d.ts

@@ -1,6 +0,0 @@
-import { Range, Segment } from './types';
-export declare function getLength(segments: Segment<any>[]): number;
-export declare function toString<T extends Segment<any>>(segments: T[]): string;
-export declare function replace<T extends Segment<any>>(segments: T[], pattern: string | RegExp, ...replacers: (T | ((match: string) => T))[]): void;
-export declare function replaceAll<T extends Segment<any>>(segments: T[], pattern: RegExp, ...replacers: (T | ((match: string) => T))[]): void;
-export declare function overwrite<T extends Segment<any>>(segments: T[], range: number | Range, ...inserts: T[]): T[];

package/out/base.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.overwrite = exports.replaceAll = exports.replace = exports.toString = exports.getLength = void 0;
-const binarySearch_1 = require("./binarySearch");
-const track_1 = require("./track");
-function getLength(segments) {
-    let length = 0;
-    for (const segment of segments) {
-        length += typeof segment == 'string' ? segment.length : segment[0].length;
-    }
-    return length;
-}
-exports.getLength = getLength;
-function toString(segments) {
-    return segments.map(s => typeof s === 'string' ? s : s[0]).join('');
-}
-exports.toString = toString;
-function replace(segments, pattern, ...replacers) {
-    const str = toString(segments);
-    const match = str.match(pattern);
-    if (match && match.index !== undefined) {
-        const start = match.index;
-        const end = start + match[0].length;
-        (0, track_1.offsetStack)();
-        overwrite(segments, [start, end], ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
-        (0, track_1.resetOffsetStack)();
-    }
-}
-exports.replace = replace;
-function replaceAll(segments, pattern, ...replacers) {
-    const str = toString(segments);
-    const allMatch = str.matchAll(pattern);
-    let length = str.length;
-    let lengthDiff = 0;
-    for (const match of allMatch) {
-        if (match.index !== undefined) {
-            const start = match.index + lengthDiff;
-            const end = start + match[0].length;
-            (0, track_1.offsetStack)();
-            overwrite(segments, [start, end], ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
-            (0, track_1.resetOffsetStack)();
-            const newLength = getLength(segments);
-            lengthDiff += newLength - length;
-            length = newLength;
-        }
-    }
-}
-exports.replaceAll = replaceAll;
-function overwrite(segments, range, ...inserts) {
-    const offsets = toOffsets(segments);
-    const [start, end] = typeof range === 'number' ? [range, range] : range;
-    const startIndex = (0, binarySearch_1.binarySearch)(offsets, start);
-    const endIndex = (0, binarySearch_1.binarySearch)(offsets, end);
-    const startSegment = segments[startIndex];
-    const endSegment = segments[endIndex];
-    const startSegmentStart = offsets[startIndex];
-    const endSegmentStart = offsets[endIndex];
-    const endSegmentEnd = offsets[endIndex] + (typeof endSegment === 'string' ? endSegment.length : endSegment[0].length);
-    if (start > startSegmentStart) {
-        inserts.unshift(trimSegmentEnd(startSegment, start - startSegmentStart));
-    }
-    if (end < endSegmentEnd) {
-        inserts.push(trimSegmentStart(endSegment, end - endSegmentStart));
-    }
-    (0, track_1.offsetStack)();
-    const deleted = segments.splice(startIndex, endIndex - startIndex + 1, ...inserts);
-    (0, track_1.resetOffsetStack)();
-    if (end < endSegmentEnd) {
-        deleted[deleted.length - 1] = trimSegmentEnd(deleted[deleted.length - 1], end - endSegmentStart);
-    }
-    if (start > startSegmentStart) {
-        deleted[0] = trimSegmentStart(deleted[0], start - startSegmentStart);
-    }
-    return deleted;
-}
-exports.overwrite = overwrite;
-function trimSegmentEnd(segment, trimEnd) {
-    if (typeof segment === 'string') {
-        return segment.slice(0, trimEnd);
-    }
-    const originalString = segment[0];
-    const originalRange = segment[2];
-    const newString = originalString.slice(0, trimEnd);
-    const newRange = typeof originalRange === 'number' ? originalRange : [originalRange[0], originalRange[1] - (originalString.length - newString.length)];
-    return [
-        newString,
-        segment[1],
-        newRange,
-        ...segment.slice(3),
-    ];
-}
-function trimSegmentStart(segment, trimStart) {
-    if (typeof segment === 'string') {
-        return segment.slice(trimStart);
-    }
-    const originalString = segment[0];
-    const originalRange = segment[2];
-    const newString = originalString.slice(trimStart);
-    if (trimStart < 0) {
-        trimStart += originalString.length;
-    }
-    const newRange = typeof originalRange === 'number' ? originalRange + trimStart : [originalRange[0] + trimStart, originalRange[1]];
-    return [
-        newString,
-        segment[1],
-        newRange,
-        ...segment.slice(3),
-    ];
-}
-function toOffsets(segments) {
-    const offsets = [];
-    let offset = 0;
-    for (const segment of segments) {
-        offsets.push(offset);
-        offset += typeof segment == 'string' ? segment.length : segment[0].length;
-    }
-    return offsets;
-}
-//# sourceMappingURL=base.js.map

package/out/basic.d.ts

@@ -1,6 +0,0 @@
-import { Range, Segment } from './types';
-export declare function getLength(segments: Segment<any>[]): number;
-export declare function toString<T extends Segment<any>>(segments: T[]): string;
-export declare function replace<T extends Segment<any>>(segments: T[], pattern: string | RegExp, ...replacers: (T | ((match: string) => T))[]): void;
-export declare function replaceAll<T extends Segment<any>>(segments: T[], pattern: RegExp, ...replacers: (T | ((match: string) => T))[]): void;
-export declare function overwrite<T extends Segment<any>>(segments: T[], range: number | Range, ...inserts: T[]): T[];

package/out/basic.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.overwrite = exports.replaceAll = exports.replace = exports.toString = exports.getLength = void 0;
-const binarySearch_1 = require("./binarySearch");
-const track_1 = require("./track");
-function getLength(segments) {
-    let length = 0;
-    for (const segment of segments) {
-        length += typeof segment == 'string' ? segment.length : segment[0].length;
-    }
-    return length;
-}
-exports.getLength = getLength;
-function toString(segments) {
-    return segments.map(s => typeof s === 'string' ? s : s[0]).join('');
-}
-exports.toString = toString;
-function replace(segments, pattern, ...replacers) {
-    const str = toString(segments);
-    const match = str.match(pattern);
-    if (match && match.index !== undefined) {
-        const start = match.index;
-        const end = start + match[0].length;
-        (0, track_1.offsetStack)();
-        overwrite(segments, [start, end], ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
-        (0, track_1.resetOffsetStack)();
-    }
-}
-exports.replace = replace;
-function replaceAll(segments, pattern, ...replacers) {
-    const str = toString(segments);
-    const allMatch = str.matchAll(pattern);
-    let length = str.length;
-    let lengthDiff = 0;
-    for (const match of allMatch) {
-        if (match.index !== undefined) {
-            const start = match.index + lengthDiff;
-            const end = start + match[0].length;
-            (0, track_1.offsetStack)();
-            overwrite(segments, [start, end], ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
-            (0, track_1.resetOffsetStack)();
-            const newLength = getLength(segments);
-            lengthDiff += newLength - length;
-            length = newLength;
-        }
-    }
-}
-exports.replaceAll = replaceAll;
-function overwrite(segments, range, ...inserts) {
-    const offsets = toOffsets(segments);
-    const [start, end] = typeof range === 'number' ? [range, range] : range;
-    const startIndex = (0, binarySearch_1.binarySearch)(offsets, start);
-    const endIndex = (0, binarySearch_1.binarySearch)(offsets, end);
-    const startSegment = segments[startIndex];
-    const endSegment = segments[endIndex];
-    const startSegmentStart = offsets[startIndex];
-    const endSegmentStart = offsets[endIndex];
-    const endSegmentEnd = offsets[endIndex] + (typeof endSegment === 'string' ? endSegment.length : endSegment[0].length);
-    if (start > startSegmentStart) {
-        inserts.unshift(trimSegmentEnd(startSegment, start - startSegmentStart));
-    }
-    if (end < endSegmentEnd) {
-        inserts.push(trimSegmentStart(endSegment, end - endSegmentStart));
-    }
-    (0, track_1.offsetStack)();
-    const deleted = segments.splice(startIndex, endIndex - startIndex + 1, ...inserts);
-    (0, track_1.resetOffsetStack)();
-    if (end < endSegmentEnd) {
-        deleted[deleted.length - 1] = trimSegmentEnd(deleted[deleted.length - 1], end - endSegmentStart);
-    }
-    if (start > startSegmentStart) {
-        deleted[0] = trimSegmentStart(deleted[0], start - startSegmentStart);
-    }
-    return deleted;
-}
-exports.overwrite = overwrite;
-function trimSegmentEnd(segment, trimEnd) {
-    if (typeof segment === 'string') {
-        return segment.slice(0, trimEnd);
-    }
-    const originalString = segment[0];
-    const originalRange = segment[2];
-    const newString = originalString.slice(0, trimEnd);
-    const newRange = typeof originalRange === 'number' ? originalRange : [originalRange[0], originalRange[1] - (originalString.length - newString.length)];
-    return [
-        newString,
-        segment[1],
-        newRange,
-        ...segment.slice(3),
-    ];
-}
-function trimSegmentStart(segment, trimStart) {
-    if (typeof segment === 'string') {
-        return segment.slice(trimStart);
-    }
-    const originalString = segment[0];
-    const originalRange = segment[2];
-    const newString = originalString.slice(trimStart);
-    if (trimStart < 0) {
-        trimStart += originalString.length;
-    }
-    const newRange = typeof originalRange === 'number' ? originalRange + trimStart : [originalRange[0] + trimStart, originalRange[1]];
-    return [
-        newString,
-        segment[1],
-        newRange,
-        ...segment.slice(3),
-    ];
-}
-function toOffsets(segments) {
-    const offsets = [];
-    let offset = 0;
-    for (const segment of segments) {
-        offsets.push(offset);
-        offset += typeof segment == 'string' ? segment.length : segment[0].length;
-    }
-    return offsets;
-}
-//# sourceMappingURL=basic.js.map

package/out/binarySearch.d.ts

@@ -1 +0,0 @@
-export declare function binarySearch(offsets: number[], start: number): number;

package/out/binarySearch.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.binarySearch = void 0;
-function binarySearch(offsets, start) {
-    let low = 0;
-    let high = offsets.length - 1;
-    while (low <= high) {
-        const mid = Math.floor((low + high) / 2);
-        const midValue = offsets[mid];
-        if (midValue < start) {
-            low = mid + 1;
-        }
-        else if (midValue > start) {
-            high = mid - 1;
-        }
-        else {
-            low = mid;
-            high = mid;
-            break;
-        }
-    }
-    return Math.max(Math.min(low, high, offsets.length - 1), 0);
-}
-exports.binarySearch = binarySearch;
-//# sourceMappingURL=binarySearch.js.map