unplugin-keywords 2.13.1 → 2.15.0

package/dist/api.d.ts

@@ -16,6 +16,7 @@ declare const transformCode: (code: string, id: string) => {
   keywords: KeywordSet;
 } | null;
 declare const extractKeywords: (code: string, id: string) => KeywordSet | null;
+declare const preprocessForExtract: (code: string, id: string) => Promise<string | null>;
 //#endregion
 //#region src/internal/cli.d.ts
 interface RunnerOptions {
@@ -45,5 +46,5 @@ declare const createCounter: (secret: string) => Hasher;
 */
 
 //#endregion
-export { createCounter, createHasher, createRunner, extractKeywords, transformCode };
+export { Hasher, KeywordSet, createCounter, createHasher, createRunner, extractKeywords, preprocessForExtract, transformCode };
 //# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -1,10 +1,10 @@
-import { a as transformCode, i as extractKeywords, n as createHasher, r as createRunner, t as createCounter } from "./hash-C4xUIITd.js";
+import { a as preprocessForExtract, i as extractKeywords, n as createHasher, o as transformCode, r as createRunner, t as createCounter } from "./hash-C5ttE6yV.js";
 //#region src/api.ts
 /**
 * @license
 * SPDX-License-Identifier: MIT
 */
 //#endregion
-export { createCounter, createHasher, createRunner, extractKeywords, transformCode };
+export { createCounter, createHasher, createRunner, extractKeywords, preprocessForExtract, transformCode };
 
 //# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -1 +1 @@
-{"version":3,"file":"api.js","names":[],"sources":["../src/api.ts"],"sourcesContent":["/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nexport { createRunner } from './internal/cli.js';\nexport { createCounter, createHasher } from './internal/hash.js';\nexport { extractKeywords, transformCode } from './internal/transform.js';\n"],"mappings":""}
+{"version":3,"file":"api.js","names":[],"sources":["../src/api.ts"],"sourcesContent":["/**\n * @license\n * SPDX-License-Identifier: MIT\n */\n\nexport * from './internal/cli.js';\nexport * from './internal/hash.js';\nexport * from './internal/transform.js';\n"],"mappings":""}

package/dist/bun.js

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

package/dist/esbuild.js

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

package/dist/farm.js

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

package/dist/{hash-C4xUIITd.js → hash-C5ttE6yV.js}

@@ -150,7 +150,14 @@ const transformPlugin = (mode) => {
 								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;
+								else if (parentPath.node.computed) {
+									const propPath = parentPath.get("property");
+									const evalResult = Array.isArray(propPath) ? {
+										confident: false,
+										value: null
+									} : propPath.evaluate();
+									if (evalResult.confident && typeof evalResult.value === "string") keyword = evalResult.value;
+								}
 								if (keyword) {
 									const uidNode = processKeyword(keyword);
 									if (uidNode) parentPath.replaceWith(types.cloneNode(uidNode));
@@ -174,8 +181,12 @@ const transformPlugin = (mode) => {
 								const objPath = tsPath.get("objectType");
 								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;
+									let keyword;
+									if (types.isTSLiteralType(indexNode)) {
+										if (types.isStringLiteral(indexNode.literal)) keyword = indexNode.literal.value;
+										else if (types.isTemplateLiteral(indexNode.literal) && indexNode.literal.quasis.length === 1 && indexNode.literal.quasis[0]?.value?.cooked) keyword = indexNode.literal.quasis[0].value.cooked;
+									}
+									if (keyword) {
 										const uidNode = processKeyword(keyword);
 										if (uidNode) tsPath.replaceWith(types.tsTypeQuery(types.cloneNode(uidNode)));
 									}
@@ -270,6 +281,16 @@ const extractKeywords = (code, id) => {
 		raw: new Set(metadata?.keywords?.raw ?? [])
 	};
 };
+const preprocessForExtract = async (code, id) => {
+	let finalCode = code;
+	if (!code.includes("~keywords") && !code.includes("~keywords/public") && !code.includes("~keywords/raw")) return null;
+	if (/\.svelte$/.test(id)) try {
+		finalCode = (await import("svelte/compiler")).compile(finalCode, { filename: id }).js.code;
+	} catch {
+		return null;
+	}
+	return finalCode;
+};
 //#endregion
 //#region src/internal/typegen.ts
 /**
@@ -309,7 +330,7 @@ const collectKeywordsFromRoot = async (root, silent, ignoredDirs = [], concurren
 	};
 	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}", {
+	const files = await globby("**/*.{js,ts,mjs,mts,jsx,tsx,mjsx,mtsx,svelte}", {
 		cwd: root,
 		absolute: false,
 		ignore: ["**/node_modules/**", ...ignoredDirs.map((dir) => `${dir}/**`)],
@@ -317,16 +338,20 @@ const collectKeywordsFromRoot = async (root, silent, ignoredDirs = [], concurren
 	});
 	let processed = 0;
 	await pLimit({ concurrency }).map(files, async (file) => {
+		let code;
 		try {
-			const keywords = extractKeywords(await readFile(file, "utf-8"), file);
-			if (!keywords) return;
-			for (const keyword of keywords.local) collectedKeywords.local.add(keyword);
-			for (const keyword of keywords.public) collectedKeywords.public.add(keyword);
-			for (const keyword of keywords.raw) collectedKeywords.raw.add(keyword);
-			processed++;
-		} catch (error) {
-			if (!silent) console.error(`Failed to process ${file}: ${error}`);
+			code = await readFile(file, "utf-8");
+		} catch {
+			return;
 		}
+		code = await preprocessForExtract(code, file);
+		if (!code) return;
+		const keywords = extractKeywords(code, file);
+		if (!keywords) return;
+		for (const keyword of keywords.local) collectedKeywords.local.add(keyword);
+		for (const keyword of keywords.public) collectedKeywords.public.add(keyword);
+		for (const keyword of keywords.raw) collectedKeywords.raw.add(keyword);
+		processed++;
 	});
 	const elapsed = performance.now() - start;
 	if (!silent) console.error(`Scan complete: ${processed}/${files.length} files, ${collectedKeywords.local.size} local, ${collectedKeywords.public.size} public, ${collectedKeywords.raw.size} raw keywords (${elapsed.toFixed(2)}ms).`);
@@ -2761,6 +2786,6 @@ const createCounter = (secret) => {
 	};
 };
 //#endregion
-export { transformCode as a, VIRTUAL_INTERNAL_MODULE_ID as c, VIRTUAL_MODULE_ID as d, VIRTUAL_PUBLIC_MODULE_ID as f, extractKeywords as i, VIRTUAL_INTERNAL_PUBLIC_MODULE_ID as l, createHasher as n, encodeIdentifier as o, VIRTUAL_RAW_MODULE_ID as p, createRunner as r, PLUGIN_NAME as s, createCounter as t, VIRTUAL_INTERNAL_RAW_MODULE_ID as u };
+export { preprocessForExtract as a, PLUGIN_NAME as c, VIRTUAL_INTERNAL_RAW_MODULE_ID as d, VIRTUAL_MODULE_ID as f, extractKeywords as i, VIRTUAL_INTERNAL_MODULE_ID as l, VIRTUAL_RAW_MODULE_ID as m, createHasher as n, transformCode as o, VIRTUAL_PUBLIC_MODULE_ID as p, createRunner as r, encodeIdentifier as s, createCounter as t, VIRTUAL_INTERNAL_PUBLIC_MODULE_ID as u };
 
-//# sourceMappingURL=hash-C4xUIITd.js.map
+//# sourceMappingURL=hash-C5ttE6yV.js.map

package/dist/hash-C5ttE6yV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-C5ttE6yV.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';\nexport const VIRTUAL_RAW_MODULE_ID = '~keywords/raw';\n\nexport const VIRTUAL_INTERNAL_MODULE_ID = '~keywords-internal';\nexport const VIRTUAL_INTERNAL_PUBLIC_MODULE_ID = '~keywords-internal/public';\nexport const VIRTUAL_INTERNAL_RAW_MODULE_ID = '~keywords-internal/raw';\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_INTERNAL_RAW_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n  VIRTUAL_RAW_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  raw: 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    raw: Map<string, t.Identifier>;\n  };\n}\n\ninterface TransformMetadata {\n  keywords?: { local: string[]; public: string[]; raw: 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 = {\n            local: new Set(),\n            public: new Set(),\n            raw: new Set(),\n          };\n          state.keywordUids = {\n            local: new Map(),\n            public: new Map(),\n            raw: new Map(),\n          };\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            raw: Array.from(state.keywords.raw),\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            for (const [keyword, safeId] of state.keywordUids.raw.entries()) {\n              const encoded = encodeIdentifier(keyword);\n              newImports.push(\n                t.importDeclaration(\n                  [t.importDefaultSpecifier(safeId)],\n                  t.stringLiteral(\n                    `${VIRTUAL_INTERNAL_RAW_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          sourceValue !== VIRTUAL_RAW_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const isRaw = sourceValue === VIRTUAL_RAW_MODULE_ID;\n        const targetSet = isRaw\n          ? state.keywords.raw\n          : isPublic\n            ? state.keywords.public\n            : state.keywords.local;\n        const targetMap = isRaw\n          ? state.keywordUids.raw\n          : 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 (parentPath.node.computed) {\n                  const propPath = parentPath.get('property');\n                  const evalResult = Array.isArray(propPath)\n                    ? { confident: false, value: null }\n                    : propPath.evaluate();\n                  if (\n                    evalResult.confident &&\n                    typeof evalResult.value === 'string'\n                  ) {\n                    keyword = evalResult.value;\n                  }\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                  let keyword: string | undefined;\n                  if (t.isTSLiteralType(indexNode)) {\n                    if (t.isStringLiteral(indexNode.literal)) {\n                      keyword = indexNode.literal.value;\n                    } else if (\n                      t.isTemplateLiteral(indexNode.literal) &&\n                      indexNode.literal.quasis.length === 1 &&\n                      indexNode.literal.quasis[0]?.value?.cooked\n                    ) {\n                      keyword = indexNode.literal.quasis[0].value.cooked;\n                    }\n                  }\n                  if (keyword) {\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          sourceValue !== VIRTUAL_RAW_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const isRaw = sourceValue === VIRTUAL_RAW_MODULE_ID;\n        const targetSet = isRaw\n          ? state.keywords.raw\n          : 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 = isRaw\n                ? VIRTUAL_INTERNAL_RAW_MODULE_ID\n                : 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\nconst isJsx = (id: string): boolean => /\\.m?[jt]sx$/.test(id);\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    !code.includes(VIRTUAL_RAW_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: ['typescript', ...(isJsx(id) ? (['jsx'] as const) : [])],\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    raw: new Set(metadata?.keywords?.raw ?? []),\n  };\n  return {\n    code: result.code ?? '',\n    map: result.map ?? null,\n    keywords,\n  };\n};\n\nexport const extractKeywords = (\n  code: string,\n  id: string,\n): KeywordSet | null => {\n  if (\n    !code.includes(VIRTUAL_MODULE_ID) &&\n    !code.includes(VIRTUAL_PUBLIC_MODULE_ID) &&\n    !code.includes(VIRTUAL_RAW_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: ['typescript', ...(isJsx(id) ? (['jsx'] as const) : [])],\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    raw: new Set(metadata?.keywords?.raw ?? []),\n  };\n};\n\nexport const preprocessForExtract = async (\n  code: string,\n  id: string,\n): Promise<string | null> => {\n  let finalCode = code;\n  if (\n    !code.includes(VIRTUAL_MODULE_ID) &&\n    !code.includes(VIRTUAL_PUBLIC_MODULE_ID) &&\n    !code.includes(VIRTUAL_RAW_MODULE_ID)\n  ) {\n    return null;\n  }\n  if (/\\.svelte$/.test(id)) {\n    try {\n      const compiler = await import('svelte/compiler');\n      const result = compiler.compile(finalCode, { filename: id });\n      finalCode = result.js.code;\n    } catch {\n      return null;\n    }\n  }\n  return finalCode;\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  mode: 'local' | 'public' | 'raw' = 'local',\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 = mode === 'public' ? '*'.repeat(HASH_LENGTH) : '==';\n    const value =\n      mode === 'raw' ? keyword : `${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 {\n  extractKeywords,\n  type KeywordSet,\n  preprocessForExtract,\n} 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 = {\n    local: new Set(),\n    public: new Set(),\n    raw: new Set(),\n  };\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,svelte}', {\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    let code: string | null;\n    try {\n      code = await readFile(file, 'utf-8');\n    } catch {\n      return;\n    }\n    code = await preprocessForExtract(code, file);\n    if (!code) {\n      return;\n    }\n    const keywords = extractKeywords(code, file);\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    for (const keyword of keywords.raw) {\n      collectedKeywords.raw.add(keyword);\n    }\n    processed++;\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, ` +\n        `${collectedKeywords.raw.size} raw 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    './raw': {\n      types: './raw.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, 'public');\n      const rawContent = generateTypeDeclaration(keywords.raw, 'raw');\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(path.join(outPath, 'raw.d.ts'), `${rawContent.trim()}\\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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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9HH,MAAM,cAAc;AACpB,MAAM,eAAe,GAAG,YAAY;AAEpC,MAAM,YAAY,OAAO,GAAmB;AAC5C,MAAM,aAAa,OAAO,aAAa,OAAO;AAK9C,MAAa,gBAAgB,WAA2B;CACtD,MAAM,mBAAA;CAEN,MAAM,wBAAQ,IAAI,KAAqB;CACvC,QAAQ,UAAU;EAChB,IAAI,MAAM,IAAI,MAAM,EAClB,OAAO,MAAM,IAAI,MAAM;EAGzB,MAAM,OAAO;EACb,IAAI,QAAQ;EACZ,IAAI;EAEJ,GAAG;GACD,MAAM,IAAI,MAAM,UAAU;GAC1B;GACA,MAAM,UAAU,MAAkB,KAAK,GAAG,MAAM,OAAO,GAAG,MAAM,GAAG,EAAE,OAAO,GAAG;GAE/E,MAAM,SADS,WAAW,UAAU,OACf,CAAC,OAAO,QAAQ,CAAC,OAAO,MAAM;GAEnD,IAAI,UAAU,OAAO,KAAK,SAAS;GACnC,SAAS;GAET,UAAU,YAAY,OAAO,UAAU,UAAU;GACjD,WAAW;GACX,KAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,KAAK;IACzC,UAAU,aAAa,OAAO,UAAU,WAAW;IACnD,WAAW;;WAENC,2BAAU,IAAI,OAAO;EAE9B,MAAM,IAAI,OAAO,OAAO;EACxB,OAAO;;;AAKX,MAAM,WAAW,KAAa,QAAgB,SAAyB;CACrE,MAAM,MAAM,MAAM,KAAK,IAAI;CAI3B,MAAM,iBAAiB,SAAS,UAAU,QAAQ,MAAMC,oBAHjC,IAAI,SAAS,KAAK,EAGmC;CAC5E,MAAM,aAAa,OAAO,KAAK,eAAe;CAE9C,IAAI,aAAa;CACjB,KAAK,IAAI,IAAI,IAAI,SAAS,GAAG,IAAI,GAAG,KAAK;EACvC,MAAM,WAAW,WAAW,aAAa,WAAW;EACpD,cAAc;EACd,MAAM,IAAI,YAAY,IAAI;EAC1B,MAAM,OAAO,IAAI;EACjB,IAAI,KAAK,IAAI;EACb,IAAI,KAAK;;CAGX,OAAO,IAAI,KAAK,GAAG;;AAGrB,MAAa,iBAAiB,WAA2B;CACvD,MAAM,gBAAgB,QAAQ,aAAa,QAAQ,QAAQ;CAC3D,MAAM,iBAAiB,QAAQ,cAAc,QAAQ,SAAS;CAE9D,IAAI,QAAQ;CACZ,MAAM,wBAAQ,IAAI,KAAqB;CACvC,QAAQ,UAAU;EAChB,IAAI,MAAM,IAAI,MAAM,EAClB,OAAO,MAAM,IAAI,MAAM;EAGzB,IAAI;EACJ,GAAG;GACD,SAAS;GACT,IAAI,UAAU;GACd;GAEA,UAAU,cAAc,UAAU,cAAc;GAChD,UAAU,KAAK,MAAM,UAAU,cAAc,OAAO;GACpD,OAAO,UAAU,GAAG;IAClB;IACA,UAAU,eAAe,UAAU,eAAe;IAClD,UAAU,KAAK,MAAM,UAAU,eAAe,OAAO;;WAEhDD,2BAAU,IAAI,OAAO;EAE9B,MAAM,IAAI,OAAO,OAAO;EACxB,OAAO"}

package/dist/index.js

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

package/dist/{plugin-cEMprzlf.js → plugin-DEHtvPIq.js}

@@ -1,4 +1,4 @@
-import { a as transformCode, c as VIRTUAL_INTERNAL_MODULE_ID, d as VIRTUAL_MODULE_ID, f as VIRTUAL_PUBLIC_MODULE_ID, i as extractKeywords, l as VIRTUAL_INTERNAL_PUBLIC_MODULE_ID, n as createHasher, o as encodeIdentifier, p as VIRTUAL_RAW_MODULE_ID, r as createRunner, s as PLUGIN_NAME, t as createCounter, u as VIRTUAL_INTERNAL_RAW_MODULE_ID } from "./hash-C4xUIITd.js";
+import { a as preprocessForExtract, c as PLUGIN_NAME, d as VIRTUAL_INTERNAL_RAW_MODULE_ID, f as VIRTUAL_MODULE_ID, i as extractKeywords, l as VIRTUAL_INTERNAL_MODULE_ID, m as VIRTUAL_RAW_MODULE_ID, n as createHasher, o as transformCode, p as VIRTUAL_PUBLIC_MODULE_ID, r as createRunner, s as encodeIdentifier, t as createCounter, u as VIRTUAL_INTERNAL_PUBLIC_MODULE_ID } from "./hash-C5ttE6yV.js";
 import { readFile } from "node:fs/promises";
 import pLimit from "p-limit";
 //#region src/internal/plugin.ts
@@ -13,7 +13,7 @@ const splitQuery = (id) => {
 	return [id.slice(0, index), id.slice(index + 1)];
 };
 const toIncludes = (id) => [new RegExp(`^${id}/`)];
-const SUFFIX_REGEX = /\.m?[jt]sx?($|\?)/;
+const SUFFIX_REGEX = /\.(?:m?[jt]sx?|svelte)(?:$|\?)/;
 const COMMON_EXCLUDES = [/\/node_modules\//];
 const unpluginFactory = ({ isDev, secret }) => {
 	const runner = createRunner({ silent: true });
@@ -129,6 +129,8 @@ const unpluginFactory = ({ isDev, secret }) => {
 			} catch {
 				return;
 			}
+			code = await preprocessForExtract(code, validId);
+			if (!code) return;
 			const keywords = extractKeywords(code, validId);
 			if (!keywords) return;
 			let isAdded = false;
@@ -156,4 +158,4 @@ const unpluginFactory = ({ isDev, secret }) => {
 //#endregion
 export { unpluginFactory as t };
 
-//# sourceMappingURL=plugin-cEMprzlf.js.map
+//# sourceMappingURL=plugin-DEHtvPIq.js.map

package/dist/plugin-DEHtvPIq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-DEHtvPIq.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_INTERNAL_RAW_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n  VIRTUAL_RAW_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  preprocessForExtract,\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?|svelte)(?:$|\\?)/;\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 = {\n    local: new Set(),\n    public: new Set(),\n    raw: new Set(),\n  };\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      for (const keyword of keywords.raw) {\n        typegenKeywords.raw.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      if (!isInitialized) {\n        runnerLimit(async () => {\n          if (!isInitialized) {\n            await runInit();\n          }\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            ...toIncludes(VIRTUAL_INTERNAL_RAW_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            ...toIncludes(resolveId(VIRTUAL_INTERNAL_RAW_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: [\n            VIRTUAL_MODULE_ID,\n            VIRTUAL_PUBLIC_MODULE_ID,\n            VIRTUAL_RAW_MODULE_ID,\n          ],\n        },\n      },\n      handler(code, id) {\n        const [validId] = splitQuery(id);\n        const result = transformCode(code, validId);\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        for (const keyword of keywords.raw) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_INTERNAL_RAW_MODULE_ID}/${KEYWORD_ROUTE}/${encoded}`,\n          );\n          if (resolvedMap.has(resolvedId)) {\n            continue;\n          }\n          resolvedMap.set(\n            resolvedId,\n            `export default ${JSON.stringify(keyword)};\\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      const [validId] = splitQuery(id);\n      let code: string | null;\n      try {\n        code = await readFile(validId, 'utf-8');\n      } catch {\n        return;\n      }\n      code = await preprocessForExtract(code, validId);\n      if (!code) {\n        return;\n      }\n      const keywords = extractKeywords(code, validId);\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      for (const keyword of keywords.raw) {\n        if (!typegenKeywords.raw.has(keyword)) {\n          typegenKeywords.raw.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-cEMprzlf.js";
+import { t as unpluginFactory } from "./plugin-DEHtvPIq.js";
 import { createRolldownPlugin } from "unplugin";
 //#region src/rolldown.ts
 /**

package/dist/rollup.js

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

package/dist/rspack.js

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

package/dist/vite.js

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

package/dist/webpack.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unplugin-keywords",
-  "version": "2.13.1",
+  "version": "2.15.0",
   "description": "A build plugin for structural string literal minification and obfuscation.",
   "keywords": [
     "unplugin",
@@ -74,12 +74,21 @@
     "p-limit": "^7.3.0",
     "unplugin": "^3.0.0"
   },
+  "peerDependencies": {
+    "svelte": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "svelte": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@biomejs/biome": "^2.4.14",
     "@mdn/browser-compat-data": "^8.0.0",
     "@tsconfig/bases": "^1.0.23",
     "@types/node": "^25.6.0",
     "globals": "^17.6.0",
+    "svelte": "^5.55.9",
     "tsdown": "^0.22.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"

package/dist/hash-C4xUIITd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash-C4xUIITd.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';\nexport const VIRTUAL_RAW_MODULE_ID = '~keywords/raw';\n\nexport const VIRTUAL_INTERNAL_MODULE_ID = '~keywords-internal';\nexport const VIRTUAL_INTERNAL_PUBLIC_MODULE_ID = '~keywords-internal/public';\nexport const VIRTUAL_INTERNAL_RAW_MODULE_ID = '~keywords-internal/raw';\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_INTERNAL_RAW_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n  VIRTUAL_RAW_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  raw: 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    raw: Map<string, t.Identifier>;\n  };\n}\n\ninterface TransformMetadata {\n  keywords?: { local: string[]; public: string[]; raw: 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 = {\n            local: new Set(),\n            public: new Set(),\n            raw: new Set(),\n          };\n          state.keywordUids = {\n            local: new Map(),\n            public: new Map(),\n            raw: new Map(),\n          };\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            raw: Array.from(state.keywords.raw),\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            for (const [keyword, safeId] of state.keywordUids.raw.entries()) {\n              const encoded = encodeIdentifier(keyword);\n              newImports.push(\n                t.importDeclaration(\n                  [t.importDefaultSpecifier(safeId)],\n                  t.stringLiteral(\n                    `${VIRTUAL_INTERNAL_RAW_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          sourceValue !== VIRTUAL_RAW_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const isRaw = sourceValue === VIRTUAL_RAW_MODULE_ID;\n        const targetSet = isRaw\n          ? state.keywords.raw\n          : isPublic\n            ? state.keywords.public\n            : state.keywords.local;\n        const targetMap = isRaw\n          ? state.keywordUids.raw\n          : 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          sourceValue !== VIRTUAL_RAW_MODULE_ID\n        ) {\n          return;\n        }\n        const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;\n        const isRaw = sourceValue === VIRTUAL_RAW_MODULE_ID;\n        const targetSet = isRaw\n          ? state.keywords.raw\n          : 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 = isRaw\n                ? VIRTUAL_INTERNAL_RAW_MODULE_ID\n                : 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\nconst isJsx = (id: string): boolean => /\\.m?[jt]sx$/.test(id);\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    !code.includes(VIRTUAL_RAW_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: ['typescript', ...(isJsx(id) ? (['jsx'] as const) : [])],\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    raw: new Set(metadata?.keywords?.raw ?? []),\n  };\n  return {\n    code: result.code ?? '',\n    map: result.map ?? null,\n    keywords,\n  };\n};\n\nexport const extractKeywords = (\n  code: string,\n  id: string,\n): KeywordSet | null => {\n  if (\n    !code.includes(VIRTUAL_MODULE_ID) &&\n    !code.includes(VIRTUAL_PUBLIC_MODULE_ID) &&\n    !code.includes(VIRTUAL_RAW_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: ['typescript', ...(isJsx(id) ? (['jsx'] as const) : [])],\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    raw: new Set(metadata?.keywords?.raw ?? []),\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  mode: 'local' | 'public' | 'raw' = 'local',\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 = mode === 'public' ? '*'.repeat(HASH_LENGTH) : '==';\n    const value =\n      mode === 'raw' ? keyword : `${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 = {\n    local: new Set(),\n    public: new Set(),\n    raw: new Set(),\n  };\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, file);\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      for (const keyword of keywords.raw) {\n        collectedKeywords.raw.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, ` +\n        `${collectedKeywords.raw.size} raw 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    './raw': {\n      types: './raw.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, 'public');\n      const rawContent = generateTypeDeclaration(keywords.raw, 'raw');\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(path.join(outPath, 'raw.d.ts'), `${rawContent.trim()}\\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-cEMprzlf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-cEMprzlf.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_INTERNAL_RAW_MODULE_ID,\n  VIRTUAL_MODULE_ID,\n  VIRTUAL_PUBLIC_MODULE_ID,\n  VIRTUAL_RAW_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 = {\n    local: new Set(),\n    public: new Set(),\n    raw: new Set(),\n  };\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      for (const keyword of keywords.raw) {\n        typegenKeywords.raw.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      if (!isInitialized) {\n        runnerLimit(async () => {\n          if (!isInitialized) {\n            await runInit();\n          }\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            ...toIncludes(VIRTUAL_INTERNAL_RAW_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            ...toIncludes(resolveId(VIRTUAL_INTERNAL_RAW_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: [\n            VIRTUAL_MODULE_ID,\n            VIRTUAL_PUBLIC_MODULE_ID,\n            VIRTUAL_RAW_MODULE_ID,\n          ],\n        },\n      },\n      handler(code, id) {\n        const [validId] = splitQuery(id);\n        const result = transformCode(code, validId);\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        for (const keyword of keywords.raw) {\n          const encoded = encodeIdentifier(keyword);\n          const resolvedId = resolveId(\n            `${VIRTUAL_INTERNAL_RAW_MODULE_ID}/${KEYWORD_ROUTE}/${encoded}`,\n          );\n          if (resolvedMap.has(resolvedId)) {\n            continue;\n          }\n          resolvedMap.set(\n            resolvedId,\n            `export default ${JSON.stringify(keyword)};\\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      const [validId] = splitQuery(id);\n      let code: string;\n      try {\n        code = await readFile(validId, 'utf-8');\n      } catch {\n        return;\n      }\n      const keywords = extractKeywords(code, validId);\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      for (const keyword of keywords.raw) {\n        if (!typegenKeywords.raw.has(keyword)) {\n          typegenKeywords.raw.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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"}