Oh right, I forgot the new emission handler to break deobfuscators, here you go!

SpinnySpiwal · SpinnySpiwal · commit 1fe1d67c7707 · 2026-03-24T10:46:16.000Z
Also fixed 2 other inconsistencies and updated my comments in NumbersToExpressions.
diff --git a/src/prometheus/compiler/emit.lua b/src/prometheus/compiler/emit.lua
@@ -1,16 +1,137 @@
 -- This Script is Part of the Prometheus Obfuscator by Levno_710
 --
 -- emit.lua
+--
 -- This Script contains the container function body emission for the compiler.
 
 local Ast = require("prometheus.ast");
 local Scope = require("prometheus.scope");
 local util = require("prometheus.util");
 local constants = require("prometheus.compiler.constants");
+local AstKind = Ast.AstKind;
 
 local MAX_REGS = constants.MAX_REGS;
 
 return function(Compiler)
+    local function hasAnyEntries(tbl)
+        return type(tbl) == "table" and next(tbl) ~= nil;
+    end
+
+    local function unionLookupTables(a, b)
+        local out = {};
+        for k, v in pairs(a or {}) do
+            out[k] = v;
+        end
+        for k, v in pairs(b or {}) do
+            out[k] = v;
+        end
+        return out;
+    end
+
+    local function canMergeParallelAssignmentStatements(statA, statB)
+        if type(statA) ~= "table" or type(statB) ~= "table" then
+            return false;
+        end
+
+        if statA.usesUpvals or statB.usesUpvals then
+            return false;
+        end
+
+        local a = statA.statement;
+        local b = statB.statement;
+        if type(a) ~= "table" or type(b) ~= "table" then
+            return false;
+        end
+        if a.kind ~= AstKind.AssignmentStatement or b.kind ~= AstKind.AssignmentStatement then
+            return false;
+        end
+
+        if type(a.lhs) ~= "table" or type(a.rhs) ~= "table" or type(b.lhs) ~= "table" or type(b.rhs) ~= "table" then
+            return false;
+        end
+
+        if #a.lhs ~= #a.rhs or #b.lhs ~= #b.rhs then
+            return false;
+        end
+
+        -- Avoid merging vararg/call assignments because they can affect multi-return behavior.
+        local function hasUnsafeRhs(rhsList)
+            for _, rhsExpr in ipairs(rhsList) do
+                if type(rhsExpr) ~= "table" then
+                    return true;
+                end
+                local kind = rhsExpr.kind;
+                if kind == AstKind.FunctionCallExpression or kind == AstKind.PassSelfFunctionCallExpression or kind == AstKind.VarargExpression then
+                    return true;
+                end
+            end
+            return false;
+        end
+        if hasUnsafeRhs(a.rhs) or hasUnsafeRhs(b.rhs) then
+            return false;
+        end
+
+        local aReads = type(statA.reads) == "table" and statA.reads or {};
+        local aWrites = type(statA.writes) == "table" and statA.writes or {};
+        local bReads = type(statB.reads) == "table" and statB.reads or {};
+        local bWrites = type(statB.writes) == "table" and statB.writes or {};
+
+        -- Allow merging even if one statement has no writes (e.g., x = o(x) style assignments)
+        -- Only require that at least one of them has writes
+        if not hasAnyEntries(aWrites) and not hasAnyEntries(bWrites) then
+            return false;
+        end
+
+        for r in pairs(aReads) do
+            if bWrites[r] then
+                return false;
+            end
+        end
+
+        for r, b in pairs(aWrites) do
+            if bWrites[r] or bReads[r] then
+                return false;
+            end
+        end
+
+        return true;
+    end
+
+    local function mergeParallelAssignmentStatements(statA, statB)
+        local lhs = {};
+        local rhs = {};
+        local aLhs, bLhs = statA.statement.lhs, statB.statement.lhs;
+        local aRhs, bRhs = statA.statement.rhs, statB.statement.rhs;
+        for i = 1, #aLhs do lhs[i] = aLhs[i]; end
+        for i = 1, #bLhs do lhs[#aLhs + i] = bLhs[i]; end
+        for i = 1, #aRhs do rhs[i] = aRhs[i]; end
+        for i = 1, #bRhs do rhs[#aRhs + i] = bRhs[i]; end
+
+        return {
+            statement = Ast.AssignmentStatement(lhs, rhs),
+            writes = unionLookupTables(statA.writes, statB.writes),
+            reads = unionLookupTables(statA.reads, statB.reads),
+            usesUpvals = statA.usesUpvals or statB.usesUpvals,
+        };
+    end
+
+    local function mergeAdjacentParallelAssignments(blockstats)
+        local merged = {};
+        local i = 1;
+        while i <= #blockstats do
+            local stat = blockstats[i];
+            i = i + 1;
+
+            while i <= #blockstats and canMergeParallelAssignmentStatements(stat, blockstats[i]) do
+                stat = mergeParallelAssignmentStatements(stat, blockstats[i]);
+                i = i + 1;
+            end
+
+            table.insert(merged, stat);
+        end
+        return merged;
+    end
+
     function Compiler:emitContainerFuncBody()
         local blocks = {};
 
