@vue/language-core 3.2.8 → 3.3.0

package/lib/types.d.ts

@@ -16,6 +16,7 @@ export type RawPlugin = string | (Record<string, any> & {
 });
 export interface VueCodeInformation extends CodeInformation {
     __importCompletion?: boolean;
+    __propsCompletion?: boolean;
     __shorthandExpression?: 'html' | 'js';
     __combineToken?: symbol;
     __linkedToken?: symbol;
@@ -43,6 +44,7 @@ export interface VueCompilerOptions {
     inferTemplateDollarSlots: boolean;
     skipTemplateCodegen: boolean;
     fallthroughAttributes: boolean;
+    checkRequiredFallthroughAttributes: boolean;
     resolveStyleImports: boolean;
     resolveStyleClassNames: boolean | 'scoped';
     fallthroughComponentNames: string[];
@@ -85,28 +87,42 @@ export interface VueLanguagePluginReturn {
     resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
     compileSFCScript?(lang: string, script: string): ts.SourceFile | undefined;
     compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
-    compileSFCStyle?(lang: string, style: string): Pick<Sfc['styles'][number], 'imports' | 'bindings' | 'classNames'> | undefined;
+    compileSFCStyle?(lang: string, style: string): Pick<IRStyle, 'imports' | 'bindings' | 'classNames'> | undefined;
     updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
         start: number;
         end: number;
         newText: string;
     }): CompilerDOM.CodegenResult | undefined;
-    getEmbeddedCodes?(fileName: string, sfc: Sfc): {
+    getEmbeddedCodes?(fileName: string, ir: IR): {
         id: string;
         lang: string;
     }[];
-    resolveEmbeddedCode?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedCode): void;
+    resolveEmbeddedCode?(fileName: string, ir: IR, embeddedFile: VueEmbeddedCode): void;
 }
 export type VueLanguagePlugin<T extends Record<string, any> = {}> = (ctx: {
     modules: {
         typescript: typeof ts;
         '@vue/compiler-dom': typeof CompilerDOM;
+        '@vue/language-core': typeof import('../index');
     };
     compilerOptions: ts.CompilerOptions;
     vueCompilerOptions: VueCompilerOptions;
     config: T;
 }) => VueLanguagePluginReturn | VueLanguagePluginReturn[];
