knip 6.26.0 → 6.27.0

package/dist/ConfigurationChief.d.ts

@@ -757,6 +757,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        temporal?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1104,6 +1109,7 @@ export declare class ConfigurationChief {
         "tanstack-router"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         taskfile?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tauri?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        temporal?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "ts-node"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         tsdown?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -58,7 +58,7 @@ export declare class DependencyDeputy {
         isPeerOptional: boolean;
     }[];
     getOptionalPeerDependencies(workspaceName: string): DependencySet;
-    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, isDevOnly?: boolean, isTypeOnly?: boolean): boolean;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string, isDevOnly?: boolean, isTypeOnly?: boolean, isResolved?: boolean): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): Set<string> | undefined;
     private isInDependencies;
     settleDependencyIssues(): {

package/dist/DependencyDeputy.js

@@ -122,7 +122,7 @@ export class DependencyDeputy {
     getOptionalPeerDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.optionalPeerDependencies ?? new Set();
     }
-    maybeAddReferencedExternalDependency(workspace, packageName, isDevOnly, isTypeOnly) {
+    maybeAddReferencedExternalDependency(workspace, packageName, isDevOnly, isTypeOnly, isResolved) {
         if (!this.isReportDependencies)
             return true;
         if (isBuiltin(packageName))
@@ -150,7 +150,7 @@ export class DependencyDeputy {
             this.addReferencedDependency(workspace.name, packageName);
             return true;
         }
-        if (!this.isStrict) {
+        if (!this.isStrict && isResolved !== false) {
             for (const name of workspaceNames) {
                 const hosts = this.getHostDependenciesFor(name, packageName);
                 if (hosts.length === 0)

package/dist/ProjectPrincipal.d.ts

@@ -7,7 +7,7 @@ import type { Paths } from './types/project.ts';
 import type { ResolveGlobPattern } from './typescript/resolve-module-names.ts';
 import { SourceFileManager } from './typescript/SourceFileManager.ts';
 import type { MainOptions } from './util/create-options.ts';
-import type { ToSourceFilePath, WorkspaceManifestHandler } from './util/to-source-path.ts';
+import type { ToSourceFilePath, WorkspacePackageTargetHandler } from './util/to-source-path.ts';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
     projectPaths: Set<string>;
@@ -25,14 +25,14 @@ export declare class ProjectPrincipal {
     private extensions;
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
-    private findWorkspaceManifestImports;
+    private findWorkspacePackageTarget;
     fileManager: SourceFileManager;
     private resolveModule;
     resolveGlobPattern: ResolveGlobPattern;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
     private onPathAdded;
-    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
+    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspacePackageTarget?: WorkspacePackageTargetHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
     addPaths(paths: Paths, basePath: string, scope: string): void;
     addRootDirs(rootDirs: string[] | undefined, scope: string): void;

package/dist/ProjectPrincipal.js

@@ -35,17 +35,17 @@ export class ProjectPrincipal {
     extensions = new Set(DEFAULT_EXTENSIONS);
     cache;
     toSourceFilePath;
-    findWorkspaceManifestImports;
+    findWorkspacePackageTarget;
     fileManager;
     resolveModule = () => undefined;
     resolveGlobPattern = pattern => [pattern];
     resolvedFiles = new Set();
     deletedFiles = new Set();
     onPathAdded;
-    constructor(options, toSourceFilePath, findWorkspaceManifestImports) {
+    constructor(options, toSourceFilePath, findWorkspacePackageTarget) {
         this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
-        this.findWorkspaceManifestImports = findWorkspaceManifestImports;
+        this.findWorkspacePackageTarget = findWorkspacePackageTarget;
         this.tsConfigFile = options.tsConfigFile ? toAbsolute(options.tsConfigFile, options.cwd) : undefined;
         this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
         this.fileManager = new SourceFileManager({
@@ -91,7 +91,7 @@ export class ProjectPrincipal {
         const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
         const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
         const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
-        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports, this.tsConfigFile);
+        this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspacePackageTarget, this.tsConfigFile);
         this.resolveGlobPattern = createGlobAliasResolver(scopedPaths);
     }
     readFile(filePath) {

package/dist/binaries/fallback.js

@@ -7,7 +7,11 @@ const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode',
 const positionalBinaries = new Set(['concurrently']);
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, { boolean: ['quiet', 'verbose'], '--': endOfCommandBinaries.includes(binary) });
-    const bin = binary.startsWith('.') ? toEntry(binary) : isValidBinary(binary) ? toBinary(binary) : undefined;
+    const bin = binary.startsWith('.') || binary.includes('/')
+        ? toEntry(binary)
+        : isValidBinary(binary)
+            ? toBinary(binary)
+            : undefined;
     const pos = positionals.has(binary) ? [toDeferResolve(parsed._[0])] : [];
     const newCommand = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
     const commands = positionalBinaries.has(binary) ? parsed._.flatMap(cmd => fromArgs([cmd])) : [];

package/dist/binaries/resolvers/bun.js

@@ -2,6 +2,7 @@ import parseArgs from '../../util/parse-args.js';
 import { toBinary, toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';
+import { argsAfter, expandScript } from '../util.js';
 import { resolveX } from './bunx.js';
 const commands = new Set([
     'add',
@@ -59,10 +60,12 @@ export const resolve = (_binary, args, options) => {
         return [binary, ...resolveX(argsForX, options)];
     }
     const { manifest, cwd, fromArgs } = options;
-    if (command === 'run' && manifest.scriptNames.has(script))
-        return [binary];
-    if (manifest.scriptNames.has(command))
-        return [binary];
+    if (command === 'run' && manifest.scriptNames.has(script)) {
+        return [binary, ...(expandScript(script, argsAfter(args, script), manifest.scripts, options) ?? [])];
+    }
+    if (manifest.scriptNames.has(command)) {
+        return [binary, ...(expandScript(command, argsAfter(args, command), manifest.scripts, options) ?? [])];
+    }
     if (command !== 'run' && commands.has(command))
         return [binary];
     const filePath = command === 'run' ? script : command;
@@ -74,5 +77,10 @@ export const resolve = (_binary, args, options) => {
         return [binary, toEntry(resolved)];
     const dir = parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const opts = dir ? { cwd: dir } : {};
-    return command === 'run' ? [binary] : [binary, ...fromArgs(args, opts)];
+    if (command !== 'run')
+        return [binary, ...fromArgs(args, opts)];
+    const input = toBinary(filePath, { optional: true });
+    if (dir)
+        input.dir = dir;
+    return [binary, input];
 };

package/dist/binaries/resolvers/npm.js

@@ -1,4 +1,5 @@
 import parseArgs from '../../util/parse-args.js';
+import { expandScript } from '../util.js';
 export const resolve = (_binary, args, options) => {
     const { fromArgs, manifest } = options;
     const parsed = parseArgs(args, { '--': true });
@@ -6,7 +7,8 @@ export const resolve = (_binary, args, options) => {
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'exec')
         return _childArgs;
-    if (command === 'run' && manifest.scriptNames.has(script))
-        return _childArgs;
+    if (command === 'run' && manifest.scriptNames.has(script)) {
+        return expandScript(script, parsed['--'] ?? [], manifest.scripts, options) ?? _childArgs;
+    }
     return [];
 };

package/dist/binaries/resolvers/pnpm.js

@@ -1,6 +1,7 @@
 import parseArgs from '../../util/parse-args.js';
 import { toBinary } from '../../util/input.js';
 import { isValidBinary } from '../../util/modules.js';
+import { argsAfter, expandScript } from '../util.js';
 import { resolveDlx } from './pnpx.js';
 const commands = [
     'add',
@@ -98,8 +99,17 @@ export const resolve = (_binary, args, options) => {
     if (command === 'exec') {
         return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));
     }
+    if (command === 'run') {
+        const script = parsed._[1];
+        if (script && manifest.scriptNames.has(script)) {
+            return expandScript(script, argsAfter(args, script), manifest.scripts, options) ?? childInputs;
+        }
+        return childInputs;
+    }
     const isScript = manifest.scriptNames.has(command);
-    if (isScript || commands.includes(command))
+    if (isScript)
+        return expandScript(command, argsAfter(args, command), manifest.scripts, options) ?? childInputs;
+    if (commands.includes(command))
         return childInputs;
     return command && isValidBinary(command) ? [toBinary(command)] : [];
 };

package/dist/binaries/resolvers/yarn.js

@@ -2,7 +2,7 @@ import parseArgs from '../../util/parse-args.js';
 import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';
-import { argsFrom } from '../util.js';
+import { argsAfter, argsFrom, expandScript } from '../util.js';
 const commands = [
     'add',
     'bin',
@@ -58,8 +58,10 @@ export const resolve = (_binary, args, options) => {
     const dirManifest = (dir && getManifest(dir)) || manifest;
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
-        if (dirManifest.scriptNames.has(binary))
-            return _childArgs;
+        if (dirManifest.scriptNames.has(binary)) {
+            const opts = dir ? { cwd: dir, manifest: dirManifest } : {};
+            return expandScript(binary, argsAfter(args, binary), dirManifest.scripts, options, opts) ?? _childArgs;
+        }
         const bin = toBinary(binary, { optional: true });
         if (dir)
             Object.assign(bin, { dir });
@@ -71,7 +73,11 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    if (dirManifest.scriptNames.has(command) || commands.includes(command))
+    if (dirManifest.scriptNames.has(command)) {
+        const opts = dir ? { cwd: dir, manifest: dirManifest } : {};
+        return expandScript(command, argsAfter(args, command), dirManifest.scripts, options, opts) ?? _childArgs;
+    }
+    if (commands.includes(command))
         return _childArgs;
     const opts = dir ? { cwd: dir } : {};
     return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);

package/dist/binaries/util.d.ts

@@ -1,2 +1,6 @@
+import type { BinaryResolverOptions, GetInputsFromScriptsOptions } from '../types/config.ts';
+import type { Input } from '../util/input.ts';
 export declare const argsFrom: (args: string[], from: string) => string[];
+export declare const argsAfter: (args: string[], token: string) => string[];
+export declare const expandScript: (name: string, forwardedArgs: string[], scripts: Record<string, string> | undefined, options: BinaryResolverOptions, opts?: Partial<GetInputsFromScriptsOptions>) => Input[] | undefined;
 export declare const parseNodeArgs: (args: string[]) => import("../util/parse-args.ts").ParsedArgs;

package/dist/binaries/util.js

@@ -1,5 +1,19 @@
 import parseArgs from '../util/parse-args.js';
 export const argsFrom = (args, from) => args.slice(args.indexOf(from));
+export const argsAfter = (args, token) => {
+    const index = args.indexOf(token);
+    return index === -1 ? [] : args.slice(index + 1).filter(arg => arg !== '--');
+};
+export const expandScript = (name, forwardedArgs, scripts, options, opts = {}) => {
+    const source = scripts?.[name];
+    if (!source || forwardedArgs.length === 0)
+        return;
+    const expandedScripts = options.expandedScripts ?? new Set();
+    if (expandedScripts.has(name))
+        return;
+    expandedScripts.add(name);
+    return options.fromArgs([source, ...forwardedArgs], { ...opts, expandedScripts });
+};
 export const parseNodeArgs = (args) => parseArgs(args, {
     string: ['r'],
     alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },

package/dist/compilers/index.d.ts

@@ -703,6 +703,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    temporal?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     travis?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1609,6 +1614,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        temporal?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/less.js

@@ -1,6 +1,6 @@
 import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['less'];
-const importMatcher = /@import\s+(?:\([^)]*\)\s+)?(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
+const importMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@import\s+(?:\([^)]*\)\s+)?(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
 const isExternalUrl = (s) => s.startsWith('//') || s.startsWith('http://') || s.startsWith('https://');
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);

package/dist/compilers/scss.js

@@ -1,6 +1,6 @@
 import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['sass', 'sass-embedded', 'node-sass'];
-const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
+const importMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);
     const hasExt = name.endsWith('.scss') || name.endsWith('.sass');

package/dist/compilers/stylus.js

@@ -1,6 +1,6 @@
 import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['stylus'];
-const importMatcher = /@(?:import|require)\s+['"]([^'"]+)['"]/g;
+const importMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:import|require)\s+['"]([^'"]+)['"]/g;
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);
     if (name.endsWith('.styl') || name.endsWith('.stylus') || name.endsWith('.css'))

package/dist/constants.js

@@ -36,6 +36,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'chmod',
     'chown',
     'cksum',
+    'claude',
     'clear',
     'cmd',
     'cmd.exe',
@@ -77,6 +78,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'id',
     'join',
     'kill',
+    'launchctl',
     'ln',
     'logname',
     'ls',
@@ -102,6 +104,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'powershell.exe',
     'pr',
     'printenv',
+    'pulumi',
     'pwd',
     'python',
     'python3',
@@ -125,12 +128,15 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'stty',
     'sudo',
     'sync',
+    'systemctl',
     'tac',
     'tar',
     'tee',
     'test',
     'time',
     'timeout',
+    'tmux',
+    'tmuxinator',
     'touch',
     'trap',
     'tr',

package/dist/graph/analyze.js

@@ -193,7 +193,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     for (const extImport of file.imports.external) {
                         const packageName = getPackageNameFromModuleSpecifier(extImport.specifier);
                         const isHandled = packageName &&
-                            deputy.maybeAddReferencedExternalDependency(ws, packageName, undefined, extImport.isTypeOnly);
+                            deputy.maybeAddReferencedExternalDependency(ws, packageName, undefined, extImport.isTypeOnly, extImport.filePath !== undefined);
                         if (!isHandled)
                             collector.addIssue({
                                 type: 'unlisted',

package/dist/graph/build.js

@@ -18,6 +18,7 @@ import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpe
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join, relative } from '../util/path.js';
+import { extensionAlias } from '../util/resolve.js';
 import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
 export async function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options, }) {
@@ -331,10 +332,21 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     file.imports.external.add({ ...unresolvedImport, specifier: sanitizedSpecifier });
                 }
                 else {
-                    if (!isGitIgnored(join(dirname(filePath), sanitizedSpecifier))) {
-                        const ext = extname(sanitizedSpecifier);
-                        if (!ext || (ext !== '.json' && !FOREIGN_FILE_EXTENSIONS.has(ext)))
-                            unresolvedImports.add(unresolvedImport);
+                    const candidate = join(dirname(filePath), sanitizedSpecifier);
+                    const ext = extname(sanitizedSpecifier);
+                    const aliases = extensionAlias[ext];
+                    let isIgnored = isGitIgnored(candidate);
+                    if (!isIgnored && aliases) {
+                        const basePath = candidate.slice(0, -ext.length);
+                        for (const alias of aliases) {
+                            if (alias !== ext && isGitIgnored(basePath + alias)) {
+                                isIgnored = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (!isIgnored && (!ext || (ext !== '.json' && !FOREIGN_FILE_EXTENSIONS.has(ext)))) {
+                        unresolvedImports.add(unresolvedImport);
                     }
                 }
             }

package/dist/plugins/_vue/auto-import.js

@@ -9,7 +9,26 @@ import { _syncGlob } from '../../util/glob.js';
 import { dirname, isInNodeModules, join } from '../../util/path.js';
 const getVueSfc = (cwd) => {
     try {
-        return createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
+        const sfc = createRequire(join(cwd, 'package.json'))('vue/compiler-sfc');
+        if (typeof sfc.parseComponent === 'function') {
+            return {
+                parse: (source, path) => ({
+                    descriptor: sfc.parse({ source, filename: path, sourceMap: false }),
+                }),
+                compileTemplate: (source, path, isTS, preprocessLang) => sfc.compileTemplate({
+                    source,
+                    filename: path,
+                    sourceMap: false,
+                    isProduction: true,
+                    prettify: false,
+                    isTS,
+                    preprocessLang,
+                }),
+            };
+        }
+        return {
+            parse: (source, path) => sfc.parse(source, { filename: path, sourceMap: false }),
+        };
     }
     catch { }
     return {
@@ -40,11 +59,15 @@ const collectIdentifiers = (source, fileName) => {
 const collectTemplateInfo = (tree) => {
     const tags = new Set();
     const identifiers = new Set();
+    const visited = new Set();
     const addExprIdentifiers = (expr) => {
         for (const id of collectIdentifiers(expr, 'expr.ts'))
             identifiers.add(id);
     };
     const visit = (node) => {
+        if (visited.has(node))
+            return;
+        visited.add(node);
         if (node.tag)
             tags.add(node.tag);
         if (node.type === 5 && node.content && !node.content.isStatic)
@@ -62,10 +85,34 @@ const collectTemplateInfo = (tree) => {
         if (node.children)
             for (const child of node.children)
                 visit(child);
+        if (node.ifConditions)
+            for (const condition of node.ifConditions)
+                visit(condition.block);
+        if (node.scopedSlots)
+            for (const name in node.scopedSlots)
+                visit(node.scopedSlots[name]);
     };
     visit(tree);
     return { tags, identifiers };
 };
+const collectVue2TemplateIdentifiers = (source) => {
+    const identifiers = new Set();
+    const visitor = new Visitor({
+        MemberExpression(node) {
+            if (!node.computed &&
+                node.object.type === 'Identifier' &&
+                node.object.name === '_vm' &&
+                node.property.type === 'Identifier') {
+                const name = node.property.name;
+                if (name !== '_self' && name !== '$set' && name !== '$delete' && !(name.length === 2 && name[0] === '_')) {
+                    identifiers.add(name);
+                }
+            }
+        },
+    });
+    visitor.visit(_parseFile('template.js', source).program);
+    return identifiers;
+};
 const toKebabCase = (s) => s.replace(/[A-Z]/g, (m, i) => (i ? '-' : '') + m.toLowerCase());
 const isLocalSpecifier = (specifier) => specifier.startsWith('.') && !isInNodeModules(specifier);
 export const collectLocalImportPaths = (filePath, result) => {
@@ -182,20 +229,33 @@ const compileVueSfc = (source, path, maps, root) => {
     if (maps.importMap.size === 0 && maps.componentMap.size === 0) {
         return [scriptBodies(source, path), stylePreprocessorImports(source, path)].filter(Boolean).join(';\n');
     }
-    const { descriptor } = sfcForRoot(root).parse(source, path);
+    const sfc = sfcForRoot(root);
+    const { descriptor } = sfc.parse(source, path);
     const scripts = [];
     if (descriptor.script?.content)
         scripts.push(descriptor.script.content);
     if (descriptor.scriptSetup?.content)
         scripts.push(descriptor.scriptSetup.content);
     const identifiers = scripts.length === 0 ? new Set() : collectIdentifiers(scripts.join('\n'), path);
+    const template = descriptor.template;
+    const compiled = template && !template.ast && sfc.compileTemplate
+        ? sfc.compileTemplate(template.content, path, descriptor.script?.lang === 'ts' ||
+            descriptor.script?.lang === 'tsx' ||
+            descriptor.scriptSetup?.lang === 'ts' ||
+            descriptor.scriptSetup?.lang === 'tsx', template.lang)
+        : undefined;
     let templateTags;
-    if (descriptor.template?.ast) {
-        const info = collectTemplateInfo(descriptor.template.ast);
+    const templateAst = template?.ast ?? compiled?.ast;
+    if (templateAst) {
+        const info = collectTemplateInfo(templateAst);
         templateTags = info.tags;
         for (const id of info.identifiers)
             identifiers.add(id);
     }
+    if (compiled?.code) {
+        for (const id of collectVue2TemplateIdentifiers(compiled.code))
+            identifiers.add(id);
+    }
     scripts.push(...getSyntheticImports(maps, identifiers, templateTags));
     const styles = stylePreprocessorImports(source, path);
     if (styles)

package/dist/plugins/_vue/types.d.ts

@@ -13,24 +13,31 @@ export interface TemplateAstNode {
     props?: TemplateAstProp[];
     content?: TemplateExpressionNode;
     children?: TemplateAstNode[];
+    ifConditions?: {
+        block: TemplateAstNode;
+    }[];
+    scopedSlots?: Record<string, TemplateAstNode>;
+}
+interface DescriptorBlock {
+    content: string;
+    lang?: string;
 }
 interface Descriptor {
-    script: {
-        content: string;
-    } | null;
-    scriptSetup: {
-        content: string;
-    } | null;
-    template: {
-        content: string;
+    script: DescriptorBlock | null;
+    scriptSetup: DescriptorBlock | null;
+    template: (DescriptorBlock & {
         ast?: TemplateAstNode;
-    } | null;
+    }) | null;
 }
-export type VueSfc = {
+export interface VueSfc {
     parse: (source: string, path: string) => {
         descriptor: Descriptor;
     };
-};
+    compileTemplate?: (source: string, path: string, isTS: boolean, preprocessLang?: string) => {
+        ast?: TemplateAstNode;
+        code: string;
+    };
+}
 export interface AutoImportMaps {
     importMap: Map<string, string>;
     componentMap: Map<string, string[]>;

package/dist/plugins/index.d.ts

@@ -144,6 +144,7 @@ export declare const Plugins: {
     'tanstack-router': import("../types/config.ts").Plugin;
     taskfile: import("../types/config.ts").Plugin;
     tauri: import("../types/config.ts").Plugin;
+    temporal: import("../types/config.ts").Plugin;
     travis: import("../types/config.ts").Plugin;
     'ts-node': import("../types/config.ts").Plugin;
     tsdown: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -138,6 +138,7 @@ import { default as tailwind } from './tailwind/index.js';
 import { default as tanstackRouter } from './tanstack-router/index.js';
 import { default as taskfile } from './taskfile/index.js';
 import { default as tauri } from './tauri/index.js';
+import { default as temporal } from './temporal/index.js';
 import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsdown } from './tsdown/index.js';
@@ -315,6 +316,7 @@ export const Plugins = {
     'tanstack-router': tanstackRouter,
     taskfile,
     tauri,
+    temporal,
     travis,
     'ts-node': tsNode,
     tsdown,

package/dist/plugins/react-email/index.js

@@ -7,6 +7,7 @@ const entry = ['emails/**/*.tsx'];
 const previewCommands = new Set(['build', 'dev', 'start']);
 const args = {
     binaries: ['email'],
+    alias: { dir: ['d'] },
     resolveInputs: (parsed, { manifest }) => {
         const inputs = [];
         if (previewCommands.has(parsed._[0])) {

package/dist/plugins/tailwind/compiler.js

@@ -1,4 +1,5 @@
-const directiveMatcher = /@(?:import|config|plugin)\s+['"]([^'"]+)['"][^;]*;/g;
+const directiveMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:(?:import|config|plugin)\s+['"]([^'"]+)['"]|import\s+url\(\s*(?:['"]([^'"]+)['"]|([^'")\s]+))\s*\))[^;]*;/g;
+const urlSchemeMatcher = /^[a-z][a-z\d+.-]*:/i;
 const compiler = (text) => {
     if (!text.includes('@import') && !text.includes('@config') && !text.includes('@plugin'))
         return '';
@@ -6,9 +7,13 @@ const compiler = (text) => {
     let match;
     let index = 0;
     directiveMatcher.lastIndex = 0;
-    while ((match = directiveMatcher.exec(text)))
-        if (match[1])
-            imports.push(`import _$${index++} from '${match[1]}';`);
+    while ((match = directiveMatcher.exec(text))) {
+        const url = match[2] ?? match[3];
+        const specifier = match[1] ?? url;
+        if (!specifier || (url && (url.startsWith('//') || urlSchemeMatcher.test(url))))
+            continue;
+        imports.push(`import _$${index++} from '${specifier}';`);
+    }
     return imports.join('\n');
 };
 export default compiler;

package/dist/plugins/tanstack-router/index.js

@@ -9,10 +9,12 @@ const enablers = [
     '@tanstack/svelte-router',
     '@tanstack/router-cli',
     '@tanstack/router-plugin',
+    '@tanstack/react-start',
+    '@tanstack/solid-start',
 ];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['tsr.config.json'];
-const production = ['src/routeTree.gen.{ts,js}'];
+const production = ['src/routeTree.gen.{ts,js}', 'src/{router,start,client,server}.{js,jsx,ts,tsx}'];
 const resolveConfig = async (localConfig, options) => {
     const { configFileDir } = options;
     const generatedRouteTree = localConfig.generatedRouteTree ?? './src/routeTree.gen.ts';