expose-kit 0.7.0 → 0.9.0

package/README.md

@@ -285,9 +285,70 @@ Notes:
 
 ---
 
+### `expose remove-reassign`
+
+Inline safe alias assignments and wrapper calls.
+```js
+const a = 0;
+const b = a;
+const c = b;
+console.log(c); // => console.log(a);
+```
+```js
+function a(arg) {
+  return b(arg);
+}
+function c(arg) {
+  return d[arg];
+}
+a(0); // => b(0)
+c(0); // => d[0]
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/remove-reassign/mocks).
+
+```bash
+expose remove-reassign path/to/file.js --output path/to/file.remove-reassign.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Only inlines const/immutable alias chains.
+- Skips object shorthand replacements and shadowed bindings.
+- Wrapper inlining is limited to single-return passthroughs.
+
+---
+
+### `expose fn-inliner`
+
+Inline proxy function calls into expressions.
+```js
+const add = (a, b) => a + b;
+const sum = add(1, 2);
+// after
+const sum = 1 + 2;
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/fn-inliner/mocks).
+
+```bash
+expose fn-inliner path/to/file.js --output path/to/file.fn-inliner.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Only inlines functions that return a single expression.
+- Skips return expressions with assignments, functions, blocks, or sequences.
+
+---
+
 ### `expose remove-unused`
-
-Remove unused variabless.
+
+Remove unused variabless.
 ```js
 // before
 var a = 0, b = 1;

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // index.ts
 import { Command } from "commander";
-import { dirname as dirname8, join as join8 } from "path";
+import { dirname as dirname10, join as join10 } from "path";
 import { fileURLToPath } from "url";
 import chalk4 from "chalk";
 
@@ -746,11 +746,7 @@ var expand_object_default = createCommand((program2) => {
             }
             const loader = loading4("Expanding object access...").start();
             try {
-              const { code: output, replacedCount } = await expandObjectAccess(
-                fileContent,
-                filename,
-                targetName
-              );
+              const { code: output, replacedCount } = await expandObjectAccess(fileContent, filename, targetName);
               writeFileSync3(outputPath, output, "utf8");
               loader.succeed(
                 `Saved expand-object file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
