js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/util/identifiers.js

@@ -1,355 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.containsLexicallyBoundVariables = containsLexicallyBoundVariables;
-exports.getDefiningIdentifier = getDefiningIdentifier;
-exports.getFunctionParameters = getFunctionParameters;
-exports.getIdentifierInfo = getIdentifierInfo;
-exports.isFunctionParameter = isFunctionParameter;
-exports.validateChain = validateChain;
-var _assert = require("assert");
-var _traverse = require("../traverse");
-var _insert = require("./insert");
-/**
- * Ensures the chain (object and parents) are connected.
- * @param object
- * @param parents
- */
-function validateChain(object, parents) {
-  if (!Array.isArray(parents)) {
-    throw new Error("parents need to be an array");
-  }
-  if (!object) {
-    throw new Error("object must be a node (not null)");
-  }
-  if (parents.length > 0) {
-    if (object == parents[0]) {
-      throw new Error("parent overlap");
-    }
-    if (!Object.values(parents[0]).includes(object)) {
-      console.log("parents=", parents);
-      console.log("object=", object);
-      throw new Error("parents[0] is not connected to object");
-    }
-  }
-}
-function objectPatternCheck(object, parents) {
-  var objectPatternIndex = parents.findIndex(x => x.type === "ObjectPattern");
-  if (objectPatternIndex == -1) {
-    return true;
-  }
-  var property = parents[objectPatternIndex].properties.find(property => parents[objectPatternIndex - 2] === property);
-  if (property.key === (parents[objectPatternIndex - 3] || object)) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * Returns detailed information about the given Identifier node.
- * @param object
- * @param parents
- */
-function getIdentifierInfo(object, parents) {
-  if (object.type != "Identifier") {
-    console.log(object);
-    throw new Error("object is not an Identifier, its a type=" + object.type);
-  }
-  var parent = parents[0] || {};
-  var isAccessor = parent.type == "MemberExpression" && parent.object != object && parent.property === object && !parent.computed;
-  var propIndex = parents.findIndex(x => x.type == "Property" || x.type == "MethodDefinition");
-  var isPropertyKey = propIndex != -1 && parents[propIndex].key == (parents[propIndex - 1] || object) && !parents[propIndex].computed;
-  var objectPatternIndex = parents.findIndex(x => x.type == "ObjectPattern");
-  if (objectPatternIndex !== -1 && parents[objectPatternIndex].properties == parents[objectPatternIndex - 1]) {
-    if (objectPatternIndex - propIndex == 2) {
-      if (parents[propIndex].value === (parents[propIndex - 1] || object)) {
-        isPropertyKey = false;
-      }
-    }
-  }
-  var varIndex = parents.findIndex(x => x.type == "VariableDeclarator");
-  var isVariableDeclaration = varIndex != -1 && parents[varIndex].id == (parents[varIndex - 1] || object) && parents.find(x => x.type == "VariableDeclaration") && objectPatternCheck(object, parents);
-  var functionIndex = parents.findIndex(x => (0, _insert.isFunction)(x));
-
-  // Assignment pattern check!
-  if (isVariableDeclaration) {
-    var slicedParents = parents.slice(0, functionIndex != -1 ? Math.min(varIndex, functionIndex) : varIndex);
-    var i = 0;
-    for (var parent of slicedParents) {
-      var childNode = slicedParents[i - 1] || object;
-      if (parent.type === "AssignmentPattern" && parent.right === childNode) {
-        isVariableDeclaration = false;
-        break;
-      }
-      i++;
-    }
-  }
-  var forIndex = parents.findIndex(x => x.type == "ForStatement");
-  var isForInitializer = forIndex != -1 && parents[forIndex].init == (parents[forIndex - 1] || object);
-  var isFunctionDeclaration = functionIndex != -1 && parents[functionIndex].type == "FunctionDeclaration" && parents[functionIndex].id == object;
-  var isNamedFunctionExpression = functionIndex != -1 && parents[functionIndex].type === "FunctionExpression" && parents[functionIndex].id === object;
-  var isAFunctionParameter = isFunctionParameter(object, parents);
-  var isClauseParameter = false;
-
-  // Special case for Catch clauses
-  var clauseIndex = parents.findIndex(x => x.type == "CatchClause");
-  if (clauseIndex != -1) {
-    if (parents[clauseIndex].param == (parents[clauseIndex - 1] || object)) {
-      isClauseParameter = true;
-    }
-  }
-  var isImportSpecifier = (parent.type == "ImportDefaultSpecifier" || parent.type == "ImportSpecifier") && parent.local == object;
-  var isFunctionCall = parent.callee == object; // NewExpression and CallExpression
-
-  var assignmentIndex = parents.findIndex(p => p.type === "AssignmentExpression");
-  var isAssignmentLeft = assignmentIndex !== -1 && parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object) && objectPatternCheck(object, parents);
-  var isAssignmentValue = assignmentIndex !== -1 && parents[assignmentIndex].right === (parents[assignmentIndex - 1] || object);
-  var isUpdateExpression = parent.type == "UpdateExpression";
-  var isClassDeclaration = (parent.type == "ClassDeclaration" || parent.type == "ClassExpression") && parent.id == object;
-  var isMethodDefinition = parent.type == "MethodDefinition" && parent.key == object && !parent.computed;
-  var isMetaProperty = parent.type == "MetaProperty";
-  var isLabel = parent.type == "LabeledStatement" && parent.label == object;
-
-  // Fix 1: Labels are properly identified
-  if (parent.type == "BreakStatement" || parent.type == "ContinueStatement") {
-    if (parent.label == object) {
-      isLabel = true;
-    }
-  }
-  var isDeleteExpression = false;
-  var deleteIndex = parents.findIndex(x => x.type == "UnaryExpression" && x.operator == "delete");
-  if (deleteIndex != -1) {
-    isDeleteExpression = true;
-  }
-  var isReferenced = !isAccessor && !isPropertyKey && !isMetaProperty && !isLabel && !object.name.startsWith("0") && !object.name.startsWith("'");
-  return {
-    /**
-     * MemberExpression: `parent.identifier`
-     */
-    isAccessor,
-    /**
-     * Property: `{identifier: ...}`
-     */
-    isPropertyKey,
-    /**
-     * `var identifier = ...`
-     */
-    isVariableDeclaration,
-    /**
-     * `function identifier(){...}`
-     */
-    isFunctionDeclaration,
-    /**
-     * `function a(identifier){...}`
-     */
-    isFunctionParameter: isAFunctionParameter,
-    /**
-     * ```js
-     * try ... catch ( identifier ) {
-     *  ...
-     * }
-     * ```
-     */
-    isClauseParameter,
-    /**
-     * CallExpression: `identifier()`
-     */
-    isFunctionCall,
-    /**
-     * AssignmentExpression: `identifier = ...`
-     */
-    isAssignmentLeft,
-    /**
-     * AssignmentExpression (right): `x = identifier`
-     */
-    isAssignmentValue,
-    /**
-     * UpdateExpression: `identifier++`
-     */
-    isUpdateExpression,
-    /**
-     * ClassDeclaration `class identifier {...}`
-     */
-    isClassDeclaration,
-    /**
-     * Method Definition inside a class body
-     * ```js
-     * class Rectangle {
-     *     identifier(){...}
-     *
-     *     get identifier(){...}
-     * }
-     * ```
-     */
-    isMethodDefinition,
-    /**
-     * `new.target` or `yield.input`
-     */
-    isMetaProperty,
-    /**
-     * LabelStatement: `identifier: for ( var i...)`
-     */
-    isLabel,
-    /**
-     * ```js
-     * for (var i=0; ...) {
-     *  ...
-     * }
-     * ```
-     */
-    isForInitializer,
-    /**
-     * ```js
-     * import identifier from "...";
-     * import {key as identifier} from "...";
-     * ```
-     */
-    isImportSpecifier,
-    /**
-     * ```js
-     * delete identifier[identifier]
-     * ```
-     */
-    isDeleteExpression: isDeleteExpression,
-    spec: {
-      /**
-       * - `export function identifier()...`
-       * - `export var identifier = ...`
-       */
-      isExported: isVariableDeclaration && parents[3] && parents[3].type == "ExportNamedDeclaration" || isFunctionDeclaration && parents[1] && parents[1].type == "ExportNamedDeclaration",
-      /**
-       * Is the Identifier defined, i.e a variable declaration, function declaration, parameter, or class definition
-       */
-      isDefined: isVariableDeclaration || isFunctionDeclaration || isNamedFunctionExpression || isAFunctionParameter || isClassDeclaration || isClauseParameter || isMethodDefinition || isImportSpecifier,
-      /**
-       * Is the Identifier modified, either by an `AssignmentExpression` or `UpdateExpression`
-       */
-      isModified: isAssignmentLeft || isUpdateExpression || isDeleteExpression,
-      /**
-       * Is the Identifier referenced as a variable.
-       *
-       * - true: `if ( identifier ) {...}`
-       * - false `if ( obj.identifier ) {...}`
-       * - false `identifier: for ( var ...)`
-       * - false `var {identifier: ...}`
-       * - false `break identifier;`
-       */
-      isReferenced: isReferenced
-    }
-  };
-}
-function getDefiningIdentifier(object, parents) {
-  (0, _assert.ok)(object.type == "Identifier", "must be identifier");
-  (0, _assert.ok)(typeof object.name === "string");
-  (0, _assert.ok)(parents[parents.length - 1].type == "Program", "root node must be type Program. Found '" + parents[parents.length - 1].type + "'");
-  var seen = new Set();
-  var i = 0;
-  for (var parent of parents) {
-    var l;
-    var bestScore = Infinity;
-    (0, _traverse.walk)(parent, parents.slice(i + 1), (o, p) => {
-      // if (p.find((x) => seen.has(x))) {
-      //   return "EXIT";
-      // }
-
-      if (o.type == "Identifier" && o.name === object.name && o !== object) {
-        var info = getIdentifierInfo(o, p);
-        if (info.spec.isDefined) {
-          var contexts = p.filter(x => (0, _insert.isVarContext)(x));
-          var definingContext = info.isFunctionDeclaration ? (0, _insert.getVarContext)(p[0], p.slice(1)) : (0, _insert.getVarContext)(o, p);
-          if (parents.includes(definingContext)) {
-            var index = contexts.indexOf(definingContext);
-            if (index < bestScore) {
-              l = [o, p];
-              bestScore = index;
-            }
-          }
-        }
-      }
-    });
-    if (l) {
-      // console.log(l[0].name, "->", l[0], bestScore);
-
-      return l;
-    }
-    seen.add(parent);
-    i++;
-  }
-}
-function isFunctionParameter(o, p, c) {
-  (0, _assert.ok)(o);
-  (0, _assert.ok)(p);
-  validateChain(o, p);
-  if (o.type !== "Identifier") {
-    return false;
-  }
-  var object = p.find(x => (0, _insert.isFunction)(x) && x.params);
-  if (!object) {
-    return false;
-  }
-  c = c || (0, _insert.getVarContext)(o, p);
-  if (c === object) {
-    var pIndex = p.indexOf(object.params);
-    if (pIndex == -1) {
-      return false;
-    }
-    var param = p[pIndex - 1] || o;
-    var paramIndex = object.params.indexOf(param);
-    (0, _assert.ok)(paramIndex !== -1);
-    var sliced = p.slice(0, pIndex);
-    var isReferenced = true;
-    var i = 0;
-    for (var node of sliced) {
-      var down = sliced[i - 1] || o;
-      (0, _assert.ok)(down);
-      if (node.type) {
-        if (node.type == "AssignmentPattern" && node.right === down) {
-          isReferenced = false;
-          break;
-        }
-        if (node.type == "Property" && node.key === down && sliced[i + 2] && sliced[i + 2].type == "ObjectPattern") {
-          isReferenced = false;
-          break;
-        }
-      }
-      i++;
-    }
-    if (isReferenced) {
-      return true;
-    }
-  }
-  return false;
-}
-function getFunctionParameters(object, parents) {
-  (0, _assert.ok)((0, _insert.isFunction)(object));
-  (0, _assert.ok)(object.params);
-  var locations = [];
-  (0, _traverse.walk)(object.params, [object, ...parents], (o, p) => {
-    if (o.type == "Identifier") {
-      if (isFunctionParameter(o, p, object)) {
-        locations.push([o, p]);
-      }
-    }
-  });
-  return locations;
-}
-function containsLexicallyBoundVariables(object, parents) {
-  var contains = false;
-  (0, _traverse.walk)(object, parents, (o, p) => {
-    if (o.type == "VariableDeclaration") {
-      if (o.kind === "let" || o.kind === "const") {
-        // Control Flow Flattening changes the lexical block, therefore this is not possible
-        // Maybe a transformation to remove let
-        contains = true;
-        return "EXIT";
-      }
-    }
-    if (o.type == "ClassDeclaration") {
-      contains = true;
-      return "EXIT";
-    }
-  });
-  return contains;
-}

