unplugin-keywords 2.11.1 → 2.12.0

package/README.md

@@ -13,18 +13,18 @@
 
 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.
+`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 allows 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 from '~keywords'`). Developers unambiguously declare which identifiers are safe to obfuscate directly in the source code.
+  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 from '~keywords'`). Developers clearly state 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 `~keywords/public` relies on deterministic hashing, identical keys inherently produce identical hashes across independent builds, preserving structural contracts.
+  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 `~keywords/public` relies on deterministic hashing, identical keys always produce the same hashes across independent builds, 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:**
@@ -53,7 +53,7 @@ Standard minifiers operate exclusively on variable bindings and function names,
 `unplugin-keywords` solves this 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.
+Developers reference strings via a virtual module. The strongly recommended pattern is to use a namespace import (`import * as K`), which clearly marks keyword usage throughout the file.
 
 ```ts
 import * as K from '~keywords';

package/dist/api.js

@@ -1,4 +1,4 @@
-import { a as transformCode, i as extractKeywords, n as createHasher, r as createRunner, t as createCounter } from "./hash-CKju2_N1.js";
+import { a as transformCode, i as extractKeywords, n as createHasher, r as createRunner, t as createCounter } from "./hash-BJl6coaB.js";
 //#region src/api.ts
 /**
 * @license

package/dist/bun.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createBunPlugin } from "unplugin";
 //#region src/bun.ts
 /**

package/dist/esbuild.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createEsbuildPlugin } from "unplugin";
 //#region src/esbuild.ts
 /**

package/dist/farm.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createFarmPlugin } from "unplugin";
 //#region src/farm.ts
 /**

package/dist/{hash-CKju2_N1.js → hash-BJl6coaB.js}

@@ -11,6 +11,8 @@ import { createHmac, hkdfSync } from "node:crypto";
 */
 const VIRTUAL_MODULE_ID = "~keywords";
 const VIRTUAL_PUBLIC_MODULE_ID = "~keywords/public";
+const VIRTUAL_INTERNAL_MODULE_ID = "~keywords-internal";
+const VIRTUAL_INTERNAL_PUBLIC_MODULE_ID = "~keywords-internal/public";
 const PLUGIN_NAME = "unplugin-keywords";
 //#endregion
 //#region src/internal/encode.ts
@@ -82,11 +84,11 @@ const transformPlugin = (mode) => {
 						const newImports = [];
 						for (const [keyword, safeId] of state.keywordUids.local.entries()) {
 							const encoded = encodeIdentifier(keyword);
-							newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_MODULE_ID}/_/${encoded}`)));
+							newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_INTERNAL_MODULE_ID}/_/${encoded}`)));
 						}
 						for (const [keyword, safeId] of state.keywordUids.public.entries()) {
 							const encoded = encodeIdentifier(keyword);
-							newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_PUBLIC_MODULE_ID}/_/${encoded}`)));
+							newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_INTERNAL_PUBLIC_MODULE_ID}/_/${encoded}`)));
 						}
 						if (newImports.length > 0) path.unshiftContainer("body", newImports);
 					}
