js-confuser 1.7.3 → 2.0.0-alpha.0

package/src/transforms/es5/antiDestructuring.ts

@@ -1,294 +0,0 @@
-import { ok } from "assert";
-import Template from "../../templates/template";
-import { getBlock, walk } from "../../traverse";
-import {
-  ArrayExpression,
-  ArrayPattern,
-  AssignmentExpression,
-  BinaryExpression,
-  BlockStatement,
-  CallExpression,
-  ConditionalExpression,
-  Identifier,
-  Literal,
-  MemberExpression,
-  Node,
-  ReturnStatement,
-  SequenceExpression,
-  ThisExpression,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import {
-  getBlockBody,
-  prepend,
-  clone,
-  getIndexDirect,
-} from "../../util/insert";
-import Transform from "../transform";
-
-/**
- * Removes destructuring from function parameters.
- *
- * ```
- * // input
- * function({property}){
- * }
- *
- * // output
- * function(){
- *  var [{property}] = arguments;
- * }
- *
- * // input
- * var fn = ({property})=>{};
- *
- * // output
- * var fn = (_)=>{
- *  var [{property}] = [_];
- * }
- * ```
- */
-class AntiDestructuringParameters extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object: Node, parents: Node[]) {
-    return (object.param || object.params) && object.body;
-  }
-
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      if (object.param) {
-        // Catch clause
-        if (object.param.type != "Identifier") {
-          var catchName = this.getPlaceholder();
-          var cloned = { ...object.param };
-
-          object.param = Identifier(catchName);
-
-          getBlockBody(object.body).unshift(
-            VariableDeclaration([
-              VariableDeclarator(cloned, Identifier(catchName)),
-            ])
-          );
-        }
-
-        return;
-      }
-
-      // For function parameters
-      var isDestructed = false;
-      var parameters = object.params;
-
-      walk(parameters, [object, ...parents], (o, p) => {
-        if (
-          o.type == "ArrayPattern" ||
-          o.type == "ObjectPattern" ||
-          o.type == "AssignmentPattern" ||
-          o.type == "RestElement"
-        ) {
-          isDestructed = true;
-          return "EXIT";
-        }
-      });
-
-      if (isDestructed) {
-        if (object.expression) {
-          object.body = BlockStatement([ReturnStatement({ ...object.body })]);
-        } else if (object.body.type != "BlockStatement") {
-          object.body = BlockStatement([{ ...object.body }]);
-        }
-
-        var arrayPattern = ArrayPattern(parameters);
-
-        // `arguments` is not allowed in arrow functions
-        if (
-          object.type == "ArrowFunctionExpression" &&
-          !object.params.find((x) => x.type == "RestElement")
-        ) {
-          // new names
-
-          object.params = Array(object.params.length)
-            .fill(0)
-            .map(() => Identifier(this.getPlaceholder()));
-
-          getBlockBody(object.body).unshift(
-            VariableDeclaration(
-              VariableDeclarator(arrayPattern, ArrayExpression(object.params))
-            )
-          );
-        } else {
-          object.params = [];
-
-          getBlockBody(object.body).unshift(
-            VariableDeclaration(
-              VariableDeclarator(
-                arrayPattern,
-                new Template(`Array.prototype.slice.call(arguments)`).single()
-                  .expression
-              )
-            )
-          );
-
-          if (object.type == "ArrowFunctionExpression") {
-            object.type = "FunctionExpression";
-            object.expression = false;
-
-            this.replace(
-              object,
-              CallExpression(
-                MemberExpression(clone(object), Identifier("bind"), false),
-                [ThisExpression()]
-              )
-            );
-          }
-        }
-      }
-    };
-  }
-}
-
-/**
- * Removes destructuring so the script can work in ES5 environments.
- */
-export default class AntiDestructuring extends Transform {
-  constructor(o) {
-    super(o);
-
-    this.before.push(new AntiDestructuringParameters(o));
-  }
-
-  match(object: Node, parents: Node[]) {
-    return (
-      object.type == "AssignmentExpression" ||
-      object.type == "VariableDeclarator"
-    );
-  }
-
-  transform(object: Node, parents: Node[]) {
-    var block = getBlock(object, parents);
-
-    var body = getBlockBody(block);
-
-    var temp = this.getPlaceholder();
-
-    var exprs = [];
-    var names: Set<string> = new Set();
-    var operator = "=";
-
-    var id = null; // The object being set
-    var extracting = null; // The object being extracted from
-    if (object.type == "AssignmentExpression") {
-      id = object.left;
-      extracting = object.right;
-      operator = object.operator;
-    } else if (object.type == "VariableDeclarator") {
-      id = object.id;
-      extracting = object.init;
-    } else {
-      ok(false);
-    }
-
-    var should = false;
-    walk(id, [], (o, p) => {
-      if (o.type && o.type.includes("Pattern")) {
-        should = true;
-      }
-    });
-
-    if (should) {
-      prepend(
-        block,
-        VariableDeclaration([VariableDeclarator(Identifier(temp))])
-      );
-
-      const recursive = (x: Node, realm: Node) => {
-        realm = clone(realm);
-
-        if (x.type == "Identifier") {
-          exprs.push(AssignmentExpression(operator, clone(x), realm));
-
-          names.add(x.name);
-        } else if (x.type == "MemberExpression") {
-          exprs.push(AssignmentExpression(operator, clone(x), realm));
-        } else if (x.type == "ObjectPattern") {
-          x.properties.forEach((property) => {
-            recursive(
-              property.value,
-              MemberExpression(realm, property.key, property.computed)
-            );
-          });
-        } else if (x.type == "ArrayPattern") {
-          x.elements.forEach((element, i) => {
-            if (element) {
-              if (element.type == "RestElement") {
-                if (i != x.elements.length - 1) {
-                  this.error(
-                    new Error(
-                      "Uncaught SyntaxError: Rest element must be last element"
-                    )
-                  );
-                }
-                recursive(
-                  element.argument,
-                  CallExpression(
-                    MemberExpression(realm, Identifier("slice"), false),
-                    [Literal(i)]
-                  )
-                );
-              } else {
-                recursive(element, MemberExpression(realm, Literal(i), true));
-              }
-            }
-          });
-        } else if (x.type == "AssignmentPattern") {
-          var condition = ConditionalExpression(
-            BinaryExpression("===", realm, Identifier("undefined")),
-            x.right,
-            realm
-          );
-          recursive(x.left, condition);
-        } else {
-          throw new Error("unknown type: " + x.type);
-        }
-      };
-
-      recursive(id, Identifier(temp));
-
-      return () => {
-        var seq = SequenceExpression([
-          AssignmentExpression(
-            "=",
-            Identifier(temp),
-            clone(extracting) || Identifier("undefined")
-          ),
-          ...exprs,
-        ]);
-
-        if (object.type == "VariableDeclarator") {
-          var i = getIndexDirect(object, parents[0]);
-
-          var extra = Array.from(names).map((x) => {
-            return {
-              type: "VariableDeclarator",
-              id: Identifier(x),
-              init: null,
-            };
-          });
-
-          extra.push({
-            type: "VariableDeclarator",
-            id: Identifier(this.getPlaceholder()),
-            init: seq,
-          });
-
-          parents[0].splice(i, 1, ...extra);
-        } else {
-          this.replace(object, seq);
-        }
-      };
-    }
-  }
-}

