@vue/language-core 3.1.5 → 3.1.6

package/lib/virtualCode/normalize.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTemplateAST = normalizeTemplateAST;
+const CompilerDOM = require("@vue/compiler-dom");
+const forEachTemplateNode_1 = require("../utils/forEachTemplateNode");
+// See https://github.com/vuejs/core/issues/3498
+function normalizeTemplateAST(root) {
+    // @ts-ignore
+    const transformContext = {
+        onError: () => { },
+        helperString: str => str.toString(),
+        replaceNode: () => { },
+        cacheHandlers: false,
+        prefixIdentifiers: false,
+        scopes: {
+            vFor: 0,
+            vOnce: 0,
+            vPre: 0,
+            vSlot: 0,
+        },
+        expressionPlugins: ['typescript'],
+    };
+    for (const { children, codegenNode, props } of (0, forEachTemplateNode_1.forEachElementNode)(root)) {
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (child.type !== CompilerDOM.NodeTypes.ELEMENT) {
+                continue;
+            }
+            const forNode = getVForNode(child, transformContext);
+            if (forNode) {
+                children[i] = forNode;
+                continue;
+            }
+            const ifNode = getVIfNode(child, transformContext);
+            if (ifNode) {
+                const normalized = normalizeIfBranch(ifNode, children, i);
+                children.splice(i, normalized.end - i + 1, normalized.node);
+                continue;
+            }
+        }
+        // #4539
+        if (codegenNode
+            && 'props' in codegenNode
+            && codegenNode.props
+            && 'properties' in codegenNode.props) {
+            for (const p of codegenNode.props.properties) {
+                if (p.key.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                    && p.key.content === 'key'
+                    && !p.key.isHandlerKey
+                    && !p.key.loc.source
+                    && p.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                    && p.value.constType === CompilerDOM.ConstantTypes.NOT_CONSTANT) {
+                    const contentBeforeValue = root.loc.source.slice(0, p.value.loc.start.offset);
+                    const argOffset = contentBeforeValue.lastIndexOf('key');
+                    props.push({
+                        type: CompilerDOM.NodeTypes.DIRECTIVE,
+                        name: 'bind',
+                        exp: p.value,
+                        loc: p.loc,
+                        arg: {
+                            ...p.key,
+                            loc: {
+                                start: { line: -1, column: -1, offset: argOffset },
+                                end: { line: -1, column: -1, offset: argOffset + 'key'.length },
+                                source: 'key',
+                            },
+                        },
+                        modifiers: [],
+                    });
+                    break;
+                }
+            }
+        }
+    }
+}
+function normalizeIfBranch(ifNode, children, start) {
+    let end = start;
+    let comments = [];
+    for (let i = start + 1; i < children.length; i++) {
+        const sibling = children[i];
+        if (sibling.type === CompilerDOM.NodeTypes.COMMENT) {
+            comments.push(sibling);
+            continue;
+        }
+        if (sibling.type === CompilerDOM.NodeTypes.TEXT && !sibling.content.trim()) {
+            continue;
+        }
+        const elseBranch = getVElseDirective(sibling);
+        if (elseBranch) {
+            const branchNode = {
+                ...elseBranch.element,
+                props: elseBranch.element.props.filter(prop => prop !== elseBranch.directive),
+            };
+            const branch = createIfBranch(branchNode, elseBranch.directive);
+            if (comments.length) {
+                branch.children = [...comments, ...branch.children];
+            }
+            ifNode.branches.push(branch);
+            comments = [];
+            end = i;
+            continue;
+        }
+        break;
+    }
+    return { node: ifNode, end };
+}
+// source: https://github.com/vuejs/core/blob/25ebe3a42cd80ac0256355c2740a0258cdd7419d/packages/compiler-core/src/transforms/vIf.ts#L207
+function createIfBranch(node, dir) {
+    const isTemplateIf = node.tagType === CompilerDOM.ElementTypes.TEMPLATE;
+    return {
+        type: CompilerDOM.NodeTypes.IF_BRANCH,
+        loc: node.loc,
+        condition: dir.name === 'else' ? undefined : dir.exp,
+        children: isTemplateIf && !CompilerDOM.findDir(node, 'for') ? node.children : [node],
+        userKey: CompilerDOM.findProp(node, 'key'),
+        isTemplateIf,
+    };
+}
+function getVElseDirective(node) {
+    if (node.type !== CompilerDOM.NodeTypes.ELEMENT) {
+        return;
+    }
+    const directive = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && (prop.name === 'else-if' || prop.name === 'else'));
+    if (directive) {
+        return {
+            element: node,
+            directive,
+        };
+    }
+}
+function getVForNode(node, transformContext) {
+    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'for');
+    if (forDirective) {
+        let forNode;
+        CompilerDOM.processFor(node, forDirective, transformContext, _forNode => {
+            forNode = { ..._forNode };
+            return undefined;
+        });
+        if (forNode) {
+            forNode.children = [{
+                    ...node,
+                    props: node.props.filter(prop => prop !== forDirective),
+                }];
+            return forNode;
+        }
+    }
+}
+function getVIfNode(node, transformContext) {
+    const ifDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'if');
+    if (ifDirective) {
+        let ifNode;
+        CompilerDOM.processIf(node, ifDirective, transformContext, _ifNode => {
+            ifNode = { ..._ifNode };
+            return undefined;
+        });
+        if (ifNode) {
+            for (const branch of ifNode.branches) {
+                branch.children = [{
+                        ...node,
+                        props: node.props.filter(prop => prop !== ifDirective),
+                    }];
+            }
+            return ifNode;
+        }
+    }
+}
+//# sourceMappingURL=normalize.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.1.5",
+	"version": "3.1.6",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,7 +13,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.23",
+		"@volar/language-core": "2.4.26",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/shared": "^3.5.0",
 		"alien-signals": "^3.0.0",
