ts-const-value-transformer 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## v0.1.0
+
+Initial version.

package/LICENSE

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

package/README.md

@@ -0,0 +1,250 @@
+# ts-const-value-transformer
+
+Transforms constant variables with actual literals in TypeScript project.
+Provides 'transformer' for TypeScript building ecosystems, 'loader' for webpack, and transform and print APIs.
+
+- [Motivation](#motivation)
+- [Usage](#usage)
+  - [Using transformer](#using-transformer)
+  - [Using webpack loader](#using-webpack-loader)
+  - [Transform options](#transform-options)
+  - [APIs](#apis)
+- [Additional notes](#additional-notes)
+- [License](#license)
+
+## Motivation
+
+Usually, constant variables will be replaced with actual values by [terser](https://terser.org/), [swc](https://swc.rs/) or etc. ([swc example](https://play.swc.rs/?version=1.15.3&code=H4sIAAAAAAAAA9PXVygvyixJVcgvUihILAYykvNTUhUyUotSebl4uZLz84pLFBIVbBWqebkUFBKtFAx1QIwkKwUjMCPZSsGYl6vWGqI0PydVLyc%2FXSNRL1FHIVEvCUQkawIlAet2OZpnAAAA&config=H4sIAAAAAAAAA32US3LbMAyG9zmFR%2Bts20UPkF3PwKFJUKbDh4YAHWsyvnshSrLdGNJOwocfIAEQ32%2BHQ3dG0%2F05fPMn%2Fwy6IJT7P1twTKSvbOnARI2m%2BIG695WecUJOB4Rmus2kI116oKbCX4t7F3JGWN0XW%2FTJu%2FE5oclxKID4ZGMrx6sREuH%2F%2BoWV%2FDUBKvXZfsw5gE47RGlUPhH0UKTAJoegBwR10UWIMp1UF49ZSjHBSmDVUPIg8mQ9%2BZw45yu1oK0y2YKAfAFD%2FgKSjHOxLCFfT7hPwxaOte9bk3%2Bo4aJD1STkhGtrCZ9WiHrKHkm5mqQSznCjBjNcivtT6Z0qQLWkV905%2B7TRk08ArkDQiElHkOI2D8fztKV2u0qfHI8sjQLn%2BZZumaDnoirvnVDZqTJQyEvdLGCrgamyRjrOgjfKh96CAud4VoTQ%2BOXJnKSkNA6QnQC4v9pJUzUDdX%2BFG3x6EDv4g29J8oAtHlHTaZviGI857CSIQKdsdxy4FZS3ceEtcR22eU0WeDTAii4VG3hdAvwAKKvQluXLbPDz4IiqD%2Fn4WBOLw%2B2%2BhKNO%2FeO9z3v4bXHoYra1wWXDT%2F2d9%2FLv7uG0buH1BJ3Hv6uw5bz9A1EN%2Bh8sBgAA)), but if the variables are exported, the variables are not replaced ([swc example](https://play.swc.rs/?version=1.15.3&code=H4sIAAAAAAAAAyXKwQqAIBCE4bvgO8yxQIzqZvQwmy0VRBsqFETvXtZl%2BGD%2BqsIRlsSQgJ3iCy8jY%2BbAWmnlZYsJhB6XVgA51CZjcGg%2BeIdWq7v7U1nZrjIVZMmA7JDHl%2B%2FJ5y4h4aJcPrXX%2FP90AAAA&config=H4sIAAAAAAAAA32US3LbMAyG9zmFR%2Bts20UPkF3PwKFJUKbDh4YAHWsyvnshSrLdGNJOwocfIAEQ32%2BHQ3dG0%2F05fPMn%2Fwy6IJT7P1twTKSvbOnARI2m%2BIG695WecUJOB4Rmus2kI116oKbCX4t7F3JGWN0XW%2FTJu%2FE5oclxKID4ZGMrx6sREuH%2F%2BoWV%2FDUBKvXZfsw5gE47RGlUPhH0UKTAJoegBwR10UWIMp1UF49ZSjHBSmDVUPIg8mQ9%2BZw45yu1oK0y2YKAfAFD%2FgKSjHOxLCFfT7hPwxaOte9bk3%2Bo4aJD1STkhGtrCZ9WiHrKHkm5mqQSznCjBjNcivtT6Z0qQLWkV905%2B7TRk08ArkDQiElHkOI2D8fztKV2u0qfHI8sjQLn%2BZZumaDnoirvnVDZqTJQyEvdLGCrgamyRjrOgjfKh96CAud4VoTQ%2BOXJnKSkNA6QnQC4v9pJUzUDdX%2BFG3x6EDv4g29J8oAtHlHTaZviGI857CSIQKdsdxy4FZS3ceEtcR22eU0WeDTAii4VG3hdAvwAKKvQluXLbPDz4IiqD%2Fn4WBOLw%2B2%2BhKNO%2FeO9z3v4bXHoYra1wWXDT%2F2d9%2FLv7uG0buH1BJ3Hv6uw5bz9A1EN%2Bh8sBgAA)). But if the variables are strictly typed, the variables should be replaced probably safely.  
+This package aims to replace those variables/property references/enum values with actual values, to reduce code side (and, perhaps, to increase execution speed).
+
+## Usage
+
+First, install with:
+
+```sh
+npm install --save-dev ts-const-value-transformer
+```
+
+### Using transformer
+
+Transformer is a feature for TypeScript build system to convert parsed source code (AST) to another AST.
+TypeScript compiler `tsc` does not accept transformers, but some TypeScript-related ecosystems such as
+[ts-loader](https://www.npmjs.com/package/ts-loader) and [ts-patch](https://www.npmjs.com/package/ts-patch) accept transformers to intercept builds.
+
+To use with ts-loader, write webpack configuration as follows:
+
+```js
+import { createTransformer } from 'ts-const-value-transformer';
+// or: const { createTransformer } = require('ts-const-value-transformer');
+// (you can use 'require' for ES modules starting from Node.js v20.19.0; see https://nodejs.org/api/modules.html#loading-ecmascript-modules-using-require)
+
+const yourWebpackConfiguration = {
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: [
+          {
+            loader: 'ts-loader',
+            options: {
+              getCustomTransformers: (program) => ({
+                before: [
+                  createTransformer(program, {
+                    options: {
+                      /* ts-const-value-transformer options (see below) */
+                    },
+                  }),
+                ],
+              }),
+              // ...other configurations
+            },
+          },
+        ],
+      },
+    ],
+  },
+  // ...other configurations
+};
+```
+
+or:
+
+```js
+const yourWebpackConfiguration = {
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: [
+          {
+            loader: 'ts-loader',
+            options: {
+              // If you specify only one transformer, you can use 'ts-const-value-transformer/getCustomTransformers' module
+              getCustomTransformers:
+                'ts-const-value-transformer/getCustomTransformers',
+              // ...other configurations
+            },
+          },
+        ],
+      },
+    ],
+  },
+  // ...other configurations
+};
+```
+
+To use with ts-patch, write tsconfig.json as follows:
+
+```jsonc
+  "compilerOptions": {
+    // ...
+    "plugins": [
+      { "transform": "ts-const-value-transformer", "options": { /* ts-const-value-transformer options (see below) */ } }
+    ]
+  }
+```
+
+### Using webpack loader
+
+You can use webpack loader for transformation. If you use loaders to transpile TS files other than ts-loader, `ts-const-value-transformer/loader` is a choice.  
+Note that this may increase the build time because of parsing processes.
+
+> If you are using ts-loader, you should use the transformer described above for performance reason.
+
+```js
+const yourWebpackConfiguration = {
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: [
+          {
+            loader: 'babel-loader',
+            options: {
+              presets: ['@babel/preset-typescript'],
+            },
+          },
+          {
+            loader: 'ts-const-value-transformer/loader',
+            options; {
+              project: 'tsconfig.json', // your tsconfig.json
+              // typescript: 'typescript', // if you are using another 'typescript' package, you can specify the module name here
+              // ... other options from `TransformOptions` fields
+              // hoistProperty: false,
+              // ...
+            }
+          },
+        ],
+      },
+    ],
+  },
+  // ...other configurations
+};
+```
+
+### Transform options
+
+```ts
+export interface TransformOptions {
+  /** `typescript` namespace object */
+  ts?: typeof ts;
+  /** Hoist property expressions (`x.prop`) which the value is constant. Default is true, but if the property getter has side effects (not recommended), set false explicitly. */
+  hoistProperty?: boolean | undefined;
+  /** Hoist function calls which the return value is constant. Default is false because function calls may have side effects. */
+  unsafeHoistFunctionCall?: boolean | undefined;
+  /** Hoist expressions with `as XXX`. Default is false because the base (non-`as`) value may be non-constant. */
+  unsafeHoistAsExpresion?: boolean | undefined;
+}
+```
+
+Note that you must pass `options` field to `createTransformer` function or `"plugins"` specifier.
+
+### APIs
+
+```ts
+import {
+  createTransformer,
+  printSource,
+  printSourceWithMap,
+  transformSource,
+  version,
+  type TransformOptions,
+} from 'ts-const-value-transformer';
+```
+
+#### createTransformer: (program: ts.Program, config?: { options?: TransformOptions }, extras?: { ts?: typeof ts }) => ts.TransformerFactory<ts.SourceFile>
+
+Used with TypeScript API or ts-loader.
+
+Call example:
+
+```js
+import * as path from 'path';
+import * as ts from 'typescript';
+import { createTransformer } from 'ts-const-value-transformer';
+
+const PROJECT_DIR = path.resolve('.');
+
+// Load tsconfig.json file
+const configFile = ts.readJsonConfigFile(
+  path.resolve(PROJECT_DIR, 'tsconfig.json'),
+  ts.sys.readFile
+);
+const config = ts.parseJsonSourceFileConfigFileContent(
+  configFile,
+  ts.sys,
+  PROJECT_DIR
+);
+
+// Initialize the program
+const program = ts.createProgram({
+  options: config.options,
+  rootNames: config.fileNames,
+});
+
+// Load the source file to transform
+const fileName = path.resolve(PROJECT_DIR, 'index.mts');
+const sourceFile = program.getSourceFile(fileName)!;
+
+// Do transform
+const transformer = createTransformer(program);
+const result = ts.transform(
+  sourceFile,
+  [transformer],
+  program.getCompilerOptions()
+);
+const transformedSource = result.transformed[0]!;
+// You can emit the transformed code by using `printSource` (see below):
+//   console.log(printSource(transformedSource));
+```
+
+#### printSource: (sourceFile: ts.SourceFile) => string
+
+Prints (generates) source code from `SourceFile`. The source file must be one generated by `transformSource` or existing in the TS project (available with `getSourceFile()` in `ts.Program`).
+
+#### printSourceWithMap: (sourceFile: ts.SourceFile, originalSourceName: string, startOfSourceMap?: RawSourceMap) => [string, RawSourceMap]
+
+Prints (generates) source code from `SourceFile`, along with raw source-map data. The source file must be one generated by `transformSource` or existing in the TS project (available with `getSourceFile()` in `ts.Program`).
+
+- `originalSourceName` would be the file name of `sourceFile`, but you can specify another name.
+- `startOfSourceMap` is a base source map (if original source file is a generated-content) if available.
+
+#### transformSource: (sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext, options?: TransformOptions) => ts.SourceFile
+
+Transforms the source file with TypeScript project. You don't need to call this function directly; use `createTransformer` instead.
+
+#### version: string
+
+The version string of this package.
+
+#### type TransformOptions
+
+See [Transform options](#transform-options).
+
+## Additional notes
+
+I think there should be more optimization methods by using strictly-typed information, like other programming languages.
+
+## License
+
+[MIT License](./LICENSE)

package/dist/createTransformer.d.mts

@@ -0,0 +1,9 @@
+import type * as ts from 'typescript';
+import { type TransformOptions } from './transform.mjs';
+interface Config {
+    options?: TransformOptions;
+}
+export default function createTransformer(program: ts.Program, config?: Config, extras?: {
+    ts?: typeof ts;
+}): ts.TransformerFactory<ts.SourceFile>;
+export {};

package/dist/createTransformer.mjs

@@ -0,0 +1,15 @@
+import { transformSource } from './transform.mjs';
+export default function createTransformer(program, 
+// for ttypescript and ts-patch
+config, 
+// for ts-patch
+extras) {
+    return (context) => {
+        return (sourceFile) => {
+            return transformSource(sourceFile, program, context, {
+                ...config?.options,
+                ...(extras?.ts && { ts: extras?.ts }),
+            });
+        };
+    };
+}

package/dist/getCustomTransformers.d.mts

@@ -0,0 +1,6 @@
+import type * as ts from 'typescript';
+export default function getCustomTransformers(program: ts.Program, _getProgram: () => ts.Program): {
+    before?: Array<ts.TransformerFactory<ts.SourceFile>>;
+    after?: Array<ts.TransformerFactory<ts.SourceFile>>;
+    afterDeclarations?: Array<ts.TransformerFactory<ts.SourceFile>>;
+};

package/dist/getCustomTransformers.mjs

@@ -0,0 +1,7 @@
+// for ts-loader
+import createTransformer from './createTransformer.mjs';
+export default function getCustomTransformers(program, _getProgram) {
+    return { before: [createTransformer(program)] };
+}
+
+export { getCustomTransformers as 'module.exports' };

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import createTransformer from './createTransformer.mjs';
+import version from './version.mjs';
+export { printSource, printSourceWithMap, transformSource, type TransformOptions, } from './transform.mjs';
+export { createTransformer, version };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import createTransformer from './createTransformer.mjs';
+import version from './version.mjs';
+export { printSource, printSourceWithMap, transformSource, } from './transform.mjs';
+export { createTransformer, version };

package/dist/loader.d.mts

@@ -0,0 +1,9 @@
+import type * as tsNamespace from 'typescript';
+import type * as webpack from 'webpack';
+import { type TransformOptions } from './transform.mjs';
+export interface TsConstValueTransformerLoaderOptions extends TransformOptions {
+    project?: string;
+    typescript?: string | typeof tsNamespace;
+}
+declare const loader: webpack.LoaderDefinitionFunction<TsConstValueTransformerLoaderOptions | undefined>;
+export default loader;

package/dist/loader.mjs

@@ -0,0 +1,78 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import createTransformer from './createTransformer.mjs';
+import { printSourceWithMap } from './transform.mjs';
+const programMap = new Map();
+const loader = function (content, sourceMap) {
+    this.async();
+    void (async () => {
+        try {
+            const options = this.getOptions() || {};
+            let ts;
+            if (options.typescript != null) {
+                if (typeof options.typescript === 'string') {
+                    ts = (await import(options.typescript));
+                }
+                else {
+                    ts = options.typescript;
+                }
+            }
+            else if (options.ts != null) {
+                ts = options.ts;
+            }
+            else {
+                ts = await import('typescript');
+            }
+            const project = options.project ?? 'tsconfig.json';
+            let program = programMap.get(project);
+            if (!program) {
+                const getCurrentDirectory = () => path.dirname(this.resourcePath);
+                const config = ts.getParsedCommandLineOfConfigFile(project, void 0, {
+                    fileExists: fs.existsSync,
+                    getCurrentDirectory,
+                    // eslint-disable-next-line @typescript-eslint/unbound-method
+                    readDirectory: ts.sys.readDirectory,
+                    readFile: (file) => fs.readFileSync(path.isAbsolute(file)
+                        ? file
+                        : path.join(getCurrentDirectory(), file), 'utf-8'),
+                    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+                    onUnRecoverableConfigFileDiagnostic: (diag) => {
+                        throw new Error(ts.formatDiagnostics([diag], {
+                            getCanonicalFileName: (f) => f,
+                            getCurrentDirectory,
+                            getNewLine: () => '\n',
+                        }));
+                    },
+                });
+                if (!config) {
+                    throw new Error(`[ts-const-value-transformer-loader] Unable to load tsconfig file (effective name = '${project}')`);
+                }
+                program = ts.createProgram({
+                    options: config.options,
+                    rootNames: config.fileNames,
+                });
+                programMap.set(project, program);
+            }
+            const sourceFile = program.getSourceFile(this.resource);
+            if (!sourceFile) {
+                throw new Error(`'${this.resource}' is not in the TypeScript project.`);
+            }
+            sourceFile.update(content, {
+                span: { start: 0, length: sourceFile.end },
+                newLength: content.length,
+            });
+            const transformer = createTransformer(program, {
+                options: { ...options, ts },
+            });
+            const result = ts.transform(sourceFile, [transformer], program.getCompilerOptions());
+            const printed = printSourceWithMap(result.transformed[0], this.resource, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            typeof sourceMap === 'string' ? JSON.parse(sourceMap) : sourceMap);
+            this.callback(null, printed[0], printed[1]);
+        }
+        catch (e) {
+            this.callback(e);
+        }
+    })();
+};
+export default loader;

package/dist/transform.d.mts

@@ -0,0 +1,15 @@
+import * as sourceMap from 'source-map';
+import * as ts from 'typescript';
+export interface TransformOptions {
+    /** `typescript` namespace object */
+    ts?: typeof ts;
+    /** Hoist property expressions (`x.prop`) which the value is constant. Default is true, but if the property getter has side effects (not recommended), set false explicitly. */
+    hoistProperty?: boolean | undefined;
+    /** Hoist function calls which the return value is constant. Default is false because function calls may have side effects. */
+    unsafeHoistFunctionCall?: boolean | undefined;
+    /** Hoist expressions with `as XXX`. Default is false because the base (non-`as`) value may be non-constant. */
+    unsafeHoistAsExpresion?: boolean | undefined;
+}
+export declare function transformSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext, options?: TransformOptions): ts.SourceFile;
+export declare function printSource(sourceFile: ts.SourceFile): string;
+export declare function printSourceWithMap(sourceFile: ts.SourceFile, originalSourceName: string, startOfSourceMap?: sourceMap.RawSourceMap): [string, sourceMap.RawSourceMap];

package/dist/transform.mjs

@@ -0,0 +1,267 @@
+import * as sourceMap from 'source-map';
+import * as ts from 'typescript';
+const SYMBOL_ORIGINAL_NODE = Symbol('originalNode');
+function assignDefaultValues(options) {
+    return {
+        ts,
+        hoistProperty: true,
+        unsafeHoistAsExpresion: false,
+        unsafeHoistFunctionCall: false,
+        ...options,
+    };
+}
+////////////////////////////////////////////////////////////////////////////////
+export function transformSource(sourceFile, program, context, options) {
+    return visitNodeChildren(sourceFile, sourceFile, program, context, assignDefaultValues(options));
+}
+function visitNodeChildren(node, sourceFile, program, context, options) {
+    const newNode = visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options);
+    if (newNode[SYMBOL_ORIGINAL_NODE]) {
+        return newNode;
+    }
+    return ts.visitEachChild(newNode, (node) => visitNodeChildren(node, sourceFile, program, context, options), context);
+}
+function visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options) {
+    const ts = options.ts;
+    if (!ts.isExpression(node) && !ts.isIdentifier(node)) {
+        return node;
+    }
+    if (ts.isLiteralExpression(node) ||
+        ts.isObjectLiteralExpression(node) ||
+        ts.isPrefixUnaryExpression(node) ||
+        ts.isPostfixUnaryExpression(node) ||
+        ts.isBinaryExpression(node) ||
+        ts.isConditionalExpression(node) ||
+        ts.isVoidExpression(node) ||
+        ts.isSpreadElement(node) ||
+        (!options.hoistProperty &&
+            ts.isPropertyAccessExpression(node) &&
+            !isEnumAccess(node, program, ts)) ||
+        (!options.unsafeHoistFunctionCall && ts.isCallLikeExpression(node)) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword) {
+        return node;
+    }
+    if (ts.isIdentifier(node)) {
+        if (
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        !node.parent ||
+            (!ts.isExpression(node.parent) &&
+                (!('initializer' in node.parent) ||
+                    node !== node.parent.initializer)) ||
+            (!options.hoistProperty &&
+                ts.isPropertyAccessExpression(node.parent) &&
+                node === node.parent.name)) {
+            return node;
+        }
+    }
+    if (!options.unsafeHoistAsExpresion &&
+        (hasAsExpression(node, context, ts) ||
+            hasParentAsExpression(node.parent, context, ts))) {
+        return node;
+    }
+    try {
+        const typeChecker = program.getTypeChecker();
+        const type = typeChecker.getTypeAtLocation(node);
+        const flags = type.getFlags();
+        let newNode;
+        if (type.isStringLiteral()) {
+            newNode = context.factory.createStringLiteral(type.value);
+        }
+        else if (type.isNumberLiteral()) {
+            if (type.value < 0) {
+                newNode = context.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, context.factory.createNumericLiteral(-type.value));
+            }
+            else {
+                newNode = context.factory.createNumericLiteral(type.value);
+            }
+        }
+        else if (flags & ts.TypeFlags.BigIntLiteral) {
+            newNode = context.factory.createBigIntLiteral(typeChecker.typeToString(type));
+        }
+        else if (flags & ts.TypeFlags.BooleanLiteral) {
+            const text = typeChecker.typeToString(type);
+            newNode =
+                text === 'true'
+                    ? context.factory.createTrue()
+                    : context.factory.createFalse();
+        }
+        else if (flags & ts.TypeFlags.Null) {
+            newNode = context.factory.createNull();
+        }
+        else if (flags & ts.TypeFlags.Undefined) {
+            newNode = context.factory.createVoidZero();
+        }
+        else {
+            return node;
+        }
+        const result = ts.addSyntheticTrailingComment(newNode, ts.SyntaxKind.MultiLineCommentTrivia, ` ${node.getText(sourceFile)} `);
+        ts.setTextRange(result, node);
+        result[SYMBOL_ORIGINAL_NODE] = node;
+        return result;
+    }
+    catch {
+        return node;
+    }
+}
+function isEnumAccess(node, program, tsInstance) {
+    const ts = tsInstance;
+    const typeChecker = program.getTypeChecker();
+    const type = typeChecker.getTypeAtLocation(node);
+    return (type.getFlags() & ts.TypeFlags.EnumLiteral) !== 0;
+}
+function isAsConstExpression(node) {
+    return node.type.getText() === 'const';
+}
+function hasAsExpression(node, context, tsInstance) {
+    const ts = tsInstance;
+    // including 'as const'
+    if (ts.isAsExpression(node)) {
+        return true;
+    }
+    let found = false;
+    ts.visitEachChild(node, (node) => {
+        if (!found) {
+            found = hasAsExpression(node, context, ts);
+        }
+        return node;
+    }, context);
+    return found;
+}
+function hasParentAsExpression(node, context, tsInstance) {
+    const ts = tsInstance;
+    if (node == null) {
+        return false;
+    }
+    // excluding 'as const'
+    if (ts.isAsExpression(node) && !isAsConstExpression(node)) {
+        return true;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        if (hasAsExpression(node.expression, context, ts)) {
+            return true;
+        }
+    }
+    return hasParentAsExpression(node.parent, context, ts);
+}
+////////////////////////////////////////////////////////////////////////////////
+export function printSource(sourceFile) {
+    return printSourceImpl(sourceFile)[0];
+}
+export function printSourceWithMap(sourceFile, originalSourceName, startOfSourceMap) {
+    const generator = new sourceMap.SourceMapGenerator(startOfSourceMap);
+    generator.setSourceContent(originalSourceName, sourceFile.getFullText());
+    return printSourceImpl(sourceFile, originalSourceName, generator);
+}
+function positionToLineAndColumn(sourceFile, pos, generatedDiff) {
+    let line = 0;
+    let lastLinePos = 0;
+    for (const linePos of sourceFile.getLineStarts()) {
+        if (pos < linePos) {
+            break;
+        }
+        lastLinePos = linePos;
+        ++line;
+    }
+    return { line, column: pos - lastLinePos + generatedDiff };
+}
+function printSourceImpl(sourceFile, originalSourceName, mapGenerator) {
+    const printer = ts.createPrinter({ removeComments: true });
+    const r = printNode(printer, sourceFile.getFullText(), sourceFile, sourceFile, { pos: 0, diff: 0, lastLine: 0 }, originalSourceName, mapGenerator);
+    return [r, mapGenerator?.toJSON()];
+}
+function printNode(printer, baseSource, sourceFile, node, posContext, originalSourceName, mapGenerator) {
+    const originalNode = node[SYMBOL_ORIGINAL_NODE];
+    if (originalNode) {
+        let result = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+        const comments = ts.getSyntheticTrailingComments(node);
+        if (comments) {
+            for (const comment of comments) {
+                result += ` /*${comment.text}*/`;
+            }
+        }
+        const old = originalNode.getText(sourceFile);
+        const oldFull = baseSource.substring(originalNode.pos, originalNode.end);
+        const i = oldFull.lastIndexOf(old);
+        const leadingUnchanged = i < 0 ? 0 : i;
+        const newText = i < 0
+            ? result
+            : oldFull.substring(0, i) + result + oldFull.substring(i + old.length);
+        if (mapGenerator) {
+            if (posContext.pos < node.pos) {
+                addMappingForCurrent();
+            }
+            posContext.pos = node.pos;
+            if (leadingUnchanged > 0) {
+                addMappingForCurrent();
+            }
+            posContext.pos = node.pos + leadingUnchanged;
+            addMappingForCurrent(old);
+        }
+        posContext.diff += result.length - old.length;
+        posContext.pos += old.length;
+        addMappingForCurrent();
+        posContext.pos = node.end;
+        addMappingForCurrent();
+        return newText;
+    }
+    let output = '';
+    let headPrinted = false;
+    let lastChildPos = 0;
+    ts.visitEachChild(node, (child) => {
+        if (!headPrinted) {
+            headPrinted = true;
+            if (child.pos > node.pos) {
+                const text = baseSource.substring(node.pos, child.pos);
+                output += text;
+                addMappingForCurrent();
+                posContext.pos = child.pos;
+            }
+        }
+        else if (child.pos > lastChildPos) {
+            const text = baseSource.substring(lastChildPos, child.pos);
+            output += text;
+            addMappingForCurrent();
+            posContext.pos = child.pos;
+        }
+        output += printNode(printer, baseSource, sourceFile, child, posContext, originalSourceName, mapGenerator);
+        lastChildPos = child.end;
+        return child;
+    }, void 0);
+    if (!headPrinted) {
+        output = baseSource.substring(node.pos, node.end);
+        addMappingForCurrent();
+        posContext.pos = node.end;
+    }
+    else if (lastChildPos < node.end) {
+        const text = baseSource.substring(lastChildPos, node.end);
+        output += text;
+        addMappingForCurrent();
+        posContext.pos = node.end;
+    }
+    addMappingForCurrent();
+    return output;
+    function addMappingForCurrent(name) {
+        const original = positionToLineAndColumn(sourceFile, posContext.pos, 0);
+        if (original.line !== posContext.lastLine) {
+            posContext.diff = 0;
+            posContext.lastLine = original.line;
+            if (mapGenerator && original.column > 0) {
+                mapGenerator.addMapping({
+                    original: { line: original.line, column: 0 },
+                    generated: { line: original.line, column: 0 },
+                    source: originalSourceName,
+                });
+            }
+        }
+        if (mapGenerator) {
+            mapGenerator.addMapping({
+                original,
+                generated: positionToLineAndColumn(sourceFile, posContext.pos, posContext.diff),
+                source: originalSourceName,
+                name,
+            });
+        }
+    }
+}

package/dist/version.d.mts

@@ -0,0 +1,2 @@
+declare const _default: "0.1.0";
+export default _default;

package/dist/version.mjs

@@ -0,0 +1 @@
+export default '0.1.0';

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "ts-const-value-transformer",
+  "version": "0.1.0",
+  "engines": {
+    "node": ">=20.19.3"
+  },
+  "description": "Transforms constant variables with actual literals in TypeScript project.",
+  "type": "module",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "default": "./dist/index.mjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    },
+    "./getCustomTransformers": {
+      "default": "./dist/getCustomTransformers.mjs",
+      "import": "./dist/getCustomTransformers.mjs",
+      "types": "./dist/getCustomTransformers.d.mts"
+    },
+    "./getCustomTransformers.mjs": {
+      "default": "./dist/getCustomTransformers.mjs",
+      "import": "./dist/getCustomTransformers.mjs",
+      "types": "./dist/getCustomTransformers.d.mts"
+    },
+    "./loader": {
+      "default": "./dist/loader.mjs",
+      "import": "./dist/loader.mjs",
+      "types": "./dist/loader.d.mts"
+    },
+    "./loader.mjs": {
+      "default": "./dist/loader.mjs",
+      "import": "./dist/loader.mjs",
+      "types": "./dist/loader.d.mts"
+    }
+  },
+  "types": "./dist/index.d.mts",
+  "author": "jet (ジェット)",
+  "license": "MIT",
+  "homepage": "https://github.com/jet2jet/ts-const-value-transformer",
+  "keywords": [
+    "typescript",
+    "transformer",
+    "optimize",
+    "optimizer",
+    "optimization",
+    "webpack-loader"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jet2jet/ts-const-value-transformer.git"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/jet2jet"
+  },
+  "scripts": {
+    "build": "npm run build:esm",
+    "build:esm": "tsc -p ./tsconfig.app.json && npm run build:esm:addModuleExports",
+    "build:esm:addModuleExports": "node ./tools/addModuleExports.mjs ./dist/getCustomTransformers.mjs",
+    "lint": "npm run lint:eslint && npm run lint:prettier",
+    "lint:eslint": "eslint -c eslint.config.mjs --ext .mjs,.mts .",
+    "lint:eslint:fix": "eslint -c eslint.config.mjs --fix --ext .mjs,.mts .",
+    "lint:fix": "npm run lint:eslint:fix && npm run lint:prettier:fix",
+    "lint:prettier": "prettier --config ./.prettierrc.yml --check \"**/*.{js,jsx,ts,tsx,yml,json,md}\"",
+    "lint:prettier:fix": "prettier --config ./.prettierrc.yml --write \"**/*.{js,jsx,ts,tsx,yml,json,md}\"",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config ./jest.config.mjs",
+    "test:update": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config ./jest.config.mjs -u",
+    "typecheck": "tsc --project tsconfig.json --noEmit && echo \"Done\".",
+    "version": "node ./tools/updateVersion.mjs ./src/main/version.mts && git add -A ./src/main/version.mts"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "~20.19.22",
+    "@typescript-eslint/eslint-plugin": "^8.48.0",
+    "@typescript-eslint/parser": "^8.48.0",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-n": "^17.23.1",
+    "eslint-plugin-promise": "^7.2.1",
+    "jest": "^30.2.0",
+    "memfs": "^4.51.0",
+    "neostandard": "^0.12.2",
+    "prettier": "^3.6.2",
+    "ts-jest": "^29.4.5",
+    "ts-loader": "^9.5.4",
+    "ts-patch": "^3.3.0",
+    "tslib": "^2.8.1",
+    "typescript": "~5.5.4",
+    "webpack": "^5.103.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.5"
+  },
+  "dependencies": {
+    "source-map": "^0.7.6"
+  }
+}