package/src/transforms/es5/antiES6Object.ts

@@ -1,267 +0,0 @@
-import Transform from "../transform";
-import {
-  Node,
-  Literal,
-  Identifier,
-  CallExpression,
-  ObjectExpression,
-  ArrayExpression,
-  Property,
-  MemberExpression,
-  SpreadElement,
-} from "../../util/gen";
-import { prepend } from "../../util/insert";
-import { getBlock } from "../../traverse";
-import Template from "../../templates/template";
-
-var HelperFunctions = new Template(
-  `
-  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-  `
-);
-
-class AntiSpread extends Transform {
-  helper: boolean;
-
-  constructor(o) {
-    super(o);
-
-    this.helper = false;
-  }
-
-  match(object: Node, parents: Node[]) {
-    return (
-      object.type == "ObjectExpression" || object.type == "ArrayExpression"
-    );
-  }
-
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      if (object.type == "ArrayExpression") {
-        var spreadIndex = object.elements.findIndex(
-          (x) => x.type == "SpreadElement"
-        );
-        if (spreadIndex !== -1) {
-          var after = object.elements.slice(spreadIndex);
-          var groups = [];
-
-          after.forEach((element) => {
-            if (element.type === "SpreadElement") {
-              groups.push(element.argument);
-            } else {
-              if (!groups.length) {
-                groups.push(ArrayExpression([]));
-              }
-              if (groups[groups.length - 1].type != "ArrayExpression") {
-                groups.push(ArrayExpression([]));
-              }
-              groups[groups.length - 1].elements.push(element);
-            }
-          });
-
-          this.replace(
-            object,
-            CallExpression(
-              MemberExpression(
-                ArrayExpression(object.elements.slice(0, spreadIndex)),
-                Identifier("concat"),
-                false
-              ),
-              groups.map((group) => {
-                // [].concat(arguments) -> [].concat(Array.prototype.slice.call(arguments))
-                return CallExpression(
-                  MemberExpression(
-                    MemberExpression(
-                      MemberExpression(
-                        Identifier("Array"),
-                        Identifier("prototype"),
-                        false
-                      ),
-                      Identifier("slice"),
-                      false
-                    ),
-                    Identifier("call"),
-                    false
-                  ),
-                  [group]
-                );
-              })
-            )
-          );
-        }
-      } else if (object.type == "ObjectExpression") {
-        var spreadIndex;
-        while (true) {
-          spreadIndex = object.properties.findIndex(
-            (x) => x.type == "SpreadElement"
-          );
-          if (spreadIndex === -1) {
-            break;
-          }
-
-          // add helper functions only once
-          if (!this.helper) {
-            this.helper = true;
-            prepend(parents[parents.length - 1], ...HelperFunctions.compile());
-          }
-
-          var before = object.properties.slice(0, spreadIndex);
-          var after = object.properties.slice(spreadIndex + 1);
-
-          var call = CallExpression(Identifier("_objectSpread"), [
-            ObjectExpression(before),
-            object.properties[spreadIndex].argument,
-          ]);
-
-          if (after.length) {
-            var newObject = ObjectExpression(after);
-            this.replace(
-              object,
-              CallExpression(Identifier("_objectSpread"), [call, newObject])
-            );
-
-            object = newObject;
-          } else {
-            this.replace(object, call);
-            break;
-          }
-        }
-      }
-    };
-  }
-}
-
-export default class AntiES6Object extends Transform {
-  makerFn: string;
-
-  constructor(o) {
-    super(o);
-
-    this.makerFn = null;
-
-    this.after.push(new AntiSpread(o));
-  }
-
-  match(object: Node, parents: Node[]) {
-    return object.type == "ObjectExpression";
-  }
-
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      var block = getBlock(object, parents);
-      var needsChanging = false;
-
-      object.properties.forEach((property) => {
-        if (property.type == "SpreadElement") {
-          needsChanging = true;
-          return;
-        }
-
-        // AntiShorthand
-        object.shorthand = false;
-
-        if (!property.key) {
-          this.error(new Error("Property missing key"));
-        }
-
-        if (!["Literal", "Identifier"].includes(property.key.type)) {
-          property.computed = true;
-        }
-
-        if (property.computed && property.key.type == "Literal") {
-          property.computed = false;
-        }
-
-        if (property.kind != "init" || property.method || property.computed) {
-          needsChanging = true;
-        }
-      });
-
-      if (needsChanging) {
-        if (!this.makerFn) {
-          this.makerFn = this.getPlaceholder();
-
-          prepend(
-            parents[parents.length - 1] || block,
-            new Template(`
-            function {name}(base, computedProps, getters, setters){
-
-              for ( var i = 0; i < computedProps.length; i++ ) {
-                base[computedProps[i][0]] = computedProps[i][1];
-              }
-
-              var keys=Object.create(null);
-              Object.keys(getters).forEach(key=>(keys[key] = 1))
-              Object.keys(setters).forEach(key=>(keys[key] = 1))
-
-              Object.keys(keys).forEach(key=>{
-                Object.defineProperty(base, key, {
-                  set: setters[key],
-                  get: getters[key],
-                  configurable: true
-                });
-              })
-              return base; 
-            }
-          `).single({ name: this.makerFn })
-          );
-        }
-
-        // {a: 1} Es5 compliant properties
-        var baseProps = [];
-        // {[a]: 1} -> Computed props to array [a, 1]
-        var computedProps = [];
-        // {get a(){}} -> Property descriptors
-        var getters = ObjectExpression([]);
-        var setters = ObjectExpression([]);
-
-        object.properties.forEach((prop) => {
-          var key = prop.key;
-          if (!key) {
-            return;
-          }
-
-          if (key.type == "Identifier" && !prop.computed) {
-            key = Literal(key.name);
-          }
-
-          if (prop.computed) {
-            var array = [prop.key, prop.value];
-
-            computedProps.push(ArrayExpression(array));
-          } else if (prop.kind == "get" || prop.kind == "set") {
-            if (prop.kind == "get") {
-              getters.properties.push(Property(key, prop.value));
-            } else {
-              setters.properties.push(Property(key, prop.value));
-            }
-          } else {
-            prop.method = false;
-
-            baseProps.push(prop);
-          }
-        });
-
-        if (
-          setters.properties.length ||
-          getters.properties.length ||
-          computedProps.length
-        ) {
-          this.objectAssign(
-            object,
-            CallExpression(Identifier(this.makerFn), [
-              ObjectExpression(baseProps),
-              ArrayExpression(computedProps),
-              getters,
-              setters,
-            ])
-          );
-        }
-      }
-    };
-  }
-}