package/dist/util/insert.js

@@ -1,362 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.append = append;
-exports.clone = clone;
-exports.computeFunctionLength = computeFunctionLength;
-exports.deleteDeclaration = deleteDeclaration;
-exports.deleteDirect = deleteDirect;
-exports.getAllDefiningContexts = getAllDefiningContexts;
-exports.getBlockBody = getBlockBody;
-exports.getContexts = getContexts;
-exports.getDefiningContext = getDefiningContext;
-exports.getFunction = getFunction;
-exports.getIndexDirect = getIndexDirect;
-exports.getLexContext = getLexContext;
-exports.getReferencingContexts = getReferencingContexts;
-exports.getVarContext = getVarContext;
-exports.isClass = isClass;
-exports.isContext = isContext;
-exports.isForInitialize = isForInitialize;
-exports.isFunction = isFunction;
-exports.isLexContext = isLexContext;
-exports.isStrictModeFunction = isStrictModeFunction;
-exports.isVarContext = isVarContext;
-exports.prepend = prepend;
-var _assert = require("assert");
-var _traverse = require("../traverse");
-var _identifiers = require("./identifiers");
-function isClass(object) {
-  return object.type === "ClassDeclaration" || object.type === "ClassExpression";
-}
-
-/**
- * - `FunctionDeclaration`
- * - `FunctionExpression`
- * - `ArrowFunctionExpression`
- * @param object
- * @returns
- */
-function isFunction(object) {
-  return ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(object && object.type);
-}
-function isStrictModeFunction(object) {
-  (0, _assert.ok)(isFunction(object));
-  return object.body.type === "BlockStatement" && object.body.body[0] && object.body.body[0].type === "ExpressionStatement" && object.body.body[0].directive === "use strict";
-}
-
-/**
- * The function context where the object is.
- *
- * - Determines if async context.
- * - Determines variable context.
- *
- * @param object
- * @param parents
- */
-function getFunction(object, parents) {
-  return parents.find(x => isFunction(x));
-}
-
-/**
- * Refers to the current function or Root node
- * @param parents
- */
-function getVarContext(object, parents) {
-  var fn = getFunction(object, parents);
-  if (fn) {
-    return fn;
-  }
-  var top = parents[parents.length - 1] || object;
-  if (top) {
-    (0, _assert.ok)(top.type == "Program", "Root node not program, its " + top.type);
-    return top;
-  }
-  throw new Error("Missing root node");
-}
-
-/**
- * `Function` or root node
- * @param object
- * @returns
- */
-function isVarContext(object) {
-  return isFunction(object) || object.type == "Program" || object.type == "DoExpression"; // Stage 1
-}
-
-/**
- * `Block` or root node
- * @param object
- * @returns
- */
-function isLexContext(object) {
-  return (0, _traverse.isBlock)(object) || object.type == "Program";
-}
-
-/**
- * Either a `var context` or `lex context`
- * @param object
- * @returns
- */
-function isContext(object) {
-  return isVarContext(object) || isLexContext(object);
-}
-function getContexts(object, parents) {
-  return [object, ...parents].filter(x => isContext(x));
-}
-
-/**
- * Refers to the current lexical block or Root node.
- * @param parents
- */
-function getLexContext(object, parents) {
-  var block = (0, _traverse.getBlock)(object, parents);
-  if (block) {
-    return block;
-  }
-  var top = parents[parents.length - 1];
-  if (!top) {
-    throw new Error("Missing root node");
-  }
-}
-function getDefiningContext(o, p) {
-  (0, _identifiers.validateChain)(o, p);
-  (0, _assert.ok)(o.type == "Identifier");
-  var info = (0, _identifiers.getIdentifierInfo)(o, p);
-  (0, _assert.ok)(info.spec.isDefined);
-  if (info.isVariableDeclaration) {
-    var variableDeclaration = p.find(x => x.type == "VariableDeclaration");
-    (0, _assert.ok)(variableDeclaration);
-    if (variableDeclaration.kind === "let" || variableDeclaration.kind === "const") {
-      var context = getVarContext(o, p);
-      if (context && context.type === "Program") {
-        return getLexContext(o, p);
-      }
-    }
-  }
-  if (info.isFunctionDeclaration) {
-    return getVarContext(p[0], p.slice(1));
-  }
-  return getVarContext(o, p);
-}
-
-/**
- * A more accurate context finding function.
- * @param o Object
- * @param p Parents
- * @returns Contexts
- */
-function getAllDefiningContexts(o, p) {
-  var contexts = [getDefiningContext(o, p)];
-  var info = (0, _identifiers.getIdentifierInfo)(o, p);
-  if (info.isFunctionParameter) {
-    // Get Function
-    var fn = getFunction(o, p);
-
-    // contexts.push(fn.body);
-  }
-  if (info.isClauseParameter) {
-    var catchClause = p.find(x => x.type === "CatchClause");
-    if (catchClause) {
-      return [catchClause];
-    }
-  }
-  return contexts;
-}
-function getReferencingContexts(o, p, info) {
-  (0, _identifiers.validateChain)(o, p);
-  (0, _assert.ok)(o.type == "Identifier");
-  if (!info) {
-    info = (0, _identifiers.getIdentifierInfo)(o, p);
-  }
-  (0, _assert.ok)(info.spec.isReferenced);
-  return [getVarContext(o, p), getLexContext(o, p)];
-}
-function getBlockBody(block) {
-  if (!block) {
-    throw new Error("no block body");
-  }
-  if (Array.isArray(block)) {
-    return block;
-  }
-  return getBlockBody(block.body);
-}
-function getIndexDirect(object, parent) {
-  return Object.keys(parent).find(x => parent[x] == object);
-}
-
-/**
- * Attempts to a delete a variable/functions declaration.
- * @param object
- * @param parents
- */
-function deleteDeclaration(object, parents) {
-  (0, _identifiers.validateChain)(object, parents);
-
-  // variables
-  var list = [object, ...parents];
-  var declaratorIndex = list.findIndex(x => x.type == "VariableDeclarator");
-  if (declaratorIndex != -1) {
-    var declarator = list[declaratorIndex]; // {type: VariableDeclarator, id: Identifier, init: Literal|Expression...}
-    var declarations = list[declaratorIndex + 1]; // declarator[]
-    var VariableDeclaration = list[declaratorIndex + 2];
-    var body = list[declaratorIndex + 3];
-    deleteDirect(declarator, declarations);
-    if (VariableDeclaration.declarations.length == 0) {
-      deleteDirect(VariableDeclaration, body);
-    }
-  } else {
-    if (object.type != "FunctionDeclaration") {
-      throw new Error("No method to delete: " + object.type);
-    }
-    deleteDirect(object, parents[0]);
-  }
-}
-
-/**
- * Object must be directly nested in parent
- */
-function deleteDirect(object, parent) {
-  if (!object) {
-    throw new Error("object undefined");
-  }
-  if (!parent) {
-    throw new Error("parent undefined");
-  }
-  (0, _identifiers.validateChain)(object, [parent]);
-  if (typeof parent === "object") {
-    if (Array.isArray(parent)) {
-      var index = parent.indexOf(object);
-      if (index != -1) {
-        // delete
-        parent.splice(index, 1);
-      } else {
-        console.log("parent=", parent);
-        console.log("object=", object);
-        throw new Error("index -1");
-      }
-    } else {
-      var keyName = Object.keys(parent).find(x => parent[x] == object);
-      if (keyName) {
-        delete parent[keyName];
-      } else {
-        throw new Error("keyName undefined");
-      }
-    }
-  }
-}
-function prepend(block) {
-  (0, _assert.ok)(!Array.isArray(block), "block should not be array");
-  for (var _len = arguments.length, nodes = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    nodes[_key - 1] = arguments[_key];
-  }
-  if (block.type == "Program") {
-    var moveBy = 0;
-    block.body.forEach((stmt, i) => {
-      if (stmt.type == "ImportDeclaration") {
-        if (moveBy == i) {
-          moveBy++;
-        }
-      }
-      if (stmt.type === "ExpressionStatement" && typeof stmt.directive === "string") {
-        if (moveBy == i) {
-          moveBy++;
-        }
-      }
-    });
-    block.body.splice(moveBy, 0, ...nodes);
-  } else if (block.type === "SwitchCase") {
-    block.consequent.unshift(...nodes);
-  } else {
-    var bodyArray = getBlockBody(block);
-
-    // Check for 'use strict'
-    if (bodyArray[0] && bodyArray[0].directive) {
-      // Insert under 'use strict' directive
-      bodyArray.splice(1, 0, ...nodes);
-    } else {
-      // Prepend at the top of the block
-      bodyArray.unshift(...nodes);
-    }
-  }
-}
-function append(block) {
-  (0, _assert.ok)(!Array.isArray(block), "block should not be array");
-  for (var _len2 = arguments.length, nodes = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-    nodes[_key2 - 1] = arguments[_key2];
-  }
-  getBlockBody(block).push(...nodes);
-}
-function clone(object) {
-  if (typeof object === "object" && object) {
-    if (Array.isArray(object)) {
-      var newArray = [];
-      object.forEach(element => {
-        newArray.push(clone(element));
-      });
-      return newArray;
-    } else {
-      var newObject = {};
-      Object.keys(object).forEach(key => {
-        if (!(key + "").startsWith("$")) {
-          newObject[key] = clone(object[key]);
-        }
-      });
-      return newObject;
-    }
-  }
-  return object;
-}
-
-/**
- * | Return Value | Description |
- * | --- | --- |
- * | `"initializer"` | For-statement initializer (`.init`) |
- * | `"left-hand"` | For-In/Of-statement left-hand (`.left`) |
- * | `false` | None of the above |
- *
- * Determines if given node is a for-loop initializer.
- *
- * @param o
- * @param p
- * @returns
- */
-function isForInitialize(o, p) {
-  (0, _identifiers.validateChain)(o, p);
-  var forIndex = p.findIndex(x => x.type == "ForStatement" || x.type == "ForInStatement" || x.type == "ForOfStatement");
-  if (p.slice(0, forIndex).find(x => ["ArrowFunctionExpression", "BlockStatement"].includes(x.type))) {
-    return false;
-  }
-  if (forIndex !== -1) {
-    if (p[forIndex].type == "ForStatement") {
-      if (p[forIndex].init == (p[forIndex - 1] || o)) {
-        return "initializer";
-      }
-    } else {
-      if (p[forIndex].left == (p[forIndex - 1] || o)) {
-        return "left-hand";
-      }
-    }
-  }
-  return false;
-}
-
-/**
- * Computes the `function.length` property given the parameter nodes.
- *
- * @param params
- * @returns
- */
-function computeFunctionLength(params) {
-  var count = 0;
-  for (var parameterNode of params) {
-    if (parameterNode.type === "Identifier" || parameterNode.type === "ObjectPattern" || parameterNode.type === "ArrayPattern") {
-      count++;
-    } else {
-      break;
-    }
-  }
-  return count;
-}