@vue/language-core 2.0.0 → 2.0.2

package/lib/virtualFile/computedFiles.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedFiles = void 0;
+const language_core_1 = require("@volar/language-core");
+const computeds_1 = require("computeds");
+const embeddedFile_1 = require("./embeddedFile");
+function computedFiles(plugins, fileName, sfc, codegenStack) {
+    const nameToBlock = (0, computeds_1.computed)(() => {
+        const blocks = {};
+        if (sfc.template) {
+            blocks[sfc.template.name] = sfc.template;
+        }
+        if (sfc.script) {
+            blocks[sfc.script.name] = sfc.script;
+        }
+        if (sfc.scriptSetup) {
+            blocks[sfc.scriptSetup.name] = sfc.scriptSetup;
+        }
+        for (const block of sfc.styles) {
+            blocks[block.name] = block;
+        }
+        for (const block of sfc.customBlocks) {
+            blocks[block.name] = block;
+        }
+        return blocks;
+    });
+    const pluginsResult = plugins.map(plugin => computedPluginFiles(plugins, plugin, fileName, sfc, nameToBlock, codegenStack));
+    const flatResult = (0, computeds_1.computed)(() => pluginsResult.map(r => r()).flat());
+    const structuredResult = (0, computeds_1.computed)(() => {
+        const embeddedCodes = [];
+        let remain = [...flatResult()];
+        while (remain.length) {
+            const beforeLength = remain.length;
+            consumeRemain();
+            if (beforeLength === remain.length) {
+                break;
+            }
+        }
+        for (const { file, snapshot, mappings, codegenStacks } of remain) {
+            embeddedCodes.push({
+                id: file.id,
+                languageId: (0, language_core_1.resolveCommonLanguageId)(`/dummy.${file.lang}`),
+                linkedCodeMappings: file.linkedCodeMappings,
+                snapshot,
+                mappings,
+                codegenStacks,
+                embeddedCodes: [],
+            });
+            console.error('Unable to resolve embedded: ' + file.parentCodeId + ' -> ' + file.id);
+        }
+        return embeddedCodes;
+        function consumeRemain() {
+            for (let i = remain.length - 1; i >= 0; i--) {
+                const { file, snapshot, mappings, codegenStacks } = remain[i];
+                if (!file.parentCodeId) {
+                    embeddedCodes.push({
+                        id: file.id,
+                        languageId: (0, language_core_1.resolveCommonLanguageId)(`/dummy.${file.lang}`),
+                        linkedCodeMappings: file.linkedCodeMappings,
+                        snapshot,
+                        mappings,
+                        codegenStacks,
+                        embeddedCodes: [],
+                    });
+                    remain.splice(i, 1);
+                }
+                else {
+                    const parent = findParentStructure(file.parentCodeId, embeddedCodes);
+                    if (parent) {
+                        parent.embeddedCodes ??= [];
+                        parent.embeddedCodes.push({
+                            id: file.id,
+                            languageId: (0, language_core_1.resolveCommonLanguageId)(`/dummy.${file.lang}`),
+                            linkedCodeMappings: file.linkedCodeMappings,
+                            snapshot,
+                            mappings,
+                            codegenStacks,
+                            embeddedCodes: [],
+                        });
+                        remain.splice(i, 1);
+                    }
+                }
+            }
+        }
+        function findParentStructure(id, current) {
+            for (const child of current) {
+                if (child.id === id) {
+                    return child;
+                }
+                let parent = findParentStructure(id, child.embeddedCodes ?? []);
+                if (parent) {
+                    return parent;
+                }
+            }
+        }
+    });
+    return structuredResult;
+}
+exports.computedFiles = computedFiles;
+function computedPluginFiles(plugins, plugin, fileName, sfc, nameToBlock, codegenStack) {
+    const embeddedFiles = {};
+    const files = (0, computeds_1.computed)(() => {
+        try {
+            if (!plugin.getEmbeddedCodes) {
+                return Object.values(embeddedFiles);
+            }
+            const fileInfos = plugin.getEmbeddedCodes(fileName, sfc);
+            for (const oldId of Object.keys(embeddedFiles)) {
+                if (!fileInfos.some(file => file.id === oldId)) {
+                    delete embeddedFiles[oldId];
+                }
+            }
+            for (const fileInfo of fileInfos) {
+                if (!embeddedFiles[fileInfo.id]) {
+                    embeddedFiles[fileInfo.id] = (0, computeds_1.computed)(() => {
+                        const [content, stacks] = codegenStack ? (0, language_core_1.track)([]) : [[], []];
+                        const file = new embeddedFile_1.VueEmbeddedCode(fileInfo.id, fileInfo.lang, content, stacks);
+                        for (const plugin of plugins) {
+                            if (!plugin.resolveEmbeddedCode) {
+                                continue;
+                            }
+                            try {
+                                plugin.resolveEmbeddedCode(fileName, sfc, file);
+                            }
+                            catch (e) {
+                                console.error(e);
+                            }
+                        }
+                        const newText = (0, language_core_1.toString)(file.content);
+                        const changeRanges = new Map();
+                        const snapshot = {
+                            getText: (start, end) => newText.slice(start, end),
+                            getLength: () => newText.length,
+                            getChangeRange(oldSnapshot) {
+                                if (!changeRanges.has(oldSnapshot)) {
+                                    changeRanges.set(oldSnapshot, undefined);
+                                    const oldText = oldSnapshot.getText(0, oldSnapshot.getLength());
+                                    const changeRange = fullDiffTextChangeRange(oldText, newText);
+                                    if (changeRange) {
+                                        changeRanges.set(oldSnapshot, changeRange);
+                                    }
+                                }
+                                return changeRanges.get(oldSnapshot);
+                            },
+                        };
+                        return {
+                            file,
+                            snapshot,
+                        };
+                    });
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return Object.values(embeddedFiles);
+    });
+    return (0, computeds_1.computed)(() => {
+        return files().map(_file => {
+            const { file, snapshot } = _file();
+            const mappings = (0, language_core_1.buildMappings)(file.content);
+            let lastValidMapping;
+            for (const mapping of mappings) {
+                if (mapping.source !== undefined) {
+                    const block = nameToBlock()[mapping.source];
+                    if (block) {
+                        mapping.sourceOffsets = mapping.sourceOffsets.map(offset => offset + block.startTagEnd);
+                    }
+                    else {
+                        // ignore
+                    }
+                    mapping.source = undefined;
+                }
+                if (mapping.data.__combineLastMappping) {
+                    lastValidMapping.sourceOffsets.push(...mapping.sourceOffsets);
+                    lastValidMapping.generatedOffsets.push(...mapping.generatedOffsets);
+                    lastValidMapping.lengths.push(...mapping.lengths);
+                    continue;
+                }
+                else {
+                    lastValidMapping = mapping;
+                }
+            }
+            return {
+                file,
+                snapshot,
+                mappings: mappings.filter(mapping => !mapping.data.__combineLastMappping),
+                codegenStacks: (0, language_core_1.buildStacks)(file.content, file.contentStacks),
+            };
+        });
+    });
+}
+function fullDiffTextChangeRange(oldText, newText) {
+    for (let start = 0; start < oldText.length && start < newText.length; start++) {
+        if (oldText[start] !== newText[start]) {
+            let end = oldText.length;
+            for (let i = 0; i < oldText.length - start && i < newText.length - start; i++) {
+                if (oldText[oldText.length - i - 1] !== newText[newText.length - i - 1]) {
+                    break;
+                }
+                end--;
+            }
+            let length = end - start;
+            let newLength = length + (newText.length - oldText.length);
+            if (newLength < 0) {
+                length -= newLength;
+                newLength = 0;
+            }
+            return {
+                span: { start, length },
+                newLength,
+            };
+        }
+    }
+}
+//# sourceMappingURL=computedFiles.js.map

package/lib/virtualFile/computedMappings.d.ts

@@ -0,0 +1,4 @@
+import { Mapping } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { Sfc, VueCodeInformation } from '../types';
+export declare function computedMappings(snapshot: () => ts.IScriptSnapshot, sfc: Sfc): () => Mapping<VueCodeInformation>[];

package/lib/virtualFile/computedMappings.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedMappings = void 0;
+const language_core_1 = require("@volar/language-core");
+const computeds_1 = require("computeds");
+const utils_1 = require("../generators/utils");
+function computedMappings(snapshot, sfc) {
+    return (0, computeds_1.computed)(() => {
+        const str = [[snapshot().getText(0, snapshot().getLength()), undefined, 0, (0, utils_1.enableAllFeatures)({})]];
+        for (const block of [
+            sfc.script,
+            sfc.scriptSetup,
+            sfc.template,
+            ...sfc.styles,
+            ...sfc.customBlocks,
+        ]) {
+            if (block) {
+                (0, language_core_1.replaceSourceRange)(str, undefined, block.startTagEnd, block.endTagStart, '\n\n');
+            }
+        }
+        return str
+            .filter(s => typeof s !== 'string')
+            .map((m) => {
+            const text = m[0];
+            const start = m[2];
+            return {
+                sourceOffsets: [start],
+                generatedOffsets: [start],
+                lengths: [text.length],
+                data: m[3],
+            };
+        });
+    });
+}
+exports.computedMappings = computedMappings;
+//# sourceMappingURL=computedMappings.js.map

package/lib/virtualFile/computedSfc.d.ts

@@ -0,0 +1,4 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript';
+import type { Sfc, VueLanguagePlugin } from '../types';
+export declare function computedSfc(ts: typeof import('typescript'), plugins: ReturnType<VueLanguagePlugin>[], fileName: string, snapshot: () => ts.IScriptSnapshot, parsed: () => SFCParseResult | undefined): Sfc;

package/lib/virtualFile/computedSfc.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedSfc = void 0;
+const computeds_1 = require("computeds");
+const parseCssClassNames_1 = require("../utils/parseCssClassNames");
+const parseCssVars_1 = require("../utils/parseCssVars");
+function computedSfc(ts, plugins, fileName, snapshot, parsed) {
+    const untrackedSnapshot = () => {
+        (0, computeds_1.pauseTracking)();
+        const res = snapshot();
+        (0, computeds_1.resetTracking)();
+        return res;
+    };
+    const template = computedNullableSfcBlock('template', 'html', (0, computeds_1.computed)(() => parsed()?.descriptor.template ?? undefined), (_block, base) => {
+        const compiledAst = computedTemplateAst(base);
+        return mergeObject(base, {
+            get ast() { return compiledAst()?.ast; },
+            get errors() { return compiledAst()?.errors; },
+            get warnings() { return compiledAst()?.warnings; },
+        });
+    });
+    const script = computedNullableSfcBlock('script', 'js', (0, computeds_1.computed)(() => parsed()?.descriptor.script ?? undefined), (block, base) => {
+        const src = (0, computeds_1.computed)(() => block().src);
+        const srcOffset = (0, computeds_1.computed)(() => {
+            const _src = src();
+            return _src ? untrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_src) - base.startTagEnd : -1;
+        });
+        const ast = (0, computeds_1.computed)(() => ts.createSourceFile(fileName + '.' + base.lang, base.content, 99));
+        return mergeObject(base, {
+            get src() { return src(); },
+            get srcOffset() { return srcOffset(); },
+            get ast() { return ast(); },
+        });
+    });
+    const scriptSetup = computedNullableSfcBlock('scriptSetup', 'js', (0, computeds_1.computed)(() => parsed()?.descriptor.scriptSetup ?? undefined), (block, base) => {
+        const generic = (0, computeds_1.computed)(() => {
+            const _block = block();
+            return typeof _block.attrs.generic === 'string' ? _block.attrs.generic : undefined;
+        });
+        const genericOffset = (0, computeds_1.computed)(() => {
+            const _generic = generic();
+            return _generic !== undefined ? untrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_generic) - base.startTagEnd : -1;
+        });
+        const ast = (0, computeds_1.computed)(() => ts.createSourceFile(fileName + '.' + base.lang, base.content, 99));
+        return mergeObject(base, {
+            get generic() { return generic(); },
+            get genericOffset() { return genericOffset(); },
+            get ast() { return ast(); },
+        });
+    });
+    const styles = (0, computeds_1.computedArray)((0, computeds_1.computed)(() => parsed()?.descriptor.styles ?? []), (block, i) => {
+        const base = computedSfcBlock('style_' + i, 'css', block);
+        const module = (0, computeds_1.computed)(() => typeof block().module === 'string' ? block().module : block().module ? '$style' : undefined);
+        const scoped = (0, computeds_1.computed)(() => !!block().scoped);
+        const cssVars = (0, computeds_1.computed)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)]);
+        const classNames = (0, computeds_1.computed)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)]);
+        return (0, computeds_1.computed)(() => mergeObject(base, {
+            get module() { return module(); },
+            get scoped() { return scoped(); },
+            get cssVars() { return cssVars(); },
+            get classNames() { return classNames(); },
+        }));
+    });
+    const customBlocks = (0, computeds_1.computedArray)((0, computeds_1.computed)(() => parsed()?.descriptor.customBlocks ?? []), (block, i) => {
+        const base = computedSfcBlock('customBlock_' + i, 'txt', block);
+        const type = (0, computeds_1.computed)(() => block().type);
+        return (0, computeds_1.computed)(() => mergeObject(base, {
+            get type() { return type(); },
+        }));
+    });
+    return {
+        get template() { return template(); },
+        get script() { return script(); },
+        get scriptSetup() { return scriptSetup(); },
+        get styles() { return styles; },
+        get customBlocks() { return customBlocks; },
+        get templateAst() { return template()?.ast; },
+        get scriptAst() { return script()?.ast; },
+        get scriptSetupAst() { return scriptSetup()?.ast; },
+    };
+    function computedTemplateAst(base) {
+        let cache;
+        return (0, computeds_1.computed)(() => {
+            if (cache?.template === base.content) {
+                return {
+                    errors: [],
+                    warnings: [],
+                    ast: cache?.result.ast,
+                };
+            }
+            // incremental update
+            if (cache?.plugin.updateSFCTemplate) {
+                const change = untrackedSnapshot().getChangeRange(cache.snapshot);
+                if (change) {
+                    (0, computeds_1.pauseTracking)();
+                    const templateOffset = base.startTagEnd;
+                    (0, computeds_1.resetTracking)();
+                    const newText = untrackedSnapshot().getText(change.span.start, change.span.start + change.newLength);
+                    const newResult = cache.plugin.updateSFCTemplate(cache.result, {
+                        start: change.span.start - templateOffset,
+                        end: change.span.start + change.span.length - templateOffset,
+                        newText,
+                    });
+                    if (newResult) {
+                        cache.template = base.content;
+                        cache.snapshot = untrackedSnapshot();
+                        cache.result = newResult;
+                        return {
+                            errors: [],
+                            warnings: [],
+                            ast: newResult.ast,
+                        };
+                    }
+                }
+            }
+            const errors = [];
+            const warnings = [];
+            let options = {
+                onError: (err) => errors.push(err),
+                onWarn: (err) => warnings.push(err),
+                expressionPlugins: ['typescript'],
+            };
+            for (const plugin of plugins) {
+                if (plugin.resolveTemplateCompilerOptions) {
+                    options = plugin.resolveTemplateCompilerOptions(options);
+                }
+            }
+            for (const plugin of plugins) {
+                let result;
+                try {
+                    result = plugin.compileSFCTemplate?.(base.lang, base.content, options);
+                }
+                catch (e) {
+                    const err = e;
+                    errors.push(err);
+                }
+                if (result || errors.length) {
+                    if (result && !errors.length && !warnings.length) {
+                        cache = {
+                            template: base.content,
+                            snapshot: untrackedSnapshot(),
+                            result: result,
+                            plugin,
+                        };
+                    }
+                    else {
+                        cache = undefined;
+                    }
+                    return {
+                        errors,
+                        warnings,
+                        ast: result?.ast,
+                    };
+                }
+            }
+            return {
+                errors,
+                warnings,
+                ast: undefined,
+            };
+        });
+    }
+    function computedNullableSfcBlock(name, defaultLang, block, resolve) {
+        const hasBlock = (0, computeds_1.computed)(() => !!block());
+        return (0, computeds_1.computed)(() => {
+            if (!hasBlock()) {
+                return;
+            }
+            const _block = (0, computeds_1.computed)(() => block());
+            return resolve(_block, computedSfcBlock(name, defaultLang, _block));
+        });
+    }
+    function computedSfcBlock(name, defaultLang, block) {
+        const lang = (0, computeds_1.computed)(() => block().lang ?? defaultLang);
+        const attrs = (0, computeds_1.computed)(() => block().attrs); // TODO: computed it
+        const content = (0, computeds_1.computed)(() => block().content);
+        const startTagEnd = (0, computeds_1.computed)(() => block().loc.start.offset);
+        const endTagStart = (0, computeds_1.computed)(() => block().loc.end.offset);
+        const start = (0, computeds_1.computed)(() => untrackedSnapshot().getText(0, startTagEnd()).lastIndexOf('<' + block().type));
+        const end = (0, computeds_1.computed)(() => endTagStart() + untrackedSnapshot().getText(endTagStart(), untrackedSnapshot().getLength()).indexOf('>') + 1);
+        return {
+            name,
+            get lang() { return lang(); },
+            get attrs() { return attrs(); },
+            get content() { return content(); },
+            get startTagEnd() { return startTagEnd(); },
+            get endTagStart() { return endTagStart(); },
+            get start() { return start(); },
+            get end() { return end(); },
+        };
+    }
+}
+exports.computedSfc = computedSfc;
+function mergeObject(a, b) {
+    return Object.defineProperties(a, Object.getOwnPropertyDescriptors(b));
+}
+//# sourceMappingURL=computedSfc.js.map

