@vue/language-core 3.1.8 → 3.2.1

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/computedSfc.js

@@ -1,340 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.templateInlineTsAsts = void 0;
-exports.computedSfc = computedSfc;
-const CompilerDOM = require("@vue/compiler-dom");
-const alien_signals_1 = require("alien-signals");
-const signals_1 = require("../utils/signals");
-exports.templateInlineTsAsts = new WeakMap();
-function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
-    const getUntrackedSnapshot = () => {
-        const pausedSub = (0, alien_signals_1.setActiveSub)(undefined);
-        const res = getSnapshot();
-        (0, alien_signals_1.setActiveSub)(pausedSub);
-        return res;
-    };
-    const getContent = (0, alien_signals_1.computed)(() => {
-        return getSnapshot().getText(0, getSnapshot().getLength());
-    });
-    const getComments = (0, alien_signals_1.computed)(oldValue => {
-        const newValue = getParseResult()?.descriptor.comments ?? [];
-        if (oldValue?.length === newValue.length
-            && oldValue.every((v, i) => v === newValue[i])) {
-            return oldValue;
-        }
-        return newValue;
-    });
-    const getTemplate = computedNullableSfcBlock('template', 'html', (0, alien_signals_1.computed)(() => getParseResult()?.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 getScript = computedNullableSfcBlock('script', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.script ?? undefined), (block, base) => {
-        const getSrc = computedAttrValue('__src', base, block);
-        const getAst = (0, alien_signals_1.computed)(() => {
-            for (const plugin of plugins) {
-                const ast = plugin.compileSFCScript?.(base.lang, base.content);
-                if (ast) {
-                    return ast;
-                }
-            }
-            return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
-        });
-        return mergeObject(base, {
-            get src() {
-                return getSrc();
-            },
-            get ast() {
-                return getAst();
-            },
-        });
-    });
-    const getOriginalScriptSetup = computedNullableSfcBlock('scriptSetup', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.scriptSetup ?? undefined), (block, base) => {
-        const getGeneric = computedAttrValue('__generic', base, block);
-        const getAst = (0, alien_signals_1.computed)(() => {
-            for (const plugin of plugins) {
-                const ast = plugin.compileSFCScript?.(base.lang, base.content);
-                if (ast) {
-                    return ast;
-                }
-            }
-            return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
-        });
-        return mergeObject(base, {
-            get generic() {
-                return getGeneric();
-            },
-            get ast() {
-                return getAst();
-            },
-        });
-    });
-    const hasScript = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.script);
-    const hasScriptSetup = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.scriptSetup);
-    const getScriptSetup = (0, alien_signals_1.computed)(() => {
-        if (!hasScript() && !hasScriptSetup()) {
-            // #region monkey fix: https://github.com/vuejs/language-tools/pull/2113
-            return {
-                content: '',
-                lang: 'ts',
-                name: '',
-                start: 0,
-                end: 0,
-                startTagEnd: 0,
-                endTagStart: 0,
-                generic: undefined,
-                genericOffset: 0,
-                attrs: {},
-                ast: ts.createSourceFile('', '', 99, false, ts.ScriptKind.TS),
-            };
-        }
-        return getOriginalScriptSetup();
-    });
-    const styles = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.styles ?? []), (getBlock, i) => {
-        const base = computedSfcBlock('style_' + i, 'css', getBlock);
-        const getSrc = computedAttrValue('__src', base, getBlock);
-        const getModule = computedAttrValue('__module', base, getBlock);
-        const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
-        const getIr = (0, alien_signals_1.computed)(() => {
-            for (const plugin of plugins) {
-                const ast = plugin.compileSFCStyle?.(base.lang, base.content);
-                if (ast) {
-                    return ast;
-                }
-            }
-        });
-        const getImports = (0, signals_1.computedItems)(() => getIr()?.imports ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
-        const getBindings = (0, signals_1.computedItems)(() => getIr()?.bindings ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
-        const getClassNames = (0, signals_1.computedItems)(() => getIr()?.classNames ?? [], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
-        return () => mergeObject(base, {
-            get src() {
-                return getSrc();
-            },
-            get module() {
-                return getModule();
-            },
-            get scoped() {
-                return getScoped();
-            },
-            get imports() {
-                return getImports();
-            },
-            get bindings() {
-                return getBindings();
-            },
-            get classNames() {
-                return getClassNames();
-            },
-        });
-    });
-    const customBlocks = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.customBlocks ?? []), (getBlock, i) => {
-        const base = computedSfcBlock('custom_block_' + i, 'txt', getBlock);
-        const getType = (0, alien_signals_1.computed)(() => getBlock().type);
-        return () => mergeObject(base, {
-            get type() {
-                return getType();
-            },
-        });
-    });
-    return {
-        get content() {
-            return getContent();
-        },
-        get comments() {
-            return getComments();
-        },
-        get template() {
-            return getTemplate();
-        },
-        get script() {
-            return getScript();
-        },
-        get scriptSetup() {
-            return getScriptSetup();
-        },
-        get styles() {
-            return styles;
-        },
-        get customBlocks() {
-            return customBlocks;
-        },
-    };
-    function computedTemplateAst(base) {
-        let cache;
-        let inlineTsAsts;
-        function updateInlineTsAsts(newAst, oldAst) {
-            let newTsAsts = exports.templateInlineTsAsts.get(newAst);
-            if (!newTsAsts) {
-                exports.templateInlineTsAsts.set(newAst, newTsAsts = new Map());
-            }
-            const oldTsAsts = oldAst && exports.templateInlineTsAsts.get(oldAst) || inlineTsAsts;
-            if (oldTsAsts) {
-                for (const [text, ast] of oldTsAsts) {
-                    if (!ast.__volar_used) {
-                        oldTsAsts.delete(text);
-                    }
-                    else {
-                        newTsAsts.set(text, ast);
-                        ast.__volar_used = false;
-                    }
-                }
-            }
-            inlineTsAsts = new Map(newTsAsts);
-        }
-        return (0, alien_signals_1.computed)(() => {
-            if (cache?.template === base.content) {
-                return {
-                    errors: [],
-                    warnings: [],
-                    ast: cache.result.ast,
-                };
-            }
-            // incremental update
-            if (cache?.plugin.updateSFCTemplate) {
-                const change = getUntrackedSnapshot().getChangeRange(cache.snapshot);
-                if (change) {
-                    const pausedSub = (0, alien_signals_1.setActiveSub)(undefined);
-                    const templateOffset = base.startTagEnd;
-                    (0, alien_signals_1.setActiveSub)(pausedSub);
-                    const newText = getUntrackedSnapshot().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) {
-                        updateInlineTsAsts(newResult.ast, cache.result.ast);
-                        cache.template = base.content;
-                        cache.snapshot = getUntrackedSnapshot();
-                        cache.result = newResult;
-                        return {
-                            errors: [],
-                            warnings: [],
-                            ast: newResult.ast,
-                        };
-                    }
-                }
-            }
-            const errors = [];
-            const warnings = [];
-            const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset();
-            let options = {
-                onError: err => errors.push(err),
-                onWarn: err => warnings.push(err),
-                expressionPlugins: ['typescript'],
-                nodeTransforms,
-                directiveTransforms,
-            };
-            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);
-                    if (result) {
-                        updateInlineTsAsts(result.ast, cache?.result.ast);
-                    }
-                }
-                catch (e) {
-                    const err = e;
-                    errors.push(err);
-                }
-                if (result || errors.length) {
-                    if (result && !errors.length && !warnings.length) {
-                        cache = {
-                            template: base.content,
-                            snapshot: getUntrackedSnapshot(),
-                            result: result,
-                            plugin,
-                        };
-                    }
-                    else {
-                        cache = undefined;
-                    }
-                    return {
-                        errors,
-                        warnings,
-                        ast: result?.ast,
-                    };
-                }
-            }
-            return {
-                errors,
-                warnings,
-                ast: undefined,
-            };
-        });
-    }
-    function computedNullableSfcBlock(name, defaultLang, getBlock, resolve) {
-        const hasBlock = (0, alien_signals_1.computed)(() => !!getBlock());
-        return (0, alien_signals_1.computed)(() => {
-            if (!hasBlock()) {
-                return;
-            }
-            const _block = (0, alien_signals_1.computed)(() => getBlock());
-            return resolve(_block, computedSfcBlock(name, defaultLang, _block));
-        });
-    }
-    function computedSfcBlock(name, defaultLang, getBlock) {
-        const getLang = (0, alien_signals_1.computed)(() => getBlock().lang ?? defaultLang);
-        const getAttrs = (0, alien_signals_1.computed)(() => getBlock().attrs); // TODO: computed it
-        const getContent = (0, alien_signals_1.computed)(() => getBlock().content);
-        const getStartTagEnd = (0, alien_signals_1.computed)(() => getBlock().loc.start.offset);
-        const getEndTagStart = (0, alien_signals_1.computed)(() => getBlock().loc.end.offset);
-        const getStart = (0, alien_signals_1.computed)(() => getUntrackedSnapshot().getText(0, getStartTagEnd()).lastIndexOf('<' + getBlock().type));
-        const getEnd = (0, alien_signals_1.computed)(() => getEndTagStart()
-            + getUntrackedSnapshot().getText(getEndTagStart(), getUntrackedSnapshot().getLength()).indexOf('>') + 1);
-        return {
-            name,
-            get lang() {
-                return getLang();
-            },
-            get attrs() {
-                return getAttrs();
-            },
-            get content() {
-                return getContent();
-            },
-            get startTagEnd() {
-                return getStartTagEnd();
-            },
-            get endTagStart() {
-                return getEndTagStart();
-            },
-            get start() {
-                return getStart();
-            },
-            get end() {
-                return getEnd();
-            },
-        };
-    }
-    function computedAttrValue(key, base, getBlock) {
-        return (0, alien_signals_1.computed)(() => {
-            const val = getBlock()[key];
-            if (typeof val === 'object') {
-                return {
-                    ...val,
-                    offset: base.start + val.offset,
-                };
-            }
-            return val;
-        });
-    }
-}
-function mergeObject(a, b) {
-    return Object.defineProperties(a, Object.getOwnPropertyDescriptors(b));
-}
-//# sourceMappingURL=computedSfc.js.map