muggle-string 0.3.0 → 0.4.0

package/out/base.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,119 @@
+"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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,119 @@
+"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/common.d.ts

@@ -0,0 +1,9 @@
+import { Range, Segment } from './types';
+export * from './types';
+export * from './track';
+export * from './segment';
+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[]): void;

package/out/common.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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");
+__exportStar(require("./types"), exports);
+__exportStar(require("./track"), exports);
+__exportStar(require("./segment"), exports);
+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));
+    }
+    combineStrings(inserts);
+    (0, track_1.offsetStack)();
+    segments.splice(startIndex, endIndex - startIndex + 1, ...inserts);
+    (0, track_1.resetOffsetStack)();
+}
+exports.overwrite = overwrite;
+function combineStrings(segments) {
+    for (let i = segments.length - 1; i >= 1; i--) {
+        if (typeof segments[i] === 'string' && typeof segments[i - 1] === 'string') {
+            segments[i - 1] = segments[i - 1] + segments[i];
+            (0, track_1.offsetStack)();
+            segments.splice(i, 1);
+            (0, track_1.resetOffsetStack)();
+        }
+    }
+}
+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=common.js.map

package/out/getLength.d.ts

@@ -0,0 +1,2 @@
+import type { Segment } from './types';
+export declare function getLength(segments: Segment<any>[]): number;

package/out/getLength.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLength = void 0;
+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;
+//# sourceMappingURL=getLength.js.map

package/out/index.d.ts

@@ -3,6 +3,7 @@ export * from './types';
 export * from './track';
 export declare function getLength(segments: Segment<any>[]): number;
 export declare function toString<T extends Segment<any>>(segments: T[]): string;
+export declare function create(source: string): Segment[];
 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 replaceSourceRange<T extends Segment<any>>(segments: T[], source: string | undefined, startOffset: number, endOffset: number, ...newSegments: T[]): boolean;

package/out/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceRange = exports.replaceSourceRange = exports.replaceAll = exports.replace = exports.toString = exports.getLength = void 0;
+exports.replaceRange = exports.replaceSourceRange = exports.replaceAll = exports.replace = exports.create = exports.toString = exports.getLength = void 0;
 const binarySearch_1 = require("./binarySearch");
 const track_1 = require("./track");
 __exportStar(require("./types"), exports);
@@ -31,6 +31,10 @@ function toString(segments) {
     return segments.map(s => typeof s === 'string' ? s : s[0]).join('');
 }
 exports.toString = toString;
+function create(source) {
+    return [[source, undefined, 0]];
+}
+exports.create = create;
 function replace(segments, pattern, ...replacers) {
     const str = toString(segments);
     const match = str.match(pattern);
@@ -68,8 +72,8 @@ function replaceSourceRange(segments, source, startOffset, endOffset, ...newSegm
             continue;
         }
         if (segment[1] === source) {
-            const segmentStart = typeof segment[2] === 'number' ? segment[2] : segment[2][0];
-            const segmentEnd = typeof segment[2] === 'number' ? segment[2] + segment[0].length : segment[2][1];
+            const segmentStart = segment[2];
+            const segmentEnd = segment[2] + segment[0].length;
             if (segmentStart <= startOffset && segmentEnd >= endOffset) {
                 const inserts = [];
                 if (startOffset > segmentStart) {
@@ -131,32 +135,22 @@ 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),
+        segment[0].slice(0, trimEnd),
+        ...segment.slice(1),
     ];
 }
 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;
+        trimStart += segment[0].length;
     }
-    const newRange = typeof originalRange === 'number' ? originalRange + trimStart : [originalRange[0] + trimStart, originalRange[1]];
     return [
-        newString,
+        segment[0].slice(trimStart),
         segment[1],
-        newRange,
+        segment[2] + trimStart,
         ...segment.slice(3),
     ];
 }

package/out/map.d.ts

@@ -0,0 +1,3 @@
+import { Segment } from './types';
+export declare function clone(segments: Segment<any>[]): Segment<any>[];
+export declare function generateMap(segments: Segment<any>[], readSource: (source?: string) => [number, string]): string;

