nitro-nightly 3.0.1-20260119-145349-d0c4950f → 3.0.1-20260120-020848-6786d069

package/dist/_libs/estree-walker+unimport.mjs

@@ -0,0 +1,378 @@
+import "../_chunks/nitro.mjs";
+import { I as parse, s as getMagicString } from "./acorn+confbox+js-tokens+magic-string+mlly+pkg-types+sourcemap-codec+strip-literal+unimport.mjs";
+import "node:path";
+import "node:process";
+import "scule";
+
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef {{
+*   skip: () => void;
+*   remove: () => void;
+*   replace: (node: Node) => void;
+* }} WalkerContext
+*/
+var WalkerBase = class {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	* @param {Node} node
+	*/
+	replace(parent, prop, index, node) {
+		if (parent && prop) if (index != null)
+ /** @type {Array<Node>} */ parent[prop][index] = node;
+		else
+ /** @type {Node} */ parent[prop] = node;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	*/
+	remove(parent, prop, index) {
+		if (parent && prop) if (index !== null && index !== void 0)
+ /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+		else delete parent[prop];
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef { import('./walker.js').WalkerContext} WalkerContext
+* @typedef {(
+*    this: WalkerContext,
+*    node: Node,
+*    parent: Node | null,
+*    key: string | number | symbol | null | undefined,
+*    index: number | null | undefined
+* ) => void} SyncHandler
+*/
+var SyncWalker = class extends WalkerBase {
+	/**
+	*
+	* @param {SyncHandler} [enter]
+	* @param {SyncHandler} [leave]
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+		/** @type {SyncHandler | undefined} */
+		this.enter = enter;
+		/** @type {SyncHandler | undefined} */
+		this.leave = leave;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Node} node
+	* @param {Parent | null} parent
+	* @param {keyof Parent} [prop]
+	* @param {number | null} [index]
+	* @returns {Node | null}
+	*/
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			/** @type {keyof Node} */
+			let key;
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+				if (value && typeof value === "object") {
+					if (Array.isArray(value)) {
+						const nodes = value;
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i)) i--;
+							}
+						}
+					} else if (isNode(value)) this.visit(value, node, key, null);
+				}
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/**
+* Ducktype a node.
+*
+* @param {unknown} value
+* @returns {value is Node}
+*/
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+//#endregion
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+/**
+* @typedef {import('estree').Node} Node
+* @typedef {import('./sync.js').SyncHandler} SyncHandler
+* @typedef {import('./async.js').AsyncHandler} AsyncHandler
+*/
+/**
+* @param {Node} ast
+* @param {{
+*   enter?: SyncHandler
+*   leave?: SyncHandler
+* }} walker
+* @returns {Node | null}
+*/
+function walk(ast, { enter, leave }) {
+	return new SyncWalker(enter, leave).visit(ast, null);
+}
+
+//#endregion
+//#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/chunks/detect-acorn.mjs
+async function detectImportsAcorn(code, ctx, options) {
+	const s = getMagicString(code);
+	const map = await ctx.getImportMap();
+	let matchedImports = [];
+	const enableAutoImport = options?.autoImport !== false;
+	const enableTransformVirtualImports = options?.transformVirtualImports !== false && ctx.options.virtualImports?.length;
+	if (enableAutoImport || enableTransformVirtualImports) {
+		const ast = parse(s.original, {
+			sourceType: "module",
+			ecmaVersion: "latest",
+			locations: true
+		});
+		const virtualImports = createVirtualImportsAcronWalker(map, ctx.options.virtualImports);
+		const scopes = traveseScopes(ast, enableTransformVirtualImports ? virtualImports.walk : {});
+		if (enableAutoImport) {
+			const identifiers = scopes.unmatched;
+			matchedImports.push(...Array.from(identifiers).map((name) => {
+				const item = map.get(name);
+				if (item && !item.disabled) return item;
+				return null;
+			}).filter(Boolean));
+			for (const addon of ctx.addons) matchedImports = await addon.matchImports?.call(ctx, identifiers, matchedImports) || matchedImports;
+		}
+		virtualImports.ranges.forEach(([start, end]) => {
+			s.remove(start, end);
+		});
+		matchedImports.push(...virtualImports.imports);
+	}
+	return {
+		s,
+		strippedCode: code.toString(),
+		matchedImports,
+		isCJSContext: false,
+		firstOccurrence: 0
+	};
+}
+function traveseScopes(ast, additionalWalk) {
+	const scopes = [];
+	let scopeCurrent = void 0;
+	const scopesStack = [];
+	function pushScope(node) {
+		scopeCurrent = {
+			node,
+			parent: scopeCurrent,
+			declarations: /* @__PURE__ */ new Set(),
+			references: /* @__PURE__ */ new Set()
+		};
+		scopes.push(scopeCurrent);
+		scopesStack.push(scopeCurrent);
+	}
+	function popScope(node) {
+		if (scopesStack.pop()?.node !== node) throw new Error("Scope mismatch");
+		scopeCurrent = scopesStack[scopesStack.length - 1];
+	}
+	pushScope(void 0);
+	walk(ast, {
+		enter(node, parent, prop, index) {
+			additionalWalk?.enter?.call(this, node, parent, prop, index);
+			switch (node.type) {
+				case "ImportSpecifier":
+				case "ImportDefaultSpecifier":
+				case "ImportNamespaceSpecifier":
+					scopeCurrent.declarations.add(node.local.name);
+					return;
+				case "FunctionDeclaration":
+				case "ClassDeclaration":
+					if (node.id) scopeCurrent.declarations.add(node.id.name);
+					return;
+				case "VariableDeclarator":
+					if (node.id.type === "Identifier") scopeCurrent.declarations.add(node.id.name);
+					else walk(node.id, { enter(node2) {
+						if (node2.type === "ObjectPattern") node2.properties.forEach((i) => {
+							if (i.type === "Property" && i.value.type === "Identifier") scopeCurrent.declarations.add(i.value.name);
+							else if (i.type === "RestElement" && i.argument.type === "Identifier") scopeCurrent.declarations.add(i.argument.name);
+						});
+						else if (node2.type === "ArrayPattern") node2.elements.forEach((i) => {
+							if (i?.type === "Identifier") scopeCurrent.declarations.add(i.name);
+							if (i?.type === "RestElement" && i.argument.type === "Identifier") scopeCurrent.declarations.add(i.argument.name);
+						});
+					} });
+					return;
+				case "BlockStatement":
+					switch (parent?.type) {
+						case "FunctionDeclaration":
+						case "ArrowFunctionExpression":
+						case "FunctionExpression": {
+							const parameterIdentifiers = parent.params.filter((p) => p.type === "Identifier");
+							for (const id of parameterIdentifiers) scopeCurrent.declarations.add(id.name);
+							break;
+						}
+					}
+					pushScope(node);
+					return;
+				case "Identifier":
+					switch (parent?.type) {
+						case "CallExpression":
+							if (parent.callee === node || parent.arguments.includes(node)) scopeCurrent.references.add(node.name);
+							return;
+						case "MemberExpression":
+							if (parent.object === node) scopeCurrent.references.add(node.name);
+							return;
+						case "VariableDeclarator":
+							if (parent.init === node) scopeCurrent.references.add(node.name);
+							return;
+						case "SpreadElement":
+							if (parent.argument === node) scopeCurrent.references.add(node.name);
+							return;
+						case "ClassDeclaration":
+							if (parent.superClass === node) scopeCurrent.references.add(node.name);
+							return;
+						case "Property":
+							if (parent.value === node) scopeCurrent.references.add(node.name);
+							return;
+						case "TemplateLiteral":
+							if (parent.expressions.includes(node)) scopeCurrent.references.add(node.name);
+							return;
+						case "AssignmentExpression":
+							if (parent.right === node) scopeCurrent.references.add(node.name);
+							return;
+						case "IfStatement":
+						case "WhileStatement":
+						case "DoWhileStatement":
+							if (parent.test === node) scopeCurrent.references.add(node.name);
+							return;
+						case "SwitchStatement":
+							if (parent.discriminant === node) scopeCurrent.references.add(node.name);
+							return;
+					}
+					if (parent?.type.includes("Expression")) scopeCurrent.references.add(node.name);
+			}
+		},
+		leave(node, parent, prop, index) {
+			additionalWalk?.leave?.call(this, node, parent, prop, index);
+			switch (node.type) {
+				case "BlockStatement": popScope(node);
+			}
+		}
+	});
+	const unmatched = /* @__PURE__ */ new Set();
+	for (const scope of scopes) for (const name of scope.references) {
+		let defined = false;
+		let parent = scope;
+		while (parent) {
+			if (parent.declarations.has(name)) {
+				defined = true;
+				break;
+			}
+			parent = parent?.parent;
+		}
+		if (!defined) unmatched.add(name);
+	}
+	return {
+		unmatched,
+		scopes
+	};
+}
+function createVirtualImportsAcronWalker(importMap, virtualImports = []) {
+	const imports = [];
+	const ranges = [];
+	return {
+		imports,
+		ranges,
+		walk: { enter(node) {
+			if (node.type === "ImportDeclaration") {
+				if (virtualImports.includes(node.source.value)) {
+					ranges.push([node.start, node.end]);
+					node.specifiers.forEach((i) => {
+						if (i.type === "ImportSpecifier" && i.imported.type === "Identifier") {
+							const original = importMap.get(i.imported.name);
+							if (!original) throw new Error(`[unimport] failed to find "${i.imported.name}" imported from "${node.source.value}"`);
+							imports.push({
+								from: original.from,
+								name: original.name,
+								as: i.local.name
+							});
+						}
+					});
+				}
+			}
+		} }
+	};
+}
+
+//#endregion
+export { detectImportsAcorn };