@@ -70,8 +191,13 @@ return function(Compiler)
                 end
             end
 
+            local mergedBlockStats = mergeAdjacentParallelAssignments(blockstats);
+            for _=1, 7 do
+                mergedBlockStats = mergeAdjacentParallelAssignments(mergedBlockStats);
+            end
+
             blockstats = {};
-            for _, stat in ipairs(block.statements) do
+            for _, stat in ipairs(mergedBlockStats) do
                 table.insert(blockstats, stat.statement);
             end
 
@@ -80,37 +206,114 @@ return function(Compiler)
             blocks[id] = block;
         end
 
-        table.sort(blocks, function(a, b)
-            return a.id < b.id;
-        end);
-
-        local function buildIfBlock(scope, id, lBlock, rBlock)
-            local condition = Ast.LessThanExpression(self:pos(scope), Ast.NumberExpression(id));
-            return Ast.Block({
-                Ast.IfStatement(condition, lBlock, {}, rBlock);
-            }, scope);
+        table.sort(blocks, function(a, b) return a.id < b.id end);
+
+        -- Build a strict threshold condition between adjacent block IDs.
+        -- Using a midpoint avoids exact-id comparisons while preserving dispatch.
+        local function buildBlockThresholdCondition(scope, leftId, rightId, useAndOr)
+            local bound = math.floor((leftId + rightId) / 2);
+            local posExpr = self:pos(scope);
+            local boundExpr = Ast.NumberExpression(bound);
+
+            if useAndOr then
+                -- Kept for compatibility with caller variations.
+                return Ast.LessThanExpression(posExpr, boundExpr);
+            else
+                local variant = math.random(1, 2);
+                if variant == 1 then
+                    return Ast.LessThanExpression(posExpr, boundExpr);
+                else
+                    return Ast.GreaterThanExpression(boundExpr, posExpr);
+                end
+            end
         end
 
-        local function buildWhileBody(tb, l, r, pScope, scope)
+        -- Build an elseif chain for a range of blocks
+        local function buildElseifChain(tb, l, r, pScope)
+            -- Handle invalid range by returning an empty block
+            if r < l then
+                local emptyScope = Scope:new(pScope);
+                return Ast.Block({}, emptyScope);
+            end
+
             local len = r - l + 1;
+
+            -- For single block
             if len == 1 then
-                tb[r].block.scope:setParent(pScope);
-                return tb[r].block;
-            elseif len == 0 then
-                return nil;
+                tb[l].block.scope:setParent(pScope);
+                return tb[l].block;
             end
 
-            local mid = l + math.ceil(len / 2);
-            local bound = math.random(tb[mid - 1].id + 1, tb[mid].id);
-            local ifScope = scope or Scope:new(pScope);
+            -- For small ranges, use elseif chain
+            if len <= 4 then
+                local ifScope = Scope:new(pScope);
+                local elseifs = {};
+
+                -- First block uses the first midpoint threshold
+                tb[l].block.scope:setParent(ifScope);
+                local firstCondition = buildBlockThresholdCondition(ifScope, tb[l].id, tb[l + 1].id, false);
+                local firstBlock = tb[l].block;
+
+                -- Middle blocks use their upper midpoint threshold
+                for i = l + 1, r - 1 do
+                    tb[i].block.scope:setParent(ifScope);
+                    local condition = buildBlockThresholdCondition(ifScope, tb[i].id, tb[i + 1].id, false);
+                    table.insert(elseifs, {
+                        condition = condition,
+                        body = tb[i].block
+                    });
+                end
 
-            local lBlock = buildWhileBody(tb, l, mid - 1, ifScope);
-            local rBlock = buildWhileBody(tb, mid, r, ifScope);
+                -- Last block becomes else
+                tb[r].block.scope:setParent(ifScope);
+                local elseBlock = tb[r].block;
 