package/out/map.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMap = exports.clone = void 0;
+const sourcemap_codec_1 = require("@jridgewell/sourcemap-codec");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const base_1 = require("./base");
+function clone(segments) {
+    const cloned = [];
+    for (const s of segments) {
+        if (typeof s === 'string') {
+            cloned.push(s);
+        }
+        else {
+            cloned.push([...s]);
+        }
+    }
+    return cloned;
+}
+exports.clone = clone;
+function generateMap(segments, readSource) {
+    const cloned = clone(segments);
+    const mappings = [];
+    const sourceCode = new Map();
+    let newLineIndex = (0, base_1.toString)(cloned).indexOf('\n');
+    while (newLineIndex >= 0) {
+        onLine((0, base_1.overwrite)(cloned, [0, newLineIndex + 1]));
+        newLineIndex = (0, base_1.toString)(cloned).indexOf('\n');
+    }
+    onLine((0, base_1.overwrite)(cloned, [0, (0, base_1.getLength)(cloned)]));
+    return (0, sourcemap_codec_1.encode)(mappings);
+    function onLine(lineSegments) {
+        const lineMapping = [];
+        let currentColumn = 0;
+        let hasCodeMapping = false;
+        for (const s of lineSegments) {
+            if (typeof s === 'string') {
+                if (hasCodeMapping) {
+                    hasCodeMapping = false;
+                    // we don't break off last mapping for now
+                }
+                currentColumn += s.length;
+            }
+            else {
+                hasCodeMapping = true;
+                const source = s[1];
+                const sourceOffset = s[2][0];
+                if (!sourceCode.has(source)) {
+                    const readed = readSource(source);
+                    sourceCode.set(source, [readed[0], vscode_languageserver_textdocument_1.TextDocument.create('', '', 0, readed[1])]);
+                }
+                const [sourceIndex, document] = sourceCode.get(source);
+                const position = document.positionAt(sourceOffset);
+                lineMapping.push([
+                    currentColumn,
+                    sourceIndex,
+                    position.line,
+                    position.character,
+                ]);
+                currentColumn += s[0].length;
+            }
+        }
+        mappings.push(lineMapping);
+    }
+}
+exports.generateMap = generateMap;
+//# sourceMappingURL=map.js.map

package/out/overwriteSource.d.ts

@@ -0,0 +1,3 @@
+import { Range, Segment } from './types';
+export declare function overwriteSource<T extends Segment<any>>(segments: T[], sourceLoc: number | Range, ...newSegments: T[]): T[];
+export declare function overwriteSource<T extends Segment<any>>(segments: T[], source: string, sourceLoc: number | Range, ...newSegments: T[]): T[];

package/out/overwriteSource.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwriteSource = void 0;
+const base_1 = require("./base");
+function overwriteSource(segments, ...args) {
+    let loc;
+    let newSegments;
+    if (typeof args[0] === 'string') {
+        const source = args[0];
+        const sourceLoc = args[1];
+        loc = typeof sourceLoc === 'number'
+            ? searchSource(segments, source, sourceLoc)
+            : [searchSource(segments, source, sourceLoc[0]), searchSource(segments, source, sourceLoc[1])];
+        newSegments = args.slice(2);
+    }
+    else {
+        const sourceLoc = args[0];
+        loc = typeof sourceLoc === 'number'
+            ? searchSource(segments, sourceLoc)
+            : [searchSource(segments, sourceLoc[0]), searchSource(segments, sourceLoc[1])];
+        newSegments = args.slice(1);
+    }
+    return (0, base_1.overwrite)(segments, loc, ...newSegments);
+}
+exports.overwriteSource = overwriteSource;
+function searchSource(segments, ...args) {
+    const source = args.length >= 2 ? args[0] : undefined;
+    const sourceLoc = args.length >= 2 ? args[1] : args[0];
+    let _offset = 0;
+    let result;
+    for (const segment of segments) {
+        if (typeof segment === 'string') {
+            _offset += segment.length;
+            continue;
+        }
+        if (segment[1] === source) {
+            const segmentStart = typeof segment[2] === 'number' ? segment[2] : segment[2][0];
+            const segmentEnd = typeof segment[2] === 'number' ? segment[2] + segment[0].length : segment[2][1];
+            if (sourceLoc >= segmentStart && sourceLoc <= segmentEnd) {
+                result = _offset + (sourceLoc - segmentStart);
+                break;
+            }
+        }
+        _offset += segment[0].length;
+    }
+    if (result === undefined) {
+        throw new Error(`Source index not found, source: ${source}, index: ${sourceLoc}`);
+    }
+    return result;
+}
+//# sourceMappingURL=overwriteSource.js.map

