init

node_modules/muggle-string/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/muggle-string/README.md

@@ -0,0 +1,72 @@
+This library aims to provide codegen helpers and data structure for Vue language plugin API v1.x that does not depend on Volar runtime.
+
+## Why "Muggle"?
+
+A better situation is Volar can use magic-string on the Vue plugin API, but currently can't do this easily.
+
+This solution is just for Vue language plugin API v1.x and planned to be deprecate in v2.
+
+## Usage
+
+The example is base-on [magic-string readme](https://github.com/rich-harris/magic-string#usage).
+
+```html
+<script>problems = 99</script>
+
+<more-script lang="js">console.log( answer )</more-script>
+```
+
+```ts
+import {
+	toString,
+	replace,
+} from 'muggle-string';
+
+/** @type {import('@volar/vue-language-core').VueLanguagePlugin} */
+const plugin = () => {
+	return {
+		name: 'example-vue-language-plugin',
+		version: 1,
+		resolveEmbeddedFile(fileName, sfc, embeddedFile) {
+			if (embeddedFile.fileName.replace(fileName, '').match(/^\.(js|ts|jsx|tsx)$/)) {
+
+				const s = embeddedFile.content;
+				toString(s); // 'problems = 99'
+
+				replace(s, 'problems', 'answer');
+				toString(s); // 'answer = 99'
+
+				replace(s, '99', '42');
+				toString(s); // 'answer = 42'
+
+				// add string by Array method directly
+				s.unshift('var ');
+				s.push(';');
+				toString(s); // 'var answer = 42;'
+
+				for (const block of sfc.customBlocks) {
+					if (block.type === 'more-script') {
+						s.push([
+							block.content, // text to add
+							block.name, // source
+							0, // content offset in source
+							{
+								// language capabilities to enable in this segment
+								hover: true,
+								references: true,
+								definition: true,
+								diagnostic: true,
+								rename: true,
+								completion: true,
+								semanticTokens: true,
+							},
+						]);
+						toString(s); // 'var answer = 42;console.log( answer )'
+					}
+				}
+			}
+		}
+	};
+};
+module.exports = plugin;
+```

node_modules/muggle-string/out/binarySearch.d.ts

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

node_modules/muggle-string/out/binarySearch.js

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

node_modules/muggle-string/out/index.d.ts

@@ -0,0 +1,10 @@
+import { Segment } from "./types";
+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;
+export declare function replaceRange<T extends Segment<any>>(segments: T[], startOffset: number, endOffset: number, ...newSegments: T[]): void;

node_modules/muggle-string/out/index.js

@@ -0,0 +1,176 @@
+"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.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);
+__exportStar(require("./track"), 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 create(source) {
+    return [[source, undefined, 0]];
+}
+exports.create = create;
+function replace(segments, pattern, ...replacers) {
+    const str = toString(segments);
+    const match = str.match(pattern);
+    if (match && match.index !== undefined) {
+        const startOffset = match.index;
+        const endOffset = startOffset + match[0].length;
+        (0, track_1.offsetStack)();
+        replaceRange(segments, startOffset, endOffset, ...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 startOffset = match.index + lengthDiff;
+            const endOffset = startOffset + match[0].length;
+            (0, track_1.offsetStack)();
+            replaceRange(segments, startOffset, endOffset, ...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 replaceSourceRange(segments, source, startOffset, endOffset, ...newSegments) {
+    for (const segment of segments) {
+        if (typeof segment === 'string') {
+            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 (segmentStart <= startOffset && segmentEnd >= endOffset) {
+                const inserts = [];
+                if (startOffset > segmentStart) {
+                    inserts.push(trimSegmentEnd(segment, startOffset - segmentStart));
+                }
+                for (const newSegment of newSegments) {
+                    inserts.push(newSegment);
+                }
+                if (endOffset < segmentEnd) {
+                    inserts.push(trimSegmentStart(segment, endOffset - segmentEnd));
+                }
+                combineStrings(inserts);
+                (0, track_1.offsetStack)();
+                segments.splice(segments.indexOf(segment), 1, ...inserts);
+                (0, track_1.resetOffsetStack)();
+                return true;
+            }
+        }
+    }
+    return false;
+}
+exports.replaceSourceRange = replaceSourceRange;
+function replaceRange(segments, startOffset, endOffset, ...newSegments) {
+    const offsets = toOffsets(segments);
+    const startIndex = (0, binarySearch_1.binarySearch)(offsets, startOffset);
+    const endIndex = (0, binarySearch_1.binarySearch)(offsets, endOffset);
+    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);
+    const inserts = [];
+    if (startOffset > startSegmentStart) {
+        inserts.push(trimSegmentEnd(startSegment, startOffset - startSegmentStart));
+    }
+    for (const newSegment of newSegments) {
+        inserts.push(newSegment);
+    }
+    if (endOffset < endSegmentEnd) {
+        inserts.push(trimSegmentStart(endSegment, endOffset - endSegmentStart));
+    }
+    combineStrings(inserts);
+    (0, track_1.offsetStack)();
+    segments.splice(startIndex, endIndex - startIndex + 1, ...inserts);
+    (0, track_1.resetOffsetStack)();
+}
+exports.replaceRange = replaceRange;
+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=index.js.map

node_modules/muggle-string/out/track.d.ts

@@ -0,0 +1,5 @@
+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, stacks?: StackNode[]): [T, StackNode[]];

node_modules/muggle-string/out/track.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.track = exports.resetOffsetStack = exports.offsetStack = exports.setTracking = void 0;
+let tracking = true;
+let stackOffset = 0;
+function setTracking(value) {
+    tracking = value;
+}
+exports.setTracking = setTracking;
+function offsetStack() {
+    stackOffset++;
+}
+exports.offsetStack = offsetStack;
+function resetOffsetStack() {
+    stackOffset--;
+}
+exports.resetOffsetStack = resetOffsetStack;
+function track(segments, stacks = []) {
+    return [
+        new Proxy(segments, {
+            get(target, prop, receiver) {
+                if (tracking) {
+                    if (prop === 'push')
+                        return push;
+                    if (prop === 'pop')
+                        return pop;
+                    if (prop === 'shift')
+                        return shift;
+                    if (prop === 'unshift')
+                        return unshift;
+                    if (prop === 'splice')
+                        return splice;
+                    if (prop === 'sort')
+                        return sort;
+                    if (prop === 'reverse')
+                        return reverse;
+                }
+                return Reflect.get(target, prop, receiver);
+            }
+        }),
+        stacks,
+    ];
+    function push(...items) {
+        stacks.push({ stack: getStack(), length: items.length });
+        return segments.push(...items);
+    }
+    function pop() {
+        if (stacks.length) {
+            const last = stacks[stacks.length - 1];
+            if (last.length > 1) {
+                last.length--;
+            }
+            else {
+                stacks.pop();
+            }
+        }
+        return segments.pop();
+    }
+    function shift() {
+        if (stacks.length) {
+            const first = stacks[0];
+            if (first.length > 1) {
+                first.length--;
+            }
+            else {
+                stacks.shift();
+            }
+        }
+        return segments.shift();
+    }
+    function unshift(...items) {
+        stacks.unshift({ stack: getStack(), length: items.length });
+        return segments.unshift(...items);
+    }
+    function splice(start, deleteCount, ...items) {
+        if (deleteCount === undefined) {
+            deleteCount = segments.length - start;
+        }
+        let _stackStart = 0;
+        let operateIndex;
+        for (let i = 0; i < stacks.length; i++) {
+            const stack = stacks[i];
+            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 (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 (_deleteCount === 0) {
+                break;
+            }
+        }
+        stacks.splice(operateIndex, 0, { stack: getStack(), length: items.length });
+        return segments.splice(start, deleteCount, ...items);
+    }
+    function sort(compareFn) {
+        stacks.splice(0, stacks.length, { stack: getStack(), length: segments.length });
+        return segments.sort(compareFn);
+    }
+    function reverse() {
+        stacks.splice(0, stacks.length, { stack: getStack(), length: segments.length });
+        return segments.reverse();
+    }
+    function getStack() {
+        const stack = new Error().stack;
+        let source = stack.split('\n')[3 + stackOffset].trim();
+        if (source.endsWith(')')) {
+            source = source.slice(source.lastIndexOf('(') + 1, -1);
+        }
+        else {
+            source = source.slice(source.lastIndexOf(' ') + 1);
+        }
+        return source;
+    }
+}
+exports.track = track;
+//# sourceMappingURL=track.js.map

node_modules/muggle-string/out/types.d.ts

@@ -0,0 +1,16 @@
+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]
+] : [
+    string,
+    string | undefined,
+    number | [number, number],
+    T
+]);
+export interface StackNode {
+    length: number;
+    stack: string;
+}
+export {};

node_modules/muggle-string/out/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

node_modules/muggle-string/package.json

@@ -0,0 +1,22 @@
+{
+	"name": "muggle-string",
+	"version": "0.3.1",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/johnsoncodehk/muggle-string.git"
+	},
+	"scripts": {
+		"test": "vitest run"
+	},
+	"devDependencies": {
+		"typescript": "latest",
+		"vitest": "latest",
+		"vite": "latest"
+	}
+}