feat: init

node_modules/@vue/language-core/lib/utils/buildMappings.d.ts

@@ -0,0 +1,3 @@
+import type { Mapping } from '@volar/language-core';
+import type { Segment } from 'muggle-string';
+export declare function buildMappings<T>(chunks: Segment<T>[]): Mapping<T>[];

node_modules/@vue/language-core/lib/utils/buildMappings.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMappings = buildMappings;
+function buildMappings(chunks) {
+    let length = 0;
+    const mappings = [];
+    for (const segment of chunks) {
+        if (typeof segment === 'string') {
+            length += segment.length;
+        }
+        else {
+            mappings.push({
+                sourceOffsets: [segment[2]],
+                generatedOffsets: [length],
+                lengths: [segment[0].length],
+                data: segment[3],
+            });
+            length += segment[0].length;
+        }
+    }
+    return mappings;
+}
+//# sourceMappingURL=buildMappings.js.map

node_modules/@vue/language-core/lib/utils/collectBindings.d.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+export declare function collectBindingNames(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string[];
+export declare function collectBindingRanges(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): import("../types").TextRange<ts.Identifier>[];
+export declare function collectBindingIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[], isRest?: boolean, initializer?: ts.Expression | undefined): {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[];

node_modules/@vue/language-core/lib/utils/collectBindings.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectBindingNames = collectBindingNames;
+exports.collectBindingRanges = collectBindingRanges;
+exports.collectBindingIdentifiers = collectBindingIdentifiers;
+const shared_1 = require("./shared");
+function collectBindingNames(ts, node, ast) {
+    return collectBindingIdentifiers(ts, node).map(({ id }) => (0, shared_1.getNodeText)(ts, id, ast));
+}
+function collectBindingRanges(ts, node, ast) {
+    return collectBindingIdentifiers(ts, node).map(({ id }) => (0, shared_1.getStartEnd)(ts, id, ast));
+}
+function collectBindingIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
+    if (ts.isIdentifier(node)) {
+        results.push({ id: node, isRest, initializer });
+    }
+    else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectBindingIdentifiers(ts, el.name, results, !!el.dotDotDotToken, el.initializer);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectBindingIdentifiers(ts, node, results, false));
+    }
+    return results;
+}
+//# sourceMappingURL=collectBindings.js.map

node_modules/@vue/language-core/lib/utils/forEachTemplateNode.d.ts

@@ -0,0 +1,3 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;
+export declare function forEachInterpolationNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): Generator<CompilerDOM.InterpolationNode>;

node_modules/@vue/language-core/lib/utils/forEachTemplateNode.js

