muggle-string 0.4.1 → 1.0.0-alpha.1

package/out/sourceRewrite.js

@@ -0,0 +1,387 @@
+"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;
+        }
+        this.records = [];
+    }
+    /** The first index from `low` whose anchor is at or after `offset`. */
+    lowerBound(offset, low) {
+        const at = this.at;
+        let high = at.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (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. */
+        this.removalPairs = [];
+        /** The removed ranges, sorted and merged, filled when frozen. */
+        this.removals = new Int32Array(0);
+        /** The top-level cuts, sorted and disjoint. */
+        this.roots = [];
+        this.frozen = false;
+        this.core = this.createWriter(coreRank);
+    }
+    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.removalPairs.push(start, end);
+            },
+            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;
+            },
+        };
+    }
+    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.removalPairs;
+        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;
+        this.removals = Int32Array.from(removals);
+        this.removalPairs = [];
+        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;
+    }
+    pieces(out = []) {
+        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, head, tail } = rewrite;
+        const { start, end, children } = this;
+        if (start === end) {
+            if (this === rewrite.firstEmpty) {
+                pushAll(head, out);
+                pushAll(tail, out);
+            }
+            return out;
+        }
+        if (this.isRoot && start === 0) {
+            pushAll(head, out);
+        }
+        const walker = new Walker(rewrite.removals, rewrite.source, this.data, out, start);
+        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++) {
+                walker.keep(side[edit] === 2 /* Side.After */ ? at[edit] + 1 : at[edit]);
+                pushCode(code[edit], out);
+            }
+            if (!child) {
+                break;
+            }
+            walker.keep(child.start);
+            if (child.placeholder !== undefined) {
+                pushCode(child.placeholder, out);
+            }
+            walker.skip(child.end);
+            edit = edits.lowerBound(child.end, edit);
+        }
+        walker.keep(end);
+        if (this.isRoot && end === rewrite.text.length) {
+            pushAll(tail, out);
+        }
+        return out;
+    }
+}
+/** Pushes the kept chars of one cut, as pieces between the removals. */
+class Walker {
+    constructor(removals, source, data, out, pos) {
+        this.removals = removals;
+        this.source = source;
+        this.data = data;
+        this.out = out;
+        this.pos = pos;
+        /** The first removal that ends after `pos`. */
+        this.removal = 0;
+        this.seek();
+    }
+    /** The kept chars from `pos` to `to`. */
+    keep(to) {
+        const { removals, out } = this;
+        const size = removals.length;
+        let { pos, removal } = this;
+        while (pos < to) {
+            while (removal < size && removals[removal + 1] <= pos) {
+                removal += 2;
+            }
+            if (removal < size && removals[removal] <= pos) {
+                pos = removals[removal + 1] < to ? removals[removal + 1] : to;
+                continue;
+            }
+            const stop = removal < size && removals[removal] < to ? removals[removal] : to;
+            out.push({ source: this.source, start: pos, end: stop, data: this.data });
+            pos = stop;
+        }
+        this.pos = pos;
+        this.removal = removal;
+    }
+    /** Moves past the chars up to `to`, which a child cut owns. */
+    skip(to) {
+        this.pos = to;
+        this.seek();
+    }
+    seek() {
+        const removals = this.removals;
+        let low = this.removal >> 1;
+        let high = removals.length >> 1;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (removals[2 * mid + 1] <= this.pos) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        this.removal = low * 2;
+    }
+}
+function pushAll(edits, out) {
+    for (const code of edits.code) {
+        pushCode(code, out);
+    }
+}
+function pushCode(code, out) {
+    if (typeof code === 'string') {
+        if (code) {
+            out.push(code);
+        }
+    }
+    else if (code instanceof Cut) {
+        code.pieces(out);
+    }
+    else if (isCodeArray(code)) {
+        for (let index = 0; index < code.length; index++) {
+            pushCode(code[index], out);
+        }
+    }
+    else {
+        out.push(code);
+    }
+}
+function isCodeArray(code) {
+    return Array.isArray(code);
+}
+//# sourceMappingURL=sourceRewrite.js.map

package/out/types.d.ts

@@ -1,16 +1,12 @@
-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: new text, which maps nowhere, or the range `start`..`end` of the text of `source`. A range without
+ * `text` is a copy of the text there; `text` is code that stands for the range, mapped as its consumer decides. An
+ * empty range is an anchor.
+ */
+export type Piece<Source, Data> = string | {
+    source: Source;
+    start: number;
+    end: number;
+    data: Data;
+    text?: string;
+};

package/package.json

@@ -1,7 +1,9 @@
 {
 	"name": "muggle-string",
-	"version": "0.4.1",
+	"version": "1.0.0-alpha.1",
+	"description": "Ranked, conflict-free rewrites of a source text, rendered as format-neutral pieces",
 	"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