package/lib/virtualFile/computedVueSfc.d.ts

@@ -0,0 +1,4 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript';
+import type { VueLanguagePlugin } from '../types';
+export declare function computedVueSfc(plugins: ReturnType<VueLanguagePlugin>[], fileName: string, snapshot: () => ts.IScriptSnapshot): () => SFCParseResult | undefined;

package/lib/virtualFile/computedVueSfc.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedVueSfc = void 0;
+const computeds_1 = require("computeds");
+function computedVueSfc(plugins, fileName, snapshot) {
+    let cache;
+    return (0, computeds_1.computed)(() => {
+        // incremental update
+        if (cache?.plugin.updateSFC) {
+            const change = snapshot().getChangeRange(cache.snapshot);
+            if (change) {
+                const newSfc = cache.plugin.updateSFC(cache.sfc, {
+                    start: change.span.start,
+                    end: change.span.start + change.span.length,
+                    newText: snapshot().getText(change.span.start, change.span.start + change.newLength),
+                });
+                if (newSfc) {
+                    cache.snapshot = snapshot();
+                    // force dirty
+                    cache.sfc = JSON.parse(JSON.stringify(newSfc));
+                    return cache.sfc;
+                }
+            }
+        }
+        for (const plugin of plugins) {
+            const sfc = plugin.parseSFC?.(fileName, snapshot().getText(0, snapshot().getLength()));
+            if (sfc) {
+                if (!sfc.errors.length) {
+                    cache = {
+                        snapshot: snapshot(),
+                        sfc,
+                        plugin,
+                    };
+                }
+                return sfc;
+            }
+        }
+    });
+}
+exports.computedVueSfc = computedVueSfc;
+//# sourceMappingURL=computedVueSfc.js.map