@@ -932,7 +928,11 @@ var object_packer_default = createCommand((program2) => {
             }
             const loader = loading5("Packing object properties...").start();
             try {
-              const { code: output, packedCount, removedStatements } = packObjectProperties(fileContent, filename);
+              const {
+                code: output,
+                packedCount,
+                removedStatements
+              } = packObjectProperties(fileContent, filename);
               writeFileSync4(outputPath, output, "utf8");
               loader.succeed(
                 `Saved object-packer file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${packedCount} properties packed, ${removedStatements} statements removed)`
@@ -1311,7 +1311,7 @@ var remove_updater_default = createCommand((program2) => {
   );
 });
 
-// commands/remove-unused/index.ts
+// commands/remove-reassign/index.ts
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 import { basename as basename7, dirname as dirname7, extname as extname7, join as join7 } from "path";
 import { parse as parse8 } from "@babel/parser";
@@ -1322,19 +1322,263 @@ import loading8 from "loading-cli";
 var createDefaultOutputPath7 = (inputPath) => {
   const ext = extname7(inputPath);
   if (!ext) {
-    return `${inputPath}.remove-unused.js`;
+    return `${inputPath}.remove-reassign.js`;
   }
   const base = basename7(inputPath, ext);
-  return join7(dirname7(inputPath), `${base}.remove-unused${ext}`);
+  return join7(dirname7(inputPath), `${base}.remove-reassign${ext}`);
 };
-var removeUnusedVariables = (code, filename) => {
+var isShorthandObjectKey = (path) => {
+  const parent = path.parentPath;
+  if (!parent || !parent.isObjectProperty()) return false;
+  return parent.node.shorthand && parent.get("key") === path;
+};
+var resolveFinalAlias = (binding, getBinding) => {
+  const visited = /* @__PURE__ */ new Set();
+  let currentBinding = binding;
+  let currentName = null;
+  while (currentBinding && !visited.has(currentBinding)) {
+    visited.add(currentBinding);
+    if (!t6.isVariableDeclarator(currentBinding.path.node)) break;
+    const init = currentBinding.path.node.init;
+    if (!init || !t6.isIdentifier(init)) break;
+    const nextBinding = getBinding(init.name);
+    if (!nextBinding || !nextBinding.constant) break;
+    currentBinding = nextBinding;
+    currentName = init.name;
+  }
+  if (!currentBinding || !currentName) {
+    return null;
+  }
+  return { targetBinding: currentBinding, targetName: currentName };
+};
+var getReturnExpression = (functionPath) => {
+  const body = functionPath.node.body;
+  if (!t6.isBlockStatement(body)) {
+    return body;
+  }
+  if (body.body.length !== 1) return null;
+  const statement = body.body[0];
+  if (!t6.isReturnStatement(statement) || !statement.argument) return null;
+  return statement.argument;
+};
+var getWrapperInfo = (functionPath, wrapperBinding) => {
+  const params = functionPath.node.params;
+  if (params.length === 0) return null;
+  const paramNames = [];
+  for (const param of params) {
+    if (!t6.isIdentifier(param)) return null;
+    paramNames.push(param.name);
+  }
+  const expression = getReturnExpression(functionPath);
+  if (!expression) return null;
+  if (t6.isCallExpression(expression)) {
+    if (!t6.isIdentifier(expression.callee)) return null;
+    if (expression.arguments.length !== paramNames.length) return null;
+    for (let i = 0; i < expression.arguments.length; i++) {
+      const arg = expression.arguments[i];
+      if (!t6.isIdentifier(arg)) return null;
+      if (arg.name !== paramNames[i]) return null;
+    }
+    const targetBinding = functionPath.scope.getBinding(expression.callee.name);
+    if (!targetBinding) return null;
+    return {
+      kind: "call",
+      wrapperBinding,
+      targetName: expression.callee.name,
+      targetBinding,
+      paramNames
+    };
+  }
+  if (t6.isMemberExpression(expression) && expression.computed && t6.isIdentifier(expression.object) && t6.isIdentifier(expression.property) && paramNames.length === 1 && expression.property.name === paramNames[0]) {
+    const targetBinding = functionPath.scope.getBinding(expression.object.name);
+    if (!targetBinding) return null;
+    return {
+      kind: "member",
+      wrapperBinding,
+      targetName: expression.object.name,
+      targetBinding
+    };
+  }
+  return null;
+};
+var removeReassign = (code, filename) => {
   const ast = parse8(code, createParseOptions(filename));
-  let changed = false;
+  const aliases = [];
+  const wrappers = [];
   patchDefault(traverse7)(ast, {
+    VariableDeclarator(path) {
+      if (!t6.isIdentifier(path.node.id)) return;
+      if (!path.node.init || !t6.isIdentifier(path.node.init)) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      const targetBinding = path.scope.getBinding(path.node.init.name);
+      if (!targetBinding || !targetBinding.constant) return;
+      const resolved = resolveFinalAlias(
+        binding,
+        (name) => path.scope.getBinding(name)
+      );
+      if (!resolved) return;
+      aliases.push({
+        aliasBinding: binding,
+        targetBinding: resolved.targetBinding,
+        targetName: resolved.targetName
+      });
+    },
+    FunctionDeclaration(path) {
+      if (!path.node.id) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding) return;
+      const wrapper = getWrapperInfo(path, binding);
+      if (wrapper) wrappers.push(wrapper);
+    }
+  });
+  patchDefault(traverse7)(ast, {
+    VariableDeclarator(path) {
+      if (!t6.isIdentifier(path.node.id)) return;
+      const initPath = path.get("init");
+      if (!initPath || !initPath.isFunctionExpression() && !initPath.isArrowFunctionExpression()) {
+        return;
+      }
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      const wrapper = getWrapperInfo(
+        initPath,
+        binding
+      );
+      if (wrapper) wrappers.push(wrapper);
+    }
+  });
+  let aliasReplacedCount = 0;
+  let wrapperReplacedCount = 0;
+  for (const alias of aliases) {
+    for (const referencePath of alias.aliasBinding.referencePaths) {
+      if (isShorthandObjectKey(referencePath)) continue;
+      const targetBinding = referencePath.scope.getBinding(alias.targetName);
+      if (targetBinding !== alias.targetBinding) continue;
+      referencePath.replaceWith(t6.identifier(alias.targetName));
+      aliasReplacedCount += 1;
+    }
+  }
+  const wrapperMap = /* @__PURE__ */ new Map();
+  for (const wrapper of wrappers) {
+    wrapperMap.set(wrapper.wrapperBinding, wrapper);
+  }
+  patchDefault(traverse7)(ast, {
+    CallExpression(path) {
+      if (!t6.isIdentifier(path.node.callee)) return;
+      const calleeBinding = path.scope.getBinding(path.node.callee.name);
+      if (!calleeBinding) return;
+      const wrapper = wrapperMap.get(calleeBinding);
+      if (!wrapper) return;
+      const targetBinding = path.scope.getBinding(wrapper.targetName);
+      if (targetBinding !== wrapper.targetBinding) return;
+      if (wrapper.kind === "call") {
+        if (path.node.arguments.length !== wrapper.paramNames.length) return;
+        for (const arg2 of path.node.arguments) {
+          if (t6.isSpreadElement(arg2)) return;
+        }
+        const nextArgs = path.node.arguments.map(
+          (arg2) => t6.cloneNode(arg2, true)
+        );
+        path.replaceWith(
+          t6.callExpression(t6.identifier(wrapper.targetName), nextArgs)
+        );
+        wrapperReplacedCount += 1;
+        return;
+      }
+      if (path.node.arguments.length !== 1) return;
+      const arg = path.node.arguments[0];
+      if (!t6.isExpression(arg) || t6.isSpreadElement(arg)) return;
+      path.replaceWith(
+        t6.memberExpression(
+          t6.identifier(wrapper.targetName),
+          t6.cloneNode(arg, true),
+          true
+        )
+      );
+      wrapperReplacedCount += 1;
+    }
+  });
+  return {
+    code: patchDefault(generate7)(ast).code,
+    aliasReplacedCount,
+    wrapperReplacedCount
+  };
+};
+var remove_reassign_default = createCommand((program2) => {
+  program2.command("remove-reassign").description("Inline safe alias assignments and wrapper calls").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--o, --output <file>", "Output file path").option("--unlimited", "Unlimited timeout").action(
+    async (fileArgument, options) => {
+      await timeout(
+        async ({ finish }) => {
+          const filename = fileArgument ?? options.file ?? await createPrompt("Enter the file path:");
+          if (!filename) {
+            showError("No file provided");
+            return finish();
+          }
+          try {
+            const fileContent = readFileSync8(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath7(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading8("Removing reassign aliases...").start();
+            try {
+              const {
+                code: output,
+                aliasReplacedCount,
+                wrapperReplacedCount
+              } = removeReassign(fileContent, filename);
+              writeFileSync7(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved remove-reassign file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${aliasReplacedCount} aliases, ${wrapperReplacedCount} calls inlined)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply remove-reassign transform");
+              showError(
+                `Error transforming file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+              );
+              return finish();
+            }
+          } catch (error) {
+            showError(
+              `Error reading file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+            return finish();
+          }
+        },
+        options.unlimited ? null : 120 * 1e3
+      );
+    }
+  );
+});
+
+// commands/remove-unused/index.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename8, dirname as dirname8, extname as extname8, join as join8 } from "path";
+import { parse as parse9 } from "@babel/parser";
+import traverse8 from "@babel/traverse";
+import generate8 from "@babel/generator";
+import * as t7 from "@babel/types";
+import loading9 from "loading-cli";
+var createDefaultOutputPath8 = (inputPath) => {
+  const ext = extname8(inputPath);
+  if (!ext) {
+    return `${inputPath}.remove-unused.js`;
+  }
+  const base = basename8(inputPath, ext);
+  return join8(dirname8(inputPath), `${base}.remove-unused${ext}`);
+};
+var removeUnusedVariables = (code, filename) => {
+  const ast = parse9(code, createParseOptions(filename));
+  let changed = false;
+  patchDefault(traverse8)(ast, {
     Scope(path) {
       for (const binding of Object.values(path.scope.bindings)) {
         if (!binding.referenced && binding.constantViolations.length === 0 && binding.path.key !== "handler" && !binding.path.isFunctionExpression()) {
-          if (t6.isProgram(binding.scope.block) && (binding.kind === "var" || binding.kind === "hoisted")) {
+          if (t7.isProgram(binding.scope.block) && (binding.kind === "var" || binding.kind === "hoisted")) {
             continue;
           }
           const targets = binding.path.parentKey === "params" ? [...binding.referencePaths, ...binding.constantViolations] : [
@@ -1343,11 +1587,11 @@ var removeUnusedVariables = (code, filename) => {
             ...binding.constantViolations
           ];
           for (const targetPath of targets) {
-            if (targetPath.isVariableDeclarator() && (t6.isArrayPattern(targetPath.node.id) && targetPath.node.id.elements.length > 1 || t6.isObjectPattern(targetPath.node.id) && targetPath.node.id.properties.length > 1)) {
+            if (targetPath.isVariableDeclarator() && (t7.isArrayPattern(targetPath.node.id) && targetPath.node.id.elements.length > 1 || t7.isObjectPattern(targetPath.node.id) && targetPath.node.id.properties.length > 1)) {
               continue;
             }
             if (targetPath.key === "consequent" || targetPath.key === "alternate" || targetPath.key === "body") {
-              targetPath.replaceWith(t6.blockStatement([]));
+              targetPath.replaceWith(t7.blockStatement([]));
             } else {
               const parentPath = targetPath.parentPath;
               if (parentPath?.isVariableDeclaration() && parentPath.node.declarations.length === 1) {
@@ -1363,7 +1607,7 @@ var removeUnusedVariables = (code, filename) => {
     }
   });
   return {
-    code: patchDefault(generate7)(ast).code,
+    code: patchDefault(generate8)(ast).code,
     changed
   };
 };
@@ -1378,20 +1622,20 @@ var remove_unused_default = createCommand((program2) => {
             return finish();
           }
           try {
-            const fileContent = readFileSync8(filename, "utf8");
-            const defaultOutputPath = createDefaultOutputPath7(filename);
+            const fileContent = readFileSync9(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath8(filename);
             let outputPath = options.output;
             if (!outputPath) {
               const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
               outputPath = promptPath || defaultOutputPath;
             }
-            const loader = loading8("Removing unused variables...").start();
+            const loader = loading9("Removing unused variables...").start();
             try {
               const { code: output, changed } = removeUnusedVariables(
                 fileContent,
                 filename
               );
-              writeFileSync7(outputPath, output, "utf8");
+              writeFileSync8(outputPath, output, "utf8");
               const diffLines = diff(fileContent, output).length;
               loader.succeed(
                 `Saved remove-unused file to: ${outputPath} (${diffLines} lines changed${changed ? ", removed unused declarations" : ", no changes"})`
@@ -1417,6 +1661,188 @@ var remove_unused_default = createCommand((program2) => {
   );
 });
 
+// commands/fn-inliner/index.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename9, dirname as dirname9, extname as extname9, join as join9 } from "path";
+import { parse as parse10 } from "@babel/parser";
+import traverse9 from "@babel/traverse";
+import generate9 from "@babel/generator";
+import * as t8 from "@babel/types";
+import loading10 from "loading-cli";
+var walk = patchDefault(traverse9);
+var createDefaultOutputPath9 = (inputPath) => {
+  const ext = extname9(inputPath);
+  if (!ext) {
+    return `${inputPath}.fn-inliner.js`;
+  }
+  const base = basename9(inputPath, ext);
+  return join9(dirname9(inputPath), `${base}.fn-inliner${ext}`);
+};
+var isProxyFunctionExpression = (node) => {
+  return t8.isFunction(node) && node.params.every((param) => t8.isIdentifier(param)) && (t8.isBlockStatement(node.body) && node.body.body.length === 1 && t8.isReturnStatement(node.body.body[0]) && (node.body.body[0].argument === void 0 || t8.isExpression(node.body.body[0].argument) && isProxyValue(node.body.body[0].argument)) || t8.isArrowFunctionExpression(node) && t8.isExpression(node.body) && isProxyValue(node.body));
+};
+var isProxyValue = (node) => {
+  if (t8.isFunction(node) || t8.isBlockStatement(node) || t8.isSequenceExpression(node)) {
+    return false;
+  }
+  let isValid = true;
+  walk(node, {
+    "SequenceExpression|BlockStatement|Function|AssignmentExpression"(path) {
+      isValid = false;
+      path.stop();
+    },
+    noScope: true
+  });
+  return isValid;
+};
+var copyExpression = (expression) => {
+  return t8.cloneNode(expression, true);
+};
+var ProxyFunction = class {
+  expression;
+  constructor(expression) {
+    this.expression = expression;
+  }
+  getReplacement(args) {
+    const expression = t8.isExpression(this.expression.body) ? copyExpression(this.expression.body) : this.expression.body.body[0].argument ? copyExpression(this.expression.body.body[0].argument) : t8.identifier("undefined");
+    this.replaceParameters(expression, args);
+    return expression;
+  }
+  replaceParameters(expression, args) {
+    const paramMap = new Map(
+      this.expression.params.map((param, index) => [
+        param.name,
+        args[index] ?? t8.identifier("undefined")
+      ])
+    );
+    const pathsToReplace = [];
+    walk(expression, {
+      enter(path) {
+        if (t8.isIdentifier(path.node) && !(path.parentPath?.isMemberExpression() && path.key === "property") && paramMap.has(path.node.name)) {
+          const replacement = paramMap.get(path.node.name);
+          pathsToReplace.push([path, replacement]);
+        }
+      },
+      noScope: true
+    });
+    for (const [path, replacement] of pathsToReplace) {
+      path.replaceWith(t8.cloneNode(replacement, true));
+    }
+  }
+};
+var ProxyFunctionVariable = class extends ProxyFunction {
+  binding;
+  constructor(binding, expression) {
+    super(expression);
+    this.binding = binding;
+  }
+  getCalls() {
+    return this.binding.referencePaths;
+  }
+  replaceCall(path) {
+    if (!path.parentPath || !path.parentPath.isCallExpression() || path.key !== "callee") {
+      return false;
+    }
+    const argumentNodes = path.parentPath.node.arguments;
+    const args = [];
+    for (const argument of argumentNodes) {
+      if (!t8.isExpression(argument)) {
+        return false;
+      }
+      args.push(t8.cloneNode(argument, true));
+    }
+    const expression = this.getReplacement(args);
+    path.parentPath.replaceWith(expression);
+    return true;
+  }
+};
+var collectProxyFunctions = (ast) => {
+  const proxies = [];
+  walk(ast, {
+    FunctionDeclaration(path) {
+      if (!path.node.id) return;
+      if (!isProxyFunctionExpression(path.node)) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      proxies.push(new ProxyFunctionVariable(binding, path.node));
+    },
+    VariableDeclarator(path) {
+      if (!t8.isIdentifier(path.node.id)) return;
+      const init = path.node.init;
+      if (!init || !isProxyFunctionExpression(init)) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      proxies.push(new ProxyFunctionVariable(binding, init));
+    }
+  });
+  return proxies;
+};
+var inlineProxyFunctions = (code, filename) => {
+  const ast = parse10(code, createParseOptions(filename));
+  const proxies = collectProxyFunctions(ast);
+  let replacedCount = 0;
+  for (const proxy of proxies) {
+    for (const referencePath of proxy.getCalls()) {
+      if (referencePath.removed) continue;
+      if (proxy.replaceCall(referencePath)) {
+        replacedCount += 1;
+      }
+    }
+  }
+  return {
+    code: patchDefault(generate9)(ast).code,
+    replacedCount
+  };
+};
+var fn_inliner_default = createCommand((program2) => {
+  program2.command("fn-inliner").description("Inline proxy function calls into expressions").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--o, --output <file>", "Output file path").option("--unlimited", "Unlimited timeout").action(
+    async (fileArgument, options) => {
+      await timeout(
+        async ({ finish }) => {
+          const filename = fileArgument ?? options.file ?? await createPrompt("Enter the file path:");
+          if (!filename) {
+            showError("No file provided");
+            return finish();
+          }
+          try {
+            const fileContent = readFileSync10(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath9(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading10("Inlining proxy functions...").start();
+            try {
+              const { code: output, replacedCount } = inlineProxyFunctions(
+                fileContent,
+                filename
+              );
+              writeFileSync9(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved fn-inliner file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply fn-inliner transform");
+              showError(
+                `Error transforming file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+              );
+              return finish();
+            }
+          } catch (error) {
+            showError(
+              `Error reading file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+            return finish();
+          }
+        },
+        options.unlimited ? null : 120 * 1e3
+      );
+    }
+  );
+});
+
 // utils/cli/showCredit.ts
 import chalk3 from "chalk";
 var beautify = (strings, ...values) => {
@@ -1441,10 +1867,10 @@ var calmGradienrain = (text) => {
   const endHue = 300;
   const saturation = 0.45;
   const value = 0.8;
-  const ease = (t7) => t7 * t7 * (3 - 2 * t7);
+  const ease = (t9) => t9 * t9 * (3 - 2 * t9);
   return text.split("").map((char, i) => {
-    const t7 = ease(i / Math.max(text.length - 1, 1));
-    const hue = startHue + (endHue - startHue) * t7;
+    const t9 = ease(i / Math.max(text.length - 1, 1));
+    const hue = startHue + (endHue - startHue) * t9;
     const c = value * saturation;
     const h = hue / 60;
     const x = c * (1 - Math.abs(h % 2 - 1));
@@ -1468,10 +1894,10 @@ ${calmGradienrain(`Expose Kit v${VERSION}`)}
 `;
 
 // index.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname8(__filename);
-var pkg = JSON.parse(readFileSync9(join8(__dirname, "package.json"), "utf8"));
+var __dirname = dirname10(__filename);
+var pkg = JSON.parse(readFileSync11(join10(__dirname, "package.json"), "utf8"));
 console.log(showCredit(pkg.version));
 console.log();
 var program = new Command();
@@ -1488,6 +1914,8 @@ var commands = [
   object_packer_default,
   pre_evaluate_default,
   remove_updater_default,
+  remove_reassign_default,
+  fn_inliner_default,
   remove_unused_default
 ];
 for (const command of commands) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expose-kit",
-	"version": "0.7.0",
+	"version": "0.9.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expose-kit",
-	"version": "0.7.0",
+	"version": "0.9.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",