luau-obfuscator 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1097 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ObfuscateDefault: () => ObfuscateDefault,
+  PASS_MAP: () => PASS_MAP,
+  PASS_ORDER: () => PASS_ORDER,
+  obfuscate: () => obfuscate,
+  obfuscateByAst: () => obfuscateByAst
+});
+module.exports = __toCommonJS(index_exports);
+var import_luau_parser3 = require("luau-parser");
+
+// src/config.ts
+var ObfuscateDefault = {
+  Vmify: { active: true },
+  Minify: { active: true },
+  StringsToExpressions: { active: true, min: 5, max: 10 },
+  NumbersToExpressions: { active: true, min: 5, max: 10 },
+  EncryptStrings: { active: true },
+  EncryptNumbers: { active: true },
+  RenameVariables: { active: true, random: () => "_" + globalThis.crypto.randomUUID().replace(/-/g, "") },
+  GlobalMapping: { active: true, tableName: "GLOBAL" },
+  ConstantArray: { active: true },
+  InsertJunk: { active: true, probability: 0.7, maxPerBlock: 5 },
+  WrapInFunction: { active: true }
+};
+function mergeConfig(defaults, partial) {
+  const result = {};
+  for (const key of Object.keys(defaults)) {
+    const def = defaults[key];
+    const part = partial[key];
+    if (!part) {
+      result[key] = def;
+    } else if (part.active === false) {
+      result[key] = { active: false };
+    } else {
+      result[key] = { ...def, ...part, active: true };
+    }
+  }
+  return result;
+}
+
+// src/passes/StripTypes.ts
+function runStripTypes(program) {
+  stripBlock(program.body);
+}
+function stripBlock(block2) {
+  const kept = [];
+  for (const stmt of block2.statements) {
+    if (stmt.type === "TypeAliasStatement" || stmt.type === "ExportTypeAliasStatement") {
+      continue;
+    }
+    stripStatement(stmt);
+    kept.push(stmt);
+  }
+  block2.statements = kept;
+}
+function stripFunctionBody(func) {
+  func.generics = [];
+  for (const param of func.params) delete param.typeAnnotation;
+  delete func.varargTypeAnnotation;
+  delete func.returnType;
+  stripBlock(func.body);
+}
+function stripStatement(stmt) {
+  switch (stmt.type) {
+    case "LocalStatement":
+      for (const name of stmt.names) delete name.typeAnnotation;
+      for (let i = 0; i < stmt.init.length; i++) stmt.init[i] = stripExpr(stmt.init[i]);
+      return;
+    case "LocalFunctionStatement":
+      stripFunctionBody(stmt.func);
+      return;
+    case "FunctionDeclarationStatement":
+      stripFunctionBody(stmt.func);
+      return;
+    case "AssignmentStatement":
+      for (let i = 0; i < stmt.targets.length; i++) stmt.targets[i] = stripExpr(stmt.targets[i]);
+      for (let i = 0; i < stmt.values.length; i++) stmt.values[i] = stripExpr(stmt.values[i]);
+      return;
+    case "CompoundAssignmentStatement":
+      stmt.target = stripExpr(stmt.target);
+      stmt.value = stripExpr(stmt.value);
+      return;
+    case "CallStatement":
+      stmt.expression = stripExpr(stmt.expression);
+      return;
+    case "DoStatement":
+      stripBlock(stmt.body);
+      return;
+    case "WhileStatement":
+      stmt.condition = stripExpr(stmt.condition);
+      stripBlock(stmt.body);
+      return;
+    case "RepeatStatement":
+      stripBlock(stmt.body);
+      stmt.condition = stripExpr(stmt.condition);
+      return;
+    case "IfStatement":
+      for (const clause of stmt.clauses) {
+        clause.condition = stripExpr(clause.condition);
+        stripBlock(clause.body);
+      }
+      if (stmt.alternate) stripBlock(stmt.alternate);
+      return;
+    case "NumericForStatement":
+      delete stmt.variable.typeAnnotation;
+      stmt.start = stripExpr(stmt.start);
+      stmt.end = stripExpr(stmt.end);
+      if (stmt.step) stmt.step = stripExpr(stmt.step);
+      stripBlock(stmt.body);
+      return;
+    case "GenericForStatement":
+      for (const v of stmt.variables) delete v.typeAnnotation;
+      for (let i = 0; i < stmt.iterators.length; i++) stmt.iterators[i] = stripExpr(stmt.iterators[i]);
+      stripBlock(stmt.body);
+      return;
+    case "ReturnStatement":
+      for (let i = 0; i < stmt.arguments.length; i++) stmt.arguments[i] = stripExpr(stmt.arguments[i]);
+      return;
+    case "BreakStatement":
+    case "ContinueStatement":
+      return;
+  }
+}
+function stripExpr(expr) {
+  switch (expr.type) {
+    case "InterpolatedStringExpression":
+      for (const part of expr.parts) {
+        if (part.kind === "expression") part.expression = stripExpr(part.expression);
+      }
+      return expr;
+    case "FunctionExpression":
+      stripFunctionBody(expr.func);
+      return expr;
+    case "TableExpression":
+      for (const field of expr.fields) {
+        if (field.type === "TableFieldPositional") {
+          field.value = stripExpr(field.value);
+        } else if (field.type === "TableFieldNamed") {
+          field.value = stripExpr(field.value);
+        } else if (field.type === "TableFieldComputed") {
+          field.key = stripExpr(field.key);
+          field.value = stripExpr(field.value);
+        }
+      }
+      return expr;
+    case "BinaryExpression":
+      expr.left = stripExpr(expr.left);
+      expr.right = stripExpr(expr.right);
+      return expr;
+    case "UnaryExpression":
+      expr.argument = stripExpr(expr.argument);
+      return expr;
+    case "MemberExpression":
+      expr.object = stripExpr(expr.object);
+      return expr;
+    case "IndexExpression":
+      expr.object = stripExpr(expr.object);
+      expr.index = stripExpr(expr.index);
+      return expr;
+    case "CallExpression":
+      expr.callee = stripExpr(expr.callee);
+      for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i]);
+      return expr;
+    case "MethodCallExpression":
+      expr.object = stripExpr(expr.object);
+      for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i]);
+      return expr;
+    case "ParenthesizedExpression":
+      expr.expression = stripExpr(expr.expression);
+      return expr;
+    case "TypeAssertionExpression":
+      return stripExpr(expr.expression);
+    case "IfElseExpression":
+      for (const clause of expr.clauses) {
+        clause.condition = stripExpr(clause.condition);
+        clause.body = stripExpr(clause.body);
+      }
+      expr.alternate = stripExpr(expr.alternate);
+      return expr;
+    default:
+      return expr;
+  }
+}
+
+// src/passes/walk.ts
+function visitArray(arr, visitor) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = mapExpression(arr[i], visitor);
+  }
+}
+function mapExpression(expr, visitor) {
+  switch (expr.type) {
+    case "InterpolatedStringExpression":
+      for (const part of expr.parts) {
+        if (part.kind === "expression") {
+          part.expression = mapExpression(part.expression, visitor);
+        }
+      }
+      break;
+    case "FunctionExpression":
+      walkFunctionBody(expr.func, visitor);
+      break;
+    case "TableExpression":
+      for (const field of expr.fields) {
+        if (field.type === "TableFieldPositional") {
+          field.value = mapExpression(field.value, visitor);
+        } else if (field.type === "TableFieldNamed") {
+          field.value = mapExpression(field.value, visitor);
+        } else if (field.type === "TableFieldComputed") {
+          field.key = mapExpression(field.key, visitor);
+          field.value = mapExpression(field.value, visitor);
+        }
+      }
+      break;
+    case "BinaryExpression":
+      expr.left = mapExpression(expr.left, visitor);
+      expr.right = mapExpression(expr.right, visitor);
+      break;
+    case "UnaryExpression":
+      expr.argument = mapExpression(expr.argument, visitor);
+      break;
+    case "MemberExpression":
+      expr.object = mapExpression(expr.object, visitor);
+      break;
+    case "IndexExpression":
+      expr.object = mapExpression(expr.object, visitor);
+      expr.index = mapExpression(expr.index, visitor);
+      break;
+    case "CallExpression":
+      expr.callee = mapExpression(expr.callee, visitor);
+      visitArray(expr.arguments, visitor);
+      break;
+    case "MethodCallExpression":
+      expr.object = mapExpression(expr.object, visitor);
+      visitArray(expr.arguments, visitor);
+      break;
+    case "ParenthesizedExpression":
+      expr.expression = mapExpression(expr.expression, visitor);
+      break;
+    case "TypeAssertionExpression":
+      expr.expression = mapExpression(expr.expression, visitor);
+      break;
+    case "IfElseExpression":
+      for (const clause of expr.clauses) {
+        clause.condition = mapExpression(clause.condition, visitor);
+        clause.body = mapExpression(clause.body, visitor);
+      }
+      expr.alternate = mapExpression(expr.alternate, visitor);
+      break;
+  }
+  return visitor(expr) ?? expr;
+}
+function walkFunctionBody(func, visitor) {
+  walkBlock(func.body, visitor);
+}
+function walkBlock(block2, visitor) {
+  for (const stmt of block2.statements) walkStatement(stmt, visitor);
+}
+function walkStatement(stmt, visitor) {
+  switch (stmt.type) {
+    case "LocalStatement":
+      visitArray(stmt.init, visitor);
+      return;
+    case "LocalFunctionStatement":
+      walkFunctionBody(stmt.func, visitor);
+      return;
+    case "FunctionDeclarationStatement":
+      walkFunctionBody(stmt.func, visitor);
+      return;
+    case "AssignmentStatement":
+      visitArray(stmt.targets, visitor);
+      visitArray(stmt.values, visitor);
+      return;
+    case "CompoundAssignmentStatement":
+      stmt.target = mapExpression(stmt.target, visitor);
+      stmt.value = mapExpression(stmt.value, visitor);
+      return;
+    case "CallStatement":
+      stmt.expression = mapExpression(stmt.expression, visitor);
+      return;
+    case "DoStatement":
+      walkBlock(stmt.body, visitor);
+      return;
+    case "WhileStatement":
+      stmt.condition = mapExpression(stmt.condition, visitor);
+      walkBlock(stmt.body, visitor);
+      return;
+    case "RepeatStatement":
+      walkBlock(stmt.body, visitor);
+      stmt.condition = mapExpression(stmt.condition, visitor);
+      return;
+    case "IfStatement":
+      for (const clause of stmt.clauses) {
+        clause.condition = mapExpression(clause.condition, visitor);
+        walkBlock(clause.body, visitor);
+      }
+      if (stmt.alternate) walkBlock(stmt.alternate, visitor);
+      return;
+    case "NumericForStatement":
+      stmt.start = mapExpression(stmt.start, visitor);
+      stmt.end = mapExpression(stmt.end, visitor);
+      if (stmt.step) stmt.step = mapExpression(stmt.step, visitor);
+      walkBlock(stmt.body, visitor);
+      return;
+    case "GenericForStatement":
+      visitArray(stmt.iterators, visitor);
+      walkBlock(stmt.body, visitor);
+      return;
+    case "ReturnStatement":
+      visitArray(stmt.arguments, visitor);
+      return;
+    case "BreakStatement":
+    case "ContinueStatement":
+    case "TypeAliasStatement":
+    case "ExportTypeAliasStatement":
+      return;
+  }
+}
+function transformExpressions(program, visitor) {
+  walkBlock(program.body, visitor);
+}
+
+// src/passes/nodeFactory.ts
+var POS = { start: 0, end: 0 };
+function identifier(name) {
+  return { type: "Identifier", name, line: POS, column: POS };
+}
+function typedIdentifier(name) {
+  return { type: "TypedIdentifier", name, line: POS, column: POS };
+}
+function stringLiteral(value) {
+  return { type: "StringLiteral", value, raw: JSON.stringify(value), line: POS, column: POS };
+}
+function numberLiteral(value) {
+  return { type: "NumberLiteral", value, raw: String(value), line: POS, column: POS };
+}
+function binary(operator, left, right) {
+  return { type: "BinaryExpression", operator, left, right, line: POS, column: POS };
+}
+function unary(operator, argument) {
+  return { type: "UnaryExpression", operator, argument, line: POS, column: POS };
+}
+function call(callee, args) {
+  return { type: "CallExpression", callee, arguments: args, line: POS, column: POS };
+}
+function member(object, property) {
+  return { type: "MemberExpression", object, property: identifier(property), line: POS, column: POS };
+}
+function index(object, key) {
+  return { type: "IndexExpression", object, index: key, line: POS, column: POS };
+}
+function paren(expression) {
+  return { type: "ParenthesizedExpression", expression, line: POS, column: POS };
+}
+function table(fields) {
+  return { type: "TableExpression", fields, line: POS, column: POS };
+}
+function computedField(key, value) {
+  return { type: "TableFieldComputed", key, value };
+}
+function positionalField(value) {
+  return { type: "TableFieldPositional", value };
+}
+function localStatement(name, init) {
+  return {
+    type: "LocalStatement",
+    names: [typedIdentifier(name)],
+    init: [init],
+    line: POS,
+    column: POS
+  };
+}
+function block(statements) {
+  return { type: "Block", statements, line: POS, column: POS };
+}
+function assignmentStatement(targets, values) {
+  return { type: "AssignmentStatement", targets, values, line: POS, column: POS };
+}
+function returnStatement(args) {
+  return { type: "ReturnStatement", arguments: args, line: POS, column: POS };
+}
+function numericForStatement(variableName, start, end, body) {
+  return {
+    type: "NumericForStatement",
+    variable: typedIdentifier(variableName),
+    start,
+    end,
+    body,
+    line: POS,
+    column: POS
+  };
+}
+function functionParam(name) {
+  return { type: "FunctionParameter", name, line: POS, column: POS };
+}
+function functionBody(params, body, hasVarargs = false) {
+  return {
+    type: "FunctionBody",
+    generics: [],
+    params,
+    hasVarargs,
+    body,
+    line: POS,
+    column: POS
+  };
+}
+function functionExpression(func) {
+  return { type: "FunctionExpression", func, line: POS, column: POS };
+}
+function localFunctionStatement(name, func) {
+  return {
+    type: "LocalFunctionStatement",
+    name: identifier(name),
+    func,
+    line: POS,
+    column: POS
+  };
+}
+function doStatement(body) {
+  return { type: "DoStatement", body, line: POS, column: POS };
+}
+function ifClause(condition, body) {
+  return { type: "IfClause", condition, body, line: POS, column: POS };
+}
+function ifStatement(clauses, alternate) {
+  return { type: "IfStatement", clauses, alternate, line: POS, column: POS };
+}
+function vararg() {
+  return { type: "VarargExpression", line: POS, column: POS };
+}
+
+// src/passes/StringsToExpressions.ts
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function toUtf8Bytes(value) {
+  return Array.from(new TextEncoder().encode(value));
+}
+function splitByteChunks(bytes, min, max) {
+  const chunks = [];
+  let i = 0;
+  while (i < bytes.length) {
+    const size = Math.max(1, randomInt(min, max));
+    chunks.push(bytes.slice(i, i + size));
+    i += size;
+  }
+  return chunks.length > 0 ? chunks : [bytes];
+}
+function stringCharCall(bytes) {
+  return call(member(identifier("string"), "char"), bytes.map(numberLiteral));
+}
+function buildConcatChain(chunks) {
+  let expr = stringCharCall(chunks[0]);
+  for (let i = 1; i < chunks.length; i++) {
+    expr = binary("..", expr, stringCharCall(chunks[i]));
+  }
+  return expr;
+}
+function runStringsToExpressions(program, options) {
+  transformExpressions(program, (expr) => {
+    if (expr.type !== "StringLiteral") return;
+    if (expr.value.length === 0) return;
+    const bytes = toUtf8Bytes(expr.value);
+    const chunks = splitByteChunks(bytes, options.min, options.max);
+    return buildConcatChain(chunks);
+  });
+}
+
+// src/passes/NumbersToExpressions.ts
+var MAX_DEPTH = 1;
+var NEST_PROBABILITY = 0.35;
+function randomInt2(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randSign() {
+  return Math.random() < 0.5 ? 1 : -1;
+}
+function pickStrategy(value, min, max) {
+  const candidates = ["add", "sub"];
+  if (value !== 0) {
+    for (let a = min; a <= max; a++) {
+      if (a !== 0 && value % a === 0) {
+        candidates.push("mul");
+        break;
+      }
+    }
+  }
+  return candidates[randomInt2(0, candidates.length - 1)];
+}
+function operand(n, min, max, depth) {
+  if (depth < MAX_DEPTH && Math.random() < NEST_PROBABILITY) {
+    return buildNumberExpr(n, min, max, depth + 1);
+  }
+  return numberLiteral(n);
+}
+function buildNumberExpr(value, min, max, depth = 0) {
+  const strategy = pickStrategy(value, min, max);
+  let inner;
+  switch (strategy) {
+    case "add": {
+      const a = randomInt2(min, max) * randSign();
+      const b = value - a;
+      inner = binary("+", operand(a, min, max, depth), operand(b, min, max, depth));
+      break;
+    }
+    case "sub": {
+      const a = randomInt2(min, max) * randSign();
+      const b = a - value;
+      inner = binary("-", operand(a, min, max, depth), operand(b, min, max, depth));
+      break;
+    }
+    case "mul": {
+      let a = 1;
+      for (let cand = min; cand <= max; cand++) {
+        if (cand !== 0 && value % cand === 0) {
+          a = cand;
+          break;
+        }
+      }
+      const b = value / a;
+      inner = binary("*", operand(a, min, max, depth), operand(b, min, max, depth));
+      break;
+    }
+  }
+  return paren(inner);
+}
+function runNumbersToExpressions(program, options) {
+  transformExpressions(program, (expr) => {
+    if (expr.type !== "NumberLiteral") return;
+    return buildNumberExpr(expr.value, options.min, options.max);
+  });
+}
+
+// src/passes/RenameVariables.ts
+var import_luau_parser = require("luau-parser");
+var counter = 0;
+function defaultRandomName() {
+  counter += 1;
+  return `_l${counter.toString(36)}`;
+}
+function runRenameVariables(program, options) {
+  const analysis = (0, import_luau_parser.analyzeScopes)(program);
+  const makeName = options.random ?? defaultRandomName;
+  for (const binding of analysis.bindings.values()) {
+    if ((0, import_luau_parser.isGlobal)(binding)) continue;
+    if (binding.kind === "self") continue;
+    const newName = makeName();
+    binding.name = newName;
+    if (binding.declarationNode) {
+      binding.declarationNode.name = newName;
+    }
+    for (const ref of binding.references) {
+      ref.name = newName;
+    }
+  }
+}
+
+// src/passes/GlobalMapping.ts
+var import_luau_parser2 = require("luau-parser");
+function randomInt3(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomKey() {
+  if (Math.random() < 0.5) return randomInt3(1, 50);
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const len = randomInt3(2, 4);
+  let s = "";
+  for (let i = 0; i < len; i++) s += chars[randomInt3(0, chars.length - 1)];
+  return s;
+}
+function randomPath() {
+  const depth = randomInt3(2, 4);
+  const path = [];
+  for (let i = 0; i < depth; i++) path.push(randomKey());
+  return path;
+}
+function isLeaf(v) {
+  return !(v instanceof Map);
+}
+function insertPath(root, path, globalName) {
+  let node = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    let next = node.get(key);
+    if (next === void 0) {
+      next = /* @__PURE__ */ new Map();
+      node.set(key, next);
+    } else if (isLeaf(next)) {
+      return false;
+    }
+    node = next;
+  }
+  const lastKey = path[path.length - 1];
+  if (node.has(lastKey)) return false;
+  node.set(lastKey, { leaf: globalName });
+  return true;
+}
+function assignPaths(globalNames) {
+  const root = /* @__PURE__ */ new Map();
+  const paths = /* @__PURE__ */ new Map();
+  for (const name of globalNames) {
+    let path = [];
+    let attempts = 0;
+    let ok = false;
+    while (!ok && attempts < 200) {
+      path = randomPath();
+      ok = insertPath(root, path, name);
+      attempts++;
+    }
+    paths.set(name, path);
+  }
+  return { root, paths };
+}
+function keyExpression(key) {
+  return typeof key === "number" ? numberLiteral(key) : stringLiteral(key);
+}
+function buildTreeTableExpr(node) {
+  const fields = [...node.entries()].map(
+    ([key, value]) => computedField(
+      keyExpression(key),
+      isLeaf(value) ? identifier(value.leaf) : buildTreeTableExpr(value)
+    )
+  );
+  return table(fields);
+}
+function buildIndexChain(tableName, path) {
+  let expr = identifier(tableName);
+  for (const key of path) {
+    expr = index(expr, keyExpression(key));
+  }
+  return expr;
+}
+function morphIntoIndexChain(node, tableName, path) {
+  const built = buildIndexChain(tableName, path);
+  const target = node;
+  for (const k of Object.keys(target)) delete target[k];
+  Object.assign(target, built);
+}
+function collectUnsafeFunctionDeclGlobals(program, analysis) {
+  const unsafe = /* @__PURE__ */ new Set();
+  function visitBlock(block2) {
+    for (const stmt of block2.statements) visitStatement(stmt);
+  }
+  function visitStatement(stmt) {
+    switch (stmt.type) {
+      case "FunctionDeclarationStatement": {
+        const binding = (0, import_luau_parser2.getBinding)(analysis, stmt.target.base);
+        if (binding && (0, import_luau_parser2.isGlobal)(binding)) unsafe.add(binding.name);
+        visitBlock(stmt.func.body);
+        return;
+      }
+      case "LocalFunctionStatement":
+        visitBlock(stmt.func.body);
+        return;
+      case "DoStatement":
+        visitBlock(stmt.body);
+        return;
+      case "WhileStatement":
+        visitBlock(stmt.body);
+        return;
+      case "RepeatStatement":
+        visitBlock(stmt.body);
+        return;
+      case "IfStatement":
+        for (const clause of stmt.clauses) visitBlock(clause.body);
+        if (stmt.alternate) visitBlock(stmt.alternate);
+        return;
+      case "NumericForStatement":
+        visitBlock(stmt.body);
+        return;
+      case "GenericForStatement":
+        visitBlock(stmt.body);
+        return;
+      default:
+        return;
+    }
+  }
+  visitBlock(program.body);
+  return unsafe;
+}
+function runGlobalMapping(program, options) {
+  const analysis = (0, import_luau_parser2.analyzeScopes)(program);
+  const unsafe = collectUnsafeFunctionDeclGlobals(program, analysis);
+  const globalBindings = [...analysis.bindings.values()].filter(
+    (b) => (0, import_luau_parser2.isGlobal)(b) && b.references.length > 0 && !unsafe.has(b.name)
+  );
+  if (globalBindings.length === 0) return;
+  const { root, paths } = assignPaths(globalBindings.map((b) => b.name));
+  for (const binding of globalBindings) {
+    const path = paths.get(binding.name);
+    for (const ref of binding.references) {
+      morphIntoIndexChain(ref, options.tableName, path);
+    }
+  }
+  program.body.statements.unshift(
+    localStatement(options.tableName, buildTreeTableExpr(root))
+  );
+}
+
+// src/passes/ConstantArray.ts
+function keyOf(kind, value) {
+  return kind === "string" ? `s:${value}` : `n:${value}`;
+}
+function shuffleIndices(length) {
+  const order = Array.from({ length }, (_, i) => i);
+  for (let i = order.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [order[i], order[j]] = [order[j], order[i]];
+  }
+  return order;
+}
+function defaultArrayName() {
+  return "_CA" + Math.random().toString(36).slice(2, 8);
+}
+function runConstantArray(program, options) {
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  transformExpressions(program, (expr) => {
+    if (expr.type === "StringLiteral") {
+      const k = keyOf("string", expr.value);
+      if (!seen.has(k)) {
+        seen.add(k);
+        order.push({ kind: "string", value: expr.value });
+      }
+    } else if (expr.type === "NumberLiteral") {
+      const k = keyOf("number", expr.value);
+      if (!seen.has(k)) {
+        seen.add(k);
+        order.push({ kind: "number", value: expr.value });
+      }
+    }
+    return void 0;
+  });
+  if (order.length === 0) return;
+  const shuffledOrder = shuffleIndices(order.length);
+  const indexOf = /* @__PURE__ */ new Map();
+  shuffledOrder.forEach((originalIndex, slot) => {
+    const entry = order[originalIndex];
+    indexOf.set(keyOf(entry.kind, entry.value), slot + 1);
+  });
+  const arrayName = options.arrayName ?? defaultArrayName();
+  transformExpressions(program, (expr) => {
+    if (expr.type === "StringLiteral") {
+      const idx = indexOf.get(keyOf("string", expr.value));
+      return index(identifier(arrayName), numberLiteral(idx));
+    }
+    if (expr.type === "NumberLiteral") {
+      const idx = indexOf.get(keyOf("number", expr.value));
+      return index(identifier(arrayName), numberLiteral(idx));
+    }
+    return void 0;
+  });
+  const fields = shuffledOrder.map((originalIndex) => {
+    const entry = order[originalIndex];
+    const value = entry.kind === "string" ? stringLiteral(entry.value) : numberLiteral(entry.value);
+    return { type: "TableFieldPositional", value };
+  });
+  program.body.statements.unshift(localStatement(arrayName, table(fields)));
+}
+
+// src/passes/EncryptStrings.ts
+function randomInt4(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomName() {
+  return "_" + globalThis.crypto.randomUUID().replace(/-/g, "");
+}
+function toUtf8Bytes2(value) {
+  return Array.from(new TextEncoder().encode(value));
+}
+function buildDecoderStatement(name) {
+  const dataParam = randomName();
+  const keyParam = randomName();
+  const outVar = randomName();
+  const iVar = randomName();
+  const body = block([
+    localStatement(outVar, table([])),
+    numericForStatement(
+      iVar,
+      numberLiteral(1),
+      unary("#", identifier(dataParam)),
+      block([
+        assignmentStatement(
+          [index(identifier(outVar), identifier(iVar))],
+          [call(member(identifier("string"), "char"), [
+            call(member(identifier("bit32"), "bxor"), [
+              index(identifier(dataParam), identifier(iVar)),
+              identifier(keyParam)
+            ])
+          ])]
+        )
+      ])
+    ),
+    returnStatement([call(member(identifier("table"), "concat"), [identifier(outVar)])])
+  ]);
+  return localFunctionStatement(name, functionBody([functionParam(dataParam), functionParam(keyParam)], body));
+}
+function runEncryptStrings(program, _options) {
+  const decoderName = randomName();
+  let used = false;
+  transformExpressions(program, (expr) => {
+    if (expr.type !== "StringLiteral") return;
+    if (expr.value.length === 0) return;
+    used = true;
+    const key = randomInt4(1, 255);
+    const bytes = toUtf8Bytes2(expr.value).map((b) => b ^ key);
+    const dataTable = table(bytes.map((b) => positionalField(numberLiteral(b))));
+    return call(identifier(decoderName), [dataTable, numberLiteral(key)]);
+  });
+  if (!used) return;
+  program.body.statements.unshift(buildDecoderStatement(decoderName));
+}
+
+// src/passes/EncryptNumbers.ts
+var UINT32_MAX = 4294967295;
+function randomInt5(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomName2() {
+  return "_" + globalThis.crypto.randomUUID().replace(/-/g, "");
+}
+function isEncryptable(value) {
+  return Number.isInteger(value) && value >= 0 && value <= UINT32_MAX;
+}
+function xor32(a, b) {
+  return (a ^ b) >>> 0;
+}
+function buildDecoderStatement2(name) {
+  const nParam = randomName2();
+  const keyParam = randomName2();
+  const body = block([
+    returnStatement([call(member(identifier("bit32"), "bxor"), [identifier(nParam), identifier(keyParam)])])
+  ]);
+  return localFunctionStatement(name, functionBody([functionParam(nParam), functionParam(keyParam)], body));
+}
+function runEncryptNumbers(program, _options) {
+  const decoderName = randomName2();
+  let used = false;
+  transformExpressions(program, (expr) => {
+    if (expr.type !== "NumberLiteral") return;
+    if (!isEncryptable(expr.value)) return;
+    used = true;
+    const key = randomInt5(1, 16777215);
+    const encoded = xor32(expr.value, key);
+    return call(identifier(decoderName), [numberLiteral(encoded), numberLiteral(key)]);
+  });
+  if (!used) return;
+  program.body.statements.unshift(buildDecoderStatement2(decoderName));
+}
+
+// src/passes/InsertJunk.ts
+function randomInt6(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomName3() {
+  return "_" + globalThis.crypto.randomUUID().replace(/-/g, "");
+}
+function junkNumberExpr() {
+  const op = Math.random() < 0.5 ? "+" : "*";
+  return binary(op, numberLiteral(randomInt6(1, 999)), numberLiteral(randomInt6(1, 999)));
+}
+function buildJunkStatement() {
+  const variants = [
+    () => localStatement(randomName3(), junkNumberExpr()),
+    () => doStatement(block([localStatement(randomName3(), junkNumberExpr())])),
+    () => ifStatement([
+      ifClause(
+        binary("==", numberLiteral(randomInt6(1, 999)), numberLiteral(randomInt6(1, 999))),
+        block([localStatement(randomName3(), junkNumberExpr())])
+      )
+    ])
+  ];
+  return variants[randomInt6(0, variants.length - 1)]();
+}
+function runInsertJunk(program, options) {
+  function processExpr(expr) {
+    switch (expr.type) {
+      case "InterpolatedStringExpression":
+        for (const part of expr.parts) {
+          if (part.kind === "expression") processExpr(part.expression);
+        }
+        return;
+      case "FunctionExpression":
+        processBlock(expr.func.body);
+        return;
+      case "TableExpression":
+        for (const field of expr.fields) {
+          if (field.type === "TableFieldPositional") processExpr(field.value);
+          else if (field.type === "TableFieldNamed") processExpr(field.value);
+          else {
+            processExpr(field.key);
+            processExpr(field.value);
+          }
+        }
+        return;
+      case "BinaryExpression":
+        processExpr(expr.left);
+        processExpr(expr.right);
+        return;
+      case "UnaryExpression":
+        processExpr(expr.argument);
+        return;
+      case "MemberExpression":
+        processExpr(expr.object);
+        return;
+      case "IndexExpression":
+        processExpr(expr.object);
+        processExpr(expr.index);
+        return;
+      case "CallExpression":
+        processExpr(expr.callee);
+        expr.arguments.forEach(processExpr);
+        return;
+      case "MethodCallExpression":
+        processExpr(expr.object);
+        expr.arguments.forEach(processExpr);
+        return;
+      case "ParenthesizedExpression":
+        processExpr(expr.expression);
+        return;
+      case "TypeAssertionExpression":
+        processExpr(expr.expression);
+        return;
+      case "IfElseExpression":
+        for (const clause of expr.clauses) {
+          processExpr(clause.condition);
+          processExpr(clause.body);
+        }
+        processExpr(expr.alternate);
+        return;
+      default:
+        return;
+    }
+  }
+  function processStatement(stmt) {
+    switch (stmt.type) {
+      case "LocalStatement":
+        stmt.init.forEach(processExpr);
+        return;
+      case "LocalFunctionStatement":
+        processBlock(stmt.func.body);
+        return;
+      case "FunctionDeclarationStatement":
+        processBlock(stmt.func.body);
+        return;
+      case "AssignmentStatement":
+        stmt.targets.forEach(processExpr);
+        stmt.values.forEach(processExpr);
+        return;
+      case "CompoundAssignmentStatement":
+        processExpr(stmt.target);
+        processExpr(stmt.value);
+        return;
+      case "CallStatement":
+        processExpr(stmt.expression);
+        return;
+      case "DoStatement":
+        processBlock(stmt.body);
+        return;
+      case "WhileStatement":
+        processExpr(stmt.condition);
+        processBlock(stmt.body);
+        return;
+      case "RepeatStatement":
+        processBlock(stmt.body);
+        processExpr(stmt.condition);
+        return;
+      case "IfStatement":
+        for (const clause of stmt.clauses) {
+          processExpr(clause.condition);
+          processBlock(clause.body);
+        }
+        if (stmt.alternate) processBlock(stmt.alternate);
+        return;
+      case "NumericForStatement":
+        processExpr(stmt.start);
+        processExpr(stmt.end);
+        if (stmt.step) processExpr(stmt.step);
+        processBlock(stmt.body);
+        return;
+      case "GenericForStatement":
+        stmt.iterators.forEach(processExpr);
+        processBlock(stmt.body);
+        return;
+      case "ReturnStatement":
+        stmt.arguments.forEach(processExpr);
+        return;
+      default:
+        return;
+    }
+  }
+  function processBlock(blk) {
+    for (const stmt of blk.statements) processStatement(stmt);
+    const result = [];
+    let inserted = 0;
+    for (const stmt of blk.statements) {
+      if (inserted < options.maxPerBlock && Math.random() < options.probability) {
+        result.push(buildJunkStatement());
+        inserted++;
+      }
+      result.push(stmt);
+    }
+    blk.statements = result;
+  }
+  processBlock(program.body);
+}
+
+// src/passes/WrapInFunction.ts
+function runWrapInFunction(program, _options) {
+  const innerBody = program.body;
+  const wrapper = functionExpression(functionBody([], innerBody, true));
+  const iife = call(paren(wrapper), [vararg()]);
+  program.body = block([returnStatement([iife])]);
+}
+
+// src/pipeline.ts
+var PASS_ORDER = [
+  "GlobalMapping",
+  "StringsToExpressions",
+  "NumbersToExpressions",
+  "RenameVariables",
+  "ConstantArray",
+  "EncryptStrings",
+  "EncryptNumbers",
+  "InsertJunk",
+  "Vmify",
+  "WrapInFunction",
+  "Minify"
+];
+var PASS_MAP = {
+  GlobalMapping: runGlobalMapping,
+  StringsToExpressions: runStringsToExpressions,
+  NumbersToExpressions: runNumbersToExpressions,
+  RenameVariables: runRenameVariables,
+  ConstantArray: runConstantArray,
+  EncryptStrings: runEncryptStrings,
+  EncryptNumbers: runEncryptNumbers,
+  InsertJunk: runInsertJunk,
+  WrapInFunction: runWrapInFunction
+};
+function runPipeline(program, config) {
+  runStripTypes(program);
+  for (const key of PASS_ORDER) {
+    const feature = config[key];
+    if (!feature.active) continue;
+    const pass = PASS_MAP[key];
+    if (!pass) continue;
+    const { active, ...options } = feature;
+    pass(program, options);
+  }
+}
+
+// src/passes/Minify.ts
+function minifyPrinted(code) {
+  return code.replace(/\r\n|\r|\n/g, " ").replace(/[ \t]+/g, " ").trim();
+}
+
+// src/index.ts
+function obfuscateByAst(program, PConfig) {
+  const config = mergeConfig(ObfuscateDefault, PConfig ?? {});
+  runPipeline(program, config);
+  const printed = import_luau_parser3.luauparser.print(program);
+  return config.Minify.active ? minifyPrinted(printed) : printed;
+}
+function obfuscate(source, PConfig) {
+  const program = import_luau_parser3.luauparser.parse(source);
+  return obfuscateByAst(program, PConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObfuscateDefault,
+  PASS_MAP,
+  PASS_ORDER,
+  obfuscate,
+  obfuscateByAst
+});