-            return buildIfBlock(ifScope, bound, lBlock, rBlock);
+                return Ast.Block({
+                    Ast.IfStatement(firstCondition, firstBlock, elseifs, elseBlock);
+                }, ifScope);
+            end
+
+            -- For larger ranges, use binary split with and/or chaining
+            local mid = l + math.ceil(len / 2);
+            local leftMaxId = tb[mid - 1].id;
+            local rightMinId = tb[mid].id;
+            -- Float-safe split: any bound strictly between adjacent IDs works.
+            -- Midpoint avoids integer-only math.random(min, max) behavior.
+            local bound = math.floor((leftMaxId + rightMinId) / 2);
+            local ifScope = Scope:new(pScope);
+
+            local lBlock = buildElseifChain(tb, l, mid - 1, ifScope);
+            local rBlock = buildElseifChain(tb, mid, r, ifScope);
+
+            -- Randomly choose between different condition styles
+            local condStyle = math.random(1, 3);
+            local condition;
+            local trueBlock, falseBlock;
+
+            if condStyle == 1 then
+                -- pos < bound
+                condition = Ast.LessThanExpression(self:pos(ifScope), Ast.NumberExpression(bound));
+                trueBlock, falseBlock = lBlock, rBlock;
+            elseif condStyle == 2 then
+                -- bound > pos
+                condition = Ast.GreaterThanExpression(Ast.NumberExpression(bound), self:pos(ifScope));
+                trueBlock, falseBlock = lBlock, rBlock;
+            else
+                -- Equivalent split using strict > with branches reversed.
+                condition = Ast.GreaterThanExpression(self:pos(ifScope), Ast.NumberExpression(bound));
+                trueBlock, falseBlock = rBlock, lBlock;
+            end
+
+            return Ast.Block({
+                Ast.IfStatement(condition, trueBlock, {}, falseBlock);
+            }, ifScope);
         end
 
-        local whileBody = buildWhileBody(blocks, 1, #blocks, self.containerFuncScope, self.whileScope);
+        local whileBody = buildElseifChain(blocks, 1, #blocks, self.containerFuncScope);
+        if self.whileScope then
+            -- Ensure whileScope is properly connected
+            self.whileScope:setParent(self.containerFuncScope);
+        end
 
         self.whileScope:addReferenceToHigherScope(self.containerFuncScope, self.returnVar, 1);
         self.whileScope:addReferenceToHigherScope(self.containerFuncScope, self.posVar);
@@ -137,6 +340,7 @@ return function(Compiler)
 
         table.insert(stats, Ast.WhileStatement(whileBody, Ast.VariableExpression(self.containerFuncScope, self.posVar)));
 
+
         table.insert(stats, Ast.AssignmentStatement({
             Ast.AssignmentVariable(self.containerFuncScope, self.posVar)
         }, {
@@ -151,4 +355,4 @@ return function(Compiler)
 
         return Ast.Block(stats, self.containerFuncScope);
     end
-end
+end
diff --git a/src/prometheus/steps/ConstantArray.lua b/src/prometheus/steps/ConstantArray.lua
@@ -99,9 +99,7 @@ local function callNameGenerator(generatorFunction, ...)
 	return generatorFunction(...);
 end
 
-function ConstantArray:init(settings)
-
-end
+function ConstantArray:init(_) end
 
 function ConstantArray:createArray()
 	local entries = {};
diff --git a/src/prometheus/steps/NumbersToExpressions.lua b/src/prometheus/steps/NumbersToExpressions.lua
@@ -31,9 +31,9 @@ NumbersToExpressions.SettingsDescriptor = {
 	},
 }
 
---[[
-	This function removes trailing zeros from a floating point number
-]]
+
+-- This is for the modulo generator. When I remove it, the obfuscated code breaks.
+-- I have no idea why, the odd part is it doesn't even use floating point numbers!
 local function filterNumber(number)
 	local formatted = string.format("%.50f", number)
 	formatted = formatted:gsub("%.?0+$", "")
@@ -50,7 +50,7 @@ local function generateModuloExpression(n)
 	return lhs, rhs
 end
 
-function NumbersToExpressions:init(settings)
+function NumbersToExpressions:init(_)
 	self.ExpressionGenerators = {
 		function(val, depth) -- Addition
 			local val2 = math.random(-2 ^ 20, 2 ^ 20)
@@ -88,7 +88,10 @@ function NumbersToExpressions:init(settings)
 				false
 			)
 		end,
-		function(val, depth) -- Advanced Modulo
+
+		-- NOTE: Please don't enable depth with this generator.
+		-- It's extremely unstable & breaks the step. I don't know why.
+		function(val, _) -- Modulo
 			if val <= 0 then
 				return false
 			end
@@ -108,7 +111,7 @@ function NumbersToExpressions:CreateNumberExpression(val, depth)
 	end
 
 	local generators = util.shuffle({ unpack(self.ExpressionGenerators) })
-	for i, generator in ipairs(generators) do
+	for _, generator in ipairs(generators) do
 		local node = generator(val, depth + 1)
 		if node then
 			return node
@@ -119,7 +122,7 @@ function NumbersToExpressions:CreateNumberExpression(val, depth)
 end
 
 function NumbersToExpressions:apply(ast)
-	visitast(ast, nil, function(node, data)
+	visitast(ast, nil, function(node, _)
 		if node.kind == AstKind.NumberExpression then
 			if math.random() <= self.Threshold then
 				return self:CreateNumberExpression(node.value, 0)
