unplugin-keywords 2.10.1 → 2.11.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +5 -5
- package/dist/api.js +1 -1
- package/dist/bun.js +1 -1
- package/dist/esbuild.js +1 -1
- package/dist/farm.js +1 -1
- package/dist/hash-Bqp-2TPm.js +2745 -0
- package/dist/hash-Bqp-2TPm.js.map +1 -0
- package/dist/index.js +1 -1
- package/dist/{plugin-BfUGt2kL.js → plugin-DlhkmOsT.js} +2 -2
- package/dist/{plugin-BfUGt2kL.js.map → plugin-DlhkmOsT.js.map} +1 -1
- package/dist/rolldown.js +1 -1
- package/dist/rollup.js +1 -1
- package/dist/rspack.js +1 -1
- package/dist/vite.js +1 -1
- package/dist/webpack.js +1 -1
- package/package.json +4 -1
- package/dist/hash-CV-Tn-Zm.js +0 -422
- package/dist/hash-CV-Tn-Zm.js.map +0 -1
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"hash-Bqp-2TPm.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 if (base62TailLength < 0 || base62TailLength > 9) {\n // 52 * 62^9 < 2^64 < 52 * 62^10\n throw new Error('Invalid MAX_HASH_LENGTH');\n }\n\n const cache = new Map<string, string>();\n return (input) => {\n if (cache.has(input)) {\n return cache.get(input) as string;\n }\n\n const info = VIRTUAL_PUBLIC_MODULE_ID;\n let retry = 0;\n let result: string;\n\n do {\n const r = retry.toString();\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\n retry++;\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
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
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-
|
|
1
|
+
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-Bqp-2TPm.js";
|
|
2
2
|
import { readFile } from "node:fs/promises";
|
|
3
3
|
import pLimit from "p-limit";
|
|
4
4
|
//#region src/internal/plugin.ts
|
|
@@ -131,4 +131,4 @@ const unpluginFactory = ({ isDev, secret }) => {
|
|
|
131
131
|
//#endregion
|
|
132
132
|
export { unpluginFactory as t };
|
|
133
133
|
|
|
134
|
-
//# sourceMappingURL=plugin-
|
|
134
|
+
//# sourceMappingURL=plugin-DlhkmOsT.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"plugin-
|
|
1
|
+
{"version":3,"file":"plugin-DlhkmOsT.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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"}
|
package/dist/rolldown.js
CHANGED
package/dist/rollup.js
CHANGED
package/dist/rspack.js
CHANGED
package/dist/vite.js
CHANGED
package/dist/webpack.js
CHANGED
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "unplugin-keywords",
|
|
3
|
-
"version": "2.
|
|
3
|
+
"version": "2.11.0",
|
|
4
4
|
"description": "A build plugin for structural string literal minification and obfuscation.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"unplugin",
|
|
@@ -80,8 +80,11 @@
|
|
|
80
80
|
},
|
|
81
81
|
"devDependencies": {
|
|
82
82
|
"@biomejs/biome": "^2.4.14",
|
|
83
|
+
"@mdn/browser-compat-data": "^7.3.16",
|
|
84
|
+
"@rollup/plugin-virtual": "^3.0.2",
|
|
83
85
|
"@tsconfig/bases": "^1.0.23",
|
|
84
86
|
"@types/node": "^25.6.0",
|
|
87
|
+
"globals": "^17.6.0",
|
|
85
88
|
"tsdown": "^0.22.0",
|
|
86
89
|
"typescript": "^6.0.3",
|
|
87
90
|
"vitest": "^4.1.5"
|
package/dist/hash-CV-Tn-Zm.js
DELETED
|
@@ -1,422 +0,0 @@
|
|
|
1
|
-
import { mkdir, readFile, writeFile } from "node:fs/promises";
|
|
2
|
-
import * as path from "node:path";
|
|
3
|
-
import { globby } from "globby";
|
|
4
|
-
import pLimit from "p-limit";
|
|
5
|
-
import { transformSync, types } from "@babel/core";
|
|
6
|
-
import { createHmac, hkdfSync } from "node:crypto";
|
|
7
|
-
//#region src/internal/constants.ts
|
|
8
|
-
/**
|
|
9
|
-
* @license
|
|
10
|
-
* SPDX-License-Identifier: MIT
|
|
11
|
-
*/
|
|
12
|
-
const VIRTUAL_MODULE_ID = "~keywords";
|
|
13
|
-
const VIRTUAL_PUBLIC_MODULE_ID = "~keywords/public";
|
|
14
|
-
const PLUGIN_NAME = "unplugin-keywords";
|
|
15
|
-
//#endregion
|
|
16
|
-
//#region src/internal/encode.ts
|
|
17
|
-
/**
|
|
18
|
-
* @license
|
|
19
|
-
* SPDX-License-Identifier: MIT
|
|
20
|
-
*/
|
|
21
|
-
const encodeIdentifier = (identifier) => {
|
|
22
|
-
let encoded = "";
|
|
23
|
-
for (let i = 0; i < identifier.length; i++) {
|
|
24
|
-
const c = identifier[i];
|
|
25
|
-
if (/[a-zA-Z0-9_]/.test(c)) encoded += c;
|
|
26
|
-
else if (c === "$") encoded += "$$";
|
|
27
|
-
else encoded += `$${c.charCodeAt(0).toString(16).padStart(4, "0")}`;
|
|
28
|
-
}
|
|
29
|
-
return encoded;
|
|
30
|
-
};
|
|
31
|
-
const toSafeVarName = (encoded) => `_$${encoded}`;
|
|
32
|
-
//#endregion
|
|
33
|
-
//#region src/internal/transform.ts
|
|
34
|
-
/**
|
|
35
|
-
* @license
|
|
36
|
-
* SPDX-License-Identifier: MIT
|
|
37
|
-
*/
|
|
38
|
-
const isPureTypeSpace = (path) => {
|
|
39
|
-
let current = path;
|
|
40
|
-
while (current) {
|
|
41
|
-
const parent = current.parentPath;
|
|
42
|
-
if (!parent) break;
|
|
43
|
-
if (parent.isTSTypeQuery()) return false;
|
|
44
|
-
if ("computed" in parent.node && parent.node.computed) {
|
|
45
|
-
if (current.key === "key" || current.key === "property") return false;
|
|
46
|
-
}
|
|
47
|
-
if (parent.isTSType() || parent.isTSTypeParameterDeclaration() || parent.isTSTypeParameterInstantiation() || parent.isTSClassImplements() || parent.isTSInterfaceHeritage()) return true;
|
|
48
|
-
if (parent.isTSInterfaceDeclaration() || parent.isTSTypeAliasDeclaration() || parent.isTSEnumDeclaration() || parent.isTSModuleDeclaration()) {
|
|
49
|
-
if (current.key === "id") return true;
|
|
50
|
-
}
|
|
51
|
-
if (parent.isTSQualifiedName() || parent.isTSEntityName()) {
|
|
52
|
-
current = current.parentPath;
|
|
53
|
-
continue;
|
|
54
|
-
}
|
|
55
|
-
if (parent.isExpression() || parent.isStatement()) break;
|
|
56
|
-
current = current.parentPath;
|
|
57
|
-
}
|
|
58
|
-
return false;
|
|
59
|
-
};
|
|
60
|
-
const transformPlugin = (mode) => {
|
|
61
|
-
const plugin = {
|
|
62
|
-
name: `${PLUGIN_NAME}:${mode}`,
|
|
63
|
-
visitor: {
|
|
64
|
-
Program: {
|
|
65
|
-
enter(_, state) {
|
|
66
|
-
state.keywords = {
|
|
67
|
-
local: /* @__PURE__ */ new Set(),
|
|
68
|
-
public: /* @__PURE__ */ new Set()
|
|
69
|
-
};
|
|
70
|
-
state.keywordUids = {
|
|
71
|
-
local: /* @__PURE__ */ new Map(),
|
|
72
|
-
public: /* @__PURE__ */ new Map()
|
|
73
|
-
};
|
|
74
|
-
},
|
|
75
|
-
exit(path, state) {
|
|
76
|
-
const metadata = state.file.metadata;
|
|
77
|
-
metadata.keywords = {
|
|
78
|
-
local: Array.from(state.keywords.local),
|
|
79
|
-
public: Array.from(state.keywords.public)
|
|
80
|
-
};
|
|
81
|
-
if (mode === "transform") {
|
|
82
|
-
const newImports = [];
|
|
83
|
-
for (const [keyword, safeId] of state.keywordUids.local.entries()) {
|
|
84
|
-
const encoded = encodeIdentifier(keyword);
|
|
85
|
-
newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_MODULE_ID}/_/${encoded}`)));
|
|
86
|
-
}
|
|
87
|
-
for (const [keyword, safeId] of state.keywordUids.public.entries()) {
|
|
88
|
-
const encoded = encodeIdentifier(keyword);
|
|
89
|
-
newImports.push(types.importDeclaration([types.importDefaultSpecifier(safeId)], types.stringLiteral(`${VIRTUAL_PUBLIC_MODULE_ID}/_/${encoded}`)));
|
|
90
|
-
}
|
|
91
|
-
if (newImports.length > 0) path.unshiftContainer("body", newImports);
|
|
92
|
-
}
|
|
93
|
-
}
|
|
94
|
-
},
|
|
95
|
-
ImportDeclaration(path, state) {
|
|
96
|
-
const sourceValue = path.node.source.value;
|
|
97
|
-
if (sourceValue !== "~keywords" && sourceValue !== "~keywords/public") return;
|
|
98
|
-
const isPublic = sourceValue === VIRTUAL_PUBLIC_MODULE_ID;
|
|
99
|
-
const targetSet = isPublic ? state.keywords.public : state.keywords.local;
|
|
100
|
-
const targetMap = isPublic ? state.keywordUids.public : state.keywordUids.local;
|
|
101
|
-
const programScope = path.scope.getProgramParent();
|
|
102
|
-
const processKeyword = (keyword) => {
|
|
103
|
-
targetSet.add(keyword);
|
|
104
|
-
if (mode === "extract") return null;
|
|
105
|
-
if (targetMap.has(keyword)) return targetMap.get(keyword);
|
|
106
|
-
const safeName = toSafeVarName(encodeIdentifier(keyword));
|
|
107
|
-
const uid = programScope.generateUidIdentifier(safeName);
|
|
108
|
-
targetMap.set(keyword, uid);
|
|
109
|
-
return uid;
|
|
110
|
-
};
|
|
111
|
-
for (const specifierPath of path.get("specifiers")) {
|
|
112
|
-
const localName = specifierPath.node.local.name;
|
|
113
|
-
const binding = path.scope.getBinding(localName);
|
|
114
|
-
if (!binding) continue;
|
|
115
|
-
if (specifierPath.isImportDefaultSpecifier() || specifierPath.isImportSpecifier()) {
|
|
116
|
-
let keyword;
|
|
117
|
-
if (specifierPath.isImportDefaultSpecifier()) keyword = "default";
|
|
118
|
-
else {
|
|
119
|
-
const imported = specifierPath.node.imported;
|
|
120
|
-
keyword = types.isIdentifier(imported) ? imported.name : imported.value;
|
|
121
|
-
}
|
|
122
|
-
const uidNode = processKeyword(keyword);
|
|
123
|
-
if (!uidNode) continue;
|
|
124
|
-
for (const refPath of binding.referencePaths) {
|
|
125
|
-
if (isPureTypeSpace(refPath)) continue;
|
|
126
|
-
if (refPath.isJSXIdentifier()) refPath.replaceWith(types.jsxIdentifier(uidNode.name));
|
|
127
|
-
else refPath.replaceWith(types.cloneNode(uidNode));
|
|
128
|
-
}
|
|
129
|
-
path.parentPath.traverse({ TSTypeQuery(tsPath) {
|
|
130
|
-
if (types.isIdentifier(tsPath.node.exprName) && tsPath.node.exprName.name === localName && tsPath.scope.getBinding(localName) === binding) tsPath.get("exprName").replaceWith(types.cloneNode(uidNode));
|
|
131
|
-
} });
|
|
132
|
-
} else if (specifierPath.isImportNamespaceSpecifier()) {
|
|
133
|
-
for (const refPath of binding.referencePaths) {
|
|
134
|
-
if (isPureTypeSpace(refPath)) continue;
|
|
135
|
-
const parentPath = refPath.parentPath;
|
|
136
|
-
if (!parentPath) continue;
|
|
137
|
-
if (parentPath.isMemberExpression() && parentPath.node.object === refPath.node) {
|
|
138
|
-
const propNode = parentPath.node.property;
|
|
139
|
-
let keyword;
|
|
140
|
-
if (!parentPath.node.computed && types.isIdentifier(propNode)) keyword = propNode.name;
|
|
141
|
-
else if (parentPath.node.computed && types.isStringLiteral(propNode)) keyword = propNode.value;
|
|
142
|
-
if (keyword) {
|
|
143
|
-
const uidNode = processKeyword(keyword);
|
|
144
|
-
if (uidNode) parentPath.replaceWith(types.cloneNode(uidNode));
|
|
145
|
-
}
|
|
146
|
-
} else if (parentPath.isJSXMemberExpression() && parentPath.node.object === refPath.node) {
|
|
147
|
-
const keyword = parentPath.node.property.name;
|
|
148
|
-
const uidNode = processKeyword(keyword);
|
|
149
|
-
if (uidNode) parentPath.replaceWith(types.jsxIdentifier(uidNode.name));
|
|
150
|
-
}
|
|
151
|
-
}
|
|
152
|
-
path.parentPath.traverse({
|
|
153
|
-
TSTypeQuery(tsPath) {
|
|
154
|
-
const expr = tsPath.node.exprName;
|
|
155
|
-
if (types.isTSQualifiedName(expr) && types.isIdentifier(expr.left) && expr.left.name === localName && tsPath.scope.getBinding(localName) === binding) {
|
|
156
|
-
const keyword = expr.right.name;
|
|
157
|
-
const uidNode = processKeyword(keyword);
|
|
158
|
-
if (uidNode) tsPath.get("exprName").replaceWith(types.cloneNode(uidNode));
|
|
159
|
-
}
|
|
160
|
-
},
|
|
161
|
-
TSIndexedAccessType(tsPath) {
|
|
162
|
-
const objPath = tsPath.get("objectType");
|
|
163
|
-
if (objPath.isTSTypeQuery() && types.isIdentifier(objPath.node.exprName) && objPath.node.exprName.name === localName && tsPath.scope.getBinding(localName) === binding) {
|
|
164
|
-
const indexNode = tsPath.node.indexType;
|
|
165
|
-
if (types.isTSLiteralType(indexNode) && types.isStringLiteral(indexNode.literal)) {
|
|
166
|
-
const keyword = indexNode.literal.value;
|
|
167
|
-
const uidNode = processKeyword(keyword);
|
|
168
|
-
if (uidNode) tsPath.replaceWith(types.tsTypeQuery(types.cloneNode(uidNode)));
|
|
169
|
-
}
|
|
170
|
-
}
|
|
171
|
-
}
|
|
172
|
-
});
|
|
173
|
-
}
|
|
174
|
-
}
|
|
175
|
-
if (mode === "transform") path.remove();
|
|
176
|
-
},
|
|
177
|
-
ExportNamedDeclaration(path, state) {
|
|
178
|
-
const sourceValue = path.node.source?.value;
|
|
179
|
-
if (sourceValue !== "~keywords" && sourceValue !== "~keywords/public") return;
|
|
180
|
-
const targetSet = sourceValue === "~keywords/public" ? state.keywords.public : state.keywords.local;
|
|
181
|
-
if (mode === "extract") {
|
|
182
|
-
for (const specifierPath of path.get("specifiers")) if (specifierPath.isExportSpecifier()) {
|
|
183
|
-
const local = specifierPath.node.local;
|
|
184
|
-
const keyword = types.isIdentifier(local) ? local.name : local.value;
|
|
185
|
-
targetSet.add(keyword);
|
|
186
|
-
}
|
|
187
|
-
return;
|
|
188
|
-
}
|
|
189
|
-
const newExports = path.get("specifiers").map((specifierPath) => {
|
|
190
|
-
if (specifierPath.isExportSpecifier()) {
|
|
191
|
-
const local = specifierPath.node.local;
|
|
192
|
-
const keyword = types.isIdentifier(local) ? local.name : local.value;
|
|
193
|
-
targetSet.add(keyword);
|
|
194
|
-
const encoded = encodeIdentifier(keyword);
|
|
195
|
-
return types.exportNamedDeclaration(null, [types.exportSpecifier(types.identifier("default"), specifierPath.node.exported)], types.stringLiteral(`${sourceValue}/_/${encoded}`));
|
|
196
|
-
}
|
|
197
|
-
return null;
|
|
198
|
-
}).filter((node) => node !== null);
|
|
199
|
-
if (newExports.length > 0) path.replaceWithMultiple(newExports);
|
|
200
|
-
else path.remove();
|
|
201
|
-
}
|
|
202
|
-
}
|
|
203
|
-
};
|
|
204
|
-
return () => plugin;
|
|
205
|
-
};
|
|
206
|
-
const transformCode = (code, id) => {
|
|
207
|
-
if (!code.includes("~keywords") && !code.includes("~keywords/public")) return null;
|
|
208
|
-
const result = transformSync(code, {
|
|
209
|
-
babelrc: false,
|
|
210
|
-
configFile: false,
|
|
211
|
-
filename: id,
|
|
212
|
-
sourceMaps: true,
|
|
213
|
-
ast: false,
|
|
214
|
-
plugins: [transformPlugin("transform")],
|
|
215
|
-
parserOpts: { plugins: ["jsx", "typescript"] }
|
|
216
|
-
});
|
|
217
|
-
if (!result) return null;
|
|
218
|
-
const metadata = result.metadata;
|
|
219
|
-
const keywords = {
|
|
220
|
-
local: new Set(metadata?.keywords?.local ?? []),
|
|
221
|
-
public: new Set(metadata?.keywords?.public ?? [])
|
|
222
|
-
};
|
|
223
|
-
return {
|
|
224
|
-
code: result.code ?? "",
|
|
225
|
-
map: result.map ?? null,
|
|
226
|
-
keywords
|
|
227
|
-
};
|
|
228
|
-
};
|
|
229
|
-
const extractKeywords = (code) => {
|
|
230
|
-
if (!code.includes("~keywords") && !code.includes("~keywords/public")) return null;
|
|
231
|
-
let result;
|
|
232
|
-
try {
|
|
233
|
-
result = transformSync(code, {
|
|
234
|
-
babelrc: false,
|
|
235
|
-
configFile: false,
|
|
236
|
-
sourceMaps: false,
|
|
237
|
-
ast: false,
|
|
238
|
-
code: false,
|
|
239
|
-
plugins: [transformPlugin("extract")],
|
|
240
|
-
parserOpts: {
|
|
241
|
-
plugins: ["jsx", "typescript"],
|
|
242
|
-
errorRecovery: true
|
|
243
|
-
}
|
|
244
|
-
});
|
|
245
|
-
} catch {
|
|
246
|
-
return null;
|
|
247
|
-
}
|
|
248
|
-
if (!result) return null;
|
|
249
|
-
const metadata = result.metadata;
|
|
250
|
-
return {
|
|
251
|
-
local: new Set(metadata?.keywords?.local ?? []),
|
|
252
|
-
public: new Set(metadata?.keywords?.public ?? [])
|
|
253
|
-
};
|
|
254
|
-
};
|
|
255
|
-
//#endregion
|
|
256
|
-
//#region src/internal/typegen.ts
|
|
257
|
-
/**
|
|
258
|
-
* @license
|
|
259
|
-
* SPDX-License-Identifier: MIT
|
|
260
|
-
*/
|
|
261
|
-
const generateTypeDeclaration = (keywords, isPublic = false) => {
|
|
262
|
-
const sortedKeywords = Array.from(keywords).sort();
|
|
263
|
-
const content = [];
|
|
264
|
-
for (const keyword of sortedKeywords) {
|
|
265
|
-
const safeName = toSafeVarName(encodeIdentifier(keyword));
|
|
266
|
-
const value = `${isPublic ? "*".repeat(7) : "=="}.${keyword}`;
|
|
267
|
-
content.push(`declare const ${safeName}: ${JSON.stringify(value)};`);
|
|
268
|
-
}
|
|
269
|
-
content.push("");
|
|
270
|
-
content.push("export {");
|
|
271
|
-
for (const keyword of sortedKeywords) {
|
|
272
|
-
const safeName = toSafeVarName(encodeIdentifier(keyword));
|
|
273
|
-
content.push(` ${safeName} as ${JSON.stringify(keyword)},`);
|
|
274
|
-
}
|
|
275
|
-
content.push("};");
|
|
276
|
-
content.push("");
|
|
277
|
-
return content.join("\n");
|
|
278
|
-
};
|
|
279
|
-
//#endregion
|
|
280
|
-
//#region src/internal/cli.ts
|
|
281
|
-
/**
|
|
282
|
-
* @license
|
|
283
|
-
* SPDX-License-Identifier: MIT
|
|
284
|
-
*/
|
|
285
|
-
const collectKeywordsFromRoot = async (root, silent, ignoredDirs = [], concurrency = 100) => {
|
|
286
|
-
const collectedKeywords = {
|
|
287
|
-
local: /* @__PURE__ */ new Set(),
|
|
288
|
-
public: /* @__PURE__ */ new Set()
|
|
289
|
-
};
|
|
290
|
-
const start = performance.now();
|
|
291
|
-
if (!silent) console.error("Scanning project files for keywords...");
|
|
292
|
-
const files = await globby("**/*.{js,ts,mjs,mts,jsx,tsx,mjsx,mtsx}", {
|
|
293
|
-
cwd: root,
|
|
294
|
-
absolute: false,
|
|
295
|
-
ignore: ["**/node_modules/**", ...ignoredDirs.map((dir) => `${dir}/**`)],
|
|
296
|
-
gitignore: true
|
|
297
|
-
});
|
|
298
|
-
let processed = 0;
|
|
299
|
-
await pLimit({ concurrency }).map(files, async (file) => {
|
|
300
|
-
try {
|
|
301
|
-
const keywords = extractKeywords(await readFile(file, "utf-8"));
|
|
302
|
-
if (!keywords) return;
|
|
303
|
-
for (const keyword of keywords.local) collectedKeywords.local.add(keyword);
|
|
304
|
-
for (const keyword of keywords.public) collectedKeywords.public.add(keyword);
|
|
305
|
-
processed++;
|
|
306
|
-
} catch (error) {
|
|
307
|
-
if (!silent) console.error(`Failed to process ${file}: ${error}`);
|
|
308
|
-
}
|
|
309
|
-
});
|
|
310
|
-
const elapsed = performance.now() - start;
|
|
311
|
-
if (!silent) console.error(`Scan complete: ${processed}/${files.length} files, ${collectedKeywords.local.size} local, ${collectedKeywords.public.size} public keywords (${elapsed.toFixed(2)}ms).`);
|
|
312
|
-
return collectedKeywords;
|
|
313
|
-
};
|
|
314
|
-
const pkgJson = {
|
|
315
|
-
private: true,
|
|
316
|
-
type: "module",
|
|
317
|
-
sideEffects: false,
|
|
318
|
-
exports: {
|
|
319
|
-
".": { types: "./index.d.ts" },
|
|
320
|
-
"./public": { types: "./public.d.ts" },
|
|
321
|
-
[`./_/*`]: `./_/*`,
|
|
322
|
-
[`./public/_/*`]: `./public/_/*`
|
|
323
|
-
}
|
|
324
|
-
};
|
|
325
|
-
const createRunner = (options) => {
|
|
326
|
-
const { root = process.cwd(), silent = false, outDir = path.join("node_modules", "~keywords") } = options ?? {};
|
|
327
|
-
return {
|
|
328
|
-
async collect() {
|
|
329
|
-
return collectKeywordsFromRoot(root, silent);
|
|
330
|
-
},
|
|
331
|
-
async save(keywords) {
|
|
332
|
-
const content = generateTypeDeclaration(keywords.local);
|
|
333
|
-
const publicContent = generateTypeDeclaration(keywords.public, true);
|
|
334
|
-
const outPath = path.join(root, outDir);
|
|
335
|
-
await mkdir(outPath, { recursive: true });
|
|
336
|
-
await writeFile(path.join(outPath, "index.d.ts"), `${content.trim()}\n`);
|
|
337
|
-
await writeFile(path.join(outPath, "public.d.ts"), `${publicContent.trim()}\n`);
|
|
338
|
-
await writeFile(path.join(outPath, "package.json"), `${JSON.stringify(pkgJson, null, 2)}\n`);
|
|
339
|
-
},
|
|
340
|
-
async run() {
|
|
341
|
-
const keywords = await this.collect();
|
|
342
|
-
await this.save(keywords);
|
|
343
|
-
}
|
|
344
|
-
};
|
|
345
|
-
};
|
|
346
|
-
//#endregion
|
|
347
|
-
//#region src/internal/hash.ts
|
|
348
|
-
/**
|
|
349
|
-
* @license
|
|
350
|
-
* SPDX-License-Identifier: MIT
|
|
351
|
-
*/
|
|
352
|
-
const ALPHA_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
353
|
-
const DIGIT_CHARS = "0123456789";
|
|
354
|
-
const BASE62_CHARS = ALPHA_CHARS + DIGIT_CHARS;
|
|
355
|
-
const ALPHA_LEN = BigInt(52);
|
|
356
|
-
const DIGIT_LEN = BigInt(10);
|
|
357
|
-
const BASE62_LEN = BigInt(BASE62_CHARS.length);
|
|
358
|
-
const createHasher = (secret) => {
|
|
359
|
-
const base62TailLength = 5;
|
|
360
|
-
if (base62TailLength < 0 || base62TailLength > 9) throw new Error("Invalid MAX_HASH_LENGTH");
|
|
361
|
-
const cache = /* @__PURE__ */ new Map();
|
|
362
|
-
return (input) => {
|
|
363
|
-
if (cache.has(input)) return cache.get(input);
|
|
364
|
-
const payload = `16:${VIRTUAL_PUBLIC_MODULE_ID}|${input.length}:${input}`;
|
|
365
|
-
const buffer = createHmac("sha256", secret).update(payload).digest("hex");
|
|
366
|
-
let entropy = BigInt(`0x${buffer}`);
|
|
367
|
-
let result = "";
|
|
368
|
-
result += ALPHA_CHARS[Number(entropy % ALPHA_LEN)];
|
|
369
|
-
entropy /= ALPHA_LEN;
|
|
370
|
-
result += DIGIT_CHARS[Number(entropy % DIGIT_LEN)];
|
|
371
|
-
entropy /= DIGIT_LEN;
|
|
372
|
-
for (let i = 0; i < base62TailLength; i++) {
|
|
373
|
-
result += BASE62_CHARS[Number(entropy % BASE62_LEN)];
|
|
374
|
-
entropy /= BASE62_LEN;
|
|
375
|
-
}
|
|
376
|
-
cache.set(input, result);
|
|
377
|
-
return result;
|
|
378
|
-
};
|
|
379
|
-
};
|
|
380
|
-
const shuffle = (str, secret, salt) => {
|
|
381
|
-
const arr = Array.from(str);
|
|
382
|
-
const keyingMaterial = hkdfSync("sha256", secret, salt, VIRTUAL_MODULE_ID, (arr.length - 1) * 4);
|
|
383
|
-
const prngBuffer = Buffer.from(keyingMaterial);
|
|
384
|
-
let byteOffset = 0;
|
|
385
|
-
for (let i = arr.length - 1; i > 0; i--) {
|
|
386
|
-
const random32 = prngBuffer.readUInt32BE(byteOffset);
|
|
387
|
-
byteOffset += 4;
|
|
388
|
-
const j = random32 % (i + 1);
|
|
389
|
-
const temp = arr[i];
|
|
390
|
-
arr[i] = arr[j];
|
|
391
|
-
arr[j] = temp;
|
|
392
|
-
}
|
|
393
|
-
return arr.join("");
|
|
394
|
-
};
|
|
395
|
-
const createCounter = (secret) => {
|
|
396
|
-
const shuffledAlpha = shuffle(ALPHA_CHARS, secret, "alpha");
|
|
397
|
-
const shuffledDigit = shuffle(DIGIT_CHARS, secret, "digit");
|
|
398
|
-
const shuffledBase62 = shuffle(BASE62_CHARS, secret, "base62");
|
|
399
|
-
let index = 0;
|
|
400
|
-
const cache = /* @__PURE__ */ new Map();
|
|
401
|
-
return (input) => {
|
|
402
|
-
if (cache.has(input)) return cache.get(input);
|
|
403
|
-
let result = "";
|
|
404
|
-
let current = index;
|
|
405
|
-
index++;
|
|
406
|
-
result += shuffledAlpha[current % shuffledAlpha.length];
|
|
407
|
-
current = Math.floor(current / shuffledAlpha.length);
|
|
408
|
-
result += shuffledDigit[current % shuffledDigit.length];
|
|
409
|
-
current = Math.floor(current / shuffledDigit.length);
|
|
410
|
-
while (current > 0) {
|
|
411
|
-
current--;
|
|
412
|
-
result += shuffledBase62[current % shuffledBase62.length];
|
|
413
|
-
current = Math.floor(current / shuffledBase62.length);
|
|
414
|
-
}
|
|
415
|
-
cache.set(input, result);
|
|
416
|
-
return result;
|
|
417
|
-
};
|
|
418
|
-
};
|
|
419
|
-
//#endregion
|
|
420
|
-
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 };
|
|
421
|
-
|
|
422
|
-
//# sourceMappingURL=hash-CV-Tn-Zm.js.map
|