@@ -0,0 +1,101 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachElementNode = forEachElementNode;
+exports.forEachInterpolationNode = forEachInterpolationNode;
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+function* forEachElementNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        yield node;
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const childNode of branch.children) {
+                yield* forEachElementNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+}
+function* forEachInterpolationNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
+        yield* forEachInterpolationNode(node.content);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
+        for (const child of node.children) {
+            if (typeof child === 'object') {
+                yield* forEachInterpolationNode(child);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
+        yield node;
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const childNode of branch.children) {
+                yield* forEachInterpolationNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+}
+//# sourceMappingURL=forEachTemplateNode.js.map

node_modules/@vue/language-core/lib/utils/parseSfc.d.ts

@@ -0,0 +1,7 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+declare module '@vue/compiler-sfc' {
+    interface SFCDescriptor {
+        comments: string[];
+    }
+}
+export declare function parse(source: string): SFCParseResult;

node_modules/@vue/language-core/lib/utils/parseSfc.js

@@ -0,0 +1,185 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const shared_1 = require("./shared");
+function parse(source) {
+    const errors = [];
+    const ast = CompilerDOM.parse(source, {
+        // there are no components at SFC parsing level
+        isNativeTag: () => true,
+        // preserve all whitespaces
+        isPreTag: () => true,
+        parseMode: 'sfc',
+        onError: e => {
+            errors.push(e);
+        },
+        comments: true,
+    });
+    const descriptor = {
+        filename: 'anonymous.vue',
+        source,
+        comments: [],
+        template: null,
+        script: null,
+        scriptSetup: null,
+        styles: [],
+        customBlocks: [],
+        cssVars: [],
+        slotted: false,
+        shouldForceReload: () => false,
+    };
+    ast.children.forEach(node => {
+        if (node.type === CompilerDOM.NodeTypes.COMMENT) {
+            descriptor.comments.push(node.content);
+            return;
+        }
+        else if (node.type !== CompilerDOM.NodeTypes.ELEMENT) {
+            return;
+        }
+        switch (node.tag) {
+            case 'template':
+                descriptor.template = createBlock(node, source);
+                break;
+            case 'script':
+                const scriptBlock = createBlock(node, source);
+                const isSetup = !!scriptBlock.setup;
+                if (isSetup && !descriptor.scriptSetup) {
+                    descriptor.scriptSetup = scriptBlock;
+                    break;
+                }
+                if (!isSetup && !descriptor.script) {
+                    descriptor.script = scriptBlock;
+                    break;
+                }
+                break;
+            case 'style':
+                const styleBlock = createBlock(node, source);
+                descriptor.styles.push(styleBlock);
+                break;
+            default:
+                descriptor.customBlocks.push(createBlock(node, source));
+                break;
+        }
+    });
+    return {
+        descriptor,
+        errors,
+    };
+}
+function createBlock(node, source) {
+    const type = node.tag;
+    let { start, end } = node.loc;
+    let content = '';
+    if (node.children.length) {
+        start = node.children[0].loc.start;
+        end = node.children[node.children.length - 1].loc.end;
+        content = source.slice(start.offset, end.offset);
+    }
+    else {
+        const offset = node.loc.source.indexOf(`</`);
+        if (offset > -1) {
+            start = {
+                line: start.line,
+                column: start.column + offset,
+                offset: start.offset + offset,
+            };
+        }
+        end = Object.assign({}, start);
+    }
+    const loc = {
+        source: content,
+        start,
+        end,
+    };
+    const attrs = {};
+    const block = {
+        type,
+        content,
+        loc,
+        attrs,
+    };
+    node.props.forEach(p => {
+        if (p.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+            attrs[p.name] = p.value ? p.value.content || true : true;
+            if (p.name === 'lang') {
+                block.lang = p.value?.content;
+            }
+            else if (p.name === 'src') {
+                block.__src = parseAttr(p, node);
+            }
+            else if (isScriptBlock(block)) {
+                if (p.name === 'vapor') {
+                    block.setup ??= attrs[p.name];
+                    block.__generic ??= true;
+                }
+                else if (p.name === 'setup') {
+                    block.setup = attrs[p.name];
+                }
+                else if (p.name === 'generic') {
+                    block.__generic = parseAttr(p, node);
+                }
+            }
+            else if (isStyleBlock(block)) {
+                if (p.name === 'scoped') {
+                    block.scoped = true;
+                }
+                else if (p.name === 'module') {
+                    block.__module = parseAttr(p, node);
+                }
+            }
+        }
+    });
+    return block;
+}
+function isScriptBlock(block) {
+    return block.type === 'script';
+}
+function isStyleBlock(block) {
+    return block.type === 'style';
+}
+function parseAttr(p, node) {
+    if (!p.value) {
+        return true;
+    }
+    const [content, offset] = (0, shared_1.normalizeAttributeValue)(p.value);
+    return {
+        text: content,
+        offset: offset - node.loc.start.offset,
+        quotes: offset > p.value.loc.start.offset,
+    };
+}
+//# sourceMappingURL=parseSfc.js.map

node_modules/@vue/language-core/lib/utils/shared.d.ts

@@ -0,0 +1,9 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Sfc, TextRange } from '../types';
+export { hyphenate as hyphenateTag } from '@vue/shared';
+export declare function hyphenateAttr(str: string): string;
+export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): readonly [string, number];
+export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: NonNullable<Sfc['template']>): [number] | [number, number];
+export declare function getStartEnd<T extends ts.Node>(ts: typeof import('typescript'), node: T, ast: ts.SourceFile): TextRange<T>;
+export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;