@@ -25,7 +25,7 @@
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
 		"@types/picomatch": "^4.0.0",
-		"@volar/typescript": "2.4.23",
+		"@volar/typescript": "2.4.26",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
 	"peerDependencies": {
@@ -36,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "d124a88fbf169e793c39ae4248da2092098de92d"
+	"gitHead": "341c06897f7f46606dddb8dd6d9e74e9c7844f02"
 }

package/lib/codegen/style/classProperty.d.ts

@@ -1,2 +0,0 @@
-import type { Code } from '../../types';
-export declare function generateClassProperty(styleIndex: number, classNameWithDot: string, offset: number, propertyType: string): Generator<Code>;

package/lib/codegen/style/classProperty.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateClassProperty = generateClassProperty;
-const codeFeatures_1 = require("../codeFeatures");
-const utils_1 = require("../utils");
-const wrapWith_1 = require("../utils/wrapWith");
-function* generateClassProperty(styleIndex, classNameWithDot, offset, propertyType) {
-    yield `${utils_1.newLine} & { `;
-    yield* (0, wrapWith_1.wrapWith)('style_' + styleIndex, offset, offset + classNameWithDot.length, codeFeatures_1.codeFeatures.navigation, `'`, [
-        classNameWithDot.slice(1),
-        'style_' + styleIndex,
-        offset + 1,
-        utils_1.combineLastMapping,
-    ], `'`);
-    yield `: ${propertyType}`;
-    yield ` }`;
-}
-//# sourceMappingURL=classProperty.js.map

package/lib/codegen/style/imports.d.ts

@@ -1,2 +0,0 @@
-import type { Code, Sfc } from '../../types';
-export declare function generateStyleImports(style: Sfc['styles'][number]): Generator<Code>;

package/lib/codegen/style/imports.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStyleImports = generateStyleImports;
-const utils_1 = require("../utils");
-const wrapWith_1 = require("../utils/wrapWith");
-function* generateStyleImports(style) {
-    const features = {
-        navigation: true,
-        verification: true,
-    };
-    if (typeof style.src === 'object') {
-        yield `${utils_1.newLine} & typeof import(`;
-        yield* (0, wrapWith_1.wrapWith)('main', style.src.offset, style.src.offset + style.src.text.length, features, `'`, [style.src.text, 'main', style.src.offset, utils_1.combineLastMapping], `'`);
-        yield `).default`;
-    }
-    for (const { text, offset } of style.imports) {
-        yield `${utils_1.newLine} & typeof import('`;
-        yield [
-            text,
-            style.name,
-            offset,
-            features,
-        ];
-        yield `').default`;
-    }
-}
-//# sourceMappingURL=imports.js.map

package/lib/codegen/template/elementChildren.d.ts

@@ -1,5 +0,0 @@
-import type * as CompilerDOM from '@vue/compiler-dom';
-import type { Code } from '../../types';
-import type { TemplateCodegenContext } from './context';
-import type { TemplateCodegenOptions } from './index';
-export declare function generateElementChildren(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, children: (CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode)[], enterNode?: boolean): Generator<Code>;

