@dacely/toildefender 0.1.6 → 0.1.7

package/processors/postprocessing.js

@@ -10,9 +10,9 @@ var utils = require("../utils");
 
 /**
  * Merges nested bind calls like
- * veilmark$bind(veilmark$bind(main, 1234), 5678)
+ * toildefender$bind(toildefender$bind(main, 1234), 5678)
  * to
- * veilmark$bind(main, 1234, 5678)
+ * toildefender$bind(main, 1234, 5678)
  * @param {Node} node
  * @returns {Node}
  */
@@ -27,7 +27,7 @@ function mergeNestedBinds(node) {
 }
 
 /**
- * Checks whether node is a call to veilmark$bind.
+ * Checks whether node is a call to toildefender$bind.
  * @param {Node} node
  * @returns {boolean}
  */
@@ -36,7 +36,7 @@ function isBindCall(node) {
     
     return node.type == "CallExpression"
         && node.callee.type == "Identifier"
-        && node.callee.name == "veilmark$bind";
+        && node.callee.name == "toildefender$bind";
 }
 
 module.exports = class Postprocessing {

package/processors/scopes.js

@@ -19,11 +19,137 @@ function isClassMethodScope(scope) {
         if (node.type == "MethodDefinition" || node.type == "ClassBody") {
             return true;
         }
-        node = node.veilmark$parent;
+        node = node.toildefender$parent;
     }
     return false;
 }
 
