add some packages

node_modules/babel-helper-evaluate-path/README.md

@@ -0,0 +1,35 @@
+# babel-helper-evaluate-path
+
+A wrapper for babel's `path.evaluate`
+
+Fixes / Features:
+
++ Detect usages before initialization / declaration
+
+```js
+function foo() {
+  console.log(b); // ReferenceError
+  let b = 1;
+}
+
+function bar() {
+  console.log(a); // a is void 0
+  var a = 5;
+  console.log(a); // 5
+}
+```
+
++ Detect usages in scopes outside of initialization for vars (hoisted)
+
+```js
+function foo() {
+  if (a) var x = 5;
+  console.log(x); // cannot determine
+}
+```
+
+## Installation
+
+```sh
+npm install babel-helper-evaluate-path
+```

node_modules/babel-helper-evaluate-path/lib/index.js

@@ -0,0 +1,283 @@
+"use strict";
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+module.exports = function evaluate(path, {
+  tdz = false
+} = {}) {
+  if (!tdz) {
+    return baseEvaluate(path);
+  }
+
+  if (path.isReferencedIdentifier()) {
+    return evaluateIdentifier(path);
+  }
+
+  const state = {
+    confident: true
+  }; // prepare
+
+  path.traverse({
+    Scope(scopePath) {
+      scopePath.skip();
+    },
+
+    ReferencedIdentifier(idPath) {
+      const binding = idPath.scope.getBinding(idPath.node.name); // don't deopt globals
+      // let babel take care of it
+
+      if (!binding) return;
+      const evalResult = evaluateIdentifier(idPath);
+
+      if (!evalResult.confident) {
+        state.confident = evalResult.confident;
+        state.deoptPath = evalResult.deoptPath;
+      }
+    }
+
+  });
+
+  if (!state.confident) {
+    return state;
+  }
+
+  return baseEvaluate(path);
+};
+
+function baseEvaluate(path) {
+  try {
+    return path.evaluate();
+  } catch (e) {
+    return {
+      confident: false,
+      error: e
+    };
+  }
+} // Original Source:
+// https://github.com/babel/babel/blob/master/packages/babel-traverse/src/path/evaluation.js
+// modified for Babel-minify use
+
+
+function evaluateIdentifier(path) {
+  if (!path.isReferencedIdentifier()) {
+    throw new Error(`Expected ReferencedIdentifier. Got ${path.type}`);
+  }
+
+  const node = path.node;
+  const binding = path.scope.getBinding(node.name);
+
+  if (!binding) {
+    return deopt(path);
+  }
+
+  if (binding.constantViolations.length > 0) {
+    return deopt(binding.path);
+  } // referenced in a different scope - deopt
+
+
+  if (shouldDeoptBasedOnScope(binding, path)) {
+    return deopt(path);
+  } // let/var/const referenced before init
+  // or "var" referenced in an outer scope
+
+
+  const flowEvalResult = evaluateBasedOnControlFlow(binding, path);
+
+  if (flowEvalResult.confident) {
+    return flowEvalResult;
+  }
+
+  if (flowEvalResult.shouldDeopt) {
+    return deopt(path);
+  }
+
+  return path.evaluate();
+} // check if referenced in a different fn scope
+// we can't determine if this function is called sync or async
+// if the binding is in program scope
+// all it's references inside a different function should be deopted
+
+
+function shouldDeoptBasedOnScope(binding, refPath) {
+  if (binding.scope.path.isProgram() && refPath.scope !== binding.scope) {
+    return true;
+  }
+
+  return false;
+}
+
+function evaluateBasedOnControlFlow(binding, refPath) {
+  if (binding.kind === "var") {
+    // early-exit
+    const declaration = binding.path.parentPath;
+
+    if (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase()) {
+      return {
+        shouldDeopt: true
+      };
+    }
+
+    let blockParent = binding.path.scope.getBlockParent().path;
+    const fnParent = binding.path.getFunctionParent();
+
+    if (blockParent === fnParent) {
+      if (!fnParent.isProgram()) blockParent = blockParent.get("body");
+    } // detect Usage Outside Init Scope
+
+
+    if (!blockParent.get("body").some(stmt => stmt.isAncestor(refPath))) {
+      return {
+        shouldDeopt: true
+      };
+    } // Detect usage before init
+
+
+    const stmts = fnParent.isProgram() ? fnParent.get("body") : fnParent.get("body").get("body");
+    const compareResult = compareBindingAndReference({
+      binding,
+      refPath,
+      stmts
+    });
+
+    if (compareResult.reference && compareResult.binding) {
+      if (compareResult.reference.scope === "current" && compareResult.reference.idx < compareResult.binding.idx) {
+        return {
+          confident: true,
+          value: void 0
+        };
+      }
+
+      return {
+        shouldDeopt: true
+      };
+    }
+  } else if (binding.kind === "let" || binding.kind === "const") {
+    // binding.path is the declarator
+    const declarator = binding.path;
+    const declaration = declarator.parentPath;
+
+    if (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase()) {
+      return {
+        shouldDeopt: true
+      };
+    }
+
+    let scopePath = declarator.scope.path;
+
+    if (scopePath.isFunction() || scopePath.isCatchClause()) {
+      scopePath = scopePath.get("body");
+    } // Detect Usage before Init
+
+
+    const stmts = scopePath.get("body");
+    const compareResult = compareBindingAndReference({
+      binding,
+      refPath,
+      stmts
+    });
+
+    if (compareResult.reference && compareResult.binding) {
+      if (compareResult.reference.scope === "current" && compareResult.reference.idx < compareResult.binding.idx) {
+        throw new Error(`ReferenceError: Used ${refPath.node.name}: ` + `${binding.kind} binding before declaration`);
+      }
+
+      if (compareResult.reference.scope === "other") {
+        return {
+          shouldDeopt: true
+        };
+      }
+    }
+  }
+
+  return {
+    confident: false,
+    shouldDeopt: false
+  };
+}
+
+function compareBindingAndReference({
+  binding,
+  refPath,
+  stmts
+}) {
+  const state = {
+    binding: null,
+    reference: null
+  };
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = stmts.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      const _step$value = _slicedToArray(_step.value, 2),
+            idx = _step$value[0],
+            stmt = _step$value[1];
+
+      if (stmt.isAncestor(binding.path)) {
+        state.binding = {
+          idx
+        };
+      }
+
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = binding.referencePaths[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          const ref = _step2.value;
+
+          if (ref === refPath && stmt.isAncestor(ref)) {
+            state.reference = {
+              idx,
+              scope: binding.path.scope === ref.scope ? "current" : "other"
+            };
+            break;
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  return state;
+}
+
+function deopt(deoptPath) {
+  return {
+    confident: false,
+    deoptPath
+  };
+}

node_modules/babel-helper-evaluate-path/package.json

@@ -0,0 +1,50 @@
+{
+  "_from": "babel-helper-evaluate-path@^0.4.1",
+  "_id": "babel-helper-evaluate-path@0.4.1",
+  "_inBundle": false,
+  "_integrity": "sha1-a3XB4OMPFmKfKoZFyjBeGo01iaY=",
+  "_location": "/babel-helper-evaluate-path",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "babel-helper-evaluate-path@^0.4.1",
+    "name": "babel-helper-evaluate-path",
+    "escapedName": "babel-helper-evaluate-path",
+    "rawSpec": "^0.4.1",
+    "saveSpec": null,
+    "fetchSpec": "^0.4.1"
+  },
+  "_requiredBy": [
+    "/babel-plugin-minify-builtins",
+    "/babel-plugin-minify-constant-folding",
+    "/babel-plugin-minify-dead-code-elimination",
+    "/babel-plugin-transform-remove-undefined"
+  ],
+  "_resolved": "https://registry.npmjs.org/babel-helper-evaluate-path/-/babel-helper-evaluate-path-0.4.1.tgz",
+  "_shasum": "6b75c1e0e30f16629f2a8645ca305e1a8d3589a6",
+  "_spec": "babel-helper-evaluate-path@^0.4.1",
+  "_where": "/home/s2/Documents/Code/minifyfromhtml/node_modules/babel-plugin-minify-builtins",
+  "author": {
+    "name": "boopathi"
+  },
+  "bugs": {
+    "url": "https://github.com/babel/minify/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "path.evaluate wrapped in a try catch",
+  "homepage": "https://github.com/babel/minify#readme",
+  "keywords": [
+    "babel-minify",
+    "babel-plugin"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "babel-helper-evaluate-path",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/minify/tree/master/packages/babel-helper-evaluate-path"
+  },
+  "version": "0.4.1"
+}