package/lib/codegen/template/elementChildren.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateElementChildren = generateElementChildren;
-const templateChild_1 = require("./templateChild");
-function* generateElementChildren(options, ctx, children, enterNode = true) {
-    yield* ctx.generateAutoImportCompletion();
-    for (const childNode of children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, enterNode);
-    }
-    yield* ctx.generateAutoImportCompletion();
-}
-//# sourceMappingURL=elementChildren.js.map

package/lib/codegen/utils/wrapWith.d.ts

@@ -1,2 +0,0 @@
-import type { Code, VueCodeInformation } from '../../types';
-export declare function wrapWith(source: string, startOffset: number, endOffset: number, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;

package/lib/codegen/utils/wrapWith.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapWith = wrapWith;
-function* wrapWith(source, startOffset, endOffset, features, ...codes) {
-    yield ['', source, startOffset, features];
-    let offset = 1;
-    for (const code of codes) {
-        if (typeof code !== 'string') {
-            offset++;
-        }
-        yield code;
-    }
-    yield ['', source, endOffset, { __combineOffset: offset }];
-}
-//# sourceMappingURL=wrapWith.js.map

package/lib/virtualFile/computedEmbeddedCodes.d.ts

@@ -1,4 +0,0 @@
-import type { VirtualCode } from '@volar/language-core';
-import type { Sfc, VueLanguagePluginReturn } from '../types';
-export declare function computedEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): () => VirtualCode[];
-export declare function resolveCommonLanguageId(lang: string): string;

package/lib/virtualFile/computedEmbeddedCodes.js