package/lib/virtualFile/embeddedFile.d.ts

@@ -0,0 +1,12 @@
+import type { Mapping, StackNode } from '@volar/language-core';
+import type { Code } from '../types';
+export declare class VueEmbeddedCode {
+    id: string;
+    lang: string;
+    content: Code[];
+    contentStacks: StackNode[];
+    parentCodeId?: string;
+    linkedCodeMappings: Mapping[];
+    embeddedCodes: VueEmbeddedCode[];
+    constructor(id: string, lang: string, content: Code[], contentStacks: StackNode[]);
+}

package/lib/virtualFile/embeddedFile.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueEmbeddedCode = void 0;
+class VueEmbeddedCode {
+    constructor(id, lang, content, contentStacks) {
+        this.id = id;
+        this.lang = lang;
+        this.content = content;
+        this.contentStacks = contentStacks;
+        this.linkedCodeMappings = [];
+        this.embeddedCodes = [];
+    }
+}
+exports.VueEmbeddedCode = VueEmbeddedCode;
+//# sourceMappingURL=embeddedFile.js.map

package/lib/virtualFile/vueFile.d.ts

@@ -0,0 +1,25 @@
+import type { Stack, VirtualCode } from '@volar/language-core';
+import { Signal } from 'computeds';
+import type * as ts from 'typescript';
+import type { VueCompilerOptions, VueLanguagePlugin } from '../types';
+export declare class VueGeneratedCode implements VirtualCode {
+    fileName: string;
+    languageId: string;
+    initSnapshot: ts.IScriptSnapshot;
+    vueCompilerOptions: VueCompilerOptions;
+    plugins: ReturnType<VueLanguagePlugin>[];
+    ts: typeof import('typescript');
+    codegenStack: boolean;
+    id: string;
+    _snapshot: Signal<ts.IScriptSnapshot>;
+    getVueSfc: () => import("@vue/compiler-sfc").SFCParseResult | undefined;
+    sfc: import("../types").Sfc;
+    getMappings: () => import("@volar/language-core").Mapping<import("../types").VueCodeInformation>[];
+    getEmbeddedCodes: () => VirtualCode[];
+    codegenStacks: Stack[];
+    get embeddedCodes(): VirtualCode[];
+    get snapshot(): ts.IScriptSnapshot;
+    get mappings(): import("@volar/language-core").Mapping<import("../types").VueCodeInformation>[];
+    constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: ReturnType<VueLanguagePlugin>[], ts: typeof import('typescript'), codegenStack: boolean);
+    update(newSnapshot: ts.IScriptSnapshot): void;
+}