@@ -177,7 +179,8 @@ const transformPlugin = (mode) => {
 			ExportNamedDeclaration(path, state) {
 				const sourceValue = path.node.source?.value;
 				if (sourceValue !== "~keywords" && sourceValue !== "~keywords/public") return;
-				const targetSet = sourceValue === "~keywords/public" ? state.keywords.public : state.keywords.local;
+				const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;
+				const targetSet = isPublic ? state.keywords.public : state.keywords.local;
 				if (mode === "extract") {
 					for (const specifierPath of path.get("specifiers")) if (specifierPath.isExportSpecifier()) {
 						const local = specifierPath.node.local;
@@ -192,7 +195,8 @@ const transformPlugin = (mode) => {
 						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}`));
+						const targetModuleId = isPublic ? VIRTUAL_INTERNAL_PUBLIC_MODULE_ID : VIRTUAL_INTERNAL_MODULE_ID;
+						return types.exportNamedDeclaration(null, [types.exportSpecifier(types.identifier("default"), specifierPath.node.exported)], types.stringLiteral(`${targetModuleId}/_/${encoded}`));
 					}
 					return null;
 				}).filter((node) => node !== null);
@@ -317,9 +321,7 @@ const pkgJson = {
 	sideEffects: false,
 	exports: {
 		".": { types: "./index.d.ts" },
-		"./public": { types: "./public.d.ts" },
-		[`./_/*`]: `./_/*`,
-		[`./public/_/*`]: `./public/_/*`
+		"./public": { types: "./public.d.ts" }
 	}
 };
 const createRunner = (options) => {
@@ -344,8 +346,8 @@ const createRunner = (options) => {
 	};
 };
 //#endregion
-//#region \0virtual:virtual:blacklist
-var _virtual_virtual_blacklist_default = new Set([
+//#region \0virtual:blacklist
+var _virtual_blacklist_default = new Set([
 	"$",
 	"$$",
 	"$0",
@@ -2694,7 +2696,7 @@ const createHasher = (secret) => {
 				result += BASE62_CHARS[Number(entropy % BASE62_LEN)];
 				entropy /= BASE62_LEN;
 			}
-		} while (_virtual_virtual_blacklist_default.has(result));
+		} while (_virtual_blacklist_default.has(result));
 		cache.set(input, result);
 		return result;
 	};
@@ -2733,12 +2735,12 @@ const createCounter = (secret) => {
 				result += shuffledBase62[current % shuffledBase62.length];
 				current = Math.floor(current / shuffledBase62.length);
 			}
-		} while (_virtual_virtual_blacklist_default.has(result));
+		} while (_virtual_blacklist_default.has(result));
 		cache.set(input, result);
 		return result;
 	};
 };
 //#endregion
-export { transformCode as a, VIRTUAL_MODULE_ID as c, extractKeywords as i, VIRTUAL_PUBLIC_MODULE_ID as l, createHasher as n, encodeIdentifier as o, createRunner as r, PLUGIN_NAME as s, createCounter as t };
+export { transformCode as a, VIRTUAL_INTERNAL_MODULE_ID as c, VIRTUAL_PUBLIC_MODULE_ID as d, extractKeywords as i, VIRTUAL_INTERNAL_PUBLIC_MODULE_ID as l, createHasher as n, encodeIdentifier as o, createRunner as r, PLUGIN_NAME as s, createCounter as t, VIRTUAL_MODULE_ID as u };
 
-//# sourceMappingURL=hash-CKju2_N1.js.map
+//# sourceMappingURL=hash-BJl6coaB.js.map

package/dist/hash-BJl6coaB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-BJl6coaB.js","names":["t","blacklist","info"],"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":["/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nexport const VIRTUAL_MODULE_ID = '~keywords';\nexport const VIRTUAL_PUBLIC_MODULE_ID = '~keywords/public';\n\nexport const VIRTUAL_INTERNAL_MODULE_ID = '~keywords-internal';\nexport const VIRTUAL_INTERNAL_PUBLIC_MODULE_ID = '~keywords-internal/public';\n\nexport const PLUGIN_NAME = 'unplugin-keywords';\n\nexport const HASH_LENGTH = 7;\n\nexport const KEYWORD_ROUTE = '_';\n\n// URL-safe so that K.abc can be used in URL\nexport const DEBUG_SEPARATOR = '.';\n","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\ndeclare 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","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport {\n  type FileResult,\n  type NodePath,\n  type PluginItem,\n  type PluginObject,\n  type PluginPass,\n  types as t,\n  transformSync,\n} from '@babel/core';\nimport {\n  KEYWORD_ROUTE,\n  PLUGIN_NAME,\n  VIRTUAL_INTERNAL_MODULE_ID,\n  VIRTUAL_INTERNAL_PUBLIC_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n} from './constants.js';\nimport { encodeIdentifier, toSafeVarName } from './encode.js';\n\nexport interface KeywordSet {\n  local: Set<string>;\n  public: 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.isTSClassImplements() ||\n      parent.isTSInterfaceHeritage()\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    local: Map<string, t.Identifier>;\n    public: Map<string, t.Identifier>;\n  };\n}\n\ninterface TransformMetadata {\n  keywords?: { local: string[]; public: string[] };\n}\n\nconst transformPlugin = (mode: 'extract' | 'transform'): PluginItem => {\n  const plugin: PluginObject<TransformState> = {\n    name: `${PLUGIN_NAME}:${mode}`,\n\n    visitor: {\n      Program: {\n        enter(_, state) {\n          state.keywords = { local: new Set(), public: new Set() };\n          state.keywordUids = { local: new Map(), public: new Map() };\n        },\n\n        exit(path, state) {\n          const metadata = state.file.metadata as TransformMetadata;\n          metadata.keywords = {\n            local: Array.from(state.keywords.local),\n            public: Array.from(state.keywords.public),\n          };\n\n          if (mode === 'transform') {\n            const newImports = [];\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_INTERNAL_MODULE_ID}/${KEYWORD_ROUTE}/${encoded}`,\n                  ),\n                ),\n              );\n            }\n            for (const [\n              keyword,\n              safeId,\n            ] of state.keywordUids.public.entries()) {\n              const encoded = encodeIdentifier(keyword);\n              newImports.push(\n                t.importDeclaration(\n                  [t.importDefaultSpecifier(safeId)],\n                  t.stringLiteral(\n                    `${VIRTUAL_INTERNAL_PUBLIC_MODULE_ID}/${KEYWORD_ROUTE}/${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_PUBLIC_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const targetSet = isPublic\n          ? state.keywords.public\n          : state.keywords.local;\n        const targetMap = isPublic\n          ? state.keywordUids.public\n          : state.keywordUids.local;\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                const objPath = tsPath.get('objectType') as NodePath;\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_PUBLIC_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const targetSet = isPublic\n          ? state.keywords.public\n          : state.keywords.local;\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              const targetModuleId = isPublic\n                ? VIRTUAL_INTERNAL_PUBLIC_MODULE_ID\n                : VIRTUAL_INTERNAL_MODULE_ID;\n              return t.exportNamedDeclaration(\n                null,\n                [\n                  t.exportSpecifier(\n                    t.identifier('default'),\n                    specifierPath.node.exported,\n                  ),\n                ],\n                t.stringLiteral(\n                  `${targetModuleId}/${KEYWORD_ROUTE}/${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  return () => plugin as PluginObject;\n};\n\nexport const transformCode = (\n  code: string,\n  id: string,\n): {\n  code: string;\n  map: NonNullable<FileResult['map']> | null;\n  keywords: KeywordSet;\n} | null => {\n  if (\n    !code.includes(VIRTUAL_MODULE_ID) &&\n    !code.includes(VIRTUAL_PUBLIC_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    local: new Set(metadata?.keywords?.local ?? []),\n    public: new Set(metadata?.keywords?.public ?? []),\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_PUBLIC_MODULE_ID)\n  ) {\n    return null;\n  }\n  let result: FileResult | 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    local: new Set(metadata?.keywords?.local ?? []),\n    public: new Set(metadata?.keywords?.public ?? []),\n  };\n};\n","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { DEBUG_SEPARATOR, HASH_LENGTH } from './constants.js';\nimport { encodeIdentifier, toSafeVarName } from './encode.js';\n\nexport const generateTypeDeclaration = (\n  keywords: Set<string>,\n  isPublic: boolean = false,\n): string => {\n  const sortedKeywords = Array.from(keywords).sort();\n  const content = [];\n\n  for (const keyword of sortedKeywords) {\n    const encoded = encodeIdentifier(keyword);\n    const safeName = toSafeVarName(encoded);\n    const hash = isPublic ? '*'.repeat(HASH_LENGTH) : '==';\n    const value = `${hash}${DEBUG_SEPARATOR}${keyword}`;\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","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { 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 = { local: new Set(), public: 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.local) {\n        collectedKeywords.local.add(keyword);\n      }\n      for (const keyword of keywords.public) {\n        collectedKeywords.public.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, ` +\n        `${collectedKeywords.local.size} local, ` +\n        `${collectedKeywords.public.size} public keywords ` +\n        `(${elapsed.toFixed(2)}ms).`,\n    );\n  }\n\n  return collectedKeywords;\n};\n\nconst pkgJson = {\n  private: true,\n  type: 'module',\n  sideEffects: false,\n  exports: {\n    '.': {\n      types: './index.d.ts',\n    },\n    './public': {\n      types: './public.d.ts',\n    },\n  },\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.local);\n      const publicContent = generateTypeDeclaration(keywords.public, 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, 'public.d.ts'),\n        `${publicContent.trim()}\\n`,\n      );\n      await writeFile(\n        path.join(outPath, 'package.json'),\n        `${JSON.stringify(pkgJson, null, 2)}\\n`,\n      );\n    },\n\n    async run(): Promise<void> {\n      const keywords = await this.collect();\n      await this.save(keywords);\n    },\n  };\n};\n","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { createHmac, hkdfSync } from 'node:crypto';\nimport blacklist from 'virtual:blacklist';\nimport {\n  HASH_LENGTH,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n} from './constants.js';\n\nconst ALPHA_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst BASE62_CHARS = `${ALPHA_CHARS}0123456789`;\n\nconst ALPHA_LEN = BigInt(ALPHA_CHARS.length); // 52n\nconst BASE62_LEN = BigInt(BASE62_CHARS.length); // 62n\n\nexport type Hasher = (input: string) => string;\n\n// Format: [1 Alpha] + [N Base62]\nexport const createHasher = (secret: string): Hasher => {\n  const base62TailLength = HASH_LENGTH - 1;\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 info = VIRTUAL_PUBLIC_MODULE_ID;\n    let retry = 0;\n    let result: string;\n\n    do {\n      const r = retry.toString();\n      retry++;\n      const payload = `${info.length}:${info}|${input.length}:${input}|${r.length}:${r}`;\n      const hasher = createHmac('sha256', secret);\n      const buffer = hasher.update(payload).digest('hex');\n\n      let entropy = BigInt(`0x${buffer}`);\n      result = '';\n\n      result += ALPHA_CHARS[Number(entropy % ALPHA_LEN)];\n      entropy /= ALPHA_LEN;\n      for (let i = 0; i < base62TailLength; i++) {\n        result += BASE62_CHARS[Number(entropy % BASE62_LEN)];\n        entropy /= BASE62_LEN;\n      }\n    } while (blacklist.has(result));\n\n    cache.set(input, result);\n    return result;\n  };\n};\n\n// Fisher-Yates based deterministic shuffle\nconst shuffle = (str: string, secret: string, salt: string): string => {\n  const arr = Array.from(str);\n  const requiredBytes = (arr.length - 1) * 4;\n\n  const info = VIRTUAL_MODULE_ID;\n  const keyingMaterial = hkdfSync('sha256', secret, salt, info, requiredBytes);\n  const prngBuffer = Buffer.from(keyingMaterial);\n\n  let byteOffset = 0;\n  for (let i = arr.length - 1; i > 0; i--) {\n    const random32 = prngBuffer.readUInt32BE(byteOffset);\n    byteOffset += 4;\n    const j = random32 % (i + 1);\n    const temp = arr[i] as string;\n    arr[i] = arr[j] as string;\n    arr[j] = temp;\n  }\n\n  return arr.join('');\n};\n\nexport const createCounter = (secret: string): Hasher => {\n  const shuffledAlpha = shuffle(ALPHA_CHARS, secret, 'alpha');\n  const shuffledBase62 = shuffle(BASE62_CHARS, secret, 'base62');\n\n  let index = 0;\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    let result: string;\n    do {\n      result = '';\n      let current = index;\n      index++;\n\n      result += shuffledAlpha[current % shuffledAlpha.length];\n      current = Math.floor(current / shuffledAlpha.length);\n      while (current > 0) {\n        current--;\n        result += shuffledBase62[current % shuffledBase62.length];\n        current = Math.floor(current / shuffledBase62.length);\n      }\n    } while (blacklist.has(result));\n\n    cache.set(input, result);\n    return result;\n  };\n};\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createUnplugin } from "unplugin";
 //#region src/index.ts
 /**

package/dist/{plugin-BwhGea-8.js → plugin-B-GMuoNu.js}

@@ -1,4 +1,4 @@
-import { a as transformCode, c as VIRTUAL_MODULE_ID, i as extractKeywords, l as VIRTUAL_PUBLIC_MODULE_ID, n as createHasher, o as encodeIdentifier, r as createRunner, s as PLUGIN_NAME, t as createCounter } from "./hash-CKju2_N1.js";
+import { a as transformCode, c as VIRTUAL_INTERNAL_MODULE_ID, d as VIRTUAL_PUBLIC_MODULE_ID, i as extractKeywords, l as VIRTUAL_INTERNAL_PUBLIC_MODULE_ID, n as createHasher, o as encodeIdentifier, r as createRunner, s as PLUGIN_NAME, t as createCounter, u as VIRTUAL_MODULE_ID } from "./hash-BJl6coaB.js";
 import { readFile } from "node:fs/promises";
 import pLimit from "p-limit";
 //#region src/internal/plugin.ts
@@ -50,7 +50,7 @@ const unpluginFactory = ({ isDev, secret }) => {
 		},
 		resolveId: {
 			filter: { id: {
-				include: [...toIncludes(VIRTUAL_MODULE_ID), ...toIncludes(VIRTUAL_PUBLIC_MODULE_ID)],
+				include: [...toIncludes(VIRTUAL_INTERNAL_MODULE_ID), ...toIncludes(VIRTUAL_INTERNAL_PUBLIC_MODULE_ID)],
 				exclude: COMMON_EXCLUDES
 			} },
 			handler(id) {
@@ -59,7 +59,7 @@ const unpluginFactory = ({ isDev, secret }) => {
 		},
 		load: {
 			filter: { id: {
-				include: [...toIncludes(resolveId(VIRTUAL_MODULE_ID)), ...toIncludes(resolveId(VIRTUAL_PUBLIC_MODULE_ID))],
+				include: [...toIncludes(resolveId(VIRTUAL_INTERNAL_MODULE_ID)), ...toIncludes(resolveId(VIRTUAL_INTERNAL_PUBLIC_MODULE_ID))],
 				exclude: COMMON_EXCLUDES
 			} },
 			handler(id) {
@@ -81,14 +81,14 @@ const unpluginFactory = ({ isDev, secret }) => {
 				if (!result) return null;
 				const { code: transformed, map, keywords } = result;
 				for (const keyword of keywords.local) {
-					const resolvedId = resolveId(`${VIRTUAL_MODULE_ID}/_/${encodeIdentifier(keyword)}`);
+					const resolvedId = resolveId(`${VIRTUAL_INTERNAL_MODULE_ID}/_/${encodeIdentifier(keyword)}`);
 					if (resolvedMap.has(resolvedId)) continue;
 					const hash = hasherLocal(keyword);
 					const value = isDev ? `${hash}.${keyword}` : hash;
 					resolvedMap.set(resolvedId, `export default ${JSON.stringify(value)};\n`);
 				}
 				for (const keyword of keywords.public) {
-					const resolvedId = resolveId(`${VIRTUAL_PUBLIC_MODULE_ID}/_/${encodeIdentifier(keyword)}`);
+					const resolvedId = resolveId(`${VIRTUAL_INTERNAL_PUBLIC_MODULE_ID}/_/${encodeIdentifier(keyword)}`);
 					if (resolvedMap.has(resolvedId)) continue;
 					const hash = hasherPublic(keyword);
 					const value = isDev ? `${hash}.${keyword}` : hash;
@@ -131,4 +131,4 @@ const unpluginFactory = ({ isDev, secret }) => {
 //#endregion
 export { unpluginFactory as t };
 
-//# sourceMappingURL=plugin-BwhGea-8.js.map
+//# sourceMappingURL=plugin-B-GMuoNu.js.map

package/dist/plugin-B-GMuoNu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-B-GMuoNu.js","names":[],"sources":["../src/internal/plugin.ts"],"sourcesContent":["/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { 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,\n  PLUGIN_NAME,\n  VIRTUAL_INTERNAL_MODULE_ID,\n  VIRTUAL_INTERNAL_PUBLIC_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_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 typegenKeywords: KeywordSet = { local: new Set(), public: 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.local) {\n        typegenKeywords.local.add(keyword);\n      }\n      for (const keyword of keywords.public) {\n        typegenKeywords.public.add(keyword);\n      }\n      await runner.save(typegenKeywords);\n      isInitialized = true;\n    } catch {}\n  };\n\n  let hasherPublic: Hasher;\n  let hasherLocal: Hasher;\n  let resolvedMap: Map<string, string>;\n\n  return {\n    name: PLUGIN_NAME,\n\n    buildStart() {\n      hasherPublic = createHasher(secret);\n      hasherLocal = createCounter(secret);\n      resolvedMap = new Map();\n      runnerLimit(async () => {\n        if (!isInitialized) {\n          await runInit();\n        }\n      });\n    },\n\n    async buildEnd() {\n      // Flush the background queue\n      await runnerLimit(() => Promise.resolve());\n    },\n\n    resolveId: {\n      filter: {\n        id: {\n          include: [\n            ...toIncludes(VIRTUAL_INTERNAL_MODULE_ID),\n            ...toIncludes(VIRTUAL_INTERNAL_PUBLIC_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_INTERNAL_MODULE_ID)),\n            ...toIncludes(resolveId(VIRTUAL_INTERNAL_PUBLIC_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_PUBLIC_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.local) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_INTERNAL_MODULE_ID}/${KEYWORD_ROUTE}/${encoded}`,\n          );\n          if (resolvedMap.has(resolvedId)) {\n            continue;\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        for (const keyword of keywords.public) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_INTERNAL_PUBLIC_MODULE_ID}/${KEYWORD_ROUTE}/${encoded}`,\n          );\n          if (resolvedMap.has(resolvedId)) {\n            continue;\n          }\n          const hash = hasherPublic(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.local) {\n        if (!typegenKeywords.local.has(keyword)) {\n          typegenKeywords.local.add(keyword);\n          isAdded = true;\n        }\n      }\n      for (const keyword of keywords.public) {\n        if (!typegenKeywords.public.has(keyword)) {\n          typegenKeywords.public.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(typegenKeywords);\n            } catch {}\n          }\n        });\n      }\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/rolldown.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createRolldownPlugin } from "unplugin";
 //#region src/rolldown.ts
 /**

package/dist/rollup.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createRollupPlugin } from "unplugin";
 //#region src/rollup.ts
 /**

package/dist/rspack.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createRspackPlugin } from "unplugin";
 //#region src/rspack.ts
 /**

package/dist/vite.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createVitePlugin } from "unplugin";
 //#region src/vite.ts
 /**

package/dist/webpack.js

@@ -1,4 +1,4 @@
-import { t as unpluginFactory } from "./plugin-BwhGea-8.js";
+import { t as unpluginFactory } from "./plugin-B-GMuoNu.js";
 import { createWebpackPlugin } from "unplugin";
 //#region src/webpack.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unplugin-keywords",
-  "version": "2.11.1",
+  "version": "2.12.0",
   "description": "A build plugin for structural string literal minification and obfuscation.",
   "keywords": [
     "unplugin",
@@ -81,7 +81,6 @@
   "devDependencies": {
     "@biomejs/biome": "^2.4.14",
     "@mdn/browser-compat-data": "^7.3.16",
-    "@rollup/plugin-virtual": "^3.0.2",
     "@tsconfig/bases": "^1.0.23",
     "@types/node": "^25.6.0",
     "globals": "^17.6.0",

package/dist/hash-CKju2_N1.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash-CKju2_N1.js","names":["t","blacklist","info"],"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":["/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nexport const VIRTUAL_MODULE_ID = '~keywords';\nexport const VIRTUAL_PUBLIC_MODULE_ID = '~keywords/public';\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","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\ndeclare 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","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport {\n  type FileResult,\n  type NodePath,\n  type PluginItem,\n  type PluginObject,\n  type PluginPass,\n  types as t,\n  transformSync,\n} from '@babel/core';\nimport {\n  KEYWORD_ROUTE_SEGMENT,\n  PLUGIN_NAME,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n} from './constants.js';\nimport { encodeIdentifier, toSafeVarName } from './encode.js';\n\nexport interface KeywordSet {\n  local: Set<string>;\n  public: 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.isTSClassImplements() ||\n      parent.isTSInterfaceHeritage()\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    local: Map<string, t.Identifier>;\n    public: Map<string, t.Identifier>;\n  };\n}\n\ninterface TransformMetadata {\n  keywords?: { local: string[]; public: string[] };\n}\n\nconst transformPlugin = (mode: 'extract' | 'transform'): PluginItem => {\n  const plugin: PluginObject<TransformState> = {\n    name: `${PLUGIN_NAME}:${mode}`,\n\n    visitor: {\n      Program: {\n        enter(_, state) {\n          state.keywords = { local: new Set(), public: new Set() };\n          state.keywordUids = { local: new Map(), public: new Map() };\n        },\n\n        exit(path, state) {\n          const metadata = state.file.metadata as TransformMetadata;\n          metadata.keywords = {\n            local: Array.from(state.keywords.local),\n            public: Array.from(state.keywords.public),\n          };\n\n          if (mode === 'transform') {\n            const newImports = [];\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_MODULE_ID}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n                  ),\n                ),\n              );\n            }\n            for (const [\n              keyword,\n              safeId,\n            ] of state.keywordUids.public.entries()) {\n              const encoded = encodeIdentifier(keyword);\n              newImports.push(\n                t.importDeclaration(\n                  [t.importDefaultSpecifier(safeId)],\n                  t.stringLiteral(\n                    `${VIRTUAL_PUBLIC_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_PUBLIC_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const targetSet = isPublic\n          ? state.keywords.public\n          : state.keywords.local;\n        const targetMap = isPublic\n          ? state.keywordUids.public\n          : state.keywordUids.local;\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                const objPath = tsPath.get('objectType') as NodePath;\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_PUBLIC_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const targetSet = isPublic\n          ? state.keywords.public\n          : state.keywords.local;\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  return () => plugin as PluginObject;\n};\n\nexport const transformCode = (\n  code: string,\n  id: string,\n): {\n  code: string;\n  map: NonNullable<FileResult['map']> | null;\n  keywords: KeywordSet;\n} | null => {\n  if (\n    !code.includes(VIRTUAL_MODULE_ID) &&\n    !code.includes(VIRTUAL_PUBLIC_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    local: new Set(metadata?.keywords?.local ?? []),\n    public: new Set(metadata?.keywords?.public ?? []),\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_PUBLIC_MODULE_ID)\n  ) {\n    return null;\n  }\n  let result: FileResult | 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    local: new Set(metadata?.keywords?.local ?? []),\n    public: new Set(metadata?.keywords?.public ?? []),\n  };\n};\n","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { DEBUG_SEPARATOR, HASH_LENGTH } from './constants.js';\nimport { encodeIdentifier, toSafeVarName } from './encode.js';\n\nexport const generateTypeDeclaration = (\n  keywords: Set<string>,\n  isPublic: boolean = false,\n): string => {\n  const sortedKeywords = Array.from(keywords).sort();\n  const content = [];\n\n  for (const keyword of sortedKeywords) {\n    const encoded = encodeIdentifier(keyword);\n    const safeName = toSafeVarName(encoded);\n    const hash = isPublic ? '*'.repeat(HASH_LENGTH) : '==';\n    const value = `${hash}${DEBUG_SEPARATOR}${keyword}`;\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","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { mkdir, readFile, writeFile } from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { globby } from 'globby';\nimport pLimit from 'p-limit';\nimport { KEYWORD_ROUTE_SEGMENT } from './constants.js';\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 = { local: new Set(), public: 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.local) {\n        collectedKeywords.local.add(keyword);\n      }\n      for (const keyword of keywords.public) {\n        collectedKeywords.public.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, ` +\n        `${collectedKeywords.local.size} local, ` +\n        `${collectedKeywords.public.size} public keywords ` +\n        `(${elapsed.toFixed(2)}ms).`,\n    );\n  }\n\n  return collectedKeywords;\n};\n\nconst pkgJson = {\n  private: true,\n  type: 'module',\n  sideEffects: false,\n  exports: {\n    '.': {\n      types: './index.d.ts',\n    },\n    './public': {\n      types: './public.d.ts',\n    },\n    [`./${KEYWORD_ROUTE_SEGMENT}/*`]: `./${KEYWORD_ROUTE_SEGMENT}/*`,\n    [`./public/${KEYWORD_ROUTE_SEGMENT}/*`]: `./public/${KEYWORD_ROUTE_SEGMENT}/*`,\n  },\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.local);\n      const publicContent = generateTypeDeclaration(keywords.public, 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, 'public.d.ts'),\n        `${publicContent.trim()}\\n`,\n      );\n      await writeFile(\n        path.join(outPath, 'package.json'),\n        `${JSON.stringify(pkgJson, null, 2)}\\n`,\n      );\n    },\n\n    async run(): Promise<void> {\n      const keywords = await this.collect();\n      await this.save(keywords);\n    },\n  };\n};\n","/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { createHmac, hkdfSync } from 'node:crypto';\nimport blacklist from 'virtual:blacklist';\nimport {\n  HASH_LENGTH,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n} from './constants.js';\n\nconst ALPHA_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst BASE62_CHARS = `${ALPHA_CHARS}0123456789`;\n\nconst ALPHA_LEN = BigInt(ALPHA_CHARS.length); // 52n\nconst BASE62_LEN = BigInt(BASE62_CHARS.length); // 62n\n\nexport type Hasher = (input: string) => string;\n\n// Format: [1 Alpha] + [N Base62]\nexport const createHasher = (secret: string): Hasher => {\n  const base62TailLength = HASH_LENGTH - 1;\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 info = VIRTUAL_PUBLIC_MODULE_ID;\n    let retry = 0;\n    let result: string;\n\n    do {\n      const r = retry.toString();\n      retry++;\n      const payload = `${info.length}:${info}|${input.length}:${input}|${r.length}:${r}`;\n      const hasher = createHmac('sha256', secret);\n      const buffer = hasher.update(payload).digest('hex');\n\n      let entropy = BigInt(`0x${buffer}`);\n      result = '';\n\n      result += ALPHA_CHARS[Number(entropy % ALPHA_LEN)];\n      entropy /= ALPHA_LEN;\n      for (let i = 0; i < base62TailLength; i++) {\n        result += BASE62_CHARS[Number(entropy % BASE62_LEN)];\n        entropy /= BASE62_LEN;\n      }\n    } while (blacklist.has(result));\n\n    cache.set(input, result);\n    return result;\n  };\n};\n\n// Fisher-Yates based deterministic shuffle\nconst shuffle = (str: string, secret: string, salt: string): string => {\n  const arr = Array.from(str);\n  const requiredBytes = (arr.length - 1) * 4;\n\n  const info = VIRTUAL_MODULE_ID;\n  const keyingMaterial = hkdfSync('sha256', secret, salt, info, requiredBytes);\n  const prngBuffer = Buffer.from(keyingMaterial);\n\n  let byteOffset = 0;\n  for (let i = arr.length - 1; i > 0; i--) {\n    const random32 = prngBuffer.readUInt32BE(byteOffset);\n    byteOffset += 4;\n    const j = random32 % (i + 1);\n    const temp = arr[i] as string;\n    arr[i] = arr[j] as string;\n    arr[j] = temp;\n  }\n\n  return arr.join('');\n};\n\nexport const createCounter = (secret: string): Hasher => {\n  const shuffledAlpha = shuffle(ALPHA_CHARS, secret, 'alpha');\n  const shuffledBase62 = shuffle(BASE62_CHARS, secret, 'base62');\n\n  let index = 0;\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    let result: string;\n    do {\n      result = '';\n      let current = index;\n      index++;\n\n      result += shuffledAlpha[current % shuffledAlpha.length];\n      current = Math.floor(current / shuffledAlpha.length);\n      while (current > 0) {\n        current--;\n        result += shuffledBase62[current % shuffledBase62.length];\n        current = Math.floor(current / shuffledBase62.length);\n      }\n    } while (blacklist.has(result));\n\n    cache.set(input, result);\n    return result;\n  };\n};\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/plugin-BwhGea-8.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-BwhGea-8.js","names":[],"sources":["../src/internal/plugin.ts"],"sourcesContent":["/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nimport { 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_MODULE_ID,\n  VIRTUAL_PUBLIC_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 typegenKeywords: KeywordSet = { local: new Set(), public: 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.local) {\n        typegenKeywords.local.add(keyword);\n      }\n      for (const keyword of keywords.public) {\n        typegenKeywords.public.add(keyword);\n      }\n      await runner.save(typegenKeywords);\n      isInitialized = true;\n    } catch {}\n  };\n\n  let hasherPublic: Hasher;\n  let hasherLocal: Hasher;\n  let resolvedMap: Map<string, string>;\n\n  return {\n    name: PLUGIN_NAME,\n\n    buildStart() {\n      hasherPublic = createHasher(secret);\n      hasherLocal = createCounter(secret);\n      resolvedMap = new Map();\n      runnerLimit(async () => {\n        if (!isInitialized) {\n          await runInit();\n        }\n      });\n    },\n\n    async buildEnd() {\n      // Flush the background queue\n      await runnerLimit(() => Promise.resolve());\n    },\n\n    resolveId: {\n      filter: {\n        id: {\n          include: [\n            ...toIncludes(VIRTUAL_MODULE_ID),\n            ...toIncludes(VIRTUAL_PUBLIC_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_PUBLIC_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_PUBLIC_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.local) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_MODULE_ID}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n          );\n          if (resolvedMap.has(resolvedId)) {\n            continue;\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        for (const keyword of keywords.public) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_PUBLIC_MODULE_ID}/${KEYWORD_ROUTE_SEGMENT}/${encoded}`,\n          );\n          if (resolvedMap.has(resolvedId)) {\n            continue;\n          }\n          const hash = hasherPublic(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.local) {\n        if (!typegenKeywords.local.has(keyword)) {\n          typegenKeywords.local.add(keyword);\n          isAdded = true;\n        }\n      }\n      for (const keyword of keywords.public) {\n        if (!typegenKeywords.public.has(keyword)) {\n          typegenKeywords.public.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(typegenKeywords);\n            } catch {}\n          }\n        });\n      }\n    },\n  };\n};\n"],"mappings":"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"}