@@ -1,262 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computedEmbeddedCodes = computedEmbeddedCodes;
-exports.resolveCommonLanguageId = resolveCommonLanguageId;
-const alien_signals_1 = require("alien-signals");
-const muggle_string_1 = require("muggle-string");
-const buildMappings_1 = require("../utils/buildMappings");
-const embeddedFile_1 = require("./embeddedFile");
-function computedEmbeddedCodes(plugins, fileName, sfc) {
-    const getNameToBlockMap = (0, alien_signals_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 getPluginsResult = plugins.map(plugin => computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, name => getNameToBlockMap()[name]));
-    const getFlatResult = (0, alien_signals_1.computed)(() => getPluginsResult.map(r => r()).flat());
-    const getStructuredResult = (0, alien_signals_1.computed)(() => {
-        const embeddedCodes = [];
-        let remain = [...getFlatResult()];
-        while (remain.length) {
-            const beforeLength = remain.length;
-            consumeRemain();
-            if (beforeLength === remain.length) {
-                break;
-            }
-        }
-        for (const { code } of remain) {
-            console.error('Unable to resolve embedded: ' + code.parentCodeId + ' -> ' + code.id);
-        }
-        return embeddedCodes;
-        function consumeRemain() {
-            for (let i = remain.length - 1; i >= 0; i--) {
-                const { code, snapshot, mappings } = remain[i];
-                if (!code.parentCodeId) {
-                    embeddedCodes.push({
-                        id: code.id,
-                        languageId: resolveCommonLanguageId(code.lang),
-                        linkedCodeMappings: code.linkedCodeMappings,
-                        snapshot,
-                        mappings,
-                        embeddedCodes: [],
-                    });
-                    remain.splice(i, 1);
-                }
-                else {
-                    const parent = findParentStructure(code.parentCodeId, embeddedCodes);
-                    if (parent) {
-                        parent.embeddedCodes ??= [];
-                        parent.embeddedCodes.push({
-                            id: code.id,
-                            languageId: resolveCommonLanguageId(code.lang),
-                            linkedCodeMappings: code.linkedCodeMappings,
-                            snapshot,
-                            mappings,
-                            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 getStructuredResult;
-}
-function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByName) {
-    const computeds = new Map();
-    const getComputedKey = (code) => code.id + '__' + code.lang;
-    const getCodes = (0, alien_signals_1.computed)(() => {
-        try {
-            if (!plugin.getEmbeddedCodes) {
-                return [...computeds.values()];
-            }
-            const embeddedCodeInfos = plugin.getEmbeddedCodes(fileName, sfc);
-            for (const oldId of computeds.keys()) {
-                if (!embeddedCodeInfos.some(code => getComputedKey(code) === oldId)) {
-                    computeds.delete(oldId);
-                }
-            }
-            for (const codeInfo of embeddedCodeInfos) {
-                if (!computeds.has(getComputedKey(codeInfo))) {
-                    computeds.set(getComputedKey(codeInfo), (0, alien_signals_1.computed)(() => {
-                        const content = [];
-                        const code = new embeddedFile_1.VueEmbeddedCode(codeInfo.id, codeInfo.lang, content);
-                        for (const plugin of plugins) {
-                            if (!plugin.resolveEmbeddedCode) {
-                                continue;
-                            }
-                            try {
-                                plugin.resolveEmbeddedCode(fileName, sfc, code);
-                            }
-                            catch (e) {
-                                console.error(e);
-                            }
-                        }
-                        const newText = (0, muggle_string_1.toString)(code.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 {
-                            code,
-                            snapshot,
-                        };
-                    }));
-                }
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-        return [...computeds.values()];
-    });
-    return (0, alien_signals_1.computed)(() => {
-        return getCodes().map(_file => {
-            const { code, snapshot } = _file();
-            const mappings = (0, buildMappings_1.buildMappings)(code.content.map(segment => {
-                if (typeof segment === 'string') {
-                    return segment;
-                }
-                const source = segment[1];
-                if (source === undefined) {
-                    return segment;
-                }
-                const block = getBlockByName(source);
-                if (!block) {
-                    // console.warn('Unable to find block: ' + source);
-                    return segment;
-                }
-                return [
-                    segment[0],
-                    undefined,
-                    segment[2] + block.startTagEnd,
-                    segment[3],
-                ];
-            }));
-            const newMappings = [];
-            const tokenMappings = new Map();
-            for (let i = 0; i < mappings.length; i++) {
-                const mapping = mappings[i];
-                if (mapping.data.__combineOffset !== undefined) {
-                    const offsetMapping = mappings[i - mapping.data.__combineOffset];
-                    if (typeof offsetMapping === 'string' || !offsetMapping) {
-                        throw new Error('Invalid offset mapping, mappings: ' + mappings.length + ', i: ' + i + ', offset: '
-                            + mapping.data.__combineOffset);
-                    }
-                    offsetMapping.sourceOffsets.push(...mapping.sourceOffsets);
-                    offsetMapping.generatedOffsets.push(...mapping.generatedOffsets);
-                    offsetMapping.lengths.push(...mapping.lengths);
-                    continue;
-                }
-                if (mapping.data.__linkedToken !== undefined) {
-                    const token = mapping.data.__linkedToken;
-                    if (tokenMappings.has(token)) {
-                        const prevMapping = tokenMappings.get(token);
-                        code.linkedCodeMappings.push({
-                            sourceOffsets: [prevMapping.generatedOffsets[0]],
-                            generatedOffsets: [mapping.generatedOffsets[0]],
-                            lengths: [Number(token.description)],
-                            data: undefined,
-                        });
-                    }
-                    else {
-                        tokenMappings.set(token, mapping);
-                    }
-                    continue;
-                }
-                newMappings.push(mapping);
-            }
-            return {
-                code,
-                snapshot,
-                mappings: newMappings,
-            };
-        });
-    });
-}
-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,
-            };
-        }
-    }
-}
-function resolveCommonLanguageId(lang) {
-    switch (lang) {
-        case 'js':
-            return 'javascript';
-        case 'cjs':
-            return 'javascript';
-        case 'mjs':
-            return 'javascript';
-        case 'ts':
-            return 'typescript';
-        case 'cts':
-            return 'typescript';
-        case 'mts':
-            return 'typescript';
-        case 'jsx':
-            return 'javascriptreact';
-        case 'tsx':
-            return 'typescriptreact';
-        case 'pug':
-            return 'jade';
-        case 'md':
-            return 'markdown';
-    }
-    return lang;
-}
-//# sourceMappingURL=computedEmbeddedCodes.js.map

package/lib/virtualFile/computedSfc.d.ts

@@ -1,6 +0,0 @@
-import * as CompilerDOM from '@vue/compiler-dom';
-import type { SFCParseResult } from '@vue/compiler-sfc';
-import type * as ts from 'typescript';
-import type { Sfc, VueLanguagePluginReturn } from '../types';
-export declare const templateInlineTsAsts: WeakMap<CompilerDOM.RootNode, Map<string, ts.SourceFile>>;
-export declare function computedSfc(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, getSnapshot: () => ts.IScriptSnapshot, getParseResult: () => SFCParseResult | undefined): Sfc;

package/lib/virtualFile/computedVueSfc.d.ts

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

package/lib/virtualFile/computedVueSfc.js

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

package/lib/virtualFile/embeddedFile.d.ts

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

package/lib/virtualFile/embeddedFile.js

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