package/lib/virtualFile/vueFile.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueGeneratedCode = void 0;
+const computeds_1 = require("computeds");
+const computedFiles_1 = require("./computedFiles");
+const computedMappings_1 = require("./computedMappings");
+const computedSfc_1 = require("./computedSfc");
+const computedVueSfc_1 = require("./computedVueSfc");
+class VueGeneratedCode {
+    get embeddedCodes() {
+        return this.getEmbeddedCodes();
+    }
+    get snapshot() {
+        return this._snapshot();
+    }
+    get mappings() {
+        return this.getMappings();
+    }
+    constructor(fileName, languageId, initSnapshot, vueCompilerOptions, plugins, ts, codegenStack) {
+        this.fileName = fileName;
+        this.languageId = languageId;
+        this.initSnapshot = initSnapshot;
+        this.vueCompilerOptions = vueCompilerOptions;
+        this.plugins = plugins;
+        this.ts = ts;
+        this.codegenStack = codegenStack;
+        // sources
+        this.id = 'main';
+        // computeds
+        this.getVueSfc = (0, computedVueSfc_1.computedVueSfc)(this.plugins, this.fileName, () => this._snapshot());
+        this.sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, () => this._snapshot(), this.getVueSfc);
+        this.getMappings = (0, computedMappings_1.computedMappings)(() => this._snapshot(), this.sfc);
+        this.getEmbeddedCodes = (0, computedFiles_1.computedFiles)(this.plugins, this.fileName, this.sfc, this.codegenStack);
+        // others
+        this.codegenStacks = [];
+        this._snapshot = (0, computeds_1.signal)(initSnapshot);
+    }
+    update(newSnapshot) {
+        this._snapshot.set(newSnapshot);
+    }
+}
+exports.VueGeneratedCode = VueGeneratedCode;
+//# sourceMappingURL=vueFile.js.map

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.0.0",
+	"version": "2.0.2",
 	"license": "MIT",
 	"files": [
-		"out/**/*.js",
-		"out/**/*.d.ts"
+		"**/*.js",
+		"**/*.d.ts"
 	],
 	"repository": {
 		"type": "git",
@@ -34,5 +34,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "aa47e5a7d8a6dae62cc80dbdb5db6a9bfa4f8715"
+	"gitHead": "b377d5f990ffe7ef44f0d1871fcb8b5c2deafad1"
 }