condenser 0.2 → 0.3

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/index.js

@@ -1,59 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _options = require("../options");
-
-var _statement = _interopRequireDefault(require("./statement"));
-
-var _scopeflags = require("../util/scopeflags");
-
-var _scope = _interopRequireDefault(require("../util/scope"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class Parser extends _statement.default {
-  constructor(options, input) {
-    options = (0, _options.getOptions)(options);
-    super(options, input);
-    const ScopeHandler = this.getScopeHandler();
-    this.options = options;
-    this.inModule = this.options.sourceType === "module";
-    this.scope = new ScopeHandler(this.raise.bind(this), this.inModule);
-    this.plugins = pluginsMap(this.options.plugins);
-    this.filename = options.sourceFilename;
-  }
-
-  getScopeHandler() {
-    return _scope.default;
-  }
-
-  parse() {
-    this.scope.enter(_scopeflags.SCOPE_PROGRAM);
-    const file = this.startNode();
-    const program = this.startNode();
-    this.nextToken();
-    file.errors = null;
-    this.parseTopLevel(file, program);
-    file.errors = this.state.errors;
-    return file;
-  }
-
-}
-
-exports.default = Parser;
-
-function pluginsMap(plugins) {
-  const pluginMap = new Map();
-
-  for (let _i = 0; _i < plugins.length; _i++) {
-    const plugin = plugins[_i];
-    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
-    if (!pluginMap.has(name)) pluginMap.set(name, options || {});
-  }
-
-  return pluginMap;
-}

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/location.js

@@ -1,49 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _location = require("../util/location");
-
-var _comments = _interopRequireDefault(require("./comments"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class LocationParser extends _comments.default {
-  getLocationForPosition(pos) {
-    let loc;
-    if (pos === this.state.start) loc = this.state.startLoc;else if (pos === this.state.lastTokStart) loc = this.state.lastTokStartLoc;else if (pos === this.state.end) loc = this.state.endLoc;else if (pos === this.state.lastTokEnd) loc = this.state.lastTokEndLoc;else loc = (0, _location.getLineInfo)(this.input, pos);
-    return loc;
-  }
-
-  raise(pos, message, {
-    missingPluginNames,
-    code
-  } = {}) {
-    const loc = this.getLocationForPosition(pos);
-    message += ` (${loc.line}:${loc.column})`;
-    const err = new SyntaxError(message);
-    err.pos = pos;
-    err.loc = loc;
-
-    if (missingPluginNames) {
-      err.missingPlugin = missingPluginNames;
-    }
-
-    if (code !== undefined) {
-      err.code = code;
-    }
-
-    if (this.options.errorRecovery) {
-      if (!this.isLookahead) this.state.errors.push(err);
-      return err;
-    } else {
-      throw err;
-    }
-  }
-
-}
-
-exports.default = LocationParser;

data/lib/condenser/processors/node_modules/@babel/parser/lib/parser/lval.js

@@ -1,364 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var _identifier = require("../util/identifier");
-
-var _node = require("./node");
-
-var _scopeflags = require("../util/scopeflags");
-
-const unwrapParenthesizedExpression = node => {
-  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
-};
-
-class LValParser extends _node.NodeUtils {
-  toAssignable(node, isBinding, contextDescription) {
-    var _node$extra3;
-
-    if (node) {
-      var _node$extra;
-
-      if (this.options.createParenthesizedExpressions && node.type === "ParenthesizedExpression" || ((_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized)) {
-        const parenthesized = unwrapParenthesizedExpression(node);
-
-        if (parenthesized.type !== "Identifier" && parenthesized.type !== "MemberExpression") {
-          this.raise(node.start, "Invalid parenthesized assignment pattern");
-        }
-      }
-
-      switch (node.type) {
-        case "Identifier":
-        case "ObjectPattern":
-        case "ArrayPattern":
-        case "AssignmentPattern":
-          break;
-
-        case "ObjectExpression":
-          node.type = "ObjectPattern";
-
-          for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
-            var _node$extra2;
-
-            const prop = node.properties[i];
-            const isLast = i === last;
-            this.toAssignableObjectExpressionProp(prop, isBinding, isLast);
-
-            if (isLast && prop.type === "RestElement" && ((_node$extra2 = node.extra) == null ? void 0 : _node$extra2.trailingComma)) {
-              this.raiseRestNotLast(node.extra.trailingComma);
-            }
-          }
-
-          break;
-
-        case "ObjectProperty":
-          this.toAssignable(node.value, isBinding, contextDescription);
-          break;
-
-        case "SpreadElement":
-          {
-            this.checkToRestConversion(node);
-            node.type = "RestElement";
-            const arg = node.argument;
-            this.toAssignable(arg, isBinding, contextDescription);
-            break;
-          }
-
-        case "ArrayExpression":
-          node.type = "ArrayPattern";
-          this.toAssignableList(node.elements, isBinding, contextDescription, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingComma);
-          break;
-
-        case "AssignmentExpression":
-          if (node.operator !== "=") {
-            this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
-          }
-
-          node.type = "AssignmentPattern";
-          delete node.operator;
-          this.toAssignable(node.left, isBinding, contextDescription);
-          break;
-
-        case "ParenthesizedExpression":
-          node.expression = this.toAssignable(node.expression, isBinding, contextDescription);
-          break;
-
-        case "MemberExpression":
-          if (!isBinding) break;
-
-        default:
-      }
-    }
-
-    return node;
-  }
-
-  toAssignableObjectExpressionProp(prop, isBinding, isLast) {
-    if (prop.type === "ObjectMethod") {
-      const error = prop.kind === "get" || prop.kind === "set" ? "Object pattern can't contain getter or setter" : "Object pattern can't contain methods";
-      this.raise(prop.key.start, error);
-    } else if (prop.type === "SpreadElement" && !isLast) {
-      this.raiseRestNotLast(prop.start);
-    } else {
-      this.toAssignable(prop, isBinding, "object destructuring pattern");
-    }
-  }
-
-  toAssignableList(exprList, isBinding, contextDescription, trailingCommaPos) {
-    let end = exprList.length;
-
-    if (end) {
-      const last = exprList[end - 1];
-
-      if (last && last.type === "RestElement") {
-        --end;
-      } else if (last && last.type === "SpreadElement") {
-        last.type = "RestElement";
-        const arg = last.argument;
-        this.toAssignable(arg, isBinding, contextDescription);
-
-        if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern" && arg.type !== "ObjectPattern") {
-          this.unexpected(arg.start);
-        }
-
-        if (trailingCommaPos) {
-          this.raiseTrailingCommaAfterRest(trailingCommaPos);
-        }
-
-        --end;
-      }
-    }
-
-    for (let i = 0; i < end; i++) {
-      const elt = exprList[i];
-
-      if (elt) {
-        this.toAssignable(elt, isBinding, contextDescription);
-
-        if (elt.type === "RestElement") {
-          this.raiseRestNotLast(elt.start);
-        }
-      }
-    }
-
-    return exprList;
-  }
-
-  toReferencedList(exprList, isParenthesizedExpr) {
-    return exprList;
-  }
-
-  toReferencedListDeep(exprList, isParenthesizedExpr) {
-    this.toReferencedList(exprList, isParenthesizedExpr);
-
-    for (let _i = 0; _i < exprList.length; _i++) {
-      const expr = exprList[_i];
-
-      if (expr && expr.type === "ArrayExpression") {
-        this.toReferencedListDeep(expr.elements);
-      }
-    }
-  }
-
-  parseSpread(refShorthandDefaultPos, refNeedsArrowPos) {
-    const node = this.startNode();
-    this.next();
-    node.argument = this.parseMaybeAssign(false, refShorthandDefaultPos, undefined, refNeedsArrowPos);
-    return this.finishNode(node, "SpreadElement");
-  }
-
-  parseRestBinding() {
-    const node = this.startNode();
-    this.next();
-    node.argument = this.parseBindingAtom();
-    return this.finishNode(node, "RestElement");
-  }
-
-  parseBindingAtom() {
-    switch (this.state.type) {
-      case _types.types.bracketL:
-        {
-          const node = this.startNode();
-          this.next();
-          node.elements = this.parseBindingList(_types.types.bracketR, 93, true);
-          return this.finishNode(node, "ArrayPattern");
-        }
-
-      case _types.types.braceL:
-        return this.parseObj(true);
-    }
-
-    return this.parseIdentifier();
-  }
-
-  parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) {
-    const elts = [];
-    let first = true;
-
-    while (!this.eat(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-      }
-
-      if (allowEmpty && this.match(_types.types.comma)) {
-        elts.push(null);
-      } else if (this.eat(close)) {
-        break;
-      } else if (this.match(_types.types.ellipsis)) {
-        elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));
-        this.checkCommaAfterRest(closeCharCode);
-        this.expect(close);
-        break;
-      } else {
-        const decorators = [];
-
-        if (this.match(_types.types.at) && this.hasPlugin("decorators")) {
-          this.raise(this.state.start, "Stage 2 decorators cannot be used to decorate parameters");
-        }
-
-        while (this.match(_types.types.at)) {
-          decorators.push(this.parseDecorator());
-        }
-
-        elts.push(this.parseAssignableListItem(allowModifiers, decorators));
-      }
-    }
-
-    return elts;
-  }
-
-  parseAssignableListItem(allowModifiers, decorators) {
-    const left = this.parseMaybeDefault();
-    this.parseAssignableListItemTypes(left);
-    const elt = this.parseMaybeDefault(left.start, left.loc.start, left);
-
-    if (decorators.length) {
-      left.decorators = decorators;
-    }
-
-    return elt;
-  }
-
-  parseAssignableListItemTypes(param) {
-    return param;
-  }
-
-  parseMaybeDefault(startPos, startLoc, left) {
-    startLoc = startLoc || this.state.startLoc;
-    startPos = startPos || this.state.start;
-    left = left || this.parseBindingAtom();
-    if (!this.eat(_types.types.eq)) return left;
-    const node = this.startNodeAt(startPos, startLoc);
-    node.left = left;
-    node.right = this.parseMaybeAssign();
-    return this.finishNode(node, "AssignmentPattern");
-  }
-
-  checkLVal(expr, bindingType = _scopeflags.BIND_NONE, checkClashes, contextDescription, disallowLetBinding, strictModeChanged = false) {
-    switch (expr.type) {
-      case "Identifier":
-        if (this.state.strict && (strictModeChanged ? (0, _identifier.isStrictBindReservedWord)(expr.name, this.inModule) : (0, _identifier.isStrictBindOnlyReservedWord)(expr.name))) {
-          this.raise(expr.start, `${bindingType === _scopeflags.BIND_NONE ? "Assigning to" : "Binding"} '${expr.name}' in strict mode`);
-        }
-
-        if (checkClashes) {
-          const key = `_${expr.name}`;
-
-          if (checkClashes[key]) {
-            this.raise(expr.start, "Argument name clash");
-          } else {
-            checkClashes[key] = true;
-          }
-        }
-
-        if (disallowLetBinding && expr.name === "let") {
-          this.raise(expr.start, "'let' is not allowed to be used as a name in 'let' or 'const' declarations.");
-        }
-
-        if (!(bindingType & _scopeflags.BIND_NONE)) {
-          this.scope.declareName(expr.name, bindingType, expr.start);
-        }
-
-        break;
-
-      case "MemberExpression":
-        if (bindingType !== _scopeflags.BIND_NONE) {
-          this.raise(expr.start, "Binding member expression");
-        }
-
-        break;
-
-      case "ObjectPattern":
-        for (let _i2 = 0, _expr$properties = expr.properties; _i2 < _expr$properties.length; _i2++) {
-          let prop = _expr$properties[_i2];
-          if (prop.type === "ObjectProperty") prop = prop.value;else if (prop.type === "ObjectMethod") continue;
-          this.checkLVal(prop, bindingType, checkClashes, "object destructuring pattern", disallowLetBinding);
-        }
-
-        break;
-
-      case "ArrayPattern":
-        for (let _i3 = 0, _expr$elements = expr.elements; _i3 < _expr$elements.length; _i3++) {
-          const elem = _expr$elements[_i3];
-
-          if (elem) {
-            this.checkLVal(elem, bindingType, checkClashes, "array destructuring pattern", disallowLetBinding);
-          }
-        }
-
-        break;
-
-      case "AssignmentPattern":
-        this.checkLVal(expr.left, bindingType, checkClashes, "assignment pattern");
-        break;
-
-      case "RestElement":
-        this.checkLVal(expr.argument, bindingType, checkClashes, "rest element");
-        break;
-
-      case "ParenthesizedExpression":
-        this.checkLVal(expr.expression, bindingType, checkClashes, "parenthesized expression");
-        break;
-
-      default:
-        {
-          const message = (bindingType === _scopeflags.BIND_NONE ? "Invalid" : "Binding invalid") + " left-hand side" + (contextDescription ? " in " + contextDescription : "expression");
-          this.raise(expr.start, message);
-        }
-    }
-  }
-
-  checkToRestConversion(node) {
-    if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
-      this.raise(node.argument.start, "Invalid rest operator's argument");
-    }
-  }
-
-  checkCommaAfterRest(close) {
-    if (this.match(_types.types.comma)) {
-      if (this.lookaheadCharCode() === close) {
-        this.raiseTrailingCommaAfterRest(this.state.start);
-      } else {
-        this.raiseRestNotLast(this.state.start);
-      }
-    }
-  }
-
-  raiseRestNotLast(pos) {
-    throw this.raise(pos, `Rest element must be last element`);
-  }
-
-  raiseTrailingCommaAfterRest(pos) {
-    this.raise(pos, `Unexpected trailing comma after rest element`);
-  }
-
-}
-
-exports.default = LValParser;