package/src/transforms/es5/antiSpreadOperator.ts

@@ -1,56 +0,0 @@
-import {
-  ArrayExpression,
-  AssignmentExpression,
-  CallExpression,
-  Identifier,
-  MemberExpression,
-  Node,
-  ThisExpression,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import { prepend } from "../../util/insert";
-import Transform from "../transform";
-
-// fn(...args) -> fn.apply(this, [...args])
-export default class AntiSpreadOperator extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return (
-      object.type == "CallExpression" &&
-      object.arguments.find((x) => x.type == "SpreadElement")
-    );
-  }
-
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      var ref;
-
-      if (object.callee.type == "MemberExpression") {
-        ref = this.getPlaceholder();
-
-        object.callee.object = AssignmentExpression("=", Identifier(ref), {
-          ...object.callee.object,
-        });
-        prepend(
-          parents[parents.length - 1],
-          VariableDeclaration(VariableDeclarator(ref))
-        );
-      }
-
-      this.replace(
-        object,
-        CallExpression(
-          MemberExpression({ ...object.callee }, Identifier("apply"), false),
-          [
-            ref ? Identifier(ref) : ThisExpression(),
-            ArrayExpression(object.arguments),
-          ]
-        )
-      );
-    };
-  }
-}

package/src/transforms/es5/antiTemplate.ts

