luau-obfuscator 1.0.1 → 1.0.3

package/src/passes/vmify/runtime.ts

@@ -30,7 +30,7 @@ local ${N.handlers} = {}
 
 local function ${N.dispatch}(${N.frame}, pc)
     local instr = ${N.frame}.${N.code}[pc]
-    return ${N.handlers}[instr.${N.op}](${N.frame}, pc, instr)
+    return ${N.handlers}[instr[1]](${N.frame}, pc, instr)
 end
 
 local function ${N.rk}(${N.frame}, x)
@@ -43,156 +43,156 @@ end
 
 -- MOVE
 ${N.handlers}[${op(Opcode.MOVE)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.frame}.${N.R}[instr.${N.b}]
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- LOADK
 ${N.handlers}[${op(Opcode.LOADK)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.frame}.${N.K}[instr.${N.b} + 1]
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.K}[instr[3] + 1]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- LOADBOOL
 ${N.handlers}[${op(Opcode.LOADBOOL)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = (instr.${N.b} ~= 0)
+    ${N.frame}.${N.R}[instr[2]] = (instr[3] ~= 0)
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- LOADNIL
 ${N.handlers}[${op(Opcode.LOADNIL)}] = function(${N.frame}, pc, instr)
-    for i = instr.${N.a}, instr.${N.b} do ${N.frame}.${N.R}[i] = nil end
+    for i = instr[2], instr[3] do ${N.frame}.${N.R}[i] = nil end
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- GETUPVAL
 ${N.handlers}[${op(Opcode.GETUPVAL)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.frame}.${N.upvals}[instr.${N.b} + 1]
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.upvals}[instr[3] + 1]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- SETUPVAL
 ${N.handlers}[${op(Opcode.SETUPVAL)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.upvals}[instr.${N.b} + 1] = ${N.frame}.${N.R}[instr.${N.a}]
+    ${N.frame}.${N.upvals}[instr[3] + 1] = ${N.frame}.${N.R}[instr[2]]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- GETGLOBAL (b는 RK가 아니라 상수풀 순수 인덱스)
 ${N.handlers}[${op(Opcode.GETGLOBAL)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.globals}[${N.frame}.${N.K}[instr.${N.b} + 1]]
+    ${N.frame}.${N.R}[instr[2]] = ${N.globals}[${N.frame}.${N.K}[instr[3] + 1]]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- SETGLOBAL
 ${N.handlers}[${op(Opcode.SETGLOBAL)}] = function(${N.frame}, pc, instr)
-    ${N.globals}[${N.frame}.${N.K}[instr.${N.b} + 1]] = ${N.frame}.${N.R}[instr.${N.a}]
+    ${N.globals}[${N.frame}.${N.K}[instr[3] + 1]] = ${N.frame}.${N.R}[instr[2]]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- GETTABLE
 ${N.handlers}[${op(Opcode.GETTABLE)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.frame}.${N.R}[instr.${N.b}][${N.rk}(${N.frame}, instr.${N.c})]
+    ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]][${N.rk}(${N.frame}, instr[4])]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- SETTABLE
 ${N.handlers}[${op(Opcode.SETTABLE)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}][${N.rk}(${N.frame}, instr.${N.b})] = ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]][${N.rk}(${N.frame}, instr[3])] = ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- NEWTABLE
 ${N.handlers}[${op(Opcode.NEWTABLE)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = {}
+    ${N.frame}.${N.R}[instr[2]] = {}
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- SELF  (R[a] = R[b][key]; R[a+1] = R[b])
 ${N.handlers}[${op(Opcode.SELF)}] = function(${N.frame}, pc, instr)
-    local obj = ${N.frame}.${N.R}[instr.${N.b}]
-    ${N.frame}.${N.R}[instr.${N.a}] = obj[${N.rk}(${N.frame}, instr.${N.c})]
-    ${N.frame}.${N.R}[instr.${N.a} + 1] = obj
+    local obj = ${N.frame}.${N.R}[instr[3]]
+    ${N.frame}.${N.R}[instr[2]] = obj[${N.rk}(${N.frame}, instr[4])]
+    ${N.frame}.${N.R}[instr[2] + 1] = obj
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- ADD SUB MUL DIV MOD POW
 ${N.handlers}[${op(Opcode.ADD)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) + ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) + ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 ${N.handlers}[${op(Opcode.SUB)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) - ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) - ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 ${N.handlers}[${op(Opcode.MUL)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) * ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) * ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 ${N.handlers}[${op(Opcode.DIV)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) / ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) / ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 ${N.handlers}[${op(Opcode.MOD)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) % ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) % ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 ${N.handlers}[${op(Opcode.POW)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) ^ ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) ^ ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- IDIV (Luau 바닥 나눗셈)
 ${N.handlers}[${op(Opcode.IDIV)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) // ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) // ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- CONCAT
 ${N.handlers}[${op(Opcode.CONCAT)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) .. ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) .. ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- UNM
 ${N.handlers}[${op(Opcode.UNM)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = -${N.frame}.${N.R}[instr.${N.b}]
+    ${N.frame}.${N.R}[instr[2]] = -${N.frame}.${N.R}[instr[3]]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- NOT
 ${N.handlers}[${op(Opcode.NOT)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = not ${N.frame}.${N.R}[instr.${N.b}]
+    ${N.frame}.${N.R}[instr[2]] = not ${N.frame}.${N.R}[instr[3]]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- LEN
 ${N.handlers}[${op(Opcode.LEN)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = #${N.frame}.${N.R}[instr.${N.b}]
+    ${N.frame}.${N.R}[instr[2]] = #${N.frame}.${N.R}[instr[3]]
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- JMP (pc += a)
 ${N.handlers}[${op(Opcode.JMP)}] = function(${N.frame}, pc, instr)
-    return ${N.dispatch}(${N.frame}, pc + instr.${N.a})
+    return ${N.dispatch}(${N.frame}, pc + instr[2])
 end
 
 -- EQ LT LE (값 생성형 비교)
 ${N.handlers}[${op(Opcode.EQ)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) == ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) == ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 ${N.handlers}[${op(Opcode.LT)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) < ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) < ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 ${N.handlers}[${op(Opcode.LE)}] = function(${N.frame}, pc, instr)
-    ${N.frame}.${N.R}[instr.${N.a}] = ${N.rk}(${N.frame}, instr.${N.b}) <= ${N.rk}(${N.frame}, instr.${N.c})
+    ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) <= ${N.rk}(${N.frame}, instr[4])
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- TEST (if (not R[a]) != (c!=0) then pc += 2 else pc += 1 — 보통 다음 명령은 JMP)
 ${N.handlers}[${op(Opcode.TEST)}] = function(${N.frame}, pc, instr)
-    if (not ${N.frame}.${N.R}[instr.${N.a}]) ~= (instr.${N.c} ~= 0) then
+    if (not ${N.frame}.${N.R}[instr[2]]) ~= (instr[4] ~= 0) then
         return ${N.dispatch}(${N.frame}, pc + 2)
     end
     return ${N.dispatch}(${N.frame}, pc + 1)
@@ -200,7 +200,7 @@ end
 
 -- CALL
 ${N.handlers}[${op(Opcode.CALL)}] = function(${N.frame}, pc, instr)
-    local a, b, c = instr.${N.a}, instr.${N.b}, instr.${N.c}
+    local a, b, c = instr[2], instr[3], instr[4]
     local fn = ${N.frame}.${N.R}[a]
     local nargs
     if b == 0 then
@@ -225,7 +225,7 @@ end
 
 -- RETURN
 ${N.handlers}[${op(Opcode.RETURN)}] = function(${N.frame}, pc, instr)
-    local a, b = instr.${N.a}, instr.${N.b}
+    local a, b = instr[2], instr[3]
     if b == 0 then
         return table.unpack(${N.frame}.${N.R}, a, (${N.frame}.${N.multiTop} or (a + 1)) - 1)
     end
@@ -234,14 +234,14 @@ end
 
 -- FORPREP
 ${N.handlers}[${op(Opcode.FORPREP)}] = function(${N.frame}, pc, instr)
-    local a = instr.${N.a}
+    local a = instr[2]
     ${N.frame}.${N.R}[a] = ${N.frame}.${N.R}[a] - ${N.frame}.${N.R}[a + 2]
-    return ${N.dispatch}(${N.frame}, pc + instr.${N.b})
+    return ${N.dispatch}(${N.frame}, pc + instr[3])
 end
 
 -- FORLOOP
 ${N.handlers}[${op(Opcode.FORLOOP)}] = function(${N.frame}, pc, instr)
-    local a = instr.${N.a}
+    local a = instr[2]
     local step = ${N.frame}.${N.R}[a + 2]
     ${N.frame}.${N.R}[a] = ${N.frame}.${N.R}[a] + step
     local ok
@@ -252,26 +252,26 @@ ${N.handlers}[${op(Opcode.FORLOOP)}] = function(${N.frame}, pc, instr)
     end
     if ok then
         ${N.frame}.${N.R}[a + 3] = ${N.frame}.${N.R}[a]
-        return ${N.dispatch}(${N.frame}, pc + instr.${N.b})
+        return ${N.dispatch}(${N.frame}, pc + instr[3])
     end
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- CLOSURE
 ${N.handlers}[${op(Opcode.CLOSURE)}] = function(${N.frame}, pc, instr)
-    local childProto = ${N.frame}.${N.protos}[instr.${N.b} + 1]
+    local childProto = ${N.frame}.${N.protos}[instr[3] + 1]
     local n = #childProto.${N.upvalDescs}
     local capturedUpvals = table.create(n)
     for i = 1, n do
         local desc = childProto.${N.upvalDescs}[i]
         local captureInstr = ${N.frame}.${N.code}[pc + i]
         if desc.${N.kind} == "local" then
-            capturedUpvals[i] = ${N.frame}.${N.R}[captureInstr.${N.b}]
+            capturedUpvals[i] = ${N.frame}.${N.R}[captureInstr[3]]
         else
-            capturedUpvals[i] = ${N.frame}.${N.upvals}[captureInstr.${N.b} + 1]
+            capturedUpvals[i] = ${N.frame}.${N.upvals}[captureInstr[3] + 1]
         end
     end
-    ${N.frame}.${N.R}[instr.${N.a}] = function(...)
+    ${N.frame}.${N.R}[instr[2]] = function(...)
         return ${N.execute}(childProto, capturedUpvals, ...)
     end
     return ${N.dispatch}(${N.frame}, pc + 1 + n)
@@ -279,22 +279,22 @@ end
 
 -- VARARG
 ${N.handlers}[${op(Opcode.VARARG)}] = function(${N.frame}, pc, instr)
-    local count = instr.${N.b} == 0 and ${N.frame}.${N.nVarargs} or (instr.${N.b} - 1)
+    local count = instr[3] == 0 and ${N.frame}.${N.nVarargs} or (instr[3] - 1)
     for i = 1, count do
-        ${N.frame}.${N.R}[instr.${N.a} + i - 1] = ${N.frame}.${N.varargs}[i]
+        ${N.frame}.${N.R}[instr[2] + i - 1] = ${N.frame}.${N.varargs}[i]
     end
-    if instr.${N.b} == 0 then
-        ${N.frame}.${N.multiTop} = instr.${N.a} + count
+    if instr[3] == 0 then
+        ${N.frame}.${N.multiTop} = instr[2] + count
     end
     return ${N.dispatch}(${N.frame}, pc + 1)
 end
 
 -- SETLIST
 ${N.handlers}[${op(Opcode.SETLIST)}] = function(${N.frame}, pc, instr)
-    local tbl = ${N.frame}.${N.R}[instr.${N.a}]
-    local valuesBase = instr.${N.b}
+    local tbl = ${N.frame}.${N.R}[instr[2]]
+    local valuesBase = instr[3]
     local top = ${N.frame}.${N.multiTop} or (valuesBase + 1)
-    local startIdx = instr.${N.c}
+    local startIdx = instr[4]
     local n = top - valuesBase
     for i = 0, n - 1 do
         tbl[startIdx + i] = ${N.frame}.${N.R}[valuesBase + i]
@@ -331,4 +331,4 @@ function ${N.execute}(proto, upvals, ...)
     return ${N.dispatch}(${N.frame}, 1)
 end
 `
-}
+}

package/src/passes/vmify/serialize.ts

@@ -3,7 +3,7 @@ import type { Proto, ConstValue } from "./chunk"
 import { Opcode } from "./opcodes"
 import type { VmNames } from "./names"
 import {
-    table, positionalField, namedField, numberLiteral, stringLiteral, booleanLiteral, nilLiteral,
+    table, positionalField, namedField, numberLiteral, vmNumberLiteral, stringLiteral, booleanLiteral, nilLiteral,
 } from "../nodeFactory"
 
 /** proto.consts[]를 Luau 배열 리터럴로: { [1] = v1, [2] = v2, ... } (1-based는 그대로 유지) */
@@ -26,14 +26,14 @@ function serializeConstValue(v: ConstValue): Expression {
  * 테이블을 바로 찾아낼 수 있기 때문. runtime.ts가 같은 names로 instr.<key>를 읽으므로
  * 반드시 컴파일 시점에 쓴 것과 동일한 VmNames 인스턴스를 넘겨야 한다.
  */
-function serializeInstrs(proto: Proto, names: VmNames): Expression {
+function serializeInstrs(proto: Proto): Expression {
     const fields: TableField[] = proto.code.map((instr) =>
         positionalField(
             table([
-                namedField(names.op, numberLiteral(instr.op as number)),
-                namedField(names.a, numberLiteral(instr.a)),
-                namedField(names.b, numberLiteral(instr.b)),
-                namedField(names.c, numberLiteral(instr.c)),
+                positionalField(vmNumberLiteral(instr.op as number)),
+                positionalField(vmNumberLiteral(instr.a)),
+                positionalField(vmNumberLiteral(instr.b)),
+                positionalField(vmNumberLiteral(instr.c)),
             ]),
         ))
     return table(fields)
@@ -44,7 +44,7 @@ function serializeUpvalDescs(proto: Proto, names: VmNames): Expression {
         positionalField(
             table([
                 namedField(names.kind, stringLiteral(d.kind)),
-                namedField(names.index, numberLiteral(d.index)),
+                namedField(names.index, vmNumberLiteral(d.index)),
             ]),
         ))
     return table(fields)
@@ -54,10 +54,10 @@ function serializeUpvalDescs(proto: Proto, names: VmNames): Expression {
  *  (필드 키는 전부 names에서 온 무작위 이름). */
 export function serializeProto(proto: Proto, names: VmNames): Expression {
     const fields: TableField[] = [
-        namedField(names.numParams, numberLiteral(proto.numParams)),
+        namedField(names.numParams, vmNumberLiteral(proto.numParams)),
         namedField(names.hasVarargs, booleanLiteral(proto.hasVarargs)),
-        namedField(names.maxRegs, numberLiteral(proto.maxRegs)),
-        namedField(names.code, serializeInstrs(proto, names)),
+        namedField(names.maxRegs, vmNumberLiteral(proto.maxRegs)),
+        namedField(names.code, serializeInstrs(proto)),
         namedField(names.consts, serializeConsts(proto.consts)),
         namedField(names.upvalDescs, serializeUpvalDescs(proto, names)),
         namedField(names.protos, table(proto.protos.map((p) => positionalField(serializeProto(p, names))))),
@@ -65,4 +65,4 @@ export function serializeProto(proto: Proto, names: VmNames): Expression {
     return table(fields)
 }
 
-export { Opcode }
+export { Opcode }

package/src/passes/walk.ts

@@ -10,79 +10,177 @@ function visitArray(arr: Expression[], visitor: ExpressionVisitor): void {
     }
 }
 
-export function mapExpression(expr: Expression, visitor: ExpressionVisitor): Expression {
+interface ChildAccessor {
+    get(): Expression
+    set(v: Expression): void
+}
+
+/**
+ * expr의 "자식 Expression"들에 대한 getter/setter 목록을 반환한다.
+ * (FunctionExpression은 별도 처리하므로 여기서는 빈 배열을 반환한다.)
+ */
+function getExpressionChildren(expr: Expression): ChildAccessor[] {
     switch (expr.type) {
-        case "InterpolatedStringExpression":
+        case "InterpolatedStringExpression": {
+            const children: ChildAccessor[] = []
             for (const part of expr.parts) {
                 if (part.kind === "expression") {
-                    part.expression = mapExpression(part.expression, visitor)
+                    children.push({
+                        get: () => part.expression,
+                        set: (v) => { part.expression = v },
+                    })
                 }
             }
-            break
+            return children
+        }
 
         case "FunctionExpression":
-            walkFunctionBody(expr.func, visitor)
-            break
+            return []
 
-        case "TableExpression":
+        case "TableExpression": {
+            const children: ChildAccessor[] = []
             for (const field of expr.fields) {
                 if (field.type === "TableFieldPositional") {
-                    field.value = mapExpression(field.value, visitor)
+                    children.push({ get: () => field.value, set: (v) => { field.value = v } })
                 } else if (field.type === "TableFieldNamed") {
-                    field.value = mapExpression(field.value, visitor)
+                    children.push({ get: () => field.value, set: (v) => { field.value = v } })
                 } else if (field.type === "TableFieldComputed") {
-                    field.key = mapExpression(field.key, visitor)
-                    field.value = mapExpression(field.value, visitor)
+                    children.push({ get: () => field.key, set: (v) => { field.key = v } })
+                    children.push({ get: () => field.value, set: (v) => { field.value = v } })
                 }
             }
-            break
+            return children
+        }
 
         case "BinaryExpression":
-            expr.left = mapExpression(expr.left, visitor)
-            expr.right = mapExpression(expr.right, visitor)
-            break
+            return [
+                { get: () => expr.left, set: (v) => { expr.left = v } },
+                { get: () => expr.right, set: (v) => { expr.right = v } },
+            ]
 
         case "UnaryExpression":
-            expr.argument = mapExpression(expr.argument, visitor)
-            break
+            return [{ get: () => expr.argument, set: (v) => { expr.argument = v } }]
 
         case "MemberExpression":
-            expr.object = mapExpression(expr.object, visitor)
-            break
+            return [{ get: () => expr.object, set: (v) => { expr.object = v } }]
 
         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
+            return [
+                { get: () => expr.object, set: (v) => { expr.object = v } },
+                { get: () => expr.index, set: (v) => { expr.index = v } },
+            ]
+
+        case "CallExpression": {
+            const children: ChildAccessor[] = [
+                { get: () => expr.callee, set: (v) => { expr.callee = v } },
+            ]
+            for (let i = 0; i < expr.arguments.length; i++) {
+                const idx = i
+                children.push({
+                    get: () => expr.arguments[idx],
+                    set: (v) => { expr.arguments[idx] = v },
+                })
+            }
+            return children
+        }
+
+        case "MethodCallExpression": {
+            const children: ChildAccessor[] = [
+                { get: () => expr.object, set: (v) => { expr.object = v } },
+            ]
+            for (let i = 0; i < expr.arguments.length; i++) {
+                const idx = i
+                children.push({
+                    get: () => expr.arguments[idx],
+                    set: (v) => { expr.arguments[idx] = v },
+                })
+            }
+            return children
+        }
 
         case "ParenthesizedExpression":
-            expr.expression = mapExpression(expr.expression, visitor)
-            break
+            return [{ get: () => expr.expression, set: (v) => { expr.expression = v } }]
 
         case "TypeAssertionExpression":
-            expr.expression = mapExpression(expr.expression, visitor)
-            break
+            return [{ get: () => expr.expression, set: (v) => { expr.expression = v } }]
 
-        case "IfElseExpression":
+        case "IfElseExpression": {
+            const children: ChildAccessor[] = []
             for (const clause of expr.clauses) {
-                clause.condition = mapExpression(clause.condition, visitor)
-                clause.body = mapExpression(clause.body, visitor)
+                children.push({ get: () => clause.condition, set: (v) => { clause.condition = v } })
+                children.push({ get: () => clause.body, set: (v) => { clause.body = v } })
+            }
+            children.push({ get: () => expr.alternate, set: (v) => { expr.alternate = v } })
+            return children
+        }
+
+        default:
+            return []
+    }
+}
+
+interface WalkFrame {
+    expr: Expression
+    children: ChildAccessor[]
+    index: number
+    setInParent: ((v: Expression) => void) | null
+}
+
+/**
+ * Expression 트리를 후위순회(post-order)로 변형한다.
+ *
+ * 원래는 재귀 함수였지만, 문자열/숫자 난독화 패스가 만들어내는 매우 깊은
+ * BinaryExpression 체인(예: 수천 개의 `..` concat)을 순회할 때 네이티브
+ * 콜스택이 트리 깊이만큼 쌓여 "Maximum call stack size exceeded"가
+ * 발생했다. 그래서 재귀 대신 힙에 할당되는 명시적 스택을 사용해
+ * 트리 깊이와 무관하게 동작하도록 구현했다.
+ */
+export function mapExpression(root: Expression, visitor: ExpressionVisitor): Expression {
+    // FunctionExpression은 본문(statement 트리)을 별도로 순회해야 하므로 특별 취급한다.
+    // 함수 중첩 깊이는 보통 얕아서(재귀해도 안전) 그대로 재귀를 사용한다.
+    if (root.type === "FunctionExpression") {
+        walkFunctionBody(root.func, visitor)
+        return visitor(root) ?? root
+    }
+
+    let result: Expression = root
+    const stack: WalkFrame[] = [{
+        expr: root,
+        children: getExpressionChildren(root),
+        index: 0,
+        setInParent: (v) => { result = v },
+    }]
+
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1]
+
+        if (frame.index < frame.children.length) {
+            const child = frame.children[frame.index]
+            frame.index++
+            const childExpr = child.get()
+
+            if (childExpr.type === "FunctionExpression") {
+                walkFunctionBody(childExpr.func, visitor)
+                child.set(visitor(childExpr) ?? childExpr)
+                continue
             }
-            expr.alternate = mapExpression(expr.alternate, visitor)
-            break
+
+            stack.push({
+                expr: childExpr,
+                children: getExpressionChildren(childExpr),
+                index: 0,
+                setInParent: child.set,
+            })
+            continue
+        }
+
+        // 모든 자식 처리가 끝났으면 visitor를 실행하고, 부모에 반영한 뒤 pop한다.
+        const finished = visitor(frame.expr) ?? frame.expr
+        frame.setInParent?.(finished)
+        stack.pop()
     }
 
-    return visitor(expr) ?? expr
+    return result
 }
 
 function walkFunctionBody(func: FunctionBody, visitor: ExpressionVisitor): void {
@@ -170,4 +268,4 @@ function walkStatement(stmt: Statement, visitor: ExpressionVisitor): void {
 /** Program 전체를 순회하며 모든 Expression 노드에 visitor를 적용(제자리 변형). */
 export function transformExpressions(program: Program, visitor: ExpressionVisitor): void {
     walkBlock(program.body, visitor)
-}
+}

package/src/pipeline.ts

@@ -17,10 +17,10 @@ type PassFn = (program: Program, options: any) => void
 export const PASS_ORDER: (keyof ObfuscateConfig)[] = [
     "Vmify",
     "GlobalMapping",
-    "StringsToExpressions",
-    "NumbersToExpressions",
     "RenameVariables",
     "ConstantArray",
+    "StringsToExpressions",
+    "NumbersToExpressions",
     "EncryptStrings",
     "EncryptNumbers",
     "InsertJunk",
@@ -38,13 +38,10 @@ export const PASS_MAP: Partial<Record<keyof ObfuscateConfig, PassFn>> = {
     EncryptNumbers: runEncryptNumbers,
     InsertJunk: runInsertJunk,
     WrapInFunction: runWrapInFunction,
-    Vmify: runVmify
+    Vmify: runVmify,
 }
 
 export function runPipeline(program: Program, config: ObfuscateConfig): void {
-    // 타입 주석/별칭은 값 트리와 독립적으로 원본 이름을 참조하고 있어서
-    // (예: typeof(x)) 어떤 pass보다도 먼저 지워야 함. 끄면 무조건 깨지므로
-    // config로 조절 가능한 옵션이 아니라 파이프라인 진입 시 항상 실행.
     runStripTypes(program)
 
     for (const key of PASS_ORDER) {