package/out/replace.d.ts

@@ -0,0 +1,3 @@
+import type { Segment } from './types';
+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;

package/out/replace.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceAll = exports.replace = void 0;
+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;
+        offsetStack();
+        overwrite(segments, [start, end], ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
+        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;
+            offsetStack();
+            overwrite(segments, [start, end], ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
+            resetOffsetStack();
+            const newLength = getLength(segments);
+            lengthDiff += newLength - length;
+            length = newLength;
+        }
+    }
+}
+exports.replaceAll = replaceAll;
+//# sourceMappingURL=replace.js.map

package/out/segment.d.ts

@@ -0,0 +1,6 @@
+import { Segment, Range } from './types';
+export declare function segment(text: string): Segment;
+export declare function segment(text: string, start: number | Range): Segment;
+export declare function segment<T>(text: string, start: number | Range, data: T): Segment<T>;
+export declare function segment(text: string, source: string, start: number | Range): Segment;
+export declare function segment<T>(text: string, source: string, start: number | Range, data: T): Segment<T>;

package/out/segment.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segment = void 0;
+function segment(...args) {
+    const text = args[0];
+    if (args.length === 1) {
+        return text;
+    }
+    let source;
+    let start;
+    let end;
+    let hasData = false;
+    let data;
+    if (typeof args[1] !== 'number') {
+        source = args[1];
+        start = typeof args[2] == 'number' ? args[2] : args[2][0];
+        end = typeof args[2] == 'number' ? args[2] + text.length : args[2][1];
+        hasData = args.length >= 4;
+        if (hasData) {
+            data = args[3];
+        }
+    }
+    else {
+        start = typeof args[1] == 'number' ? args[1] : args[1][0];
+        end = typeof args[1] == 'number' ? args[1] + text.length : args[1][1];
+        hasData = args.length >= 3;
+        if (hasData) {
+            data = args[2];
+        }
+    }
+    if (hasData) {
+        return [text, source, [start, end], data];
+    }
+    else {
+        return [text, source, [start, end]];
+    }
+}
+exports.segment = segment;
+//# sourceMappingURL=segment.js.map

package/out/sourceBased.d.ts

@@ -0,0 +1,3 @@
+import { Range, Segment } from './types';
+export declare function overwriteSource<T extends Segment<any>>(s: T[], sourceLoc: number | Range, ...newSegments: T[]): T[];
+export declare function overwriteSource<T extends Segment<any>>(s: T[], source: string, sourceLoc: number | Range, ...newSegments: T[]): T[];

package/out/sourceBased.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwriteSource = void 0;
+const basic_1 = require("./basic");
+function searchSource(s, ...args) {
+    const source = args.length >= 2 ? args[0] : undefined;
+    const sourceLoc = args.length >= 2 ? args[1] : args[0];
+    let _offset = 0;
+    let result;
+    for (const segment of s) {
+        if (typeof segment === 'string') {
+            _offset += segment.length;
+            continue;
+        }
+        if (segment[1] === source) {
+            const segmentStart = typeof segment[2] === 'number' ? segment[2] : segment[2][0];
+            const segmentEnd = typeof segment[2] === 'number' ? segment[2] + segment[0].length : segment[2][1];
+            if (sourceLoc >= segmentStart && sourceLoc <= segmentEnd) {
+                result = _offset + (sourceLoc - segmentStart);
+                break;
+            }
+        }
+        _offset += segment[0].length;
+    }
+    if (result === undefined) {
+        throw new Error(`Source index not found, source: ${source}, index: ${sourceLoc}`);
+    }
+    return result;
+}
+function overwriteSource(s, ...args) {
+    let loc;
+    let newSegments;
+    if (typeof args[0] === 'string') {
+        const source = args[0];
+        const sourceLoc = args[1];
+        loc = typeof sourceLoc === 'number'
+            ? searchSource(s, source, sourceLoc)
+            : [searchSource(s, source, sourceLoc[0]), searchSource(s, source, sourceLoc[1])];
+        newSegments = args.slice(2);
+    }
+    else {
+        const sourceLoc = args[0];
+        loc = typeof sourceLoc === 'number'
+            ? searchSource(s, sourceLoc)
+            : [searchSource(s, sourceLoc[0]), searchSource(s, sourceLoc[1])];
+        newSegments = args.slice(1);
+    }
+    return (0, basic_1.overwrite)(s, loc, ...newSegments);
+}
+exports.overwriteSource = overwriteSource;
+//# sourceMappingURL=sourceBased.js.map