+function isNumericVmInternalNode(node) {
+    while (node) {
+        if (node.toildefender$numericVmInternal === true) {
+            return true;
+        }
+        node = node.toildefender$parent;
+    }
+    return false;
+}
+
+function isNumericVmInternalFunction(stack) {
+    return stack.some(frame => frame.node && isNumericVmInternalNode(frame.node));
+}
+
+function isNumericVmInternalScope(scope) {
+    return isNumericVmInternalNode(scope && scope.block);
+}
+
+function scopeReference(scopeVarName, index) {
+    return {
+        type: "MemberExpression",
+        object: { type: "Identifier", name: scopeVarName },
+        property: { type: "Literal", value: index },
+        computed: true,
+        toildefender$scopeObjectReference: true
+    };
+}
+
+function isReferenceIdentifier(node, stack) {
+    var parentFrame = stack[1];
+    if (!parentFrame) {
+        return true;
+    }
+
+    var parent = parentFrame.node;
+    var key = parentFrame.key;
+
+    if ((parent.type == "FunctionDeclaration" || parent.type == "FunctionExpression") && (key == "id" || key == "params")) {
+        return false;
+    }
+    if ((parent.type == "ClassDeclaration" || parent.type == "ClassExpression") && key == "id") {
+        return false;
+    }
+    if (parent.type == "VariableDeclarator" && key == "id") {
+        return false;
+    }
+    if (parent.type == "CatchClause" && key == "param") {
+        return false;
+    }
+    if ((parent.type == "MemberExpression" || parent.type == "Property") && key == "property" && parent.computed === false) {
+        return false;
+    }
+    if (parent.type == "Property" && key == "key" && parent.computed === false) {
+        return false;
+    }
+    if ((parent.type == "MethodDefinition" || parent.type == "PropertyDefinition" || parent.type == "FieldDefinition") && key == "key" && parent.computed === false) {
+        return false;
+    }
+    if ((parent.type == "LabeledStatement" || parent.type == "BreakStatement" || parent.type == "ContinueStatement") && key == "label") {
+        return false;
+    }
+
+    return true;
+}
+
+function isInsideNestedScope(stack, root, scopeBlocks) {
+    return stack.some(frame => frame.node != root && scopeBlocks.has(frame.node));
+}
+
+function isMovableVariable(variable) {
+    return variable.defs.some(def => {
+        if (isNumericVmInternalNode(def.node)) {
+            return false;
+        }
+        if (def.type == "Variable" || def.type == "CatchClause") {
+            return true;
+        }
+        return def.type == "FunctionName" && def.node.type != "FunctionExpression";
+    });
+}
+
+function markPropertyValueReplacement(stack) {
+    var parentFrame = stack[1];
+    if (!parentFrame) {
+        return;
+    }
+    var parent = parentFrame.node;
+    if (parent.type == "Property" && parent.shorthand === true && parentFrame.key == "value") {
+        parent.shorthand = false;
+    }
+}
+
+function isReferenceInsideNestedFunction(scopeBlock, identifier) {
+    var current = identifier && identifier.toildefender$parent;
+    while (current && current != scopeBlock) {
+        if (estest.isFunction(current)) {
+            return true;
+        }
+        current = current.toildefender$parent;
+    }
+    return false;
+}
+
+function normalizeRatio(value) {
+    var ratio = Number(value);
+    if (!Number.isFinite(ratio)) {
+        return 1;
+    }
+    if (ratio < 0) {
+        return 0;
+    }
+    if (ratio > 1) {
+        return 1;
+    }
+    return ratio;
+}
+
+function hashString32(value) {
+    var h = 0x811c9dc5;
+    for (var i = 0; i < value.length; i += 1) {
+        h ^= value.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h >>> 0;
+}
+
 module.exports = class Scopes {
 
     constructor (logger) {
@@ -41,19 +167,216 @@ module.exports = class Scopes {
      * @param {Node} ast Root node
      * @param {ScopeManager} scopeManager Scope manager
      */
-    createScopeObjects (ast, scopeManager) {
+    createScopeObjects (ast, scopeManager, options) {
         assert.ok(estest.isNode(ast));
         
         this.esutils.setParentsRecursive(ast);
+        options = options || {};
+        var ratio = normalizeRatio(options.ratio);
+        var seed = options.seed || "toildefender-scope";
+        var forceProgram = options.forceProgram === true;
         var scopes = scopeManager.acquireAll(ast);
         var rngAlpha = new utils.UniqueRandomAlpha(3);
+        var replacements = new WeakMap();
+        var referencesByVariable = new Map();
+        var fallbackReplacementsByName = new Map();
+        var scopeBlocks = new WeakSet();
+        scopes.forEach(scope => {
+            if (scope && scope.block) {
+                scopeBlocks.add(scope.block);
+            }
+        });
+
+        function cloneReplacement(node) {
+            return utils.cloneISwearIKnowWhatImDoing(node);
+        }
+
+        function addFallbackReplacement(name, replacement, block, scopeDecl) {
+            var entries = fallbackReplacementsByName.get(name);
+            if (!entries) {
+                entries = [];
+                fallbackReplacementsByName.set(name, entries);
+            }
+            entries.push({
+                block: block,
+                scopeDecl: scopeDecl,
+                replacement: replacement
+            });
+        }
+
+        function ancestorDistance(ancestor, node) {
+            var distance = 0;
+            var current = node;
+            while (current) {
+                if (current == ancestor) {
+                    return distance;
+                }
+                current = current.toildefender$parent;
+                distance += 1;
+            }
+            return -1;
+        }
+
+        function fallbackReplacementForName(name, node) {
+            var entries = fallbackReplacementsByName.get(name);
+            if (!entries) {
+                return null;
+            }
+
+            var best = null;
+            var bestDistance = Infinity;
+            entries.forEach(entry => {
+                var liveBlock = entry.scopeDecl && entry.scopeDecl.toildefender$parent;
+                var distance = liveBlock ? ancestorDistance(liveBlock, node) : -1;
+                if (distance < 0) {
+                    distance = ancestorDistance(entry.block, node);
+                }
+                if (distance >= 0 && distance < bestDistance) {
+                    best = entry.replacement;
+                    bestDistance = distance;
+                }
+            });
+            if (best) {
+                return best;
+            }
+            return null;
+        }
+
+        function addResolvedReference(variable, reference) {
+            if (!variable || !reference || !reference.identifier) {
+                return;
+            }
+            var references = referencesByVariable.get(variable);
+            if (!references) {
+                references = new Set();
+                referencesByVariable.set(variable, references);
+            }
+            references.add(reference);
+        }
+
         scopeManager.scopes.forEach(scope => {
-            if (!this.esutils.canInsertIntoScope(scope) || isClassMethodScope(scope)) {
+            scope.variables.forEach(variable => {
+                variable.references.forEach(reference => addResolvedReference(variable, reference));
+            });
+
+            scope.references.forEach(reference => {
+                addResolvedReference(reference.resolved, reference);
+            });
+
+            scope.through.forEach(reference => {
+                addResolvedReference(reference.resolved, reference);
+            });
+        });
+
+        function referencesFor(variable) {
+            var references = referencesByVariable.get(variable);
+            references = references ? Array.from(references) : variable.references;
+            return references.filter(reference => reference.resolved === variable);
+        }
+
+        function shouldFlattenScope(scope, movableVariables, index) {
+            if (forceProgram && scope && scope.block && scope.block.type == "Program") {
+                return true;
+            }
+            if (movableVariables.some(variable => referencesFor(variable).some(reference => isReferenceInsideNestedFunction(scope.block, reference.identifier)))) {
+                return true;
+            }
+            if (ratio >= 1) {
+                return true;
+            }
+            if (ratio <= 0) {
+                return false;
+            }
+            var blockType = scope && scope.block && scope.block.type || "";
+            var variableNames = movableVariables.map(variable => variable.name).sort().join(",");
+            var score = hashString32(`${seed}:${index}:${scope.type}:${blockType}:${variableNames}`) / 0x100000000;
+            return score < ratio;
+        }
+
+        function rewriteKnownReferences(node) {
+            if (!node) {
+                return node;
+            }
+            return traverser.traverse(node, [], (child, stack) => {
+                if (isNumericVmInternalFunction(stack)) {
+                    return child;
+                }
+                if (child.type == "Identifier" && replacements.has(child)) {
+                    markPropertyValueReplacement(stack);
+                    return cloneReplacement(replacements.get(child));
+                }
+                return child;
+            });
+        }
+
+        scopeManager.scopes.forEach((scope, scopeIndex) => {
+            if (!this.esutils.canInsertIntoScope(scope) || isClassMethodScope(scope) || isNumericVmInternalScope(scope)) {
+                return;
+            }
+            var movableVariables = scope.variables.filter(isMovableVariable);
+            if (movableVariables.length == 0) {
+                return;
+            }
+            if (!shouldFlattenScope(scope, movableVariables, scopeIndex)) {
                 return;
             }
             var scopeVarName = `$$scope$${rngAlpha.get()}`;
             
             var counter = 0;
+            var indexes = new Map();
+            var localReplacementsByName = new Map();
+            movableVariables.forEach(variable => {
+                indexes.set(variable, counter++);
+            });
+
+            movableVariables.forEach(variable => {
+                var index = indexes.get(variable);
+                variable.defs.forEach(def => {
+                    if (def.type == "Variable") {
+                        var replacement = scopeReference(scopeVarName, index);
+                        localReplacementsByName.set(variable.name, replacement);
+                        referencesFor(variable).forEach(reference => {
+                            replacements.set(reference.identifier, scopeReference(scopeVarName, index));
+                        });
+                    } else if (def.type == "CatchClause") {
+                        referencesFor(variable).forEach(reference => {
+                            replacements.set(reference.identifier, scopeReference(scopeVarName, index));
+                        });
+                    } else if (def.type == "FunctionName" && def.node.type != "FunctionExpression") {
+                        referencesFor(variable).forEach(reference => {
+                            replacements.set(reference.identifier, {
+                                type: "CallExpression",
+                                callee: { type: "Identifier", name: "toildefender$bind" },
+                                arguments: [
+                                    { type: "Identifier", name: reference.identifier.name },
+                                    { type: "Identifier", name: scopeVarName }
+                                ]
+                            });
+                        });
+                    }
+                });
+            });
+
+            var rewriteLocalReferencesByName = () => {
+                this.esutils.setParentsRecursive(scope.block);
+                traverser.traverse(scope.block, [], (node, stack) => {
+                    if (isNumericVmInternalFunction(stack)) {
+                        return node;
+                    }
+                    if (isInsideNestedScope(stack, scope.block, scopeBlocks)) {
+                        return node;
+                    }
+                    if (node.type == "Identifier" && isReferenceIdentifier(node, stack)) {
+                        var replacement = localReplacementsByName.get(node.name);
+                        if (replacement) {
+                            markPropertyValueReplacement(stack);
+                            return cloneReplacement(replacement);
+                        }
+                    }
+                    return node;
+                });
+            };
+
             var scopeDecl = {
                 type: "VariableDeclaration",
                 kind: "var",
@@ -64,13 +387,16 @@ module.exports = class Scopes {
                         init: { type: "ArrayExpression", elements: [] }
                     }
                 ],
-                veilmark$scopeObject: true
+                toildefender$scopeObject: true
             };
             
             this.esutils.insertIntoScope(scope, scopeDecl);
+            localReplacementsByName.forEach((replacement, name) => {
+                addFallbackReplacement(name, replacement, scope.block, scopeDecl);
+            });
             
-            scope.variables.forEach(variable => {
-                var index = counter++;
+            movableVariables.forEach(variable => {
+                var index = indexes.get(variable);
                 
                 variable.defs.forEach(def => {
                     if (def.type == "Variable") {
@@ -88,9 +414,9 @@ module.exports = class Scopes {
                                         object: { type: "Identifier", name: scopeVarName },
                                         property: { type: "Literal", value: index },
                                         computed: true,
-                                        veilmark$scopeObjectReference: true
+                                        toildefender$scopeObjectReference: true
                                     },
-                                    right: def.node.init
+                                    right: rewriteKnownReferences(def.node.init)
                                 }
                             });
                         }
@@ -104,25 +430,13 @@ module.exports = class Scopes {
                         } else {
                             this.esutils.replaceNode(scope.block, def.parent, { type: "BlockStatement", body: replacement });
                         }
-                        variable.references.forEach(reference => {
+                        referencesFor(variable).forEach(reference => {
                             // References can not be replaced via replaceNodeEx for whatever reason
-                            this.esutils.replaceNode(scope.block, reference.identifier, {
-                                type: "MemberExpression",
-                                object: { type: "Identifier", name: scopeVarName },
-                                property: { type: "Literal", value: index },
-                                computed: true,
-                                veilmark$scopeObjectReference: true
-                            });
+                            this.esutils.replaceNode(scope.block, reference.identifier, cloneReplacement(replacements.get(reference.identifier) || scopeReference(scopeVarName, index)));
                         });
                     } else if (def.type == "CatchClause") {
-                        Object.defineProperty(scope.block, "veilmark$exception", {
-                            value: {
-                                type: "MemberExpression",
-                                object: { type: "Identifier", name: scopeVarName },
-                                property: { type: "Literal", value: index },
-                                computed: true,
-                                veilmark$scopeObjectReference: true
-                            },
+                        Object.defineProperty(scope.block, "toildefender$exception", {
+                            value: scopeReference(scopeVarName, index),
                             configurable: true
                         });
                         this.esutils.insertIntoScope(scope, {
@@ -130,49 +444,32 @@ module.exports = class Scopes {
                             expression: {
                                 type: "AssignmentExpression",
                                 operator: "=",
-                                left: {
-                                    type: "MemberExpression",
-                                    object: { type: "Identifier", name: scopeVarName },
-                                    property: { type: "Literal", value: index },
-                                    computed: true,
-                                    veilmark$scopeObjectReference: true
-                                },
+                                left: scopeReference(scopeVarName, index),
                                 right: def.name
                             }
                         }, 1);
-                        variable.references.forEach(reference => {
-                            this.esutils.replaceNode(scope.block, reference.identifier, {
-                                type: "MemberExpression",
-                                object: { type: "Identifier", name: scopeVarName },
-                                property: { type: "Literal", value: index },
-                                computed: true,
-                                veilmark$scopeObjectReference: true
-                            });
+                        referencesFor(variable).forEach(reference => {
+                            this.esutils.replaceNode(scope.block, reference.identifier, cloneReplacement(replacements.get(reference.identifier) || scopeReference(scopeVarName, index)));
                         });
                     } else if (def.type == "FunctionName") {
                         if (def.node.type == "FunctionExpression") {
                             return;
                         }
-                        variable.references.forEach(reference => {
-                            this.esutils.replaceNode(scope.block, reference.identifier, {
-                                type: "CallExpression",
-                                callee: { type: "Identifier", name: "veilmark$bind" },
-                                arguments: [
-                                    reference.identifier,
-                                    { type: "Identifier", name: scopeVarName }
-                                ]
-                            });
+                        referencesFor(variable).forEach(reference => {
+                            this.esutils.replaceNode(scope.block, reference.identifier, cloneReplacement(replacements.get(reference.identifier)));
                         });
                     }
                 });
             });
+
+            rewriteLocalReferencesByName();
             
             traverser.traverse(scope.block, [], (node, stack) => {
                 if (scope.block == node) {
                     return node;
                 }
 
-                if (isClassMethodFunction(stack)) {
+                if (isClassMethodFunction(stack) || isNumericVmInternalFunction(stack)) {
                     return node;
                 }
                 
@@ -186,7 +483,7 @@ module.exports = class Scopes {
                 if (node.type == "FunctionExpression") {
                     return {
                         type: "CallExpression",
-                        callee: { type: "Identifier", name: "veilmark$bind" },
+                        callee: { type: "Identifier", name: "toildefender$bind" },
                         arguments: [
                             node,
                             { type: "Identifier", name: scopeVarName }
@@ -197,6 +494,25 @@ module.exports = class Scopes {
                 return node;
             });
         });
+
+        this.esutils.setParentsRecursive(ast);
+        traverser.traverse(ast, [], (node, stack) => {
+            var parentFrame = stack[1];
+            if (
+                node.type == "Identifier" &&
+                node.name.indexOf("$$var$") == 0 &&
+                parentFrame &&
+                parentFrame.node.type == "CallExpression" &&
+                parentFrame.key == "callee" &&
+                isReferenceIdentifier(node, stack)
+            ) {
+                var replacement = fallbackReplacementForName(node.name, node);
+                if (replacement) {
+                    return cloneReplacement(replacement);
+                }
+            }
+            return node;
+        });
     }
 
 };

package/processors/uglifier.js

@@ -81,10 +81,29 @@ function shortName(index) {
     return name;
 }
 
-function isRenamableVariable(scope, variable) {
+function collectUnresolvedNames(scopeManager) {
+    var names = new Set();
+    scopeManager.scopes.forEach(scope => {
+        scope.through.forEach(reference => {
+            if (!reference.resolved) {
+                names.add(reference.identifier.name);
+            }
+        });
+    });
+    return names;
+}
+
+function isRenamableVariable(scope, variable, unresolvedNames) {
     if (scope.type == "global") {
         return false;
     }
+    if (
+        typeof variable.name == "string"
+        && variable.name.indexOf("toildefender$anon$") === 0
+        && unresolvedNames.has(variable.name)
+    ) {
+        return false;
+    }
     if (variable.name == "arguments" || variable.name == "undefined") {
         return false;
     }
@@ -161,10 +180,11 @@ function modernMangle(ast) {
         sourceType: "script"
     });
 
+    var unresolvedNames = collectUnresolvedNames(scopeManager);
     var variables = [];
     scopeManager.scopes.forEach(scope => {
         scope.variables.forEach(variable => {
-            if (isRenamableVariable(scope, variable)) {
+            if (isRenamableVariable(scope, variable, unresolvedNames)) {
                 variables.push({ scope: scope, variable: variable });
             }
         });