eoapi-cdk 7.0.0 → 7.0.1

package/node_modules/acorn/src/loose/tokenize.js

@@ -1,108 +0,0 @@
-import {tokTypes as tt, Token, isNewLine, SourceLocation, getLineInfo, lineBreakG} from "../index"
-import {LooseParser} from "./state"
-
-const lp = LooseParser.prototype
-
-function isSpace(ch) {
-  return (ch < 14 && ch > 8) || ch === 32 || ch === 160 || isNewLine(ch)
-}
-
-lp.next = function() {
-  this.last = this.tok
-  if (this.ahead.length)
-    this.tok = this.ahead.shift()
-  else
-    this.tok = this.readToken()
-
-  if (this.tok.start >= this.nextLineStart) {
-    while (this.tok.start >= this.nextLineStart) {
-      this.curLineStart = this.nextLineStart
-      this.nextLineStart = this.lineEnd(this.curLineStart) + 1
-    }
-    this.curIndent = this.indentationAfter(this.curLineStart)
-  }
-}
-
-lp.readToken = function() {
-  for (;;) {
-    try {
-      this.toks.next()
-      if (this.toks.type === tt.dot &&
-          this.input.substr(this.toks.end, 1) === "." &&
-          this.options.ecmaVersion >= 6) {
-        this.toks.end++
-        this.toks.type = tt.ellipsis
-      }
-      return new Token(this.toks)
-    } catch(e) {
-      if (!(e instanceof SyntaxError)) throw e
-
-      // Try to skip some text, based on the error message, and then continue
-      let msg = e.message, pos = e.raisedAt, replace = true
-      if (/unterminated/i.test(msg)) {
-        pos = this.lineEnd(e.pos + 1)
-        if (/string/.test(msg)) {
-          replace = {start: e.pos, end: pos, type: tt.string, value: this.input.slice(e.pos + 1, pos)}
-        } else if (/regular expr/i.test(msg)) {
-          let re = this.input.slice(e.pos, pos)
-          try { re = new RegExp(re) } catch(e) {}
-          replace = {start: e.pos, end: pos, type: tt.regexp, value: re}
-        } else if (/template/.test(msg)) {
-          replace = {start: e.pos, end: pos,
-                     type: tt.template,
-                     value: this.input.slice(e.pos, pos)}
-        } else {
-          replace = false
-        }
-      } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number|expected number in radix/i.test(msg)) {
-        while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) ++pos
-      } else if (/character escape|expected hexadecimal/i.test(msg)) {
-        while (pos < this.input.length) {
-          let ch = this.input.charCodeAt(pos++)
-          if (ch === 34 || ch === 39 || isNewLine(ch)) break
-        }
-      } else if (/unexpected character/i.test(msg)) {
-        pos++
-        replace = false
-      } else if (/regular expression/i.test(msg)) {
-        replace = true
-      } else {
-        throw e
-      }
-      this.resetTo(pos)
-      if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"}
-      if (replace) {
-        if (this.options.locations)
-          replace.loc = new SourceLocation(
-            this.toks,
-            getLineInfo(this.input, replace.start),
-            getLineInfo(this.input, replace.end))
-        return replace
-      }
-    }
-  }
-}
-
-lp.resetTo = function(pos) {
-  this.toks.pos = pos
-  let ch = this.input.charAt(pos - 1)
-  this.toks.exprAllowed = !ch || /[\[\{\(,;:?\/*=+\-~!|&%^<>]/.test(ch) ||
-    /[enwfd]/.test(ch) &&
-    /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(this.input.slice(pos - 10, pos))
-
-  if (this.options.locations) {
-    this.toks.curLine = 1
-    this.toks.lineStart = lineBreakG.lastIndex = 0
-    let match
-    while ((match = lineBreakG.exec(this.input)) && match.index < pos) {
-      ++this.toks.curLine
-      this.toks.lineStart = match.index + match[0].length
-    }
-  }
-}
-
-lp.lookAhead = function(n) {
-  while (n > this.ahead.length)
-    this.ahead.push(this.readToken())
-  return this.ahead[n - 1]
-}

package/node_modules/acorn/src/lval.js

@@ -1,219 +0,0 @@
-import {types as tt} from "./tokentype"
-import {Parser} from "./state"
-import {has} from "./util"
-
-const pp = Parser.prototype
-
-// Convert existing expression atom to assignable pattern
-// if possible.
-
-pp.toAssignable = function(node, isBinding) {
-  if (this.options.ecmaVersion >= 6 && node) {
-    switch (node.type) {
-      case "Identifier":
-      if (this.inAsync && node.name === "await")
-        this.raise(node.start, "Can not use 'await' as identifier inside an async function")
-      break
-
-    case "ObjectPattern":
-    case "ArrayPattern":
-      break
-
-    case "ObjectExpression":
-      node.type = "ObjectPattern"
-      for (let i = 0; i < node.properties.length; i++) {
-        let prop = node.properties[i]
-        if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter")
-        this.toAssignable(prop.value, isBinding)
-      }
-      break
-
-    case "ArrayExpression":
-      node.type = "ArrayPattern"
-      this.toAssignableList(node.elements, isBinding)
-      break
-
-    case "AssignmentExpression":
-      if (node.operator === "=") {
-        node.type = "AssignmentPattern"
-        delete node.operator
-        this.toAssignable(node.left, isBinding)
-        // falls through to AssignmentPattern
-      } else {
-        this.raise(node.left.end, "Only '=' operator can be used for specifying default value.")
-        break
-      }
-
-    case "AssignmentPattern":
-      break
-
-    case "ParenthesizedExpression":
-      node.expression = this.toAssignable(node.expression, isBinding)
-      break
-
-    case "MemberExpression":
-      if (!isBinding) break
-
-    default:
-      this.raise(node.start, "Assigning to rvalue")
-    }
-  }
-  return node
-}
-
-// Convert list of expression atoms to binding list.
-
-pp.toAssignableList = function(exprList, isBinding) {
-  let end = exprList.length
-  if (end) {
-    let last = exprList[end - 1]
-    if (last && last.type == "RestElement") {
-      --end
-    } else if (last && last.type == "SpreadElement") {
-      last.type = "RestElement"
-      let arg = last.argument
-      this.toAssignable(arg, isBinding)
-      if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
-        this.unexpected(arg.start)
-      --end
-    }
-
-    if (isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
-      this.unexpected(last.argument.start)
-  }
-  for (let i = 0; i < end; i++) {
-    let elt = exprList[i]
-    if (elt) this.toAssignable(elt, isBinding)
-  }
-  return exprList
-}
-
-// Parses spread element.
-
-pp.parseSpread = function(refDestructuringErrors) {
-  let node = this.startNode()
-  this.next()
-  node.argument = this.parseMaybeAssign(false, refDestructuringErrors)
-  return this.finishNode(node, "SpreadElement")
-}
-
-pp.parseRest = function(allowNonIdent) {
-  let node = this.startNode()
-  this.next()
-
-  // RestElement inside of a function parameter must be an identifier
-  if (allowNonIdent) node.argument = this.type === tt.name ? this.parseIdent() : this.unexpected()
-  else node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected()
-
-  return this.finishNode(node, "RestElement")
-}
-
-// Parses lvalue (assignable) atom.
-
-pp.parseBindingAtom = function() {
-  if (this.options.ecmaVersion < 6) return this.parseIdent()
-  switch (this.type) {
-  case tt.name:
-    return this.parseIdent()
-
-  case tt.bracketL:
-    let node = this.startNode()
-    this.next()
-    node.elements = this.parseBindingList(tt.bracketR, true, true)
-    return this.finishNode(node, "ArrayPattern")
-
-  case tt.braceL:
-    return this.parseObj(true)
-
-  default:
-    this.unexpected()
-  }
-}
-
-pp.parseBindingList = function(close, allowEmpty, allowTrailingComma, allowNonIdent) {
-  let elts = [], first = true
-  while (!this.eat(close)) {
-    if (first) first = false
-    else this.expect(tt.comma)
-    if (allowEmpty && this.type === tt.comma) {
-      elts.push(null)
-    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
-      break
-    } else if (this.type === tt.ellipsis) {
-      let rest = this.parseRest(allowNonIdent)
-      this.parseBindingListItem(rest)
-      elts.push(rest)
-      if (this.type === tt.comma) this.raise(this.start, "Comma is not permitted after the rest element")
-      this.expect(close)
-      break
-    } else {
-      let elem = this.parseMaybeDefault(this.start, this.startLoc)
-      this.parseBindingListItem(elem)
-      elts.push(elem)
-    }
-  }
-  return elts
-}
-
-pp.parseBindingListItem = function(param) {
-  return param
-}
-
-// Parses assignment pattern around given atom if possible.
-
-pp.parseMaybeDefault = function(startPos, startLoc, left) {
-  left = left || this.parseBindingAtom()
-  if (this.options.ecmaVersion < 6 || !this.eat(tt.eq)) return left
-  let node = this.startNodeAt(startPos, startLoc)
-  node.left = left
-  node.right = this.parseMaybeAssign()
-  return this.finishNode(node, "AssignmentPattern")
-}
-
-// Verify that a node is an lval — something that can be assigned
-// to.
-
-pp.checkLVal = function(expr, isBinding, checkClashes) {
-  switch (expr.type) {
-  case "Identifier":
-    if (this.strict && this.reservedWordsStrictBind.test(expr.name))
-      this.raiseRecoverable(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode")
-    if (checkClashes) {
-      if (has(checkClashes, expr.name))
-        this.raiseRecoverable(expr.start, "Argument name clash")
-      checkClashes[expr.name] = true
-    }
-    break
-
-  case "MemberExpression":
-    if (isBinding) this.raiseRecoverable(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression")
-    break
-
-  case "ObjectPattern":
-    for (let i = 0; i < expr.properties.length; i++)
-      this.checkLVal(expr.properties[i].value, isBinding, checkClashes)
-    break
-
-  case "ArrayPattern":
-    for (let i = 0; i < expr.elements.length; i++) {
-      let elem = expr.elements[i]
-      if (elem) this.checkLVal(elem, isBinding, checkClashes)
-    }
-    break
-
-  case "AssignmentPattern":
-    this.checkLVal(expr.left, isBinding, checkClashes)
-    break
-
-  case "RestElement":
-    this.checkLVal(expr.argument, isBinding, checkClashes)
-    break
-
-  case "ParenthesizedExpression":
-    this.checkLVal(expr.expression, isBinding, checkClashes)
-    break
-
-  default:
-    this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue")
-  }
-}

package/node_modules/acorn/src/node.js

@@ -1,50 +0,0 @@
-import {Parser} from "./state"
-import {SourceLocation} from "./locutil"
-
-export class Node {
-  constructor(parser, pos, loc) {
-    this.type = ""
-    this.start = pos
-    this.end = 0
-    if (parser.options.locations)
-      this.loc = new SourceLocation(parser, loc)
-    if (parser.options.directSourceFile)
-      this.sourceFile = parser.options.directSourceFile
-    if (parser.options.ranges)
-      this.range = [pos, 0]
-  }
-}
-
-// Start an AST node, attaching a start offset.
-
-const pp = Parser.prototype
-
-pp.startNode = function() {
-  return new Node(this, this.start, this.startLoc)
-}
-
-pp.startNodeAt = function(pos, loc) {
-  return new Node(this, pos, loc)
-}
-
-// Finish an AST node, adding `type` and `end` properties.
-
-function finishNodeAt(node, type, pos, loc) {
-  node.type = type
-  node.end = pos
-  if (this.options.locations)
-    node.loc.end = loc
-  if (this.options.ranges)
-    node.range[1] = pos
-  return node
-}
-
-pp.finishNode = function(node, type) {
-  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
-}
-
-// Finish node at given position
-
-pp.finishNodeAt = function(node, type, pos, loc) {
-  return finishNodeAt.call(this, node, type, pos, loc)
-}

package/node_modules/acorn/src/options.js

@@ -1,128 +0,0 @@
-import {has, isArray} from "./util"
-import {SourceLocation} from "./locutil"
-
-// A second optional argument can be given to further configure
-// the parser process. These options are recognized:
-
-export const defaultOptions = {
-  // `ecmaVersion` indicates the ECMAScript version to parse. Must
-  // be either 3, 5, 6 (2015), 7 (2016), or 8 (2017). This influences support
-  // for strict mode, the set of reserved words, and support for
-  // new syntax features. The default is 7.
-  ecmaVersion: 7,
-  // `sourceType` indicates the mode the code should be parsed in.
-  // Can be either `"script"` or `"module"`. This influences global
-  // strict mode and parsing of `import` and `export` declarations.
-  sourceType: "script",
-  // `onInsertedSemicolon` can be a callback that will be called
-  // when a semicolon is automatically inserted. It will be passed
-  // th position of the comma as an offset, and if `locations` is
-  // enabled, it is given the location as a `{line, column}` object
-  // as second argument.
-  onInsertedSemicolon: null,
-  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
-  // trailing commas.
-  onTrailingComma: null,
-  // By default, reserved words are only enforced if ecmaVersion >= 5.
-  // Set `allowReserved` to a boolean value to explicitly turn this on
-  // an off. When this option has the value "never", reserved words
-  // and keywords can also not be used as property names.
-  allowReserved: null,
-  // When enabled, a return at the top level is not considered an
-  // error.
-  allowReturnOutsideFunction: false,
-  // When enabled, import/export statements are not constrained to
-  // appearing at the top of the program.
-  allowImportExportEverywhere: false,
-  // When enabled, hashbang directive in the beginning of file
-  // is allowed and treated as a line comment.
-  allowHashBang: false,
-  // When `locations` is on, `loc` properties holding objects with
-  // `start` and `end` properties in `{line, column}` form (with
-  // line being 1-based and column 0-based) will be attached to the
-  // nodes.
-  locations: false,
-  // A function can be passed as `onToken` option, which will
-  // cause Acorn to call that function with object in the same
-  // format as tokens returned from `tokenizer().getToken()`. Note
-  // that you are not allowed to call the parser from the
-  // callback—that will corrupt its internal state.
-  onToken: null,
-  // A function can be passed as `onComment` option, which will
-  // cause Acorn to call that function with `(block, text, start,
-  // end)` parameters whenever a comment is skipped. `block` is a
-  // boolean indicating whether this is a block (`/* */`) comment,
-  // `text` is the content of the comment, and `start` and `end` are
-  // character offsets that denote the start and end of the comment.
-  // When the `locations` option is on, two more parameters are
-  // passed, the full `{line, column}` locations of the start and
-  // end of the comments. Note that you are not allowed to call the
-  // parser from the callback—that will corrupt its internal state.
-  onComment: null,
-  // Nodes have their start and end characters offsets recorded in
-  // `start` and `end` properties (directly on the node, rather than
-  // the `loc` object, which holds line/column data. To also add a
-  // [semi-standardized][range] `range` property holding a `[start,
-  // end]` array with the same numbers, set the `ranges` option to
-  // `true`.
-  //
-  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
-  ranges: false,
-  // It is possible to parse multiple files into a single AST by
-  // passing the tree produced by parsing the first file as
-  // `program` option in subsequent parses. This will add the
-  // toplevel forms of the parsed file to the `Program` (top) node
-  // of an existing parse tree.
-  program: null,
-  // When `locations` is on, you can pass this to record the source
-  // file in every node's `loc` object.
-  sourceFile: null,
-  // This value, if given, is stored in every node, whether
-  // `locations` is on or off.
-  directSourceFile: null,
-  // When enabled, parenthesized expressions are represented by
-  // (non-standard) ParenthesizedExpression nodes
-  preserveParens: false,
-  plugins: {}
-}
-
-// Interpret and default an options object
-
-export function getOptions(opts) {
-  let options = {}
-
-  for (let opt in defaultOptions)
-    options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
-
-  if (options.ecmaVersion >= 2015)
-    options.ecmaVersion -= 2009
-
-  if (options.allowReserved == null)
-    options.allowReserved = options.ecmaVersion < 5
-
-  if (isArray(options.onToken)) {
-    let tokens = options.onToken
-    options.onToken = (token) => tokens.push(token)
-  }
-  if (isArray(options.onComment))
-    options.onComment = pushComment(options, options.onComment)
-
-  return options
-}
-
-function pushComment(options, array) {
-  return function (block, text, start, end, startLoc, endLoc) {
-    let comment = {
-      type: block ? 'Block' : 'Line',
-      value: text,
-      start: start,
-      end: end
-    }
-    if (options.locations)
-      comment.loc = new SourceLocation(this, startLoc, endLoc)
-    if (options.ranges)
-      comment.range = [start, end]
-    array.push(comment)
-  }
-}
-

package/node_modules/acorn/src/parseutil.js

@@ -1,128 +0,0 @@
-import {types as tt} from "./tokentype"
-import {Parser} from "./state"
-import {lineBreak, skipWhiteSpace} from "./whitespace"
-
-const pp = Parser.prototype
-
-// ## Parser utilities
-
-const literal = /^(?:'((?:[^\']|\.)*)'|"((?:[^\"]|\.)*)"|;)/
-pp.strictDirective = function(start) {
-  for (;;) {
-    skipWhiteSpace.lastIndex = start
-    start += skipWhiteSpace.exec(this.input)[0].length
-    let match = literal.exec(this.input.slice(start))
-    if (!match) return false
-    if ((match[1] || match[2]) == "use strict") return true
-    start += match[0].length
-  }
-}
-
-// Predicate that tests whether the next token is of the given
-// type, and if yes, consumes it as a side effect.
-
-pp.eat = function(type) {
-  if (this.type === type) {
-    this.next()
-    return true
-  } else {
-    return false
-  }
-}
-
-// Tests whether parsed token is a contextual keyword.
-
-pp.isContextual = function(name) {
-  return this.type === tt.name && this.value === name
-}
-
-// Consumes contextual keyword if possible.
-
-pp.eatContextual = function(name) {
-  return this.value === name && this.eat(tt.name)
-}
-
-// Asserts that following token is given contextual keyword.
-
-pp.expectContextual = function(name) {
-  if (!this.eatContextual(name)) this.unexpected()
-}
-
-// Test whether a semicolon can be inserted at the current position.
-
-pp.canInsertSemicolon = function() {
-  return this.type === tt.eof ||
-    this.type === tt.braceR ||
-    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
-}
-
-pp.insertSemicolon = function() {
-  if (this.canInsertSemicolon()) {
-    if (this.options.onInsertedSemicolon)
-      this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
-    return true
-  }
-}
-
-// Consume a semicolon, or, failing that, see if we are allowed to
-// pretend that there is a semicolon at this position.
-
-pp.semicolon = function() {
-  if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected()
-}
-
-pp.afterTrailingComma = function(tokType, notNext) {
-  if (this.type == tokType) {
-    if (this.options.onTrailingComma)
-      this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc)
-    if (!notNext)
-      this.next()
-    return true
-  }
-}
-
-// Expect a token of a given type. If found, consume it, otherwise,
-// raise an unexpected token error.
-
-pp.expect = function(type) {
-  this.eat(type) || this.unexpected()
-}
-
-// Raise an unexpected token error.
-
-pp.unexpected = function(pos) {
-  this.raise(pos != null ? pos : this.start, "Unexpected token")
-}
-
-export class DestructuringErrors {
-  constructor() {
-    this.shorthandAssign = this.trailingComma = this.parenthesizedAssign = this.parenthesizedBind = -1
-  }
-}
-
-pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
-  if (!refDestructuringErrors) return
-  if (refDestructuringErrors.trailingComma > -1)
-    this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element")
-  let parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind
-  if (parens > -1) this.raiseRecoverable(parens, "Parenthesized pattern")
-}
-
-pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
-  let pos = refDestructuringErrors ? refDestructuringErrors.shorthandAssign : -1
-  if (!andThrow) return pos >= 0
-  if (pos > -1) this.raise(pos, "Shorthand property assignments are valid only in destructuring patterns")
-}
-
-pp.checkYieldAwaitInDefaultParams = function() {
-  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
-    this.raise(this.yieldPos, "Yield expression cannot be a default value")
-  if (this.awaitPos)
-    this.raise(this.awaitPos, "Await expression cannot be a default value")
-}
-
-pp.isSimpleAssignTarget = function(expr) {
-  if (expr.type === "ParenthesizedExpression")
-    return this.isSimpleAssignTarget(expr.expression)
-  return expr.type === "Identifier" || expr.type === "MemberExpression"
-}