package/out/toString.d.ts

@@ -0,0 +1,2 @@
+import type { Segment } from './types';
+export declare function toString<T extends Segment<any>>(segments: T[]): string;

package/out/toString.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toString = void 0;
+function toString(segments) {
+    return segments.map(s => typeof s === 'string' ? s : s[0]).join('');
+}
+exports.toString = toString;
+//# sourceMappingURL=toString.js.map

package/out/track.d.ts

@@ -2,4 +2,4 @@ import { Segment, StackNode } from "./types";
 export declare function setTracking(value: boolean): void;
 export declare function offsetStack(): void;
 export declare function resetOffsetStack(): void;
-export declare function track<T extends Segment<any>[]>(segments: T): [T, StackNode[]];
+export declare function track<T extends Segment<any>[]>(segments: T, stacks?: StackNode[]): [T, StackNode[]];

package/out/track.js

@@ -15,8 +15,7 @@ function resetOffsetStack() {
     stackOffset--;
 }
 exports.resetOffsetStack = resetOffsetStack;
-function track(segments) {
-    const stacks = [];
+function track(segments, stacks = []) {
     return [
         new Proxy(segments, {
             get(target, prop, receiver) {
@@ -77,29 +76,36 @@ function track(segments) {
         if (deleteCount === undefined) {
             deleteCount = segments.length - start;
         }
-        let remainDeleteCount = deleteCount;
-        let stacksDeleteStart;
-        let stacksDeleteLength = 0;
-        let stackEnd = 0;
+        let _stackStart = 0;
+        let operateIndex;
         for (let i = 0; i < stacks.length; i++) {
             const stack = stacks[i];
-            const stackStart = stackEnd;
-            stackEnd = stackStart + stack.length;
-            while (start >= stackStart && start < stackEnd && remainDeleteCount && stack.length) {
-                stack.length--;
-                remainDeleteCount--;
-                stackEnd--;
+            const stackStart = _stackStart;
+            const stackEnd = stackStart + stack.length;
+            _stackStart = stackEnd;
+            if (start >= stackStart) {
+                operateIndex = i + 1;
+                const originalLength = stack.length;
+                stack.length = start - stackStart;
+                stacks.splice(operateIndex, 0, { stack: stack.stack, length: originalLength - stack.length });
+                break;
             }
-            if (!stack.length) {
-                stacksDeleteStart !== null && stacksDeleteStart !== void 0 ? stacksDeleteStart : (stacksDeleteStart = i);
-                stacksDeleteLength++;
+        }
+        if (operateIndex === undefined) {
+            throw new Error('Invalid splice operation');
+        }
+        let _deleteCount = deleteCount;
+        for (let i = operateIndex; i < stacks.length; i++) {
+            const stack = stacks[i];
+            while (_deleteCount > 0 && stack.length > 0) {
+                stack.length--;
+                _deleteCount--;
             }
-            if (remainDeleteCount <= 0)
+            if (_deleteCount === 0) {
                 break;
+            }
         }
-        if (stacksDeleteStart !== undefined) {
-            stacks.splice(stacksDeleteStart, stacksDeleteLength);
-        }
+        stacks.splice(operateIndex, 0, { stack: getStack(), length: items.length });
         return segments.splice(start, deleteCount, ...items);
     }
     function sort(compareFn) {

package/out/types.d.ts

@@ -1,13 +1,13 @@
 declare const NO_DATA_SYMBOL: unique symbol;
 export type Segment<T = typeof NO_DATA_SYMBOL> = string | (T extends typeof NO_DATA_SYMBOL ? [
-    string,
-    string | undefined,
-    number | [number, number]
+    text: string,
+    source: string | undefined,
+    sourceOffset: number
 ] : [
-    string,
-    string | undefined,
-    number | [number, number],
-    T
+    text: string,
+    source: string | undefined,
+    sourceOffset: number,
+    data: T
 ]);
 export interface StackNode {
     length: number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "muggle-string",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [