js-confuser 1.7.3 → 2.0.0-alpha.0

package/src/util/insert.ts

@@ -1,419 +0,0 @@
-import { ok } from "assert";
-import { getBlock, isBlock } from "../traverse";
-import { Node } from "./gen";
-import { getIdentifierInfo, validateChain } from "./identifiers";
-
-export function isClass(object: Node): boolean {
-  return (
-    object.type === "ClassDeclaration" || object.type === "ClassExpression"
-  );
-}
-
-/**
- * - `FunctionDeclaration`
- * - `FunctionExpression`
- * - `ArrowFunctionExpression`
- * @param object
- * @returns
- */
-export function isFunction(object: Node): boolean {
-  return [
-    "FunctionDeclaration",
-    "FunctionExpression",
-    "ArrowFunctionExpression",
-  ].includes(object && object.type);
-}
-
-export function isStrictModeFunction(object: Node): boolean {
-  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
- */
-export function getFunction(object: Node, parents: Node[]): Node {
-  return parents.find((x) => isFunction(x));
-}
-
-/**
- * Refers to the current function or Root node
- * @param parents
- */
-export function getVarContext(object: Node, parents: Node[]): Node {
-  var fn = getFunction(object, parents);
-  if (fn) {
-    return fn;
-  }
-
-  var top = parents[parents.length - 1] || object;
-
-  if (top) {
-    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
- */
-export function isVarContext(object: Node) {
-  return (
-    isFunction(object) ||
-    object.type == "Program" ||
-    object.type == "DoExpression"
-  ); // Stage 1
-}
-
-/**
- * `Block` or root node
- * @param object
- * @returns
- */
-export function isLexContext(object: Node): boolean {
-  return isBlock(object) || object.type == "Program";
-}
-
-/**
- * Either a `var context` or `lex context`
- * @param object
- * @returns
- */
-export function isContext(object: Node): boolean {
-  return isVarContext(object) || isLexContext(object);
-}
-
-export function getContexts(object: Node, parents: Node[]): Node[] {
-  return [object, ...parents].filter((x) => isContext(x));
-}
-
-/**
- * Refers to the current lexical block or Root node.
- * @param parents
- */
-export function getLexContext(object: Node, parents: Node[]): Node {
-  var block = getBlock(object, parents);
-  if (block) {
-    return block;
-  }
-
-  var top = parents[parents.length - 1];
-  if (!top) {
-    throw new Error("Missing root node");
-  }
-}
-
-export function getDefiningContext(o: Node, p: Node[]): Node {
-  validateChain(o, p);
-  ok(o.type == "Identifier");
-  var info = getIdentifierInfo(o, p);
-
-  ok(info.spec.isDefined);
-
-  if (info.isVariableDeclaration) {
-    var variableDeclaration = p.find((x) => x.type == "VariableDeclaration");
-    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
- */
-export function getAllDefiningContexts(o: Node, p: Node[]): Node[] {
-  var contexts = [getDefiningContext(o, p)];
-
-  var info = 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;
-}
-
-export function getReferencingContexts(
-  o: Node,
-  p: Node[],
-  info?: ReturnType<typeof getIdentifierInfo>
-): Node[] {
-  validateChain(o, p);
-  ok(o.type == "Identifier");
-
-  if (!info) {
-    info = getIdentifierInfo(o, p);
-  }
-  ok(info.spec.isReferenced);
-
-  return [getVarContext(o, p), getLexContext(o, p)];
-}
-
-export function getBlockBody(block: Node): Node[] {
-  if (!block) {
-    throw new Error("no block body");
-  }
-  if (Array.isArray(block)) {
-    return block;
-  }
-  return getBlockBody(block.body);
-}
-
-export function getIndexDirect(object: Node, parent: Node): string {
-  return Object.keys(parent).find((x) => parent[x] == object);
-}
-
-/**
- * Attempts to a delete a variable/functions declaration.
- * @param object
- * @param parents
- */
-export function deleteDeclaration(object: Node, parents: Node[]) {
-  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
- */
-export function deleteDirect(object: Node, parent: Node) {
-  if (!object) {
-    throw new Error("object undefined");
-  }
-
-  if (!parent) {
-    throw new Error("parent undefined");
-  }
-
-  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");
-      }
-    }
-  }
-}
-
-export function prepend(block: Node, ...nodes: Node[]) {
-  ok(!Array.isArray(block), "block should not be array");
-
-  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);
-    }
-  }
-}
-
-export function append(block: Node, ...nodes: Node[]) {
-  ok(!Array.isArray(block), "block should not be array");
-  getBlockBody(block).push(...nodes);
-}
-
-export function clone<T>(object: T): T {
-  if (typeof object === "object" && object) {
-    if (Array.isArray(object)) {
-      var newArray = [] as unknown as any;
-      object.forEach((element) => {
-        newArray.push(clone(element));
-      });
-
-      return newArray;
-    } else {
-      var newObject = {} as T;
-
-      Object.keys(object).forEach((key) => {
-        if (!(key + "").startsWith("$")) {
-          newObject[key] = clone(object[key]);
-        }
-      });
-
-      return newObject;
-    }
-  }
-
-  return object as any;
-}
-
-/**
- * | 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
- */
-export function isForInitialize(
-  o: Node,
-  p: Node[]
-): "initializer" | "left-hand" | false {
-  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
- */
-export function computeFunctionLength(params: Node[]): number {
-  var count = 0;
-
-  for (var parameterNode of params) {
-    if (
-      parameterNode.type === "Identifier" ||
-      parameterNode.type === "ObjectPattern" ||
-      parameterNode.type === "ArrayPattern"
-    ) {
-      count++;
-    } else {
-      break;
-    }
-  }
-
-  return count;
-}

package/src/util/math.ts

@@ -1,15 +0,0 @@
-export function getFactors(num: number) {
-  const isEven = num % 2 === 0;
-  const max = Math.sqrt(num);
-  const inc = isEven ? 1 : 2;
-  let factors = [1, num];
-
-  for (let curFactor = isEven ? 2 : 3; curFactor <= max; curFactor += inc) {
-    if (num % curFactor !== 0) continue;
-    factors.push(curFactor);
-    let compliment = num / curFactor;
-    if (compliment !== curFactor) factors.push(compliment);
-  }
-
-  return factors;
-}

package/src/util/object.ts

@@ -1,39 +0,0 @@
-export function createObject(
-  keys: string[],
-  values: any[]
-): { [key: string]: any } {
-  if (keys.length != values.length) {
-    throw new Error("length mismatch");
-  }
-
-  var newObject = {};
-
-  keys.forEach((x, i) => {
-    newObject[x] = values[i];
-  });
-
-  return newObject;
-}
-
-/**
- * Removes all `$`-prefixed properties on a deeply nested object.
- *
- * - Modifies the object.
- */
-export function remove$Properties(object: any, seen = new Set<Node>()) {
-  if (typeof object === "object" && object) {
-    if (seen.has(object)) {
-      // console.log(object);
-      // throw new Error("Already seen");
-    }
-    seen.add(object);
-
-    Object.keys(object).forEach((key) => {
-      if (key.charAt(0) == "$") {
-        delete object[key];
-      } else {
-        remove$Properties(object[key], seen);
-      }
-    });
-  }
-}

package/src/util/random.ts

@@ -1,221 +0,0 @@
-import { ok } from "assert";
-import {
-  Literal,
-  ObjectExpression,
-  Identifier,
-  Property,
-  Node,
-  ArrayExpression,
-} from "./gen";
-
-/**
- * Returns a random element from the given array
- * @param choices Array of items
- * @returns One of the items in the array at random
- */
-export function choice<T>(choices: T[]): T {
-  var index = Math.floor(Math.random() * choices.length);
-  return choices[index];
-}
-
-/**
- * Returns a true/false based on the percent chance (0%-100%)
- * @param percentChance AS A PERCENTAGE 0 - 100%
- */
-export function chance(percentChance: number): boolean {
-  return Math.random() < percentChance / 100;
-}
-
-/**
- * **Mutates the given array**
- * @param array
- */
-export function shuffle(array: any[]): any[] {
-  array.sort(() => Math.random() - 0.5);
-  return array;
-}
-
-/**
- * Returns a random string.
- */
-export function getRandomString(length: number) {
-  var result = "";
-  var characters =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  var charactersLength = characters.length;
-  for (var i = 0; i < length; i++) {
-    result += characters.charAt(Math.floor(Math.random() * charactersLength));
-  }
-  return result;
-}
-
-export function getRandom(min, max) {
-  return Math.random() * (max - min) + min;
-}
-
-export function getRandomInteger(min, max) {
-  return Math.floor(getRandom(min, max));
-}
-
-export function splitIntoChunks(str: string, size: number) {
-  ok(typeof str === "string", "str must be typeof string");
-  ok(typeof size === "number", "size must be typeof number");
-  ok(Math.floor(size) === size, "size must be integer");
-
-  const numChunks = Math.ceil(str.length / size);
-  const chunks: string[] = new Array(numChunks);
-
-  for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
-    chunks[i] = str.substr(o, size);
-  }
-
-  return chunks;
-}
-
-/**
- * Returns a random expression that will test to `false`.
- */
-export function getRandomFalseExpression() {
-  var type = choice(["0", "false", "null", "undefined", "NaN", "emptyString"]);
-
-  switch (type) {
-    case "0":
-      return Literal(0);
-    case "false":
-      return Literal(false);
-    case "null":
-      return Identifier("null");
-    case "undefined":
-      return Identifier("undefined");
-    case "NaN":
-      return Identifier("NaN");
-    default:
-      // case "emptyString":
-      return Literal("");
-  }
-}
-
-/**
- * Returns a random expression that will test to `true`
- */
-export function getRandomTrueExpression() {
-  var type = choice([
-    "number",
-    "true",
-    "Infinity",
-    "nonEmptyString",
-    "array",
-    "object",
-  ]);
-
-  switch (type) {
-    case "number":
-      return Literal(getRandomInteger(1, 100));
-    case "true":
-      return Identifier("true");
-    case "Infinity":
-      return Identifier("Infinity");
-    case "nonEmptyString":
-      return Literal(getRandomString(getRandomInteger(3, 9)));
-    case "array":
-      return ArrayExpression([]);
-    default:
-      //case "object":
-      return ObjectExpression([]);
-  }
-}
-
-export function alphabeticalGenerator(index: number) {
-  let name = "";
-  while (index > 0) {
-    var t = (index - 1) % 52;
-    var thisChar =
-      t >= 26 ? String.fromCharCode(65 + t - 26) : String.fromCharCode(97 + t);
-    name = thisChar + name;
-    index = ((index - t) / 52) | 0;
-  }
-  if (!name) {
-    name = "_";
-  }
-  return name;
-}
-
-export function createZeroWidthGenerator() {
-  var keywords = [
-    "if",
-    "in",
-    "for",
-    "let",
-    "new",
-    "try",
-    "var",
-    "case",
-    "else",
-    "null",
-    "break",
-    "catch",
-    "class",
-    "const",
-    "super",
-    "throw",
-    "while",
-    "yield",
-    "delete",
-    "export",
-    "import",
-    "public",
-    "return",
-    "switch",
-    "default",
-    "finally",
-    "private",
-    "continue",
-    "debugger",
-    "function",
-    "arguments",
-    "protected",
-    "instanceof",
-    "await",
-    "async",
-
-    // new key words and other fun stuff :P
-    "NaN",
-    "undefined",
-    "true",
-    "false",
-    "typeof",
-    "this",
-    "static",
-    "void",
-    "of",
-  ];
-
-  var maxSize = 0;
-  var currentKeyWordsArray: string[] = [];
-
-  function generateArray() {
-    var result = keywords
-      .map(
-        (keyWord) =>
-          keyWord + "\u200C".repeat(Math.max(maxSize - keyWord.length, 1))
-      )
-      .filter((craftedVariableName) => craftedVariableName.length == maxSize);
-
-    if (!result.length) {
-      ++maxSize;
-      return generateArray();
-    }
-
-    return shuffle(result);
-  }
-
-  function getNextVariable(): string {
-    if (!currentKeyWordsArray.length) {
-      ++maxSize;
-      currentKeyWordsArray = generateArray();
-    }
-    return currentKeyWordsArray.pop();
-  }
-
-  return { generate: getNextVariable };
-}

package/src/util/scope.ts

@@ -1,21 +0,0 @@
-import { ok } from "assert";
-import { isBlock } from "../traverse";
-import { Node } from "./gen";
-
-export function isLexicalScope(object: Node) {
-  return isBlock(object) || object.type == "SwitchCase";
-}
-
-export function getLexicalScope(object: Node, parents: Node[]): Node {
-  return [object, ...parents].find((node) => isLexicalScope(node));
-}
-
-export function getLexicalScopeBody(object: Node): Node[] {
-  ok(isLexicalScope(object));
-
-  return isBlock(object)
-    ? object.body
-    : object.type === "SwitchCase"
-    ? object.consequent
-    : ok("Unhandled case");
-}