unplugin-keywords 2.5.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cueaz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,256 @@
+# unplugin-keywords
+
+[![NPM][npm-badge]][npm-url]
+[![Github CI][ci-badge]][ci-url]
+[![MIT licensed][license-badge]][license-url]
+
+[npm-badge]: https://img.shields.io/npm/v/unplugin-keywords.svg
+[npm-url]: https://www.npmjs.com/package/unplugin-keywords
+[ci-badge]: https://github.com/cueaz/unplugin-keywords/actions/workflows/check.yaml/badge.svg
+[ci-url]: https://github.com/cueaz/unplugin-keywords/actions/workflows/check.yaml
+[license-badge]: https://img.shields.io/badge/license-MIT-blue.svg
+[license-url]: https://github.com/cueaz/unplugin-keywords/blob/main/LICENSE
+
+A build plugin for structural string literal minification and obfuscation.
+
+`unplugin-keywords` addresses a fundamental limitation in JavaScript minification: the inability to safely mangle string literals used as object keys, custom event types, or structural constants. By explicitly importing these identifiers from a virtual module, the plugin extracts them at the AST level and maps them to deterministic, short hashes during the build process. This explicit opt-in mechanism empowers bundlers to inline and obfuscate application internals without breaking semantic contracts.
+
+## Motivation vs. Property Mangling
+
+Traditional JavaScript minifiers rely on property mangling (e.g., Terser's `mangle.properties`) to reduce structural identifiers. `unplugin-keywords` provides a module-based alternative that addresses the structural limitations of global mangling.
+
+*   **Explicit Opt-In:**
+    Traditional property mangling requires maintaining complex, global exclusion rules (e.g., [`mangle.json`](https://github.com/preactjs/signals/blob/main/mangle.json)), which are fragile and hard to scale. `unplugin-keywords` utilizes explicit imports (`import * as K`). Developers unambiguously declare which identifiers are safe to obfuscate directly in the source code.
+*   **Gradual Adoption:**
+    Unlike global mangling flags that affect the entire codebase simultaneously, installing this plugin alters nothing by default. It allows incremental adoption on a per-file or per-module basis.
+*   **Cross-Boundary Consistency:**
+    Standard mangled properties cannot safely cross package boundaries; a property mangled to `a` in Package A will not map to `a` in Package B. Because `virtual:keywords` relies on deterministic hashing, identical keys inherently produce identical hashes across independent builds (provided they share the same `secret` configuration), preserving structural contracts.
+*   **Universal Application:**
+    Standard minifiers only mangle object keys, leaving string literal values intact. This plugin processes both keys and values uniformly (e.g., `[K.type]: K.SET_USER`). It extends obfuscation to literal types (`const mode: typeof K.extract | typeof K.transform = K.extract`) and even arbitrary static strings (`throw new Error(K['Invalid State'])`).
+*   **Trade-offs:**
+    This explicit approach sacrifices some source code readability. Furthermore, as demonstrated in the benchmarks below, standard gzip compression handles unmodified semantic strings highly effectively. If reducing the gzipped network payload is the sole objective, the architectural overhead of this plugin outweighs the minimal payload reduction.
+
+## Visual Demo: `@preact/signals-core`
+
+A side-by-side comparison of minified bundles:
+
+| [Unmodified](https://github.com/cueaz/unplugin-keywords/blob/main/demo/signals/src/original.ts) (Standard Minification) | [Keywordified](https://github.com/cueaz/unplugin-keywords/blob/main/demo/signals/src/keywordified.ts) (Literal Obfuscation) |
+|:---:|:---:|
+| <picture><source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/cueaz/unplugin-keywords/refs/heads/main/demo/signals/dist_sample/original.min.js.light.png" width="400"><img src="https://raw.githubusercontent.com/cueaz/unplugin-keywords/refs/heads/main/demo/signals/dist_sample/original.min.js.dark.png" width="400" alt="Original"></picture> | <picture><source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/cueaz/unplugin-keywords/refs/heads/main/demo/signals/dist_sample/keywordified.min.js.light.png" width="400"><img src="https://raw.githubusercontent.com/cueaz/unplugin-keywords/refs/heads/main/demo/signals/dist_sample/keywordified.min.js.dark.png" width="400" alt="Keywordified"></picture> |
+| 6.86 kB │ gzip: **2.09 kB** | **5.40 kB** │ gzip: 2.03 kB |
+
+> [!NOTE]
+> **Baseline Metrics:** The "Unmodified" metrics represent standard `tsdown` minification. The official [`@preact/signals-core@1.14.1`](https://bundlephobia.com/package/@preact/signals-core@1.14.1) release achieves a smaller footprint (5.4 kB Minified / 1.9 kB Gzipped) by employing a hand-crafted [`mangle.json`](https://github.com/preactjs/signals/blob/main/mangle.json) for manual property obfuscation.
+>
+> **Compression Efficiency:** While the raw bundle size is reduced by 21.3%, the gzipped size is only 2.9% smaller. This demonstrates the effectiveness of standard gzip compression on unmodified code: if minimizing the gzipped network payload is the sole objective, adopting this plugin is unnecessary.
+
+*For more information, see the [demo documentation](https://github.com/cueaz/unplugin-keywords/blob/main/demo/signals/README.md).*
+
+## How It Works
+
+Standard minifiers operate exclusively on variable bindings and function names, leaving structural strings intact. While this preserves the semantic contract, it inflates bundle size and exposes internal state architecture (e.g., Redux action types, state machine nodes).
+
+`unplugin-keywords` shifts this paradigm by treating structural strings as imported module bindings.
+
+**1. Source Code (Development):**
+Developers reference strings via a virtual module. The strongly recommended pattern is to use a namespace import (`import * as K`), which clearly demarcates keyword usage throughout the file.
+
+```ts
+import * as K from 'virtual:keywords';
+
+const action = {
+  [K.type]: K.SET_USER,
+  [K.payload]: data,
+};
+```
+
+**2. AST Transformation:**
+During the build phase, the plugin traverses the AST, resolving bindings and statically resolving member expressions. It replaces valid identifier access with a generated AST node pointing to a deterministic base62 hash or a minimal lexical sequence.
+
+**3. Minified Output (Production):**
+The bundler receives the transformed code and processes the hashed literals. Depending on the frequency of usage, the minifier will either inline the strings directly or extract them into single-character variables to save bytes.
+
+```ts
+// Example of minifier output: strings may be inlined or assigned to variables if used multiple times
+const _="z2pL21k";const a={a3fB9zX:_,k1Mw8pA:data};
+```
+
+## Dual-Module Architecture
+
+`unplugin-keywords` provides two distinct virtual modules. While exclusively using `K.*` is a perfectly valid and robust approach, the dual-module system allows further bundle size reduction.
+
+*   **`virtual:keywords` (Stable Hash):**
+    Generates deterministic, key-derived hashes (e.g., `"z2pL21k"`). Designed for **public-facing APIs** and structural contracts that must remain consistent across package boundaries (e.g., `package.json` exports).
+    *Convention:* `import * as K from 'virtual:keywords';`
+
+*   **`virtual:keywords/local` (Lexical Counter):**
+    Generates the shortest possible sequential identifiers via bijective numeration (e.g., `"_a"`, `"_b"`, `"_c"`). Strictly designated for **internal and local** implementations where cross-boundary stability is irrelevant.
+    *Convention:* `import * as L from 'virtual:keywords/local';`
+
+**Module Separation:**
+To minimize bundle size, identifiers can be partitioned: bind public interfaces to `K.*`, and obscure all internal state and private members behind `L.*`.
+
+## Integration
+
+Install the package:
+
+```bash
+npm install -D unplugin-keywords
+```
+
+Configure your bundler. Example for Vite:
+
+```ts
+import { defineConfig } from 'vite';
+import keywords from 'unplugin-keywords/vite';
+
+export default defineConfig(({ mode }) => ({
+  plugins: [
+    keywords({
+      // Preserves keyword suffix in development for debugging (e.g., "zXpL21k.SET_USER")
+      isDev: mode === 'development',
+      // Initializes the hashing algorithm. Modify to rotate hashes globally.
+      secret: 'my-secret-key',
+    }),
+  ],
+}));
+```
+
+To enable type checking and IDE auto-completion, execute the CLI and register the output in `tsconfig.json`:
+
+```bash
+npx keywords
+```
+
+```jsonc
+{
+  "compilerOptions": {
+    "paths": {
+      "virtual:keywords": ["./node_modules/.keywords/index.d.ts"],
+      "virtual:keywords/local": ["./node_modules/.keywords/local.d.ts"]
+    }
+  }
+}
+```
+
+> [!TIP]
+> During development, the plugin automatically runs a background type generation process while the bundler is running. Manual CLI execution is only necessary for pre-flight type checking (e.g., in CI) before the bundler runs.
+
+## Example: Class-Based Architectures
+
+The namespace import pattern is applicable in class-based architectures where structural symbols are heavily used for internal state and lifecycle methods.
+
+> [!IMPORTANT]
+> Overriding lifecycle methods (e.g., `[K.render]`) requires a modified base class—such as a custom build of Lit—compiled with `unplugin-keywords` to dispatch the hashed keys. Sharing this dictionary across the ecosystem enables consistent obfuscation.
+
+```ts
+// Source: https://github.com/lit/lit/blob/main/packages/lit-html/src/directives/async-replace.ts
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import * as K from 'virtual:keywords';
+import * as L from 'virtual:keywords/local';
+import {
+  AsyncDirective,
+  type DirectiveParameters,
+} from '../async-directive.js';
+import { type ChildPart, noChange } from '../lit-html.js';
+import { forAwaitOf, Pauser, PseudoWeakRef } from './private-async-helpers.js';
+
+type Mapper<T> = (v: T, index?: number) => unknown;
+
+export class AsyncReplaceDirective extends AsyncDirective {
+  private [L.__value]?: AsyncIterable<unknown>;
+  private [L.__weakThis] = new PseudoWeakRef(this);
+  private [L.__pauser] = new Pauser();
+
+  [K.render]<T>(_value: AsyncIterable<T>, _mapper?: Mapper<T>) {
+    return noChange;
+  }
+
+  override [K.update](_part: ChildPart, [value, mapper]: DirectiveParameters<this>) {
+    if (!this[K.isConnected]) {
+      this[K.disconnected]();
+    }
+
+    if (value === this[L.__value]) {
+      return noChange;
+    }
+    this[L.__value] = value;
+    let i = 0;
+    const { [L.__weakThis]: weakThis, [L.__pauser]: pauser } = this;
+
+    forAwaitOf(value, async (v: unknown) => {
+      while (pauser[L.get]()) {
+        await pauser[L.get]();
+      }
+
+      const _this = weakThis[L.deref]();
+      if (_this !== undefined) {
+        if (_this[L.__value] !== value) {
+          return false;
+        }
+        if (mapper !== undefined) {
+          v = mapper(v, i);
+        }
+        _this[K.commitValue](v, i);
+        i++;
+      }
+      return true;
+    });
+
+    return noChange;
+  }
+
+  protected [K.commitValue](value: unknown, _index: number) {
+    this[K.setValue](value);
+  }
+
+  override [K.disconnected]() {
+    this[L.__weakThis][L.disconnect]();
+    this[L.__pauser][L.pause]();
+  }
+
+  override [K.reconnected]() {
+    this[L.__weakThis][L.reconnect](this);
+    this[L.__pauser][L.resume]();
+  }
+}
+```
+*In production, all internal properties (e.g., `__value`, `__pauser`) will be completely minified to short sequence identifiers (via `virtual:keywords/local`), obfuscating internal property names from the bundled Lit component.*
+
+> [!TIP]
+> Native ECMAScript private fields (`#prop`) are safely mangled by standard minifiers, eliminating the need for plugin obfuscation for internal class state.
+
+
+## Other Supported Patterns
+
+```ts
+// Modular Imports
+import { type, 'kebab-case' as kebab } from 'virtual:keywords';
+
+// JSX Injection
+const View = () => (
+  <K.Container>
+    <div />
+  </K.Container>
+);
+
+// Advanced TypeScript Inference
+interface StateMachine {
+  [K.idle]: typeof K.active;
+  value: (typeof K)['kebab-case'];
+}
+
+// Module Re-exports
+export { internalState as state } from 'virtual:keywords';
+
+// UNSUPPORTED: Export All (Lacks static traceability)
+export * from 'virtual:keywords';
+```
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,4 @@
+import { createRunner } from '../dist/api.js';
+
+const runner = createRunner();
+await runner.run();

package/dist/api.d.ts

@@ -0,0 +1,33 @@
+import { BabelFileResult } from "@babel/core";
+
+//#region src/internal/transform.d.ts
+interface KeywordSet {
+  main: Set<string>;
+  local: Set<string>;
+}
+declare const transformCode: (code: string, id: string) => {
+  code: string;
+  map: NonNullable<BabelFileResult["map"]> | null;
+  keywords: KeywordSet;
+} | null;
+declare const extractKeywords: (code: string) => KeywordSet | null;
+//#endregion
+//#region src/internal/cli.d.ts
+interface RunnerOptions {
+  root: string;
+  silent: boolean;
+  outDir: string;
+}
+declare const createRunner: (options?: Partial<RunnerOptions>) => {
+  collect(): Promise<KeywordSet>;
+  save(keywords: KeywordSet): Promise<void>;
+  run(): Promise<void>;
+};
+//#endregion
+//#region src/internal/hash.d.ts
+type Hasher = (input: string) => string;
+declare const createHasher: (secret: string) => Hasher;
+declare const createCounter: () => Hasher;
+//#endregion
+export { createCounter, createHasher, createRunner, extractKeywords, transformCode };
+//# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -0,0 +1,2 @@
+import { a as transformCode, i as extractKeywords, n as createHasher, r as createRunner, t as createCounter } from "./hash-DMsO2VqQ.js";
+export { createCounter, createHasher, createRunner, extractKeywords, transformCode };

package/dist/esbuild.d.ts

@@ -0,0 +1,7 @@
+import { t as Options } from "./plugin-Coz4K9xU.js";
+
+//#region src/esbuild.d.ts
+declare const _default: (options: Options) => EsbuildPlugin;
+//#endregion
+export { type Options, _default as default };
+//# sourceMappingURL=esbuild.d.ts.map

package/dist/esbuild.js

@@ -0,0 +1,8 @@
+import { t as unpluginFactory } from "./plugin-Cj1x2KK1.js";
+import { createEsbuildPlugin } from "unplugin";
+//#region src/esbuild.ts
+var esbuild_default = createEsbuildPlugin(unpluginFactory);
+//#endregion
+export { esbuild_default as default };
+
+//# sourceMappingURL=esbuild.js.map

package/dist/esbuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild.js","names":[],"sources":["../src/esbuild.ts"],"sourcesContent":["import { createEsbuildPlugin } from 'unplugin';\nimport { type Options, unpluginFactory } from './internal/plugin.js';\n\nexport default createEsbuildPlugin(unpluginFactory);\nexport type { Options };\n"],"mappings":";;;AAGA,IAAA,kBAAe,oBAAoB,gBAAgB"}

package/dist/hash-DMsO2VqQ.js

@@ -0,0 +1,360 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+import { globby } from "globby";
+import pLimit from "p-limit";
+import { transformSync, types } from "@babel/core";
+import { createHmac } from "node:crypto";
+//#region src/internal/constants.ts
+const VIRTUAL_MODULE_ID = "virtual:keywords";
+const VIRTUAL_LOCAL_MODULE_ID = "virtual:keywords/local";
+const PLUGIN_NAME = "unplugin-keywords";
+//#endregion
+//#region src/internal/encode.ts
+const encodeIdentifier = (identifier) => {
+	let encoded = "";
+	for (let i = 0; i < identifier.length; i++) {
+		const c = identifier[i];
+		if (/[a-zA-Z0-9_]/.test(c)) encoded += c;
+		else if (c === "$") encoded += "$$";
+		else encoded += `$${c.charCodeAt(0).toString(16).padStart(4, "0")}`;
+	}
+	return encoded;
+};
+const toSafeVarName = (encoded) => `_$${encoded}`;
+//#endregion
+//#region src/internal/transform.ts
+const isPureTypeSpace = (path) => {
+	let current = path;
+	while (current) {
+		const parent = current.parentPath;
+		if (!parent) break;
+		if (parent.isTSTypeQuery()) return false;
+		if ("computed" in parent.node && parent.node.computed) {
+			if (current.key === "key" || current.key === "property") return false;
+		}
+		if (parent.isTSType() || parent.isTSTypeParameterDeclaration() || parent.isTSTypeParameterInstantiation() || parent.isTSExpressionWithTypeArguments()) return true;
+		if (parent.isTSInterfaceDeclaration() || parent.isTSTypeAliasDeclaration() || parent.isTSEnumDeclaration() || parent.isTSModuleDeclaration()) {
+			if (current.key === "id") return true;
+		}
+		if (parent.isTSQualifiedName() || parent.isTSEntityName()) {
+			current = current.parentPath;
+			continue;
+		}
+		if (parent.isExpression() || parent.isStatement()) break;
+		current = current.parentPath;
+	}
+	return false;
+};
+const transformPlugin = (mode) => {
+	return {
+		name: `${PLUGIN_NAME}:${mode}`,
+		visitor: {
+			Program: {
+				enter(_, state) {
+					state.keywords = {
+						main: /* @__PURE__ */ new Set(),
+						local: /* @__PURE__ */ new Set()
+					};
+					state.keywordUids = {
+						main: /* @__PURE__ */ new Map(),
+						local: /* @__PURE__ */ new Map()
+					};
+				},
+				exit(path, state) {
+					const metadata = state.file.metadata;
+					metadata.keywords = {
+						main: Array.from(state.keywords.main),
+						local: Array.from(state.keywords.local)
+					};
+					if (mode === "transform") {
+						const newImports = [];
+						for (const [keyword, safeId] of state.keywordUids.main.entries()) {
+							const encoded = encodeIdentifier(keyword);
+							newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_MODULE_ID}/_/${encoded}`)));
+						}
+						for (const [keyword, safeId] of state.keywordUids.local.entries()) {
+							const encoded = encodeIdentifier(keyword);
+							newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_LOCAL_MODULE_ID}/_/${encoded}`)));
+						}
+						if (newImports.length > 0) path.unshiftContainer("body", newImports);
+					}
+				}
+			},
+			ImportDeclaration(path, state) {
+				const sourceValue = path.node.source.value;
+				if (sourceValue !== "virtual:keywords" && sourceValue !== "virtual:keywords/local") return;
+				const isLocal = sourceValue === VIRTUAL_LOCAL_MODULE_ID;
+				const targetSet = isLocal ? state.keywords.local : state.keywords.main;
+				const targetMap = isLocal ? state.keywordUids.local : state.keywordUids.main;
+				const programScope = path.scope.getProgramParent();
+				const processKeyword = (keyword) => {
+					targetSet.add(keyword);
+					if (mode === "extract") return null;
+					if (targetMap.has(keyword)) return targetMap.get(keyword);
+					const safeName = toSafeVarName(encodeIdentifier(keyword));
+					const uid = programScope.generateUidIdentifier(safeName);
+					targetMap.set(keyword, uid);
+					return uid;
+				};
+				for (const specifierPath of path.get("specifiers")) {
+					const localName = specifierPath.node.local.name;
+					const binding = path.scope.getBinding(localName);
+					if (!binding) continue;
+					if (specifierPath.isImportDefaultSpecifier() || specifierPath.isImportSpecifier()) {
+						let keyword;
+						if (specifierPath.isImportDefaultSpecifier()) keyword = "default";
+						else {
+							const imported = specifierPath.node.imported;
+							keyword = types.isIdentifier(imported) ? imported.name : imported.value;
+						}
+						const uidNode = processKeyword(keyword);
+						if (!uidNode) continue;
+						for (const refPath of binding.referencePaths) {
+							if (isPureTypeSpace(refPath)) continue;
+							if (refPath.isJSXIdentifier()) refPath.replaceWith(types.jsxIdentifier(uidNode.name));
+							else refPath.replaceWith(types.cloneNode(uidNode));
+						}
+						path.parentPath.traverse({ TSTypeQuery(tsPath) {
+							if (types.isIdentifier(tsPath.node.exprName) && tsPath.node.exprName.name === localName && tsPath.scope.getBinding(localName) === binding) tsPath.get("exprName").replaceWith(types.cloneNode(uidNode));
+						} });
+					} else if (specifierPath.isImportNamespaceSpecifier()) {
+						for (const refPath of binding.referencePaths) {
+							if (isPureTypeSpace(refPath)) continue;
+							const parentPath = refPath.parentPath;
+							if (!parentPath) continue;
+							if (parentPath.isMemberExpression() && parentPath.node.object === refPath.node) {
+								const propNode = parentPath.node.property;
+								let keyword;
+								if (!parentPath.node.computed && types.isIdentifier(propNode)) keyword = propNode.name;
+								else if (parentPath.node.computed && types.isStringLiteral(propNode)) keyword = propNode.value;
+								if (keyword) {
+									const uidNode = processKeyword(keyword);
+									if (uidNode) parentPath.replaceWith(types.cloneNode(uidNode));
+								}
+							} else if (parentPath.isJSXMemberExpression() && parentPath.node.object === refPath.node) {
+								const keyword = parentPath.node.property.name;
+								const uidNode = processKeyword(keyword);
+								if (uidNode) parentPath.replaceWith(types.jsxIdentifier(uidNode.name));
+							}
+						}
+						path.parentPath.traverse({
+							TSTypeQuery(tsPath) {
+								const expr = tsPath.node.exprName;
+								if (types.isTSQualifiedName(expr) && types.isIdentifier(expr.left) && expr.left.name === localName && tsPath.scope.getBinding(localName) === binding) {
+									const keyword = expr.right.name;
+									const uidNode = processKeyword(keyword);
+									if (uidNode) tsPath.get("exprName").replaceWith(types.cloneNode(uidNode));
+								}
+							},
+							TSIndexedAccessType(tsPath) {
+								let objPath = tsPath.get("objectType");
+								while (objPath.isTSParenthesizedType()) objPath = objPath.get("typeAnnotation");
+								if (objPath.isTSTypeQuery() && types.isIdentifier(objPath.node.exprName) && objPath.node.exprName.name === localName && tsPath.scope.getBinding(localName) === binding) {
+									const indexNode = tsPath.node.indexType;
+									if (types.isTSLiteralType(indexNode) && types.isStringLiteral(indexNode.literal)) {
+										const keyword = indexNode.literal.value;
+										const uidNode = processKeyword(keyword);
+										if (uidNode) tsPath.replaceWith(types.tsTypeQuery(types.cloneNode(uidNode)));
+									}
+								}
+							}
+						});
+					}
+				}
+				if (mode === "transform") path.remove();
+			},
+			ExportNamedDeclaration(path, state) {
+				const sourceValue = path.node.source?.value;
+				if (sourceValue !== "virtual:keywords" && sourceValue !== "virtual:keywords/local") return;
+				const targetSet = sourceValue === "virtual:keywords/local" ? state.keywords.local : state.keywords.main;
+				if (mode === "extract") {
+					for (const specifierPath of path.get("specifiers")) if (specifierPath.isExportSpecifier()) {
+						const local = specifierPath.node.local;
+						const keyword = types.isIdentifier(local) ? local.name : local.value;
+						targetSet.add(keyword);
+					}
+					return;
+				}
+				const newExports = path.get("specifiers").map((specifierPath) => {
+					if (specifierPath.isExportSpecifier()) {
+						const local = specifierPath.node.local;
+						const keyword = types.isIdentifier(local) ? local.name : local.value;
+						targetSet.add(keyword);
+						const encoded = encodeIdentifier(keyword);
+						return types.exportNamedDeclaration(null, [types.exportSpecifier(types.identifier("default"), specifierPath.node.exported)], types.stringLiteral(`${sourceValue}/_/${encoded}`));
+					}
+					return null;
+				}).filter((node) => node !== null);
+				if (newExports.length > 0) path.replaceWithMultiple(newExports);
+				else path.remove();
+			}
+		}
+	};
+};
+const transformCode = (code, id) => {
+	if (!code.includes("virtual:keywords") && !code.includes("virtual:keywords/local")) return null;
+	const result = transformSync(code, {
+		babelrc: false,
+		configFile: false,
+		filename: id,
+		sourceMaps: true,
+		ast: false,
+		plugins: [transformPlugin("transform")],
+		parserOpts: { plugins: ["jsx", "typescript"] }
+	});
+	if (!result) return null;
+	const metadata = result.metadata;
+	const keywords = {
+		main: new Set(metadata?.keywords?.main ?? []),
+		local: new Set(metadata?.keywords?.local ?? [])
+	};
+	return {
+		code: result.code ?? "",
+		map: result.map ?? null,
+		keywords
+	};
+};
+const extractKeywords = (code) => {
+	if (!code.includes("virtual:keywords") && !code.includes("virtual:keywords/local")) return null;
+	let result;
+	try {
+		result = transformSync(code, {
+			babelrc: false,
+			configFile: false,
+			sourceMaps: false,
+			ast: false,
+			code: false,
+			plugins: [transformPlugin("extract")],
+			parserOpts: {
+				plugins: ["jsx", "typescript"],
+				errorRecovery: true
+			}
+		});
+	} catch {
+		return null;
+	}
+	if (!result) return null;
+	const metadata = result.metadata;
+	return {
+		main: new Set(metadata?.keywords?.main ?? []),
+		local: new Set(metadata?.keywords?.local ?? [])
+	};
+};
+//#endregion
+//#region src/internal/typegen.ts
+const generateTypeDeclaration = (keywords, isLocal = false) => {
+	const sortedKeywords = Array.from(keywords).sort();
+	const content = [];
+	for (const keyword of sortedKeywords) {
+		const safeName = toSafeVarName(encodeIdentifier(keyword));
+		const value = `${isLocal ? "==" : "*".repeat(7)}.${keyword}`;
+		content.push(`declare const ${safeName}: ${JSON.stringify(value)};`);
+	}
+	content.push("");
+	content.push("export {");
+	for (const keyword of sortedKeywords) {
+		const safeName = toSafeVarName(encodeIdentifier(keyword));
+		content.push(`  ${safeName} as ${JSON.stringify(keyword)},`);
+	}
+	content.push("};");
+	content.push("");
+	return content.join("\n");
+};
+//#endregion
+//#region src/internal/cli.ts
+const collectKeywordsFromRoot = async (root, silent, ignoredDirs = [], concurrency = 100) => {
+	const collectedKeywords = {
+		main: /* @__PURE__ */ new Set(),
+		local: /* @__PURE__ */ new Set()
+	};
+	const start = performance.now();
+	if (!silent) console.error("Scanning project files for keywords...");
+	const files = await globby("**/*.{js,ts,mjs,mts,jsx,tsx,mjsx,mtsx}", {
+		cwd: root,
+		absolute: false,
+		ignore: ["**/node_modules/**", ...ignoredDirs.map((dir) => `${dir}/**`)],
+		gitignore: true
+	});
+	let processed = 0;
+	await pLimit({ concurrency }).map(files, async (file) => {
+		try {
+			const keywords = extractKeywords(await readFile(file, "utf-8"));
+			if (!keywords) return;
+			for (const keyword of keywords.main) collectedKeywords.main.add(keyword);
+			for (const keyword of keywords.local) collectedKeywords.local.add(keyword);
+			processed++;
+		} catch (error) {
+			if (!silent) console.error(`Failed to process ${file}: ${error}`);
+		}
+	});
+	const elapsed = performance.now() - start;
+	if (!silent) console.error(`Scan complete: ${processed}/${files.length} files, ${collectedKeywords.main.size} main, ${collectedKeywords.local.size} local keywords (${elapsed.toFixed(2)}ms).`);
+	return collectedKeywords;
+};
+const createRunner = (options) => {
+	const { root = process.cwd(), silent = false, outDir = path.join("node_modules", ".keywords") } = options ?? {};
+	return {
+		async collect() {
+			return collectKeywordsFromRoot(root, silent);
+		},
+		async save(keywords) {
+			const content = generateTypeDeclaration(keywords.main);
+			const localContent = generateTypeDeclaration(keywords.local, true);
+			const outPath = path.join(root, outDir);
+			await mkdir(outPath, { recursive: true });
+			await writeFile(path.join(outPath, "index.d.ts"), `${content.trim()}\n`);
+			await writeFile(path.join(outPath, "local.d.ts"), `${localContent.trim()}\n`);
+		},
+		async run() {
+			const keywords = await this.collect();
+			await this.save(keywords);
+		}
+	};
+};
+//#endregion
+//#region src/internal/hash.ts
+const ALPHA_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const DIGIT_CHARS = "0123456789";
+const BASE62_CHARS = ALPHA_CHARS + DIGIT_CHARS;
+const ALPHA_LEN = BigInt(52);
+const DIGIT_LEN = BigInt(10);
+const BASE62_LEN = BigInt(BASE62_CHARS.length);
+const createHasher = (secret) => {
+	const base62TailLength = 5;
+	if (base62TailLength < 0 || base62TailLength > 9) throw new Error("Invalid MAX_HASH_LENGTH");
+	const cache = /* @__PURE__ */ new Map();
+	return (input) => {
+		if (cache.has(input)) return cache.get(input);
+		let entropy = createHmac("sha256", secret).update(input).digest().readBigUInt64BE(0);
+		let result = "";
+		result += ALPHA_CHARS[Number(entropy % ALPHA_LEN)];
+		entropy /= ALPHA_LEN;
+		result += DIGIT_CHARS[Number(entropy % DIGIT_LEN)];
+		entropy /= DIGIT_LEN;
+		for (let i = 0; i < base62TailLength; i++) {
+			result += BASE62_CHARS[Number(entropy % BASE62_LEN)];
+			entropy /= BASE62_LEN;
+		}
+		cache.set(input, result);
+		return result;
+	};
+};
+const createCounter = () => {
+	let index = 0;
+	return () => {
+		let result = "_";
+		result += ALPHA_CHARS[index % 52];
+		let remain = Math.floor(index / 52);
+		while (remain > 0) {
+			remain--;
+			result += BASE62_CHARS[remain % BASE62_CHARS.length];
+			remain = Math.floor(remain / BASE62_CHARS.length);
+		}
+		index++;
+		return result;
+	};
+};
+//#endregion
+export { transformCode as a, VIRTUAL_LOCAL_MODULE_ID as c, extractKeywords as i, VIRTUAL_MODULE_ID as l, createHasher as n, encodeIdentifier as o, createRunner as r, PLUGIN_NAME as s, createCounter as t };
+
+//# sourceMappingURL=hash-DMsO2VqQ.js.map

package/dist/hash-DMsO2VqQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-DMsO2VqQ.js","names":["t"],"sources":["../src/internal/constants.ts","../src/internal/encode.ts","../src/internal/transform.ts","../src/internal/typegen.ts","../src/internal/cli.ts","../src/internal/hash.ts"],"sourcesContent":["export const VIRTUAL_MODULE_ID = 'virtual:keywords';\nexport const VIRTUAL_LOCAL_MODULE_ID = 'virtual:keywords/local';\n\nexport const PLUGIN_NAME = 'unplugin-keywords';\n\nexport const HASH_LENGTH = 7;\n\nexport const KEYWORD_ROUTE_SEGMENT = '_';\n\n// URL-safe so that K.abc can be used in URL\nexport const DEBUG_SEPARATOR = '.';\n","declare const __encoded__: unique symbol;\ntype Encoded = string & { [__encoded__]: never };\n\nexport const encodeIdentifier = (identifier: string): Encoded => {\n  let encoded = '';\n  for (let i = 0; i < identifier.length; i++) {\n    const c = identifier[i] as string;\n    if (/[a-zA-Z0-9_]/.test(c)) {\n      encoded += c;\n    } else if (c === '$') {\n      encoded += '$$';\n    } else {\n      encoded += `$${c.charCodeAt(0).toString(16).padStart(4, '0')}`;\n    }\n  }\n  return encoded as Encoded;\n};\n\nexport const toSafeVarName = (encoded: Encoded): string => `_$${encoded}`;\n","import {\n  type BabelFileResult,\n  type NodePath,\n  type PluginObj,\n  type PluginPass,\n  types as t,\n  transformSync,\n} from '@babel/core';\nimport {\n  KEYWORD_ROUTE_SEGMENT,\n  PLUGIN_NAME,\n  VIRTUAL_LOCAL_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n} from './constants.js';\nimport { encodeIdentifier, toSafeVarName } from './encode.js';\n\nexport interface KeywordSet {\n  main: Set<string>;\n  local: Set<string>;\n}\n\nconst isPureTypeSpace = (path: NodePath): boolean => {\n  let current: NodePath | null = path;\n  while (current) {\n    const parent = current.parentPath;\n    if (!parent) {\n      break;\n    }\n    // 1. Value crossings via `typeof`\n    if (parent.isTSTypeQuery()) {\n      return false;\n    }\n    // 2. Computed keys (e.g., interface I { [Abc]: string })\n    if ('computed' in parent.node && parent.node.computed) {\n      if (current.key === 'key' || current.key === 'property') {\n        return false;\n      }\n    }\n    // 3-A. Definitive Type Contexts\n    if (\n      parent.isTSType() ||\n      parent.isTSTypeParameterDeclaration() ||\n      parent.isTSTypeParameterInstantiation() ||\n      parent.isTSExpressionWithTypeArguments()\n    ) {\n      return true;\n    }\n    // 3-B. Type Declaration Identifiers (e.g., interface Abc {}, type Abc = {})\n    if (\n      parent.isTSInterfaceDeclaration() ||\n      parent.isTSTypeAliasDeclaration() ||\n      parent.isTSEnumDeclaration() ||\n      parent.isTSModuleDeclaration()\n    ) {\n      if (current.key === 'id') {\n        return true;\n      }\n    }\n    // 4. Continue up structural TS nodes (A.B.C)\n    if (parent.isTSQualifiedName() || parent.isTSEntityName()) {\n      current = current.parentPath;\n      continue;\n    }\n    // 5. If we reach standard JS statements/expressions, it implies Value Space.\n    if (parent.isExpression() || parent.isStatement()) {\n      break;\n    }\n    current = current.parentPath;\n  }\n  return false;\n};\n\ninterface TransformState extends PluginPass {\n  keywords: KeywordSet;\n  keywordUids: {\n    main: Map<string, t.Identifier>;\n    local: Map<string, t.Identifier>;\n  };\n}\n\ninterface TransformMetadata {\n  keywords?: { main: string[]; local: string[] };\n}\n\nconst transformPlugin = (\n  mode: 'extract' | 'transform',\n): PluginObj<TransformState> => {\n  return {\n    name: `${PLUGIN_NAME}:${mode}`,\n\n    visitor: {\n      Program: {\n        enter(_, state) {\n          state.keywords = { main: new Set(), local: new Set() };\n          state.keywordUids = { main: new Map(), local: new Map() };\n        },\n\n        exit(path, state) {\n          const metadata = state.file.metadata as TransformMetadata;\n          metadata.keywords = {\n            main: Array.from(state.keywords.main),\n            local: Array.from(state.keywords.local),\n          };\n\n          if (mode === 'transform') {\n            const newImports = [];\n            for (const [keyword, safeId] of state.keywordUids.main.entries()) {\n              const encoded = encodeIdentifier(keyword);\n              newImports.push(\n                t.importDeclaration(\n                  [t.importDefaultSpecifier(safeId)],\n                  t.stringLiteral(\n                    `${VIRTUAL_MODULE_ID}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n                  ),\n                ),\n              );\n            }\n            for (const [keyword, safeId] of state.keywordUids.local.entries()) {\n              const encoded = encodeIdentifier(keyword);\n              newImports.push(\n                t.importDeclaration(\n                  [t.importDefaultSpecifier(safeId)],\n                  t.stringLiteral(\n                    `${VIRTUAL_LOCAL_MODULE_ID}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n                  ),\n                ),\n              );\n            }\n            if (newImports.length > 0) {\n              path.unshiftContainer('body', newImports);\n            }\n          }\n        },\n      },\n\n      ImportDeclaration(path, state) {\n        const sourceValue = path.node.source.value;\n        if (\n          sourceValue !== VIRTUAL_MODULE_ID &&\n          sourceValue !== VIRTUAL_LOCAL_MODULE_ID\n        ) {\n          return;\n        }\n        const isLocal = sourceValue === VIRTUAL_LOCAL_MODULE_ID;\n        const targetSet = isLocal ? state.keywords.local : state.keywords.main;\n        const targetMap = isLocal\n          ? state.keywordUids.local\n          : state.keywordUids.main;\n\n        const programScope = path.scope.getProgramParent();\n        const processKeyword = (keyword: string): t.Identifier | null => {\n          targetSet.add(keyword);\n          if (mode === 'extract') {\n            return null;\n          }\n          if (targetMap.has(keyword)) {\n            return targetMap.get(keyword) as t.Identifier;\n          }\n          const encoded = encodeIdentifier(keyword);\n          const safeName = toSafeVarName(encoded);\n          const uid = programScope.generateUidIdentifier(safeName);\n          targetMap.set(keyword, uid);\n          return uid;\n        };\n\n        for (const specifierPath of path.get('specifiers')) {\n          const localName = specifierPath.node.local.name;\n          const binding = path.scope.getBinding(localName);\n          if (!binding) {\n            continue;\n          }\n\n          // Case A: Default & Named Imports\n          if (\n            specifierPath.isImportDefaultSpecifier() ||\n            specifierPath.isImportSpecifier()\n          ) {\n            let keyword: string;\n            if (specifierPath.isImportDefaultSpecifier()) {\n              keyword = 'default';\n            } else {\n              const imported = specifierPath.node.imported;\n              keyword = t.isIdentifier(imported)\n                ? imported.name\n                : imported.value;\n            }\n            const uidNode = processKeyword(keyword);\n            if (!uidNode) {\n              continue;\n            }\n\n            // 1) Fast Path: Values & JSX\n            for (const refPath of binding.referencePaths) {\n              if (isPureTypeSpace(refPath)) {\n                continue;\n              }\n              if (refPath.isJSXIdentifier()) {\n                refPath.replaceWith(t.jsxIdentifier(uidNode.name));\n              } else {\n                refPath.replaceWith(t.cloneNode(uidNode));\n              }\n            }\n\n            // 2) Slow Path: TS Types\n            // NOTE: Can be skipped due to type erasure, but for consistency\n            path.parentPath.traverse({\n              // e.g., type T = typeof abc;\n              TSTypeQuery(tsPath) {\n                if (\n                  t.isIdentifier(tsPath.node.exprName) &&\n                  tsPath.node.exprName.name === localName &&\n                  tsPath.scope.getBinding(localName) === binding\n                ) {\n                  tsPath.get('exprName').replaceWith(t.cloneNode(uidNode));\n                }\n              },\n            });\n          }\n\n          // Case B: Namespace Imports\n          else if (specifierPath.isImportNamespaceSpecifier()) {\n            // 1) Fast Path: JS Values & JSX accesses\n            for (const refPath of binding.referencePaths) {\n              if (isPureTypeSpace(refPath)) {\n                continue;\n              }\n              const parentPath = refPath.parentPath;\n              if (!parentPath) {\n                continue;\n              }\n              if (\n                parentPath.isMemberExpression() &&\n                parentPath.node.object === refPath.node\n              ) {\n                const propNode = parentPath.node.property;\n                let keyword: string | undefined;\n                if (!parentPath.node.computed && t.isIdentifier(propNode)) {\n                  keyword = propNode.name;\n                } else if (\n                  parentPath.node.computed &&\n                  t.isStringLiteral(propNode)\n                ) {\n                  keyword = propNode.value;\n                }\n                if (keyword) {\n                  const uidNode = processKeyword(keyword);\n                  if (uidNode) {\n                    parentPath.replaceWith(t.cloneNode(uidNode));\n                  }\n                }\n              } else if (\n                parentPath.isJSXMemberExpression() &&\n                parentPath.node.object === refPath.node\n              ) {\n                const keyword = parentPath.node.property.name;\n                const uidNode = processKeyword(keyword);\n                if (uidNode) {\n                  parentPath.replaceWith(t.jsxIdentifier(uidNode.name));\n                }\n              }\n            }\n\n            // 2) Slow Path: TS Namespace Types\n            path.parentPath.traverse({\n              // e.g., type T = typeof A.abc;\n              TSTypeQuery(tsPath) {\n                const expr = tsPath.node.exprName;\n                if (\n                  t.isTSQualifiedName(expr) &&\n                  t.isIdentifier(expr.left) &&\n                  expr.left.name === localName &&\n                  tsPath.scope.getBinding(localName) === binding\n                ) {\n                  const keyword = expr.right.name;\n                  const uidNode = processKeyword(keyword);\n                  if (uidNode) {\n                    tsPath.get('exprName').replaceWith(t.cloneNode(uidNode));\n                  }\n                }\n              },\n\n              // e.g., type T = ((typeof A))['prop'];\n              TSIndexedAccessType(tsPath) {\n                let objPath = tsPath.get('objectType') as NodePath;\n                // Unpack highly nested parentheses gracefully\n                while (objPath.isTSParenthesizedType()) {\n                  objPath = objPath.get('typeAnnotation') as NodePath;\n                }\n                if (\n                  objPath.isTSTypeQuery() &&\n                  t.isIdentifier(objPath.node.exprName) &&\n                  objPath.node.exprName.name === localName &&\n                  tsPath.scope.getBinding(localName) === binding\n                ) {\n                  const indexNode = tsPath.node.indexType;\n                  if (\n                    t.isTSLiteralType(indexNode) &&\n                    t.isStringLiteral(indexNode.literal)\n                  ) {\n                    const keyword = indexNode.literal.value;\n                    const uidNode = processKeyword(keyword);\n                    if (uidNode) {\n                      tsPath.replaceWith(t.tsTypeQuery(t.cloneNode(uidNode)));\n                    }\n                  }\n                }\n              },\n            });\n          }\n        }\n\n        if (mode === 'transform') {\n          path.remove();\n        }\n      },\n\n      ExportNamedDeclaration(path, state) {\n        const sourceValue = path.node.source?.value;\n        if (\n          sourceValue !== VIRTUAL_MODULE_ID &&\n          sourceValue !== VIRTUAL_LOCAL_MODULE_ID\n        ) {\n          return;\n        }\n        const isLocal = sourceValue === VIRTUAL_LOCAL_MODULE_ID;\n        const targetSet = isLocal ? state.keywords.local : state.keywords.main;\n\n        if (mode === 'extract') {\n          for (const specifierPath of path.get('specifiers')) {\n            if (specifierPath.isExportSpecifier()) {\n              const local = specifierPath.node.local as\n                | t.Identifier\n                | t.StringLiteral; // local can be a StringLiteral in ES2022\n              const keyword = t.isIdentifier(local) ? local.name : local.value;\n              targetSet.add(keyword);\n            }\n          }\n          return;\n        }\n\n        const newExports = path\n          .get('specifiers')\n          .map((specifierPath) => {\n            if (specifierPath.isExportSpecifier()) {\n              const local = specifierPath.node.local as\n                | t.Identifier\n                | t.StringLiteral; // local can be a StringLiteral in ES2022\n              const keyword = t.isIdentifier(local) ? local.name : local.value;\n              targetSet.add(keyword);\n              const encoded = encodeIdentifier(keyword);\n              return t.exportNamedDeclaration(\n                null,\n                [\n                  t.exportSpecifier(\n                    t.identifier('default'),\n                    specifierPath.node.exported,\n                  ),\n                ],\n                t.stringLiteral(\n                  `${sourceValue}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n                ),\n              );\n            }\n            return null;\n          })\n          .filter((node): node is t.ExportNamedDeclaration => node !== null);\n\n        if (newExports.length > 0) {\n          path.replaceWithMultiple(newExports);\n        } else {\n          path.remove();\n        }\n      },\n    },\n  };\n};\n\nexport const transformCode = (\n  code: string,\n  id: string,\n): {\n  code: string;\n  map: NonNullable<BabelFileResult['map']> | null;\n  keywords: KeywordSet;\n} | null => {\n  if (\n    !code.includes(VIRTUAL_MODULE_ID) &&\n    !code.includes(VIRTUAL_LOCAL_MODULE_ID)\n  ) {\n    return null;\n  }\n  const result = transformSync(code, {\n    babelrc: false,\n    configFile: false,\n    filename: id,\n    sourceMaps: true,\n    ast: false,\n    plugins: [transformPlugin('transform')],\n    parserOpts: {\n      plugins: ['jsx', 'typescript'],\n    },\n  });\n  if (!result) {\n    return null;\n  }\n  const metadata = result.metadata as TransformMetadata | undefined;\n  const keywords: KeywordSet = {\n    main: new Set(metadata?.keywords?.main ?? []),\n    local: new Set(metadata?.keywords?.local ?? []),\n  };\n  return {\n    code: result.code ?? '',\n    map: result.map ?? null,\n    keywords,\n  };\n};\n\nexport const extractKeywords = (code: string): KeywordSet | null => {\n  if (\n    !code.includes(VIRTUAL_MODULE_ID) &&\n    !code.includes(VIRTUAL_LOCAL_MODULE_ID)\n  ) {\n    return null;\n  }\n  let result: BabelFileResult | null;\n  try {\n    result = transformSync(code, {\n      babelrc: false,\n      configFile: false,\n      sourceMaps: false,\n      ast: false,\n      code: false,\n      plugins: [transformPlugin('extract')],\n      parserOpts: {\n        plugins: ['jsx', 'typescript'],\n        errorRecovery: true,\n      },\n    });\n  } catch {\n    return null;\n  }\n  if (!result) {\n    return null;\n  }\n  const metadata = result.metadata as TransformMetadata | undefined;\n  return {\n    main: new Set(metadata?.keywords?.main ?? []),\n    local: new Set(metadata?.keywords?.local ?? []),\n  };\n};\n","import { DEBUG_SEPARATOR, HASH_LENGTH } from './constants.js';\nimport { encodeIdentifier, toSafeVarName } from './encode.js';\n\nexport const generateTypeDeclaration = (\n  keywords: Set<string>,\n  isLocal: boolean = false,\n): string => {\n  const sortedKeywords = Array.from(keywords).sort();\n  const content = [];\n  // content.push(\n  //   'type Keyword<K extends string, V extends string> = V & { readonly __keyword__: K };',\n  // );\n  // content.push('');\n\n  for (const keyword of sortedKeywords) {\n    const encoded = encodeIdentifier(keyword);\n    const safeName = toSafeVarName(encoded);\n    const hash = isLocal ? '==' : '*'.repeat(HASH_LENGTH);\n    const value = `${hash}${DEBUG_SEPARATOR}${keyword}`;\n    // content.push(\n    //   `declare const ${safeName}: Keyword<${JSON.stringify(keyword)}, ${JSON.stringify(value)}>;`,\n    // );\n    content.push(`declare const ${safeName}: ${JSON.stringify(value)};`);\n  }\n  content.push('');\n\n  content.push('export {');\n  for (const keyword of sortedKeywords) {\n    const encoded = encodeIdentifier(keyword);\n    const safeName = toSafeVarName(encoded);\n    content.push(`  ${safeName} as ${JSON.stringify(keyword)},`);\n  }\n  content.push('};');\n  content.push('');\n\n  return content.join('\\n');\n};\n","import { mkdir, readFile, writeFile } from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { globby } from 'globby';\nimport pLimit from 'p-limit';\nimport { extractKeywords, type KeywordSet } from './transform.js';\nimport { generateTypeDeclaration } from './typegen.js';\n\nconst collectKeywordsFromRoot = async (\n  root: string,\n  silent: boolean,\n  ignoredDirs: string[] = [],\n  concurrency: number = 100,\n): Promise<KeywordSet> => {\n  const collectedKeywords: KeywordSet = { main: new Set(), local: new Set() };\n\n  const start = performance.now();\n  if (!silent) {\n    console.error('Scanning project files for keywords...');\n  }\n\n  const files = await globby('**/*.{js,ts,mjs,mts,jsx,tsx,mjsx,mtsx}', {\n    cwd: root,\n    absolute: false,\n    ignore: ['**/node_modules/**', ...ignoredDirs.map((dir) => `${dir}/**`)],\n    gitignore: true,\n  });\n\n  let processed = 0;\n  const limit = pLimit({ concurrency });\n  await limit.map(files, async (file) => {\n    try {\n      const code = await readFile(file, 'utf-8');\n      const keywords = extractKeywords(code);\n      if (!keywords) {\n        return;\n      }\n      for (const keyword of keywords.main) {\n        collectedKeywords.main.add(keyword);\n      }\n      for (const keyword of keywords.local) {\n        collectedKeywords.local.add(keyword);\n      }\n      processed++;\n    } catch (error) {\n      if (!silent) {\n        console.error(`Failed to process ${file}: ${error}`);\n      }\n    }\n  });\n\n  const elapsed = performance.now() - start;\n  if (!silent) {\n    console.error(\n      `Scan complete: ${processed}/${files.length} files, ${collectedKeywords.main.size} main, ${collectedKeywords.local.size} local keywords (${elapsed.toFixed(2)}ms).`,\n    );\n  }\n\n  return collectedKeywords;\n};\n\ninterface RunnerOptions {\n  root: string;\n  silent: boolean;\n  outDir: string;\n}\n\nexport const createRunner = (options?: Partial<RunnerOptions>) => {\n  const {\n    root = process.cwd(),\n    silent = false,\n    outDir = path.join('node_modules', '.keywords'),\n  } = options ?? {};\n  return {\n    async collect(): Promise<KeywordSet> {\n      return collectKeywordsFromRoot(root, silent);\n    },\n\n    async save(keywords: KeywordSet): Promise<void> {\n      const content = generateTypeDeclaration(keywords.main);\n      const localContent = generateTypeDeclaration(keywords.local, true);\n      const outPath = path.join(root, outDir);\n      await mkdir(outPath, { recursive: true });\n      await writeFile(path.join(outPath, 'index.d.ts'), `${content.trim()}\\n`);\n      await writeFile(\n        path.join(outPath, 'local.d.ts'),\n        `${localContent.trim()}\\n`,\n      );\n    },\n\n    async run(): Promise<void> {\n      const keywords = await this.collect();\n      await this.save(keywords);\n    },\n  };\n};\n","import { createHmac } from 'node:crypto';\nimport { HASH_LENGTH } from './constants.js';\n\nconst ALPHA_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst DIGIT_CHARS = '0123456789';\nconst BASE62_CHARS = ALPHA_CHARS + DIGIT_CHARS;\n\nconst ALPHA_LEN = BigInt(ALPHA_CHARS.length); // 52n\nconst DIGIT_LEN = BigInt(DIGIT_CHARS.length); // 10n\nconst BASE62_LEN = BigInt(BASE62_CHARS.length); // 62n\n\nexport type Hasher = (input: string) => string;\n\n// Format: [1 Alpha] + [1 Digit] + [N Base62]\n// Avoids any collisions with standard JS API identifiers\nexport const createHasher = (secret: string): Hasher => {\n  const base62TailLength = HASH_LENGTH - 2;\n  if (base62TailLength < 0 || base62TailLength > 9) {\n    // 520 * 62^9 < 2^64 < 520 * 62^10\n    throw new Error('Invalid MAX_HASH_LENGTH');\n  }\n\n  const cache = new Map<string, string>();\n  return (input) => {\n    if (cache.has(input)) {\n      return cache.get(input) as string;\n    }\n\n    const hasher = createHmac('sha256', secret);\n    const buffer = hasher.update(input).digest();\n\n    let entropy = buffer.readBigUInt64BE(0);\n    let result = '';\n\n    result += ALPHA_CHARS[Number(entropy % ALPHA_LEN)];\n    entropy /= ALPHA_LEN;\n    result += DIGIT_CHARS[Number(entropy % DIGIT_LEN)];\n    entropy /= DIGIT_LEN;\n    for (let i = 0; i < base62TailLength; i++) {\n      result += BASE62_CHARS[Number(entropy % BASE62_LEN)];\n      entropy /= BASE62_LEN;\n    }\n\n    cache.set(input, result);\n    return result;\n  };\n};\n\nexport const createCounter = (): Hasher => {\n  let index = 0;\n  return () => {\n    let result = '_';\n\n    result += ALPHA_CHARS[index % ALPHA_CHARS.length];\n    let remain = Math.floor(index / ALPHA_CHARS.length);\n    while (remain > 0) {\n      remain--;\n      result += BASE62_CHARS[remain % BASE62_CHARS.length];\n      remain = Math.floor(remain / BASE62_CHARS.length);\n    }\n\n    index++;\n    return result;\n  };\n};\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { t as Options } from "./plugin-Coz4K9xU.js";
+import * as _$unplugin from "unplugin";
+
+//#region src/index.d.ts
+declare const _default: _$unplugin.UnpluginInstance<Options, boolean>;
+//#endregion
+export { type Options, _default as default };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,8 @@
+import { t as unpluginFactory } from "./plugin-Cj1x2KK1.js";
+import { createUnplugin } from "unplugin";
+//#region src/index.ts
+var src_default = createUnplugin(unpluginFactory);
+//#endregion
+export { src_default as default };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { createUnplugin } from 'unplugin';\nimport { type Options, unpluginFactory } from './internal/plugin.js';\n\nexport default createUnplugin(unpluginFactory);\nexport type { Options };\n"],"mappings":";;;AAGA,IAAA,cAAe,eAAe,gBAAgB"}

package/dist/plugin-Cj1x2KK1.js

@@ -0,0 +1,125 @@
+import { a as transformCode, c as VIRTUAL_LOCAL_MODULE_ID, i as extractKeywords, l as VIRTUAL_MODULE_ID, n as createHasher, o as encodeIdentifier, r as createRunner, s as PLUGIN_NAME, t as createCounter } from "./hash-DMsO2VqQ.js";
+import { readFile } from "node:fs/promises";
+import pLimit from "p-limit";
+//#region src/internal/plugin.ts
+const resolveId = (id) => `\0${id}`;
+const splitQuery = (id) => {
+	const index = id.indexOf("?");
+	if (index === -1) return [id, void 0];
+	return [id.slice(0, index), id.slice(index + 1)];
+};
+const toIncludes = (id) => [new RegExp(`^${id}/`)];
+const SUFFIX_REGEX = /\.m?[jt]sx?$/;
+const COMMON_EXCLUDES = [/\/node_modules\//];
+const unpluginFactory = ({ isDev, secret }) => {
+	const runner = createRunner({ silent: true });
+	const runnerLimit = pLimit({ concurrency: 1 });
+	const allKeywords = {
+		main: /* @__PURE__ */ new Set(),
+		local: /* @__PURE__ */ new Set()
+	};
+	let isInitialized = false;
+	const runInit = async () => {
+		try {
+			const keywords = await runner.collect();
+			for (const keyword of keywords.main) allKeywords.main.add(keyword);
+			for (const keyword of keywords.local) allKeywords.local.add(keyword);
+			await runner.save(allKeywords);
+			isInitialized = true;
+		} catch {}
+	};
+	let hasherMain;
+	let hasherLocal;
+	let resolvedMap;
+	return {
+		name: PLUGIN_NAME,
+		buildStart() {
+			hasherMain = createHasher(secret);
+			hasherLocal = createCounter();
+			resolvedMap = /* @__PURE__ */ new Map();
+			runnerLimit(async () => {
+				if (!isInitialized) await runInit();
+			});
+		},
+		resolveId: {
+			filter: { id: {
+				include: [...toIncludes(VIRTUAL_MODULE_ID), ...toIncludes(VIRTUAL_LOCAL_MODULE_ID)],
+				exclude: COMMON_EXCLUDES
+			} },
+			handler(id) {
+				return resolveId(id);
+			}
+		},
+		load: {
+			filter: { id: {
+				include: [...toIncludes(resolveId(VIRTUAL_MODULE_ID)), ...toIncludes(resolveId(VIRTUAL_LOCAL_MODULE_ID))],
+				exclude: COMMON_EXCLUDES
+			} },
+			handler(id) {
+				const [validId] = splitQuery(id);
+				if (resolvedMap.has(validId)) return resolvedMap.get(validId);
+				return null;
+			}
+		},
+		transform: {
+			filter: {
+				id: {
+					include: [SUFFIX_REGEX],
+					exclude: COMMON_EXCLUDES
+				},
+				code: { include: [VIRTUAL_MODULE_ID, VIRTUAL_LOCAL_MODULE_ID] }
+			},
+			handler(code, id) {
+				const result = transformCode(code, id);
+				if (!result) return null;
+				const { code: transformed, map, keywords } = result;
+				for (const keyword of keywords.main) {
+					const resolvedId = resolveId(`${VIRTUAL_MODULE_ID}/_/${encodeIdentifier(keyword)}`);
+					const hash = hasherMain(keyword);
+					const value = isDev ? `${hash}.${keyword}` : hash;
+					resolvedMap.set(resolvedId, `export default ${JSON.stringify(value)};\n`);
+				}
+				for (const keyword of keywords.local) {
+					const resolvedId = resolveId(`${VIRTUAL_LOCAL_MODULE_ID}/_/${encodeIdentifier(keyword)}`);
+					const hash = hasherLocal(keyword);
+					const value = isDev ? `${hash}.${keyword}` : hash;
+					resolvedMap.set(resolvedId, `export default ${JSON.stringify(value)};\n`);
+				}
+				return {
+					code: transformed,
+					map
+				};
+			}
+		},
+		async watchChange(id, { event }) {
+			if (!SUFFIX_REGEX.test(id) || COMMON_EXCLUDES.some((regex) => regex.test(id)) || event === "delete") return;
+			let code;
+			try {
+				code = await readFile(id, "utf-8");
+			} catch {
+				return;
+			}
+			const keywords = extractKeywords(code);
+			if (!keywords) return;
+			let isAdded = false;
+			for (const keyword of keywords.main) if (!allKeywords.main.has(keyword)) {
+				allKeywords.main.add(keyword);
+				isAdded = true;
+			}
+			for (const keyword of keywords.local) if (!allKeywords.local.has(keyword)) {
+				allKeywords.local.add(keyword);
+				isAdded = true;
+			}
+			if (!isInitialized || isAdded) runnerLimit(async () => {
+				if (!isInitialized) await runInit();
+				else if (isAdded) try {
+					await runner.save(allKeywords);
+				} catch {}
+			});
+		}
+	};
+};
+//#endregion
+export { unpluginFactory as t };
+
+//# sourceMappingURL=plugin-Cj1x2KK1.js.map

package/dist/plugin-Cj1x2KK1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-Cj1x2KK1.js","names":[],"sources":["../src/internal/plugin.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport pLimit from 'p-limit';\nimport type { UnpluginFactory } from 'unplugin';\nimport { createRunner } from './cli.js';\nimport {\n  DEBUG_SEPARATOR,\n  KEYWORD_ROUTE_SEGMENT,\n  PLUGIN_NAME,\n  VIRTUAL_LOCAL_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n} from './constants.js';\nimport { encodeIdentifier } from './encode.js';\nimport { createCounter, createHasher, type Hasher } from './hash.js';\nimport {\n  extractKeywords,\n  type KeywordSet,\n  transformCode,\n} from './transform.js';\n\nconst resolveId = (id: string): string => `\\0${id}`;\n\nconst splitQuery = (id: string): [string, string | undefined] => {\n  const index = id.indexOf('?');\n  if (index === -1) {\n    return [id, undefined];\n  }\n  return [id.slice(0, index), id.slice(index + 1)];\n};\n\nconst toIncludes = (id: string): RegExp[] => [new RegExp(`^${id}/`)];\n\nconst SUFFIX_REGEX = /\\.m?[jt]sx?$/;\nconst COMMON_EXCLUDES = [/\\/node_modules\\//];\n\nexport interface Options {\n  /**\n   * If true, preserves the original keyword as a suffix in the generated\n   * identifier for easier debugging (e.g., `\"zXpL21k.SET_USER\"`).\n   */\n  isDev: boolean;\n  /**\n   * The cryptographic key used to initialize the deterministic HMAC algorithm.\n   * Modifying this value will globally rotate all generated hashes.\n   * To ensure cross-boundary consistency between independent builds,\n   * they must share the same secret key.\n   */\n  secret: string;\n}\n\nexport const unpluginFactory: UnpluginFactory<Options> = ({\n  isDev,\n  secret,\n}) => {\n  const runner = createRunner({ silent: true });\n  const runnerLimit = pLimit({ concurrency: 1 });\n  const allKeywords: KeywordSet = { main: new Set(), local: new Set() };\n\n  let isInitialized = false;\n  const runInit = async () => {\n    try {\n      const keywords = await runner.collect();\n      for (const keyword of keywords.main) {\n        allKeywords.main.add(keyword);\n      }\n      for (const keyword of keywords.local) {\n        allKeywords.local.add(keyword);\n      }\n      await runner.save(allKeywords);\n      isInitialized = true;\n    } catch {}\n  };\n\n  let hasherMain: Hasher;\n  let hasherLocal: Hasher;\n  let resolvedMap: Map<string, string>;\n\n  return {\n    name: PLUGIN_NAME,\n\n    buildStart() {\n      hasherMain = createHasher(secret);\n      hasherLocal = createCounter();\n      resolvedMap = new Map();\n      runnerLimit(async () => {\n        if (!isInitialized) {\n          await runInit();\n        }\n      });\n    },\n\n    resolveId: {\n      filter: {\n        id: {\n          include: [\n            ...toIncludes(VIRTUAL_MODULE_ID),\n            ...toIncludes(VIRTUAL_LOCAL_MODULE_ID),\n          ],\n          exclude: COMMON_EXCLUDES,\n        },\n      },\n      handler(id) {\n        return resolveId(id);\n      },\n    },\n\n    load: {\n      filter: {\n        id: {\n          include: [\n            ...toIncludes(resolveId(VIRTUAL_MODULE_ID)),\n            ...toIncludes(resolveId(VIRTUAL_LOCAL_MODULE_ID)),\n          ],\n          exclude: COMMON_EXCLUDES,\n        },\n      },\n      handler(id) {\n        const [validId] = splitQuery(id);\n        if (resolvedMap.has(validId)) {\n          return resolvedMap.get(validId);\n        }\n        return null;\n      },\n    },\n\n    transform: {\n      filter: {\n        id: {\n          include: [SUFFIX_REGEX],\n          exclude: COMMON_EXCLUDES,\n        },\n        code: {\n          include: [VIRTUAL_MODULE_ID, VIRTUAL_LOCAL_MODULE_ID],\n        },\n      },\n      handler(code, id) {\n        const result = transformCode(code, id);\n        if (!result) {\n          return null;\n        }\n        const { code: transformed, map, keywords } = result;\n        for (const keyword of keywords.main) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_MODULE_ID}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n          );\n          const hash = hasherMain(keyword);\n          const value = isDev ? `${hash}${DEBUG_SEPARATOR}${keyword}` : hash;\n          resolvedMap.set(\n            resolvedId,\n            `export default ${JSON.stringify(value)};\\n`,\n          );\n        }\n        for (const keyword of keywords.local) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_LOCAL_MODULE_ID}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n          );\n          const hash = hasherLocal(keyword);\n          const value = isDev ? `${hash}${DEBUG_SEPARATOR}${keyword}` : hash;\n          resolvedMap.set(\n            resolvedId,\n            `export default ${JSON.stringify(value)};\\n`,\n          );\n        }\n        return { code: transformed, map };\n      },\n    },\n\n    async watchChange(id, { event }) {\n      if (\n        !SUFFIX_REGEX.test(id) ||\n        COMMON_EXCLUDES.some((regex) => regex.test(id)) ||\n        event === 'delete'\n      ) {\n        return;\n      }\n      let code: string;\n      try {\n        code = await readFile(id, 'utf-8');\n      } catch {\n        return;\n      }\n      const keywords = extractKeywords(code);\n      if (!keywords) {\n        return;\n      }\n      let isAdded = false;\n      for (const keyword of keywords.main) {\n        if (!allKeywords.main.has(keyword)) {\n          allKeywords.main.add(keyword);\n          isAdded = true;\n        }\n      }\n      for (const keyword of keywords.local) {\n        if (!allKeywords.local.has(keyword)) {\n          allKeywords.local.add(keyword);\n          isAdded = true;\n        }\n      }\n      if (!isInitialized || isAdded) {\n        runnerLimit(async () => {\n          if (!isInitialized) {\n            await runInit();\n          } else if (isAdded) {\n            try {\n              await runner.save(allKeywords);\n            } catch {}\n          }\n        });\n      }\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/plugin-Coz4K9xU.d.ts

@@ -0,0 +1,18 @@
+//#region src/internal/plugin.d.ts
+interface Options {
+  /**
+   * If true, preserves the original keyword as a suffix in the generated
+   * identifier for easier debugging (e.g., `"zXpL21k.SET_USER"`).
+   */
+  isDev: boolean;
+  /**
+   * The cryptographic key used to initialize the deterministic HMAC algorithm.
+   * Modifying this value will globally rotate all generated hashes.
+   * To ensure cross-boundary consistency between independent builds,
+   * they must share the same secret key.
+   */
+  secret: string;
+}
+//#endregion
+export { Options as t };
+//# sourceMappingURL=plugin-Coz4K9xU.d.ts.map

package/dist/rollup.d.ts

@@ -0,0 +1,7 @@
+import { t as Options } from "./plugin-Coz4K9xU.js";
+
+//#region src/rollup.d.ts
+declare const _default: (options: Options) => any;
+//#endregion
+export { type Options, _default as default };
+//# sourceMappingURL=rollup.d.ts.map

package/dist/rollup.js

@@ -0,0 +1,8 @@
+import { t as unpluginFactory } from "./plugin-Cj1x2KK1.js";
+import { createRollupPlugin } from "unplugin";
+//#region src/rollup.ts
+var rollup_default = createRollupPlugin(unpluginFactory);
+//#endregion
+export { rollup_default as default };
+
+//# sourceMappingURL=rollup.js.map

package/dist/rollup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.js","names":[],"sources":["../src/rollup.ts"],"sourcesContent":["import { createRollupPlugin } from 'unplugin';\nimport { type Options, unpluginFactory } from './internal/plugin.js';\n\nexport default createRollupPlugin(unpluginFactory);\nexport type { Options };\n"],"mappings":";;;AAGA,IAAA,iBAAe,mBAAmB,gBAAgB"}

package/dist/vite.d.ts

@@ -0,0 +1,8 @@
+import { t as Options } from "./plugin-Coz4K9xU.js";
+import * as _$unplugin from "unplugin";
+
+//#region src/vite.d.ts
+declare const _default: (options: Options) => _$unplugin.VitePlugin<any> | _$unplugin.VitePlugin<any>[];
+//#endregion
+export { type Options, _default as default };
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.js

@@ -0,0 +1,8 @@
+import { t as unpluginFactory } from "./plugin-Cj1x2KK1.js";
+import { createVitePlugin } from "unplugin";
+//#region src/vite.ts
+var vite_default = createVitePlugin(unpluginFactory);
+//#endregion
+export { vite_default as default };
+
+//# sourceMappingURL=vite.js.map

package/dist/vite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.js","names":[],"sources":["../src/vite.ts"],"sourcesContent":["import { createVitePlugin } from 'unplugin';\nimport { type Options, unpluginFactory } from './internal/plugin.js';\n\nexport default createVitePlugin(unpluginFactory);\nexport type { Options };\n"],"mappings":";;;AAGA,IAAA,eAAe,iBAAiB,gBAAgB"}

package/dist/webpack.d.ts

@@ -0,0 +1,7 @@
+import { t as Options } from "./plugin-Coz4K9xU.js";
+
+//#region src/webpack.d.ts
+declare const _default: (options: Options) => WebpackPluginInstance;
+//#endregion
+export { type Options, _default as default };
+//# sourceMappingURL=webpack.d.ts.map

package/dist/webpack.js

@@ -0,0 +1,8 @@
+import { t as unpluginFactory } from "./plugin-Cj1x2KK1.js";
+import { createWebpackPlugin } from "unplugin";
+//#region src/webpack.ts
+var webpack_default = createWebpackPlugin(unpluginFactory);
+//#endregion
+export { webpack_default as default };
+
+//# sourceMappingURL=webpack.js.map

package/dist/webpack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.js","names":[],"sources":["../src/webpack.ts"],"sourcesContent":["import { createWebpackPlugin } from 'unplugin';\nimport { type Options, unpluginFactory } from './internal/plugin.js';\n\nexport default createWebpackPlugin(unpluginFactory);\nexport type { Options };\n"],"mappings":";;;AAGA,IAAA,kBAAe,oBAAoB,gBAAgB"}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "unplugin-keywords",
+  "version": "2.5.1",
+  "description": "A build plugin for structural string literal minification and obfuscation.",
+  "keywords": [
+    "unplugin",
+    "rollup",
+    "rollup-plugin",
+    "vite",
+    "vite-plugin",
+    "minification",
+    "obfuscation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cueaz/unplugin-keywords.git"
+  },
+  "license": "MIT",
+  "author": "cueaz",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/api.d.ts",
+      "default": "./dist/api.js"
+    },
+    "./esbuild": {
+      "types": "./dist/esbuild.d.ts",
+      "default": "./dist/esbuild.js"
+    },
+    "./rollup": {
+      "types": "./dist/rollup.d.ts",
+      "default": "./dist/rollup.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "default": "./dist/vite.js"
+    },
+    "./webpack": {
+      "types": "./dist/webpack.d.ts",
+      "default": "./dist/webpack.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "keywords": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.29.0",
+    "globby": "^16.2.0",
+    "p-limit": "^7.3.0",
+    "unplugin": "^3.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.14",
+    "@tsconfig/bases": "^1.0.23",
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "^25.6.0",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "precheck": "pnpm --filter \"./demo/*\" typegen",
+    "check": "tsc --build && biome check",
+    "format": "biome check --write",
+    "build": "tsdown",
+    "build:demo": "pnpm --filter \"./demo/*\" build",
+    "test": "vitest run",
+    "test:demo": "pnpm --filter \"./demo/*\" test"
+  }
+}