@@ -1,98 +0,0 @@
-import Template from "../../templates/template";
-import {
-  ArrayExpression,
-  BinaryExpression,
-  CallExpression,
-  Identifier,
-  Literal,
-} from "../../util/gen";
-import { prepend } from "../../util/insert";
-import Transform from "../transform";
-
-export default class AntiTemplate extends Transform {
-  makerFn: string;
-
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return (
-      object.type == "TemplateLiteral" ||
-      object.type == "TaggedTemplateExpression"
-    );
-  }
-
-  transform(object, parents) {
-    return () => {
-      if (object.type == "TemplateLiteral") {
-        if (
-          parents[0].type == "TaggedTemplateExpression" &&
-          parents[0].quasi == object
-        ) {
-          return;
-        }
-
-        if (object.quasis.length == 1 && object.expressions.length == 0) {
-          this.replace(object, Literal(object.quasis[0].value.cooked));
-        } else {
-          var binaryExpression = null;
-
-          object.quasis.forEach((q, i) => {
-            var expr = object.expressions[i];
-            var str = Literal(q.value.cooked);
-
-            if (!binaryExpression) {
-              binaryExpression = BinaryExpression("+", str, expr);
-            } else {
-              if (expr) {
-                binaryExpression.right = BinaryExpression(
-                  "+",
-                  binaryExpression.right,
-                  BinaryExpression("+", str, expr)
-                );
-              } else {
-                binaryExpression.right = BinaryExpression(
-                  "+",
-                  binaryExpression.right,
-                  str
-                );
-              }
-            }
-          });
-
-          this.replace(object, binaryExpression);
-        }
-      } else if (object.type == "TaggedTemplateExpression") {
-        var literal = object.quasi;
-
-        if (!this.makerFn) {
-          this.makerFn = "es6_template" + this.getPlaceholder();
-
-          prepend(
-            parents[parents.length - 1],
-            new Template(`
-          function {name}(arr, raw){
-            arr.raw = raw;
-            return arr;
-          }
-          `).single({ name: this.makerFn })
-          );
-        }
-
-        this.replace(
-          object,
-          CallExpression(object.tag, [
-            CallExpression(Identifier(this.makerFn), [
-              ArrayExpression(
-                literal.quasis.map((x) => Literal(x.value.cooked))
-              ),
-              ArrayExpression(literal.quasis.map((x) => Literal(x.value.raw))),
-            ]),
-            ...literal.expressions,
-          ])
-        );
-      }
-    };
-  }
-}