node_modules/@vue/language-core/lib/utils/shared.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hyphenateTag = void 0;
+exports.hyphenateAttr = hyphenateAttr;
+exports.normalizeAttributeValue = normalizeAttributeValue;
+exports.getElementTagOffsets = getElementTagOffsets;
+exports.getStartEnd = getStartEnd;
+exports.getNodeText = getNodeText;
+const shared_1 = require("@vue/shared");
+const shared_2 = require("@vue/shared");
+Object.defineProperty(exports, "hyphenateTag", { enumerable: true, get: function () { return shared_2.hyphenate; } });
+function hyphenateAttr(str) {
+    let hyphencase = (0, shared_1.hyphenate)(str);
+    // fix https://github.com/vuejs/core/issues/8811
+    if (str.length && str[0] !== str[0].toLowerCase()) {
+        hyphencase = '-' + hyphencase;
+    }
+    return hyphencase;
+}
+function normalizeAttributeValue(node) {
+    const { source, start } = node.loc;
+    if ((source.startsWith('"') && source.endsWith('"'))
+        || (source.startsWith("'") && source.endsWith("'"))) {
+        return [source.slice(1, -1), start.offset + 1];
+    }
+    return [source, start.offset];
+}
+function getElementTagOffsets(node, template) {
+    const tagOffsets = [
+        template.content.indexOf(node.tag, node.loc.start.offset),
+    ];
+    if (!node.isSelfClosing && template.lang === 'html') {
+        const endTagOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
+        if (endTagOffset > tagOffsets[0]) {
+            tagOffsets.push(endTagOffset);
+        }
+    }
+    return tagOffsets;
+}
+function getStartEnd(ts, node, ast) {
+    return {
+        node,
+        start: ts.getTokenPosOfNode(node, ast),
+        end: node.end,
+    };
+}
+function getNodeText(ts, node, ast) {
+    const { start, end } = getStartEnd(ts, node, ast);
+    return ast.text.slice(start, end);
+}
+//# sourceMappingURL=shared.js.map

node_modules/@vue/language-core/lib/utils/signals.d.ts

@@ -0,0 +1,3 @@
+export declare function reactiveArray<I, O>(getArr: () => I[], getGetter: (item: () => I, index: number) => () => O): readonly Readonly<O>[];
+export declare function computedSet<T>(source: () => Set<T>): () => Set<T>;
+export declare function computedArray<T>(source: () => T[], compareFn?: (oldItem: T, newItem: T) => boolean): () => T[];

node_modules/@vue/language-core/lib/utils/signals.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactiveArray = reactiveArray;
+exports.computedSet = computedSet;
+exports.computedArray = computedArray;
+const alien_signals_1 = require("alien-signals");
+function reactiveArray(getArr, getGetter) {
+    const arr = (0, alien_signals_1.computed)(getArr);
+    const length = (0, alien_signals_1.computed)(() => arr().length);
+    const keys = (0, alien_signals_1.computed)(() => {
+        const l = length();
+        const keys = new Array(l);
+        for (let i = 0; i < l; i++) {
+            keys.push(String(i));
+        }
+        return keys;
+    });
+    const items = (0, alien_signals_1.computed)(array => {
+        array ??= [];
+        while (array.length < length()) {
+            const index = array.length;
+            const item = (0, alien_signals_1.computed)(() => arr()[index]);
+            array.push((0, alien_signals_1.computed)(getGetter(item, index)));
+        }
+        if (array.length > length()) {
+            array.length = length();
+        }
+        return array;
+    });
+    return new Proxy({}, {
+        get(_, p, receiver) {
+            if (p === 'length') {
+                return length();
+            }
+            if (typeof p === 'string' && !isNaN(Number(p))) {
+                return items()[Number(p)]?.();
+            }
+            return Reflect.get(items(), p, receiver);
+        },
+        has(_, p) {
+            return Reflect.has(items(), p);
+        },
+        ownKeys() {
+            return keys();
+        },
+    });
+}
+function computedSet(source) {
+    return (0, alien_signals_1.computed)(oldValue => {
+        const newValue = source();
+        if (oldValue?.size === newValue.size && [...oldValue].every(c => newValue.has(c))) {
+            return oldValue;
+        }
+        return newValue;
+    });
+}
+function computedArray(source, compareFn = (oldItem, newItem) => oldItem === newItem) {
+    return (0, alien_signals_1.computed)(oldArr => {
+        oldArr ??= [];
+        const newArr = source();
+        if (oldArr.length === newArr.length && oldArr.every((item, index) => compareFn(item, newArr[index]))) {
+            return oldArr;
+        }
+        return newArr;
+    });
+}
+//# sourceMappingURL=signals.js.map