-export interface SfcBlock {
+export interface IR {
+    content: string;
+    comments: string[];
+    template: IRTemplate | undefined;
+    script: IRScript | undefined;
+    scriptSetup: IRScriptSetup | undefined;
+    styles: readonly IRStyle[];
+    customBlocks: readonly IRCustomBlock[];
+}
+export type IRAttr = true | {
+    text: string;
+    offset: number;
+};
+export interface IRBlock {
     name: string;
     start: number;
     end: number;
@@ -116,57 +132,48 @@ export interface SfcBlock {
     content: string;
     attrs: Record<string, string | true>;
 }
-export type SfcBlockAttr = true | {
-    text: string;
-    offset: number;
-    quotes: boolean;
-};
-export interface Sfc {
-    content: string;
-    comments: string[];
-    template: (SfcBlock & {
-        ast: CompilerDOM.RootNode | undefined;
-        errors: CompilerDOM.CompilerError[];
-        warnings: CompilerDOM.CompilerError[];
-    }) | undefined;
-    script: (SfcBlock & {
-        src: SfcBlockAttr | undefined;
-        ast: ts.SourceFile;
-    }) | undefined;
-    scriptSetup: (SfcBlock & {
-        generic: SfcBlockAttr | undefined;
-        ast: ts.SourceFile;
-    }) | undefined;
-    styles: readonly (SfcBlock & {
-        src: SfcBlockAttr | undefined;
-        module: SfcBlockAttr | undefined;
-        scoped: boolean;
-        imports: {
-            text: string;
-            offset: number;
-        }[];
-        bindings: {
-            text: string;
-            offset: number;
-        }[];
-        classNames: {
-            text: string;
-            offset: number;
-        }[];
-    })[];
-    customBlocks: readonly (SfcBlock & {
-        type: string;
-    })[];
+export interface IRTemplate extends IRBlock {
+    ast: CompilerDOM.RootNode | undefined;
+    errors: CompilerDOM.CompilerError[];
+    warnings: CompilerDOM.CompilerError[];
+}
+export interface IRScript extends IRBlock {
+    src: IRAttr | undefined;
+    ast: ts.SourceFile;
+}
+export interface IRScriptSetup extends IRBlock {
+    generic: IRAttr | undefined;
+    ast: ts.SourceFile;
+}
+export interface IRStyle extends IRBlock {
+    src: IRAttr | undefined;
+    module: IRAttr | undefined;
+    scoped: boolean;
+    imports: {
+        text: string;
+        offset: number;
+    }[];
+    bindings: {
+        text: string;
+        offset: number;
+    }[];
+    classNames: {
+        text: string;
+        offset: number;
+    }[];
+}
+export interface IRCustomBlock extends IRBlock {
+    type: string;
 }
 declare module '@vue/compiler-sfc' {
     interface SFCBlock {
-        __src?: SfcBlockAttr;
+        __src?: IRAttr;
     }
     interface SFCScriptBlock {
-        __generic?: SfcBlockAttr;
+        __generic?: IRAttr;
     }
     interface SFCStyleBlock {
-        __module?: SfcBlockAttr;
+        __module?: IRAttr;
     }
 }
 export interface TextRange<Node extends ts.Node = ts.Node> {

package/lib/utils/forEachTemplateNode.js

@@ -72,9 +72,6 @@ function* forEachInterpolationNode(node) {
             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') {

package/lib/utils/parseSfc.js

@@ -179,7 +179,6 @@ function parseAttr(p, node) {
     return {
         text: content,
         offset: offset - node.loc.start.offset,
-        quotes: offset > p.value.loc.start.offset,
     };
 }
 //# sourceMappingURL=parseSfc.js.map

package/lib/utils/shared.d.ts

@@ -1,9 +1,9 @@
 import type * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Sfc, TextRange } from '../types';
+import type { IRTemplate, 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 getElementTagOffsets(node: CompilerDOM.ElementNode, template: IRTemplate): [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;

package/lib/virtualCode/embeddedCodes.d.ts

@@ -1,5 +1,5 @@
 import type { Mapping, VirtualCode } from '@volar/language-core';
-import type { Code, Sfc, VueLanguagePluginReturn } from '../types';
+import type { Code, IR, VueLanguagePluginReturn } from '../types';
 export declare class VueEmbeddedCode {
     id: string;
     lang: string;
@@ -9,4 +9,4 @@ export declare class VueEmbeddedCode {
     embeddedCodes: VueEmbeddedCode[];
     constructor(id: string, lang: string, content: Code[]);
 }
-export declare function useEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): () => VirtualCode[];
+export declare function useEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, ir: IR): () => VirtualCode[];

package/lib/virtualCode/embeddedCodes.js

@@ -15,22 +15,22 @@ class VueEmbeddedCode {
     }
 }
 exports.VueEmbeddedCode = VueEmbeddedCode;
-function useEmbeddedCodes(plugins, fileName, sfc) {
+function useEmbeddedCodes(plugins, fileName, ir) {
     const getNameToBlockMap = (0, alien_signals_1.computed)(() => {
         const blocks = {};
-        if (sfc.template) {
-            blocks[sfc.template.name] = sfc.template;
+        if (ir.template) {
+            blocks[ir.template.name] = ir.template;
         }
-        if (sfc.script) {
-            blocks[sfc.script.name] = sfc.script;
+        if (ir.script) {
+            blocks[ir.script.name] = ir.script;
         }
-        if (sfc.scriptSetup) {
-            blocks[sfc.scriptSetup.name] = sfc.scriptSetup;
+        if (ir.scriptSetup) {
+            blocks[ir.scriptSetup.name] = ir.scriptSetup;
         }
-        for (const block of sfc.styles) {
+        for (const block of ir.styles) {
             blocks[block.name] = block;
         }
-        for (const block of sfc.customBlocks) {
+        for (const block of ir.customBlocks) {
             blocks[block.name] = block;
         }
         return blocks;
@@ -75,7 +75,7 @@ function useEmbeddedCodes(plugins, fileName, sfc) {
             if (!plugin.getEmbeddedCodes) {
                 return new Map();
             }
-            const newCodeList = plugin.getEmbeddedCodes(fileName, sfc);
+            const newCodeList = plugin.getEmbeddedCodes(fileName, ir);
             const map = new Map();
             for (const { id, lang } of newCodeList) {
                 const key = id + '__' + lang;
@@ -110,7 +110,7 @@ function useEmbeddedCodes(plugins, fileName, sfc) {
                     continue;
                 }
                 try {
-                    plugin.resolveEmbeddedCode(fileName, sfc, code);
+                    plugin.resolveEmbeddedCode(fileName, ir, code);
                 }
                 catch (e) {
                     console.error(e);

package/lib/virtualCode/index.d.ts

@@ -1,7 +1,7 @@
 import type { CodeMapping, VirtualCode } from '@volar/language-core';
 import type { SFCParseResult } from '@vue/compiler-sfc';
 import type * as ts from 'typescript';
-import type { Sfc, VueCompilerOptions, VueLanguagePluginReturn } from '../types';
+import type { IR, VueCompilerOptions, VueLanguagePluginReturn } from '../types';
 export declare class VueVirtualCode implements VirtualCode {
     fileName: string;
     languageId: string;
@@ -15,7 +15,9 @@ export declare class VueVirtualCode implements VirtualCode {
     private _mappings;
     get snapshot(): ts.IScriptSnapshot;
     get vueSfc(): SFCParseResult | undefined;
-    get sfc(): Sfc;
+    get ir(): IR;
+    /** @deprecated use `ir` instead */
+    get sfc(): IR;
     get embeddedCodes(): VirtualCode[];
     get mappings(): CodeMapping[];
     constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: VueLanguagePluginReturn[], ts: typeof import('typescript'));

package/lib/virtualCode/index.js

@@ -12,6 +12,10 @@ class VueVirtualCode {
     get vueSfc() {
         return this._parsedSfcResult()?.result;
     }
+    get ir() {
+        return this._ir;
+    }
+    /** @deprecated use `ir` instead */
     get sfc() {
         return this._ir;
     }

package/lib/virtualCode/ir.d.ts

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

package/lib/virtualCode/ir.js

@@ -1,43 +1,8 @@
 "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.useIR = useIR;
-const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const alien_signals_1 = require("alien-signals");
 const signals_1 = require("../utils/signals");
-const normalize_1 = require("./normalize");
 function useIR(ts, plugins, fileName, getSnapshot, getParseSfcResult) {
     const getUntrackedSnapshot = () => {
         const pausedSub = (0, alien_signals_1.setActiveSub)(undefined);
@@ -229,13 +194,10 @@ function useIR(ts, plugins, fileName, getSnapshot, getParseSfcResult) {
             }
             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) {
@@ -246,7 +208,6 @@ function useIR(ts, plugins, fileName, getSnapshot, getParseSfcResult) {
                 try {
                     const result = plugin.compileSFCTemplate?.(base.lang, base.content, options);
                     if (result) {
-                        (0, normalize_1.normalizeTemplateAST)(result.ast);
                         return {
                             snapshot: getUntrackedSnapshot(),
                             template: base.content,

package/package.json

@@ -1,10 +1,13 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.2.8",
+	"version": "3.3.0",
 	"license": "MIT",
 	"files": [
-		"**/*.js",
-		"**/*.d.ts"
+		"index.d.ts",
+		"index.js",
+		"lib/**/*.d.ts",
+		"lib/**/*.js",
+		"types"
 	],
 	"sideEffects": false,
 	"repository": {
@@ -19,17 +22,17 @@
 		"@volar/language-core": "2.4.28",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/shared": "^3.5.0",
-		"alien-signals": "^3.1.2",
+		"alien-signals": "^3.2.0",
 		"muggle-string": "^0.4.1",
 		"path-browserify": "^1.0.1",
 		"picomatch": "^4.0.4"
 	},
 	"devDependencies": {
-		"@types/node": "^22.10.4",
+		"@types/node": "^24.1.0",
 		"@types/path-browserify": "^1.0.3",
 		"@types/picomatch": "^4.0.3",
 		"@volar/typescript": "2.4.28",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
-	"gitHead": "618bd6bfb19729726787df7b52fccda72c888c95"
+	"gitHead": "1088dce8ae6b937f7525fae4982e3b3ea99d3c64"
 }

package/types/template-helpers.d.ts

@@ -143,6 +143,7 @@ declare global {
 	function __VLS_asFunctionalElement0<T>(tag: T, endTag?: T): (attrs: T) => void;
 	function __VLS_asFunctionalElement1<T>(tag: T, endTag?: T): (attrs: T & Record<string, unknown>) => void;
 	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;
+	function __VLS_omit<T, K>(target: T, props: K): Omit<T, keyof K>;
 	function __VLS_tryAsConstant<const T>(t: T): T;
 }
 

package/lib/virtualCode/normalize.d.ts

@@ -1,2 +0,0 @@
-import * as CompilerDOM from '@vue/compiler-dom';
-export declare function normalizeTemplateAST(root: CompilerDOM.RootNode): void;

package/lib/virtualCode/normalize.js

@@ -1,205 +0,0 @@
-"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.normalizeTemplateAST = normalizeTemplateAST;
-const CompilerDOM = __importStar(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') && !CompilerDOM.findDir(node, 'slot')
-            ? 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/scripts/generate-names.js

@@ -1,41 +0,0 @@
-// @ts-check
-const { readFile, writeFile } = require('node:fs/promises');
-const { join } = require('node:path');
-
-generateNames();
-
-async function generateNames() {
-	const typePath = join(__dirname, '../types/template-helpers.d.ts');
-	const typeText = await readFile(typePath, 'utf-8');
-
-	/** @type {Set<string>} */
-	const pascalNames = new Set();
-	/** @type {Set<string>} */
-	const camelNames = new Set();
-
-	const declReg = /(?<=const\s+)\w*?(?=:)|(?<=type\s+)\w*?(?=\s*=|<)|(?<=function\s+)\w*?(?=\(|<)/g;
-	const prefix = '__VLS_';
-
-	for (const match of typeText.matchAll(declReg)) {
-		const name = match[0].slice(prefix.length);
-		if (name[0]?.toUpperCase() === name[0]) {
-			pascalNames.add(name);
-		}
-		else {
-			camelNames.add(name);
-		}
-	}
-
-	const namesPath = join(__dirname, '../lib/codegen/names.ts');
-	const namesText = await readFile(namesPath, 'utf-8');
-
-	await writeFile(
-		namesPath,
-		namesText.replace(
-			/(?<=\/\/ #region .*\n).*?(?=\t\/\/ #endregion)/ms,
-			[...camelNames].sort().map(name => `\t${name}: '',\n`).join('')
-				+ '\n'
-				+ [...pascalNames].sort().map(name => `\t${name}: '',\n`).join(''),
-		),
-	);
-}