create project

kitabcitab/node_modules/acorn-node/.travis.yml

@@ -0,0 +1,22 @@
+language: node_js
+node_js:
+  - '12'
+  - '11'
+  - '10'
+  - '9'
+  - '8'
+  - '6'
+  - '4'
+  - '0.12'
+  - '0.10'
+  - '0.8'
+  - '0.6'
+before_install:
+  - 'nvm install-latest-npm'
+install:
+  - 'if [ "${TRAVIS_NODE_VERSION}" = "0.6" ] || [ "${TRAVIS_NODE_VERSION}" = "0.9" ]; then nvm install --latest-npm 0.8 && npm install && nvm use "${TRAVIS_NODE_VERSION}"; else npm install; fi;'
+sudo: false
+matrix:
+  fast_finish: true
+  allow_failures:
+    - node_js: "0.6"

kitabcitab/node_modules/acorn-node/CHANGELOG.md

@@ -0,0 +1,94 @@
+# acorn-node change log
+
+All notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## 1.8.2
+ * Revert a breaking change in import.meta parsing.
+
+## 1.8.1
+ * Fix crash in compiled private-class-elements code.
+
+## 1.8.0
+ * Upgrade acorn to v7.
+
+   For backwards compatibility, `acorn-node` still uses the `Import` node type for dynamic imports, _NOT_ `ImportExpression` like acorn v7 and estree.
+ * Add numeric separator support:
+   ```js
+   var a = 10_000_000_000_000_000_000_000_000n;
+   ```
+
+## 1.7.0
+ * Add class instance fields support:
+   ```js
+   class X {
+     pub = 1;
+     #priv = 2;
+   }
+   ```
+ * Add class static fields support:
+   ```js
+   class X {
+     static pub = 1;
+     static #priv = 2;
+   }
+   ```
+ * Add `export * as ns` support when `sourceType` is 'module':
+   ```js
+   export * as ns from './ns.mjs';
+   ```
+
+## 1.6.2
+
+ * Allow dynamic `import()` in scripts.
+ * Update minimum dependency versions, fixing a peerDependency warning.
+ * Add Node 10 and 11 to CI.
+
+## 1.6.1
+
+ * Update acorn-dynamic-import to v4.
+
+## 1.6.0
+
+ * Upgrade acorn to v6.
+ * Add bigint support.
+
+## 1.5.2
+
+ * Upgrade acorn to support optional catch binding in the AST walker.
+
+## 1.5.1
+
+ * Fix tests on Node <= 0.12.
+
+## 1.5.0
+
+ * Add tests for async iteration, optional catch binding, import.meta,
+   dynamic import, bigint (currently unsupported).
+ * Add import.meta support. (`sourceType: 'module'` only)
+ * Add dynamic import support. (`sourceType: 'module'` only)
+ * Fix optional catch binding support in the walker.
+
+## 1.4.0
+
+ * Upgrade acorn to 5.6, which supports optional catch bindings and other
+   new syntax features.
+ * Set ecmaVersion to 2019 to opt in to optional catch bindings etc.
+
+## 1.3.0
+
+ * Upgrade acorn to 5.4, which supports object spread and async iteration.
+ * Remove acorn5-object-spread plugin.
+
+## 1.2.0
+
+ * Expose `acorn/dist/walk` as `acorn-node/walk`.
+
+## 1.1.0
+
+ * Enable `allowHashBang` and `allowReturnOutsideFunction` by default.
+
+## 1.0.0
+
+ * Initial release.

kitabcitab/node_modules/acorn-node/LICENSE.md

@@ -0,0 +1,95 @@
+# [Apache License 2.0](https://spdx.org/licenses/Apache-2.0)
+
+Copyright 2018 Renée Kooi <renee@kooi.me>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+> http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+## acorn-bigint
+
+The code in the `lib/bigint` folder is compiled from code licensed as MIT:
+
+> Copyright (C) 2017-2018 by Adrian Heine
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+Find the source code at https://github.com/acornjs/acorn-bigint.
+
+## acorn-import-meta
+
+The code in the `lib/import-meta` folder is compiled from code licensed as MIT:
+
+> Copyright (C) 2017-2018 by Adrian Heine
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+Find the source code at https://github.com/acornjs/acorn-import-meta.
+
+## acorn-dynamic-import
+
+The code in the `lib/dynamic-import` folder is licensed as MIT:
+
+> MIT License
+>
+> Copyright (c) 2016 Jordan Gensler
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+Find the source code at https://github.com/kesne/acorn-dynamic-import.

kitabcitab/node_modules/acorn-node/README.md

@@ -0,0 +1,65 @@
+# acorn-node
+
+[Acorn](https://github.com/acornjs/acorn) preloaded with plugins for syntax parity with recent Node versions.
+
+It also includes versions of the plugins compiled with [Bublé](https://github.com/rich-harris/buble), so they can be run on old Node versions (0.6 and up).
+
+[![npm][npm-image]][npm-url]
+[![travis][travis-image]][travis-url]
+[![standard][standard-image]][standard-url]
+
+[npm-image]: https://img.shields.io/npm/v/acorn-node.svg?style=flat-square
+[npm-url]: https://www.npmjs.com/package/acorn-node
+[travis-image]: https://img.shields.io/travis/browserify/acorn-node/master.svg?style=flat-square
+[travis-url]: https://travis-ci.org/browserify/acorn-node
+[standard-image]: https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square
+[standard-url]: http://npm.im/standard
+
+## Install
+
+```
+npm install acorn-node
+```
+
+## Usage
+
+```js
+var acorn = require('acorn-node')
+```
+
+The API is the same as [acorn](https://github.com/acornjs/acorn), but the following syntax features are enabled by default:
+
+ - Bigint syntax `10n`
+ - Numeric separators syntax `10_000`
+ - Public and private class instance fields
+ - Public and private class static fields
+ - Dynamic `import()`
+ - The `import.meta` property
+ - `export * as ns from` syntax
+
+And the following options have different defaults from acorn, to match Node modules:
+
+ - `ecmaVersion: 2019`
+ - `allowHashBang: true`
+ - `allowReturnOutsideFunction: true`
+
+```js
+var walk = require('acorn-node/walk')
+```
+
+The Acorn syntax tree walker. Comes preconfigured for the syntax plugins if necessary.
+See the [acorn documentation](https://github.com/acornjs/acorn#distwalkjs) for details.
+
+## License
+
+The files in the repo root and the ./test folder are licensed as [Apache-2.0](LICENSE.md).
+
+The files in lib/ are generated from other packages:
+
+- lib/bigint: [acorn-bigint](https://github.com/acornjs/acorn-bigint]), MIT
+- lib/class-private-elements: [acorn-class-private-elements](https://github.com/acornjs/acorn-class-private-elements), MIT
+- lib/dynamic-import: [acorn-dynamic-import](https://github.com/acornjs/acorn-dynamic-import), MIT
+- lib/export-ns-from: [acorn-export-ns-from](https://github.com/acornjs/acorn-export-ns-from), MIT
+- lib/import-meta: [acorn-import-meta](https://github.com/acornjs/acorn-import-meta), MIT
+- lib/numeric-separator: [acorn-numeric-separator](https://github.com/acornjs/acorn-numeric-separator]), MIT
+- lib/static-class-features: [acorn-static-class-features](https://github.com/acornjs/acorn-static-class-features), MIT

kitabcitab/node_modules/acorn-node/build.js

@@ -0,0 +1,36 @@
+var fs = require('fs')
+var path = require('path')
+var mkdirp = require('mkdirp')
+var buble = require('buble')
+
+var HEADER = '/* Generated by `npm run build`, do not edit! */\n\n'
+
+function compile (name, output, fix) {
+  console.log(name, '→', output)
+  mkdirp.sync(path.dirname(path.join(__dirname, output)))
+  var source = fs.readFileSync(require.resolve(name), 'utf8')
+  if (fix) source = fix(source)
+  var result = buble.transform(source, {
+    transforms: {
+      dangerousForOf: true
+    }
+  })
+  fs.writeFileSync(path.join(__dirname, output), HEADER + result.code, 'utf8')
+}
+
+function privateClassElements (str) {
+  return str.replace('acorn-private-class-elements', '../private-class-elements')
+}
+
+compile('acorn-bigint', './lib/bigint/index.js')
+compile('acorn-numeric-separator', './lib/numeric-separator/index.js')
+compile('acorn-dynamic-import', './lib/dynamic-import/index.js')
+compile('acorn-import-meta', './lib/import-meta/index.js')
+compile('acorn-export-ns-from', './lib/export-ns-from/index.js')
+compile('acorn-class-fields', './lib/class-fields/index.js', privateClassElements)
+compile('acorn-static-class-features', './lib/static-class-features/index.js', privateClassElements)
+compile('acorn-private-class-elements', './lib/private-class-elements/index.js', function (str) {
+  return str.replace('class extends Parser', 'class Parser_ extends Parser')
+    // it also works with v7
+    .replace('if (acorn.version.indexOf("6.") != 0 || acorn.version.indexOf("6.0.") == 0) {', 'if (false) {')
+})

kitabcitab/node_modules/acorn-node/index.js

@@ -0,0 +1,38 @@
+var acorn = require('acorn')
+var xtend = require('xtend')
+
+var CJSParser = acorn.Parser
+  .extend(require('./lib/bigint'))
+  .extend(require('./lib/class-fields'))
+  .extend(require('./lib/static-class-features'))
+  .extend(require('./lib/numeric-separator'))
+  .extend(require('./lib/dynamic-import').default)
+var ESModulesParser = CJSParser
+  .extend(require('./lib/export-ns-from'))
+  .extend(require('./lib/import-meta'))
+
+function mapOptions (opts) {
+  if (!opts) opts = {}
+  return xtend({
+    ecmaVersion: 2020,
+    allowHashBang: true,
+    allowReturnOutsideFunction: true
+  }, opts)
+}
+
+function getParser (opts) {
+  if (!opts) opts = {}
+  return opts.sourceType === 'module' ? ESModulesParser : CJSParser
+}
+
+module.exports = exports = xtend(acorn, {
+  parse: function parse (src, opts) {
+    return getParser(opts).parse(src, mapOptions(opts))
+  },
+  parseExpressionAt: function parseExpressionAt (src, offset, opts) {
+    return getParser(opts).parseExpressionAt(src, offset, mapOptions(opts))
+  },
+  tokenizer: function tokenizer (src, opts) {
+    return getParser(opts).tokenizer(src, mapOptions(opts))
+  }
+})

kitabcitab/node_modules/acorn-node/lib/bigint/index.js

@@ -0,0 +1,71 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+var acorn = require("acorn")
+var tt = acorn.tokTypes
+var isIdentifierStart = acorn.isIdentifierStart
+
+module.exports = function(Parser) {
+  return /*@__PURE__*/(function (Parser) {
+    function anonymous () {
+      Parser.apply(this, arguments);
+    }
+
+    if ( Parser ) anonymous.__proto__ = Parser;
+    anonymous.prototype = Object.create( Parser && Parser.prototype );
+    anonymous.prototype.constructor = anonymous;
+
+    anonymous.prototype.parseLiteral = function parseLiteral (value) {
+      var node = Parser.prototype.parseLiteral.call(this, value)
+      if (node.raw.charCodeAt(node.raw.length - 1) == 110) { node.bigint = this.getNumberInput(node.start, node.end) }
+      return node
+    };
+
+    anonymous.prototype.readRadixNumber = function readRadixNumber (radix) {
+      var start = this.pos
+      this.pos += 2 // 0x
+      var val = this.readInt(radix)
+      if (val === null) { this.raise(this.start + 2, ("Expected number in radix " + radix)) }
+      if (this.input.charCodeAt(this.pos) == 110) {
+        var str = this.getNumberInput(start, this.pos)
+        val = typeof BigInt !== "undefined" ? BigInt(str) : null
+        ++this.pos
+      } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number") }
+      return this.finishToken(tt.num, val)
+    };
+
+    anonymous.prototype.readNumber = function readNumber (startsWithDot) {
+      var start = this.pos
+
+      // Not an int
+      if (startsWithDot) { return Parser.prototype.readNumber.call(this, startsWithDot) }
+
+      // Legacy octal
+      if (this.input.charCodeAt(start) === 48 && this.input.charCodeAt(start + 1) !== 110) {
+        return Parser.prototype.readNumber.call(this, startsWithDot)
+      }
+
+      if (this.readInt(10) === null) { this.raise(start, "Invalid number") }
+
+      // Not a BigInt, reset and parse again
+      if (this.input.charCodeAt(this.pos) != 110) {
+        this.pos = start
+        return Parser.prototype.readNumber.call(this, startsWithDot)
+      }
+
+      var str = this.getNumberInput(start, this.pos)
+      var val = typeof BigInt !== "undefined" ? BigInt(str) : null
+      ++this.pos
+      return this.finishToken(tt.num, val)
+    };
+
+    // This is basically a hook for acorn-numeric-separator
+    anonymous.prototype.getNumberInput = function getNumberInput (start, end) {
+      if (Parser.prototype.getNumberInput) { return Parser.prototype.getNumberInput.call(this, start, end) }
+      return this.input.slice(start, end)
+    };
+
+    return anonymous;
+  }(Parser))
+}

kitabcitab/node_modules/acorn-node/lib/class-fields/index.js

@@ -0,0 +1,70 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+var acorn = require("acorn")
+var tt = acorn.tokTypes
+var privateClassElements = require("../private-class-elements")
+
+function maybeParseFieldValue(field) {
+  if (this.eat(tt.eq)) {
+    var oldInFieldValue = this._inFieldValue
+    this._inFieldValue = true
+    field.value = this.parseExpression()
+    this._inFieldValue = oldInFieldValue
+  } else { field.value = null }
+}
+
+module.exports = function(Parser) {
+  Parser = privateClassElements(Parser)
+  return /*@__PURE__*/(function (Parser) {
+    function anonymous () {
+      Parser.apply(this, arguments);
+    }
+
+    if ( Parser ) anonymous.__proto__ = Parser;
+    anonymous.prototype = Object.create( Parser && Parser.prototype );
+    anonymous.prototype.constructor = anonymous;
+
+    anonymous.prototype.parseClassElement = function parseClassElement (_constructorAllowsSuper) {
+      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type == this.privateNameToken || this.type == tt.bracketL || this.type == tt.string)) {
+        var branch = this._branch()
+        if (branch.type == tt.bracketL) {
+          var count = 0
+          do {
+            if (branch.eat(tt.bracketL)) { ++count }
+            else if (branch.eat(tt.bracketR)) { --count }
+            else { branch.next() }
+          } while (count > 0)
+        } else { branch.next() }
+        if (branch.type == tt.eq || branch.canInsertSemicolon() || branch.type == tt.semi) {
+          var node = this.startNode()
+          if (this.type == this.privateNameToken) {
+            this.parsePrivateClassElementName(node)
+          } else {
+            this.parsePropertyName(node)
+          }
+          if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
+              (node.key.type === "Literal" && node.key.value === "constructor")) {
+            this.raise(node.key.start, "Classes may not have a field called constructor")
+          }
+          maybeParseFieldValue.call(this, node)
+          this.finishNode(node, "FieldDefinition")
+          this.semicolon()
+          return node
+        }
+      }
+
+      return Parser.prototype.parseClassElement.apply(this, arguments)
+    };
+
+    // Prohibit arguments in class field initializers
+    anonymous.prototype.parseIdent = function parseIdent (liberal, isBinding) {
+      var ident = Parser.prototype.parseIdent.call(this, liberal, isBinding)
+      if (this._inFieldValue && ident.name == "arguments") { this.raise(ident.start, "A class field initializer may not contain arguments") }
+      return ident
+    };
+
+    return anonymous;
+  }(Parser))
+}

kitabcitab/node_modules/acorn-node/lib/dynamic-import/index.js

@@ -0,0 +1,86 @@
+/* Generated by `npm run build`, do not edit! */
+
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DynamicImportKey = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) { descriptor.writable = true; } Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) { defineProperties(Constructor.prototype, protoProps); } if (staticProps) { defineProperties(Constructor, staticProps); } return Constructor; }; }();
+
+var _get = function () {
+  function get(object, property, receiver) { if (object === null) { object = Function.prototype; } var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }
+
+  return get;
+}();
+
+exports['default'] = dynamicImport;
+
+var _acorn = require('acorn');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) { Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } } /* eslint-disable no-underscore-dangle */
+
+
+var DynamicImportKey = exports.DynamicImportKey = 'Import';
+
+// NOTE: This allows `yield import()` to parse correctly.
+_acorn.tokTypes._import.startsExpr = true;
+
+function parseDynamicImport() {
+  var node = this.startNode();
+  this.next();
+  if (this.type !== _acorn.tokTypes.parenL) {
+    this.unexpected();
+  }
+  return this.finishNode(node, DynamicImportKey);
+}
+
+function parenAfter() {
+  return (/^(\s|\/\/.*|\/\*[^]*?\*\/)*\(/.test(this.input.slice(this.pos))
+  );
+}
+
+function dynamicImport(Parser) {
+  return function (_Parser) {
+    _inherits(_class, _Parser);
+
+    function _class() {
+      _classCallCheck(this, _class);
+
+      return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments));
+    }
+
+    _createClass(_class, [{
+      key: 'parseStatement',
+      value: function () {
+        function parseStatement(context, topLevel, exports) {
+          if (this.type === _acorn.tokTypes._import && parenAfter.call(this)) {
+            return this.parseExpressionStatement(this.startNode(), this.parseExpression());
+          }
+          return _get(_class.prototype.__proto__ || Object.getPrototypeOf(_class.prototype), 'parseStatement', this).call(this, context, topLevel, exports);
+        }
+
+        return parseStatement;
+      }()
+    }, {
+      key: 'parseExprAtom',
+      value: function () {
+        function parseExprAtom(refDestructuringErrors) {
+          if (this.type === _acorn.tokTypes._import) {
+            return parseDynamicImport.call(this);
+          }
+          return _get(_class.prototype.__proto__ || Object.getPrototypeOf(_class.prototype), 'parseExprAtom', this).call(this, refDestructuringErrors);
+        }
+
+        return parseExprAtom;
+      }()
+    }]);
+
+    return _class;
+  }(Parser);
+}

kitabcitab/node_modules/acorn-node/lib/export-ns-from/index.js

@@ -0,0 +1,43 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g
+
+var tt = require("acorn").tokTypes
+
+module.exports = function(Parser) {
+  return /*@__PURE__*/(function (Parser) {
+    function anonymous () {
+      Parser.apply(this, arguments);
+    }
+
+    if ( Parser ) anonymous.__proto__ = Parser;
+    anonymous.prototype = Object.create( Parser && Parser.prototype );
+    anonymous.prototype.constructor = anonymous;
+
+    anonymous.prototype.parseExport = function parseExport (node, exports) {
+      skipWhiteSpace.lastIndex = this.pos
+      var skip = skipWhiteSpace.exec(this.input)
+      var next = this.input.charAt(this.pos + skip[0].length)
+      if (next !== "*") { return Parser.prototype.parseExport.call(this, node, exports) }
+
+      this.next()
+      var specifier = this.startNode()
+      this.expect(tt.star)
+      if (this.eatContextual("as")) {
+        node.declaration = null
+        specifier.exported = this.parseIdent(true)
+        this.checkExport(exports, specifier.exported.name, this.lastTokStart)
+        node.specifiers = [this.finishNode(specifier, "ExportNamespaceSpecifier")]
+      }
+      this.expectContextual("from")
+      if (this.type !== tt.string) { this.unexpected() }
+      node.source = this.parseExprAtom()
+      this.semicolon()
+      return this.finishNode(node, node.specifiers ? "ExportNamedDeclaration" : "ExportAllDeclaration")
+    };
+
+    return anonymous;
+  }(Parser))
+}

kitabcitab/node_modules/acorn-node/lib/import-meta/index.js

@@ -0,0 +1,55 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+var tt = require("acorn").tokTypes
+
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g
+
+var nextTokenIsDot = function (parser) {
+  skipWhiteSpace.lastIndex = parser.pos
+  var skip = skipWhiteSpace.exec(parser.input)
+  var next = parser.pos + skip[0].length
+  return parser.input.slice(next, next + 1) === "."
+}
+
+module.exports = function(Parser) {
+  return /*@__PURE__*/(function (Parser) {
+    function anonymous () {
+      Parser.apply(this, arguments);
+    }
+
+    if ( Parser ) anonymous.__proto__ = Parser;
+    anonymous.prototype = Object.create( Parser && Parser.prototype );
+    anonymous.prototype.constructor = anonymous;
+
+    anonymous.prototype.parseExprAtom = function parseExprAtom (refDestructuringErrors) {
+      if (this.type !== tt._import || !nextTokenIsDot(this)) { return Parser.prototype.parseExprAtom.call(this, refDestructuringErrors) }
+
+      if (!this.options.allowImportExportEverywhere && !this.inModule) {
+        this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'")
+      }
+
+      var node = this.startNode()
+      node.meta = this.parseIdent(true)
+      this.expect(tt.dot)
+      node.property = this.parseIdent(true)
+      if (node.property.name !== "meta") {
+        this.raiseRecoverable(node.property.start, "The only valid meta property for import is import.meta")
+      }
+      return this.finishNode(node, "MetaProperty")
+    };
+
+    anonymous.prototype.parseStatement = function parseStatement (context, topLevel, exports) {
+      if (this.type !== tt._import || !nextTokenIsDot(this)) {
+        return Parser.prototype.parseStatement.call(this, context, topLevel, exports)
+      }
+
+      var node = this.startNode()
+      var expr = this.parseExpression()
+      return this.parseExpressionStatement(node, expr)
+    };
+
+    return anonymous;
+  }(Parser))
+}

kitabcitab/node_modules/acorn-node/lib/numeric-separator/index.js

@@ -0,0 +1,61 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+module.exports = function(Parser) {
+  return /*@__PURE__*/(function (Parser) {
+    function anonymous () {
+      Parser.apply(this, arguments);
+    }
+
+    if ( Parser ) anonymous.__proto__ = Parser;
+    anonymous.prototype = Object.create( Parser && Parser.prototype );
+    anonymous.prototype.constructor = anonymous;
+
+    anonymous.prototype.readInt = function readInt (radix, len) {
+      // Hack: len is only != null for unicode escape sequences,
+      // where numeric separators are not allowed
+      if (len != null) { return Parser.prototype.readInt.call(this, radix, len) }
+
+      var start = this.pos, total = 0, acceptUnderscore = false
+      for (;;) {
+        var code = this.input.charCodeAt(this.pos), val = (void 0)
+        if (code >= 97) { val = code - 97 + 10 } // a
+        else if (code == 95) {
+          if (!acceptUnderscore) { this.raise(this.pos, "Invalid numeric separator") }
+          ++this.pos
+          acceptUnderscore = false
+          continue
+        } else if (code >= 65) { val = code - 65 + 10 } // A
+        else if (code >= 48 && code <= 57) { val = code - 48 } // 0-9
+        else { val = Infinity }
+        if (val >= radix) { break }
+        ++this.pos
+        total = total * radix + val
+        acceptUnderscore = true
+      }
+      if (this.pos === start) { return null }
+      if (!acceptUnderscore) { this.raise(this.pos - 1, "Invalid numeric separator") }
+
+      return total
+    };
+
+    anonymous.prototype.readNumber = function readNumber (startsWithDot) {
+      var token = Parser.prototype.readNumber.call(this, startsWithDot)
+      var octal = this.end - this.start >= 2 && this.input.charCodeAt(this.start) === 48
+      var stripped = this.getNumberInput(this.start, this.end)
+      if (stripped.length < this.end - this.start) {
+        if (octal) { this.raise(this.start, "Invalid number") }
+        this.value = parseFloat(stripped)
+      }
+      return token
+    };
+
+    // This is used by acorn-bigint
+    anonymous.prototype.getNumberInput = function getNumberInput (start, end) {
+      return this.input.slice(start, end).replace(/_/g, "")
+    };
+
+    return anonymous;
+  }(Parser))
+}

kitabcitab/node_modules/acorn-node/lib/private-class-elements/index.js

@@ -0,0 +1,135 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+var acorn = require("acorn")
+if (false) {
+  throw new Error(("acorn-private-class-elements requires acorn@^6.1.0, not " + (acorn.version)))
+}
+var tt = acorn.tokTypes
+var TokenType = acorn.TokenType
+
+module.exports = function(Parser) {
+  // Only load this plugin once.
+  if (Parser.prototype.parsePrivateName) {
+    return Parser
+  }
+
+  // Make sure `Parser` comes from the same acorn as our `tt`,
+  // otherwise the comparisons fail.
+  var cur = Parser
+  while (cur && cur !== acorn.Parser) {
+    cur = cur.__proto__
+  }
+  if (cur !== acorn.Parser) {
+    throw new Error("acorn-private-class-elements does not support mixing different acorn copies")
+  }
+
+  Parser = /*@__PURE__*/(function (Parser) {
+    function Parser_ () {
+      Parser.apply(this, arguments);
+    }
+
+    if ( Parser ) Parser_.__proto__ = Parser;
+    Parser_.prototype = Object.create( Parser && Parser.prototype );
+    Parser_.prototype.constructor = Parser_;
+
+    Parser_.prototype._branch = function _branch () {
+      this.__branch = this.__branch || new Parser({ecmaVersion: this.options.ecmaVersion}, this.input)
+      this.__branch.end = this.end
+      this.__branch.pos = this.pos
+      this.__branch.type = this.type
+      this.__branch.value = this.value
+      this.__branch.containsEsc = this.containsEsc
+      return this.__branch
+    };
+
+    Parser_.prototype.parsePrivateClassElementName = function parsePrivateClassElementName (element) {
+      element.computed = false
+      element.key = this.parsePrivateName()
+      if (element.key.name == "constructor") { this.raise(element.key.start, "Classes may not have a private element named constructor") }
+      var accept = {get: "set", set: "get"}[element.kind]
+      var privateBoundNames = this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1]
+      if (Object.prototype.hasOwnProperty.call(privateBoundNames, element.key.name) && privateBoundNames[element.key.name] !== accept) {
+        this.raise(element.start, "Duplicate private element")
+      }
+      privateBoundNames[element.key.name] = element.kind || true
+      delete this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1][element.key.name]
+      return element.key
+    };
+
+    Parser_.prototype.parsePrivateName = function parsePrivateName () {
+      var node = this.startNode()
+      node.name = this.value
+      this.next()
+      this.finishNode(node, "PrivateName")
+      if (this.options.allowReserved == "never") { this.checkUnreserved(node) }
+      return node
+    };
+
+    // Parse # token
+    Parser_.prototype.getTokenFromCode = function getTokenFromCode (code) {
+      if (code === 35) {
+        ++this.pos
+        var word = this.readWord1()
+        return this.finishToken(this.privateNameToken, word)
+      }
+      return Parser.prototype.getTokenFromCode.call(this, code)
+    };
+
+    // Manage stacks and check for undeclared private names
+    Parser_.prototype.parseClass = function parseClass (node, isStatement) {
+      this._privateBoundNamesStack = this._privateBoundNamesStack || []
+      var privateBoundNames = Object.create(this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1] || null)
+      this._privateBoundNamesStack.push(privateBoundNames)
+      this._unresolvedPrivateNamesStack = this._unresolvedPrivateNamesStack || []
+      var unresolvedPrivateNames = Object.create(null)
+      this._unresolvedPrivateNamesStack.push(unresolvedPrivateNames)
+      var _return = Parser.prototype.parseClass.call(this, node, isStatement)
+      this._privateBoundNamesStack.pop()
+      this._unresolvedPrivateNamesStack.pop()
+      if (!this._unresolvedPrivateNamesStack.length) {
+        var names = Object.keys(unresolvedPrivateNames)
+        if (names.length) {
+          names.sort(function (n1, n2) { return unresolvedPrivateNames[n1] - unresolvedPrivateNames[n2]; })
+          this.raise(unresolvedPrivateNames[names[0]], "Usage of undeclared private name")
+        }
+      } else { Object.assign(this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1], unresolvedPrivateNames) }
+      return _return
+    };
+
+    // Parse private element access
+    Parser_.prototype.parseSubscript = function parseSubscript (base, startPos, startLoc, noCalls, maybeAsyncArrow) {
+      if (!this.eat(tt.dot)) {
+        return Parser.prototype.parseSubscript.call(this, base, startPos, startLoc, noCalls, maybeAsyncArrow)
+      }
+      var node = this.startNodeAt(startPos, startLoc)
+      node.object = base
+      node.computed = false
+      if (this.type == this.privateNameToken) {
+        node.property = this.parsePrivateName()
+        if (!this._privateBoundNamesStack.length || !this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1][node.property.name]) {
+          this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1][node.property.name] = node.property.start
+        }
+      } else {
+        node.property = this.parseIdent(true)
+      }
+      return this.finishNode(node, "MemberExpression")
+    };
+
+    // Prohibit delete of private class elements
+    Parser_.prototype.parseMaybeUnary = function parseMaybeUnary (refDestructuringErrors, sawUnary) {
+      var _return = Parser.prototype.parseMaybeUnary.call(this, refDestructuringErrors, sawUnary)
+      if (_return.operator == "delete") {
+        if (_return.argument.type == "MemberExpression" && _return.argument.property.type == "PrivateName") {
+          this.raise(_return.start, "Private elements may not be deleted")
+        }
+      }
+      return _return
+    };
+
+    return Parser_;
+  }(Parser))
+  Parser.prototype.privateNameToken = new TokenType("privateName")
+  return Parser
+}

kitabcitab/node_modules/acorn-node/lib/static-class-features/index.js

@@ -0,0 +1,139 @@
+/* Generated by `npm run build`, do not edit! */
+
+"use strict"
+
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g
+
+var acorn = require("acorn")
+var tt = acorn.tokTypes
+
+function maybeParseFieldValue(field) {
+  if (this.eat(tt.eq)) {
+    var oldInFieldValue = this._inStaticFieldValue
+    this._inStaticFieldValue = true
+    field.value = this.parseExpression()
+    this._inStaticFieldValue = oldInFieldValue
+  } else { field.value = null }
+}
+
+var privateClassElements = require("../private-class-elements")
+
+module.exports = function(Parser) {
+  var ExtendedParser = privateClassElements(Parser)
+
+  return /*@__PURE__*/(function (ExtendedParser) {
+    function anonymous () {
+      ExtendedParser.apply(this, arguments);
+    }
+
+    if ( ExtendedParser ) anonymous.__proto__ = ExtendedParser;
+    anonymous.prototype = Object.create( ExtendedParser && ExtendedParser.prototype );
+    anonymous.prototype.constructor = anonymous;
+
+    anonymous.prototype.parseClassElement = function parseClassElement (_constructorAllowsSuper) {
+      var this$1 = this;
+
+      if (this.eat(tt.semi)) { return null }
+
+      var node = this.startNode()
+
+      var tryContextual = function (k, noLineBreak) {
+        if (typeof noLineBreak == "undefined") { noLineBreak = false }
+        var start = this$1.start, startLoc = this$1.startLoc
+        if (!this$1.eatContextual(k)) { return false }
+        if (this$1.type !== tt.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
+        if (node.key) { this$1.unexpected() }
+        node.computed = false
+        node.key = this$1.startNodeAt(start, startLoc)
+        node.key.name = k
+        this$1.finishNode(node.key, "Identifier")
+        return false
+      }
+
+      node.static = tryContextual("static")
+      if (!node.static) { return ExtendedParser.prototype.parseClassElement.apply(this, arguments) }
+
+      var isGenerator = this.eat(tt.star)
+      var isAsync = false
+      if (!isGenerator) {
+        // Special-case for `async`, since `parseClassMember` currently looks
+        // for `(` to determine whether `async` is a method name
+        if (this.options.ecmaVersion >= 8 && this.isContextual("async")) {
+          skipWhiteSpace.lastIndex = this.pos
+          var skip = skipWhiteSpace.exec(this.input)
+          var next = this.input.charAt(this.pos + skip[0].length)
+          if (next === ";" || next === "=") {
+            node.key = this.parseIdent(true)
+            node.computed = false
+            maybeParseFieldValue.call(this, node)
+            this.finishNode(node, "FieldDefinition")
+            this.semicolon()
+            return node
+          } else if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
+            isAsync = true
+            isGenerator = this.options.ecmaVersion >= 9 && this.eat(tt.star)
+          }
+        } else if (tryContextual("get")) {
+          node.kind = "get"
+        } else if (tryContextual("set")) {
+          node.kind = "set"
+        }
+      }
+      if (this.type === this.privateNameToken) {
+        this.parsePrivateClassElementName(node)
+        if (this.type !== tt.parenL) {
+          if (node.key.name === "prototype") {
+            this.raise(node.key.start, "Classes may not have a private static property named prototype")
+          }
+          maybeParseFieldValue.call(this, node)
+          this.finishNode(node, "FieldDefinition")
+          this.semicolon()
+          return node
+        }
+      } else if (!node.key) {
+        this.parsePropertyName(node)
+        if ((node.key.name || node.key.value) === "prototype" && !node.computed) {
+          this.raise(node.key.start, "Classes may not have a static property named prototype")
+        }
+      }
+      if (!node.kind) { node.kind = "method" }
+      this.parseClassMethod(node, isGenerator, isAsync)
+      if (!node.kind && (node.key.name || node.key.value) === "constructor" && !node.computed) {
+        this.raise(node.key.start, "Classes may not have a static field named constructor")
+      }
+      if (node.kind === "get" && node.value.params.length !== 0) {
+        this.raiseRecoverable(node.value.start, "getter should have no params")
+      }
+      if (node.kind === "set" && node.value.params.length !== 1) {
+        this.raiseRecoverable(node.value.start, "setter should have exactly one param")
+      }
+      if (node.kind === "set" && node.value.params[0].type === "RestElement") {
+        this.raiseRecoverable(node.value.params[0].start, "Setter cannot use rest params")
+      }
+
+      return node
+
+    };
+
+    // Parse public static fields
+    anonymous.prototype.parseClassMethod = function parseClassMethod (method, isGenerator, isAsync, _allowsDirectSuper) {
+      if (isGenerator || isAsync || method.kind != "method" || !method.static || this.options.ecmaVersion < 8 || this.type == tt.parenL) {
+        return ExtendedParser.prototype.parseClassMethod.apply(this, arguments)
+      }
+      maybeParseFieldValue.call(this, method)
+      delete method.kind
+      method = this.finishNode(method, "FieldDefinition")
+      this.semicolon()
+      return method
+    };
+
+    // Prohibit arguments in class field initializers
+    anonymous.prototype.parseIdent = function parseIdent (liberal, isBinding) {
+      var ident = ExtendedParser.prototype.parseIdent.call(this, liberal, isBinding)
+      if (this._inStaticFieldValue && ident.name == "arguments") { this.raise(ident.start, "A static class field initializer may not contain arguments") }
+      return ident
+    };
+
+    return anonymous;
+  }(ExtendedParser))
+}

kitabcitab/node_modules/acorn-node/node_modules/.bin/acorn

@@ -0,0 +1 @@
+../acorn/bin/acorn

kitabcitab/node_modules/acorn-node/node_modules/acorn/CHANGELOG.md

@@ -0,0 +1,620 @@
+## 7.4.0 (2020-08-03)
+
+### New features
+
+Add support for logical assignment operators.
+
+Add support for numeric separators.
+
+## 7.3.1 (2020-06-11)
+
+### Bug fixes
+
+Make the string in the `version` export match the actual library version.
+
+## 7.3.0 (2020-06-11)
+
+### Bug fixes
+
+Fix a bug that caused parsing of object patterns with a property named `set` that had a default value to fail.
+
+### New features
+
+Add support for optional chaining (`?.`).
+
+## 7.2.0 (2020-05-09)
+
+### Bug fixes
+
+Fix precedence issue in parsing of async arrow functions.
+
+### New features
+
+Add support for nullish coalescing.
+
+Add support for `import.meta`.
+
+Support `export * as ...` syntax.
+
+Upgrade to Unicode 13.
+
+## 6.4.1 (2020-03-09)
+
+### Bug fixes
+
+More carefully check for valid UTF16 surrogate pairs in regexp validator.
+
+## 7.1.1 (2020-03-01)
+
+### Bug fixes
+
+Treat `\8` and `\9` as invalid escapes in template strings.
+
+Allow unicode escapes in property names that are keywords.
+
+Don't error on an exponential operator expression as argument to `await`.
+
+More carefully check for valid UTF16 surrogate pairs in regexp validator.
+
+## 7.1.0 (2019-09-24)
+
+### Bug fixes
+
+Disallow trailing object literal commas when ecmaVersion is less than 5.
+
+### New features
+
+Add a static `acorn` property to the `Parser` class that contains the entire module interface, to allow plugins to access the instance of the library that they are acting on.
+
+## 7.0.0 (2019-08-13)
+
+### Breaking changes
+
+Changes the node format for dynamic imports to use the `ImportExpression` node type, as defined in [ESTree](https://github.com/estree/estree/blob/master/es2020.md#importexpression).
+
+Makes 10 (ES2019) the default value for the `ecmaVersion` option.
+
+## 6.3.0 (2019-08-12)
+
+### New features
+
+`sourceType: "module"` can now be used even when `ecmaVersion` is less than 6, to parse module-style code that otherwise conforms to an older standard.
+
+## 6.2.1 (2019-07-21)
+
+### Bug fixes
+
+Fix bug causing Acorn to treat some characters as identifier characters that shouldn't be treated as such.
+
+Fix issue where setting the `allowReserved` option to `"never"` allowed reserved words in some circumstances.
+
+## 6.2.0 (2019-07-04)
+
+### Bug fixes
+
+Improve valid assignment checking in `for`/`in` and `for`/`of` loops.
+
+Disallow binding `let` in patterns.
+
+### New features
+
+Support bigint syntax with `ecmaVersion` >= 11.
+
+Support dynamic `import` syntax with `ecmaVersion` >= 11.
+
+Upgrade to Unicode version 12.
+
+## 6.1.1 (2019-02-27)
+
+### Bug fixes
+
+Fix bug that caused parsing default exports of with names to fail.
+
+## 6.1.0 (2019-02-08)
+
+### Bug fixes
+
+Fix scope checking when redefining a `var` as a lexical binding.
+
+### New features
+
+Split up `parseSubscripts` to use an internal `parseSubscript` method to make it easier to extend with plugins.
+
+## 6.0.7 (2019-02-04)
+
+### Bug fixes
+
+Check that exported bindings are defined.
+
+Don't treat `\u180e` as a whitespace character.
+
+Check for duplicate parameter names in methods.
+
+Don't allow shorthand properties when they are generators or async methods.
+
+Forbid binding `await` in async arrow function's parameter list.
+
+## 6.0.6 (2019-01-30)
+
+### Bug fixes
+
+The content of class declarations and expressions is now always parsed in strict mode.
+
+Don't allow `let` or `const` to bind the variable name `let`.
+
+Treat class declarations as lexical.
+
+Don't allow a generator function declaration as the sole body of an `if` or `else`.
+
+Ignore `"use strict"` when after an empty statement.
+
+Allow string line continuations with special line terminator characters.
+
+Treat `for` bodies as part of the `for` scope when checking for conflicting bindings.
+
+Fix bug with parsing `yield` in a `for` loop initializer.
+
+Implement special cases around scope checking for functions.
+
+## 6.0.5 (2019-01-02)
+
+### Bug fixes
+
+Fix TypeScript type for `Parser.extend` and add `allowAwaitOutsideFunction` to options type.
+
+Don't treat `let` as a keyword when the next token is `{` on the next line.
+
+Fix bug that broke checking for parentheses around an object pattern in a destructuring assignment when `preserveParens` was on.
+
+## 6.0.4 (2018-11-05)
+
+### Bug fixes
+
+Further improvements to tokenizing regular expressions in corner cases.
+
+## 6.0.3 (2018-11-04)
+
+### Bug fixes
+
+Fix bug in tokenizing an expression-less return followed by a function followed by a regular expression.
+
+Remove stray symlink in the package tarball.
+
+## 6.0.2 (2018-09-26)
+
+### Bug fixes
+
+Fix bug where default expressions could fail to parse inside an object destructuring assignment expression.
+
+## 6.0.1 (2018-09-14)
+
+### Bug fixes
+
+Fix wrong value in `version` export.
+
+## 6.0.0 (2018-09-14)
+
+### Bug fixes
+
+Better handle variable-redefinition checks for catch bindings and functions directly under if statements.
+
+Forbid `new.target` in top-level arrow functions.
+
+Fix issue with parsing a regexp after `yield` in some contexts.
+
+### New features
+
+The package now comes with TypeScript definitions.
+
+### Breaking changes
+
+The default value of the `ecmaVersion` option is now 9 (2018).
+
+Plugins work differently, and will have to be rewritten to work with this version.
+
+The loose parser and walker have been moved into separate packages (`acorn-loose` and `acorn-walk`).
+
+## 5.7.3 (2018-09-10)
+
+### Bug fixes
+
+Fix failure to tokenize regexps after expressions like `x.of`.
+
+Better error message for unterminated template literals.
+
+## 5.7.2 (2018-08-24)
+
+### Bug fixes
+
+Properly handle `allowAwaitOutsideFunction` in for statements.
+
+Treat function declarations at the top level of modules like let bindings.
+
+Don't allow async function declarations as the only statement under a label.
+
+## 5.7.0 (2018-06-15)
+
+### New features
+
+Upgraded to Unicode 11.
+
+## 5.6.0 (2018-05-31)
+
+### New features
+
+Allow U+2028 and U+2029 in string when ECMAVersion >= 10.
+
+Allow binding-less catch statements when ECMAVersion >= 10.
+
+Add `allowAwaitOutsideFunction` option for parsing top-level `await`.
+
+## 5.5.3 (2018-03-08)
+
+### Bug fixes
+
+A _second_ republish of the code in 5.5.1, this time with yarn, to hopefully get valid timestamps.
+
+## 5.5.2 (2018-03-08)
+
+### Bug fixes
+
+A republish of the code in 5.5.1 in an attempt to solve an issue with the file timestamps in the npm package being 0.
+
+## 5.5.1 (2018-03-06)
+
+### Bug fixes
+
+Fix misleading error message for octal escapes in template strings.
+
+## 5.5.0 (2018-02-27)
+
+### New features
+
+The identifier character categorization is now based on Unicode version 10.
+
+Acorn will now validate the content of regular expressions, including new ES9 features.
+
+## 5.4.0 (2018-02-01)
+
+### Bug fixes
+
+Disallow duplicate or escaped flags on regular expressions.
+
+Disallow octal escapes in strings in strict mode.
+
+### New features
+
+Add support for async iteration.
+
+Add support for object spread and rest.
+
+## 5.3.0 (2017-12-28)
+
+### Bug fixes
+
+Fix parsing of floating point literals with leading zeroes in loose mode.
+
+Allow duplicate property names in object patterns.
+
+Don't allow static class methods named `prototype`.
+
+Disallow async functions directly under `if` or `else`.
+
+Parse right-hand-side of `for`/`of` as an assignment expression.
+
+Stricter parsing of `for`/`in`.
+
+Don't allow unicode escapes in contextual keywords.
+
+### New features
+
+Parsing class members was factored into smaller methods to allow plugins to hook into it.
+
+## 5.2.1 (2017-10-30)
+
+### Bug fixes
+
+Fix a token context corruption bug.
+
+## 5.2.0 (2017-10-30)
+
+### Bug fixes
+
+Fix token context tracking for `class` and `function` in property-name position.
+
+Make sure `%*` isn't parsed as a valid operator.
+
+Allow shorthand properties `get` and `set` to be followed by default values.
+
+Disallow `super` when not in callee or object position.
+
+### New features
+
+Support [`directive` property](https://github.com/estree/estree/compare/b3de58c9997504d6fba04b72f76e6dd1619ee4eb...1da8e603237144f44710360f8feb7a9977e905e0) on directive expression statements.
+
+## 5.1.2 (2017-09-04)
+
+### Bug fixes
+
+Disable parsing of legacy HTML-style comments in modules.
+
+Fix parsing of async methods whose names are keywords.
+
+## 5.1.1 (2017-07-06)
+
+### Bug fixes
+
+Fix problem with disambiguating regexp and division after a class.
+
+## 5.1.0 (2017-07-05)
+
+### Bug fixes
+
+Fix tokenizing of regexps in an object-desctructuring `for`/`of` loop and after `yield`.
+
+Parse zero-prefixed numbers with non-octal digits as decimal.
+
+Allow object/array patterns in rest parameters.
+
+Don't error when `yield` is used as a property name.
+
+Allow `async` as a shorthand object property.
+
+### New features
+
+Implement the [template literal revision proposal](https://github.com/tc39/proposal-template-literal-revision) for ES9.
+
+## 5.0.3 (2017-04-01)
+
+### Bug fixes
+
+Fix spurious duplicate variable definition errors for named functions.
+
+## 5.0.2 (2017-03-30)
+
+### Bug fixes
+
+A binary operator after a parenthesized arrow expression is no longer incorrectly treated as an error.
+
+## 5.0.0 (2017-03-28)
+
+### Bug fixes
+
+Raise an error for duplicated lexical bindings.
+
+Fix spurious error when an assignement expression occurred after a spread expression.
+
+Accept regular expressions after `of` (in `for`/`of`), `yield` (in a generator), and braced arrow functions.
+
+Allow labels in front or `var` declarations, even in strict mode.
+
+### Breaking changes
+
+Parse declarations following `export default` as declaration nodes, not expressions. This means that class and function declarations nodes can now have `null` as their `id`.
+
+## 4.0.11 (2017-02-07)
+
+### Bug fixes
+
+Allow all forms of member expressions to be parenthesized as lvalue.
+
+## 4.0.10 (2017-02-07)
+
+### Bug fixes
+
+Don't expect semicolons after default-exported functions or classes, even when they are expressions.
+
+Check for use of `'use strict'` directives in non-simple parameter functions, even when already in strict mode.
+
+## 4.0.9 (2017-02-06)
+
+### Bug fixes
+
+Fix incorrect error raised for parenthesized simple assignment targets, so that `(x) = 1` parses again.
+
+## 4.0.8 (2017-02-03)
+
+### Bug fixes
+
+Solve spurious parenthesized pattern errors by temporarily erring on the side of accepting programs that our delayed errors don't handle correctly yet.
+
+## 4.0.7 (2017-02-02)
+
+### Bug fixes
+
+Accept invalidly rejected code like `(x).y = 2` again.
+
+Don't raise an error when a function _inside_ strict code has a non-simple parameter list.
+
+## 4.0.6 (2017-02-02)
+
+### Bug fixes
+
+Fix exponential behavior (manifesting itself as a complete hang for even relatively small source files) introduced by the new 'use strict' check.
+
+## 4.0.5 (2017-02-02)
+
+### Bug fixes
+
+Disallow parenthesized pattern expressions.
+
+Allow keywords as export names.
+
+Don't allow the `async` keyword to be parenthesized.
+
+Properly raise an error when a keyword contains a character escape.
+
+Allow `"use strict"` to appear after other string literal expressions.
+
+Disallow labeled declarations.
+
+## 4.0.4 (2016-12-19)
+
+### Bug fixes
+
+Fix crash when `export` was followed by a keyword that can't be
+exported.
+
+## 4.0.3 (2016-08-16)
+
+### Bug fixes
+
+Allow regular function declarations inside single-statement `if` branches in loose mode. Forbid them entirely in strict mode.
+
+Properly parse properties named `async` in ES2017 mode.
+
+Fix bug where reserved words were broken in ES2017 mode.
+
+## 4.0.2 (2016-08-11)
+
+### Bug fixes
+
+Don't ignore period or 'e' characters after octal numbers.
+
+Fix broken parsing for call expressions in default parameter values of arrow functions.
+
+## 4.0.1 (2016-08-08)
+
+### Bug fixes
+
+Fix false positives in duplicated export name errors.
+
+## 4.0.0 (2016-08-07)
+
+### Breaking changes
+
+The default `ecmaVersion` option value is now 7.
+
+A number of internal method signatures changed, so plugins might need to be updated.
+
+### Bug fixes
+
+The parser now raises errors on duplicated export names.
+
+`arguments` and `eval` can now be used in shorthand properties.
+
+Duplicate parameter names in non-simple argument lists now always produce an error.
+
+### New features
+
+The `ecmaVersion` option now also accepts year-style version numbers
+(2015, etc).
+
+Support for `async`/`await` syntax when `ecmaVersion` is >= 8.
+
+Support for trailing commas in call expressions when `ecmaVersion` is >= 8.
+
+## 3.3.0 (2016-07-25)
+
+### Bug fixes
+
+Fix bug in tokenizing of regexp operator after a function declaration.
+
+Fix parser crash when parsing an array pattern with a hole.
+
+### New features
+
+Implement check against complex argument lists in functions that enable strict mode in ES7.
+
+## 3.2.0 (2016-06-07)
+
+### Bug fixes
+
+Improve handling of lack of unicode regexp support in host
+environment.
+
+Properly reject shorthand properties whose name is a keyword.
+
+### New features
+
+Visitors created with `visit.make` now have their base as _prototype_, rather than copying properties into a fresh object.
+
+## 3.1.0 (2016-04-18)
+
+### Bug fixes
+
+Properly tokenize the division operator directly after a function expression.
+
+Allow trailing comma in destructuring arrays.
+
+## 3.0.4 (2016-02-25)
+
+### Fixes
+
+Allow update expressions as left-hand-side of the ES7 exponential operator.
+
+## 3.0.2 (2016-02-10)
+
+### Fixes
+
+Fix bug that accidentally made `undefined` a reserved word when parsing ES7.
+
+## 3.0.0 (2016-02-10)
+
+### Breaking changes
+
+The default value of the `ecmaVersion` option is now 6 (used to be 5).
+
+Support for comprehension syntax (which was dropped from the draft spec) has been removed.
+
+### Fixes
+
+`let` and `yield` are now “contextual keywords”, meaning you can mostly use them as identifiers in ES5 non-strict code.
+
+A parenthesized class or function expression after `export default` is now parsed correctly.
+
+### New features
+
+When `ecmaVersion` is set to 7, Acorn will parse the exponentiation operator (`**`).
+
+The identifier character ranges are now based on Unicode 8.0.0.
+
+Plugins can now override the `raiseRecoverable` method to override the way non-critical errors are handled.
+
+## 2.7.0 (2016-01-04)
+
+### Fixes
+
+Stop allowing rest parameters in setters.
+
+Disallow `y` rexexp flag in ES5.
+
+Disallow `\00` and `\000` escapes in strict mode.
+
+Raise an error when an import name is a reserved word.
+
+## 2.6.2 (2015-11-10)
+
+### Fixes
+
+Don't crash when no options object is passed.
+
+## 2.6.0 (2015-11-09)
+
+### Fixes
+
+Add `await` as a reserved word in module sources.
+
+Disallow `yield` in a parameter default value for a generator.
+
+Forbid using a comma after a rest pattern in an array destructuring.
+
+### New features
+
+Support parsing stdin in command-line tool.
+
+## 2.5.0 (2015-10-27)
+
+### Fixes
+
+Fix tokenizer support in the command-line tool.
+
+Stop allowing `new.target` outside of functions.
+
+Remove legacy `guard` and `guardedHandler` properties from try nodes.
+
+Stop allowing multiple `__proto__` properties on an object literal in strict mode.
+
+Don't allow rest parameters to be non-identifier patterns.
+
+Check for duplicate paramter names in arrow functions.

kitabcitab/node_modules/acorn-node/node_modules/acorn/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2012-2018 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

kitabcitab/node_modules/acorn-node/node_modules/acorn/README.md

@@ -0,0 +1,269 @@
+# Acorn
+
+A tiny, fast JavaScript parser written in JavaScript.
+
+## Community
+
+Acorn is open source software released under an
+[MIT license](https://github.com/acornjs/acorn/blob/master/acorn/LICENSE).
+
+You are welcome to
+[report bugs](https://github.com/acornjs/acorn/issues) or create pull
+requests on [github](https://github.com/acornjs/acorn). For questions
+and discussion, please use the
+[Tern discussion forum](https://discuss.ternjs.net).
+
+## Installation
+
+The easiest way to install acorn is from [`npm`](https://www.npmjs.com/):
+
+```sh
+npm install acorn
+```
+
+Alternately, you can download the source and build acorn yourself:
+
+```sh
+git clone https://github.com/acornjs/acorn.git
+cd acorn
+npm install
+```
+
+## Interface
+
+**parse**`(input, options)` is the main interface to the library. The
+`input` parameter is a string, `options` can be undefined or an object
+setting some of the options listed below. The return value will be an
+abstract syntax tree object as specified by the [ESTree
+spec](https://github.com/estree/estree).
+
+```javascript
+let acorn = require("acorn");
+console.log(acorn.parse("1 + 1"));
+```
+
+When encountering a syntax error, the parser will raise a
+`SyntaxError` object with a meaningful message. The error object will
+have a `pos` property that indicates the string offset at which the
+error occurred, and a `loc` object that contains a `{line, column}`
+object referring to that same position.
+
+Options can be provided by passing a second argument, which should be
+an object containing any of these fields:
+
+- **ecmaVersion**: Indicates the ECMAScript version to parse. Must be
+  either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), 10 (2019) or 11
+  (2020, partial support). This influences support for strict mode,
+  the set of reserved words, and support for new syntax features.
+  Default is 10.
+
+  **NOTE**: Only 'stage 4' (finalized) ECMAScript features are being
+  implemented by Acorn. Other proposed new features can be implemented
+  through plugins.
+
+- **sourceType**: Indicate 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.
+
+  **NOTE**: If set to `"module"`, then static `import` / `export` syntax
+  will be valid, even if `ecmaVersion` is less than 6.
+
+- **onInsertedSemicolon**: If given a callback, that callback will be
+  called whenever a missing semicolon is inserted by the parser. The
+  callback will be given the character offset of the point where the
+  semicolon is inserted as argument, and if `locations` is on, also a
+  `{line, column}` object representing this position.
+
+- **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing
+  commas.
+
+- **allowReserved**: If `false`, using a reserved word will generate
+  an error. Defaults to `true` for `ecmaVersion` 3, `false` for higher
+  versions. When given the value `"never"`, reserved words and
+  keywords can also not be used as property names (as in Internet
+  Explorer's old parser).
+
+- **allowReturnOutsideFunction**: By default, a return statement at
+  the top level raises an error. Set this to `true` to accept such
+  code.
+
+- **allowImportExportEverywhere**: By default, `import` and `export`
+  declarations can only appear at a program's top level. Setting this
+  option to `true` allows them anywhere where a statement is allowed.
+  
+- **allowAwaitOutsideFunction**: By default, `await` expressions can
+  only appear inside `async` functions. Setting this option to
+  `true` allows to have top-level `await` expressions. They are
+  still not allowed in non-`async` functions, though.
+
+- **allowHashBang**: When this is enabled (off by default), if the
+  code starts with the characters `#!` (as in a shellscript), the
+  first line will be treated as a comment.
+
+- **locations**: When `true`, each node has a `loc` object attached
+  with `start` and `end` subobjects, each of which contains the
+  one-based line and zero-based column numbers in `{line, column}`
+  form. Default is `false`.
+
+- **onToken**: If a function is passed for this option, each found
+  token will be passed in same format as tokens returned from
+  `tokenizer().getToken()`.
+
+  If array is passed, each found token is pushed to it.
+
+  Note that you are not allowed to call the parser from the
+  callback—that will corrupt its internal state.
+
+- **onComment**: If a function is passed for this option, whenever a
+  comment is encountered the function will be called with the
+  following parameters:
+
+  - `block`: `true` if the comment is a block comment, false if it
+    is a line comment.
+  - `text`: The content of the comment.
+  - `start`: Character offset of the start of the comment.
+  - `end`: Character offset of the end of the comment.
+
+  When the `locations` options is on, the `{line, column}` locations
+  of the comment’s start and end are passed as two additional
+  parameters.
+
+  If array is passed for this option, each found comment is pushed
+  to it as object in Esprima format:
+
+  ```javascript
+  {
+    "type": "Line" | "Block",
+    "value": "comment text",
+    "start": Number,
+    "end": Number,
+    // If `locations` option is on:
+    "loc": {
+      "start": {line: Number, column: Number}
+      "end": {line: Number, column: Number}
+    },
+    // If `ranges` option is on:
+    "range": [Number, Number]
+  }
+  ```
+
+  Note that you are not allowed to call the parser from the
+  callback—that will corrupt its internal state.
+
+- **ranges**: 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](https://bugzilla.mozilla.org/show_bug.cgi?id=745678)
+  `range` property holding a `[start, end]` array with the same
+  numbers, set the `ranges` option to `true`.
+
+- **program**: It is possible to parse multiple files into a single
+  AST by passing the tree produced by parsing the first file as the
+  `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.
+
+- **sourceFile**: When the `locations` option is `true`, you can pass
+  this option to add a `source` attribute in every node’s `loc`
+  object. Note that the contents of this option are not examined or
+  processed in any way; you are free to use whatever format you
+  choose.
+
+- **directSourceFile**: Like `sourceFile`, but a `sourceFile` property
+  will be added (regardless of the `location` option) directly to the
+  nodes, rather than the `loc` object.
+
+- **preserveParens**: If this option is `true`, parenthesized expressions
+  are represented by (non-standard) `ParenthesizedExpression` nodes
+  that have a single `expression` property containing the expression
+  inside parentheses.
+
+**parseExpressionAt**`(input, offset, options)` will parse a single
+expression in a string, and return its AST. It will not complain if
+there is more of the string left after the expression.
+
+**tokenizer**`(input, options)` returns an object with a `getToken`
+method that can be called repeatedly to get the next token, a `{start,
+end, type, value}` object (with added `loc` property when the
+`locations` option is enabled and `range` property when the `ranges`
+option is enabled). When the token's type is `tokTypes.eof`, you
+should stop calling the method, since it will keep returning that same
+token forever.
+
+In ES6 environment, returned result can be used as any other
+protocol-compliant iterable:
+
+```javascript
+for (let token of acorn.tokenizer(str)) {
+  // iterate over the tokens
+}
+
+// transform code to array of tokens:
+var tokens = [...acorn.tokenizer(str)];
+```
+
+**tokTypes** holds an object mapping names to the token type objects
+that end up in the `type` properties of tokens.
+
+**getLineInfo**`(input, offset)` can be used to get a `{line,
+column}` object for a given program string and offset.
+
+### The `Parser` class
+
+Instances of the **`Parser`** class contain all the state and logic
+that drives a parse. It has static methods `parse`,
+`parseExpressionAt`, and `tokenizer` that match the top-level
+functions by the same name.
+
+When extending the parser with plugins, you need to call these methods
+on the extended version of the class. To extend a parser with plugins,
+you can use its static `extend` method.
+
+```javascript
+var acorn = require("acorn");
+var jsx = require("acorn-jsx");
+var JSXParser = acorn.Parser.extend(jsx());
+JSXParser.parse("foo(<bar/>)");
+```
+
+The `extend` method takes any number of plugin values, and returns a
+new `Parser` class that includes the extra parser logic provided by
+the plugins.
+
+## Command line interface
+
+The `bin/acorn` utility can be used to parse a file from the command
+line. It accepts as arguments its input file and the following
+options:
+
+- `--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|--ecma10`: Sets the ECMAScript version
+  to parse. Default is version 9.
+
+- `--module`: Sets the parsing mode to `"module"`. Is set to `"script"` otherwise.
+
+- `--locations`: Attaches a "loc" object to each node with "start" and
+  "end" subobjects, each of which contains the one-based line and
+  zero-based column numbers in `{line, column}` form.
+
+- `--allow-hash-bang`: If the code starts with the characters #! (as
+  in a shellscript), the first line will be treated as a comment.
+
+- `--compact`: No whitespace is used in the AST output.
+
+- `--silent`: Do not output the AST, just return the exit status.
+
+- `--help`: Print the usage information and quit.
+
+The utility spits out the syntax tree as JSON data.
+
+## Existing plugins
+
+ - [`acorn-jsx`](https://github.com/RReverser/acorn-jsx): Parse [Facebook JSX syntax extensions](https://github.com/facebook/jsx)
+ 
+Plugins for ECMAScript proposals:
+ 
+ - [`acorn-stage3`](https://github.com/acornjs/acorn-stage3): Parse most stage 3 proposals, bundling:
+   - [`acorn-class-fields`](https://github.com/acornjs/acorn-class-fields): Parse [class fields proposal](https://github.com/tc39/proposal-class-fields)
+   - [`acorn-import-meta`](https://github.com/acornjs/acorn-import-meta): Parse [import.meta proposal](https://github.com/tc39/proposal-import-meta)
+   - [`acorn-private-methods`](https://github.com/acornjs/acorn-private-methods): parse [private methods, getters and setters proposal](https://github.com/tc39/proposal-private-methods)n

kitabcitab/node_modules/acorn-node/node_modules/acorn/bin/acorn

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../dist/bin.js');

kitabcitab/node_modules/acorn-node/node_modules/acorn/dist/acorn.d.ts

@@ -0,0 +1,209 @@
+export as namespace acorn
+export = acorn
+
+declare namespace acorn {
+  function parse(input: string, options?: Options): Node
+
+  function parseExpressionAt(input: string, pos?: number, options?: Options): Node
+
+  function tokenizer(input: string, options?: Options): {
+    getToken(): Token
+    [Symbol.iterator](): Iterator<Token>
+  }
+
+  interface Options {
+    ecmaVersion?: 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020
+    sourceType?: 'script' | 'module'
+    onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    allowReserved?: boolean | 'never'
+    allowReturnOutsideFunction?: boolean
+    allowImportExportEverywhere?: boolean
+    allowAwaitOutsideFunction?: boolean
+    allowHashBang?: boolean
+    locations?: boolean
+    onToken?: ((token: Token) => any) | Token[]
+    onComment?: ((
+      isBlock: boolean, text: string, start: number, end: number, startLoc?: Position,
+      endLoc?: Position
+    ) => void) | Comment[]
+    ranges?: boolean
+    program?: Node
+    sourceFile?: string
+    directSourceFile?: string
+    preserveParens?: boolean
+  }
+
+  class Parser {
+    constructor(options: Options, input: string, startPos?: number)
+    parse(this: Parser): Node
+    static parse(this: typeof Parser, input: string, options?: Options): Node
+    static parseExpressionAt(this: typeof Parser, input: string, pos: number, options?: Options): Node
+    static tokenizer(this: typeof Parser, input: string, options?: Options): {
+      getToken(): Token
+      [Symbol.iterator](): Iterator<Token>
+    }
+    static extend(this: typeof Parser, ...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]): typeof Parser
+  }
+
+  interface Position { line: number; column: number; offset: number }
+
+  const defaultOptions: Options
+
+  function getLineInfo(input: string, offset: number): Position
+
+  class SourceLocation {
+    start: Position
+    end: Position
+    source?: string | null
+    constructor(p: Parser, start: Position, end: Position)
+  }
+
+  class Node {
+    type: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    sourceFile?: string
+    range?: [number, number]
+    constructor(parser: Parser, pos: number, loc?: SourceLocation)
+  }
+
+  class TokenType {
+    label: string
+    keyword: string
+    beforeExpr: boolean
+    startsExpr: boolean
+    isLoop: boolean
+    isAssign: boolean
+    prefix: boolean
+    postfix: boolean
+    binop: number
+    updateContext?: (prevType: TokenType) => void
+    constructor(label: string, conf?: any)
+  }
+
+  const tokTypes: {
+    num: TokenType
+    regexp: TokenType
+    string: TokenType
+    name: TokenType
+    eof: TokenType
+    bracketL: TokenType
+    bracketR: TokenType
+    braceL: TokenType
+    braceR: TokenType
+    parenL: TokenType
+    parenR: TokenType
+    comma: TokenType
+    semi: TokenType
+    colon: TokenType
+    dot: TokenType
+    question: TokenType
+    arrow: TokenType
+    template: TokenType
+    ellipsis: TokenType
+    backQuote: TokenType
+    dollarBraceL: TokenType
+    eq: TokenType
+    assign: TokenType
+    incDec: TokenType
+    prefix: TokenType
+    logicalOR: TokenType
+    logicalAND: TokenType
+    bitwiseOR: TokenType
+    bitwiseXOR: TokenType
+    bitwiseAND: TokenType
+    equality: TokenType
+    relational: TokenType
+    bitShift: TokenType
+    plusMin: TokenType
+    modulo: TokenType
+    star: TokenType
+    slash: TokenType
+    starstar: TokenType
+    _break: TokenType
+    _case: TokenType
+    _catch: TokenType
+    _continue: TokenType
+    _debugger: TokenType
+    _default: TokenType
+    _do: TokenType
+    _else: TokenType
+    _finally: TokenType
+    _for: TokenType
+    _function: TokenType
+    _if: TokenType
+    _return: TokenType
+    _switch: TokenType
+    _throw: TokenType
+    _try: TokenType
+    _var: TokenType
+    _const: TokenType
+    _while: TokenType
+    _with: TokenType
+    _new: TokenType
+    _this: TokenType
+    _super: TokenType
+    _class: TokenType
+    _extends: TokenType
+    _export: TokenType
+    _import: TokenType
+    _null: TokenType
+    _true: TokenType
+    _false: TokenType
+    _in: TokenType
+    _instanceof: TokenType
+    _typeof: TokenType
+    _void: TokenType
+    _delete: TokenType
+  }
+
+  class TokContext {
+    constructor(token: string, isExpr: boolean, preserveSpace: boolean, override?: (p: Parser) => void)
+  }
+
+  const tokContexts: {
+    b_stat: TokContext
+    b_expr: TokContext
+    b_tmpl: TokContext
+    p_stat: TokContext
+    p_expr: TokContext
+    q_tmpl: TokContext
+    f_expr: TokContext
+  }
+
+  function isIdentifierStart(code: number, astral?: boolean): boolean
+
+  function isIdentifierChar(code: number, astral?: boolean): boolean
+
+  interface AbstractToken {
+  }
+
+  interface Comment extends AbstractToken {
+    type: string
+    value: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+  }
+
+  class Token {
+    type: TokenType
+    value: any
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+    constructor(p: Parser)
+  }
+
+  function isNewLine(code: number): boolean
+
+  const lineBreak: RegExp
+
+  const lineBreakG: RegExp
+
+  const version: string
+}

kitabcitab/node_modules/acorn-node/node_modules/acorn/dist/acorn.mjs.d.ts

@@ -0,0 +1,2 @@
+import * as acorn from "./acorn";
+export = acorn;

kitabcitab/node_modules/acorn-node/node_modules/acorn/dist/bin.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var acorn = require('./acorn.js');
+
+var infile, forceFile, silent = false, compact = false, tokenize = false;
+var options = {};
+
+function help(status) {
+  var print = (status === 0) ? console.log : console.error;
+  print("usage: " + path.basename(process.argv[1]) + " [--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|...|--ecma2015|--ecma2016|--ecma2017|--ecma2018|...]");
+  print("        [--tokenize] [--locations] [---allow-hash-bang] [--compact] [--silent] [--module] [--help] [--] [infile]");
+  process.exit(status);
+}
+
+for (var i = 2; i < process.argv.length; ++i) {
+  var arg = process.argv[i];
+  if ((arg === "-" || arg[0] !== "-") && !infile) { infile = arg; }
+  else if (arg === "--" && !infile && i + 2 === process.argv.length) { forceFile = infile = process.argv[++i]; }
+  else if (arg === "--locations") { options.locations = true; }
+  else if (arg === "--allow-hash-bang") { options.allowHashBang = true; }
+  else if (arg === "--silent") { silent = true; }
+  else if (arg === "--compact") { compact = true; }
+  else if (arg === "--help") { help(0); }
+  else if (arg === "--tokenize") { tokenize = true; }
+  else if (arg === "--module") { options.sourceType = "module"; }
+  else {
+    var match = arg.match(/^--ecma(\d+)$/);
+    if (match)
+      { options.ecmaVersion = +match[1]; }
+    else
+      { help(1); }
+  }
+}
+
+function run(code) {
+  var result;
+  try {
+    if (!tokenize) {
+      result = acorn.parse(code, options);
+    } else {
+      result = [];
+      var tokenizer = acorn.tokenizer(code, options), token;
+      do {
+        token = tokenizer.getToken();
+        result.push(token);
+      } while (token.type !== acorn.tokTypes.eof)
+    }
+  } catch (e) {
+    console.error(infile && infile !== "-" ? e.message.replace(/\(\d+:\d+\)$/, function (m) { return m.slice(0, 1) + infile + " " + m.slice(1); }) : e.message);
+    process.exit(1);
+  }
+  if (!silent) { console.log(JSON.stringify(result, null, compact ? null : 2)); }
+}
+
+if (forceFile || infile && infile !== "-") {
+  run(fs.readFileSync(infile, "utf8"));
+} else {
+  var code = "";
+  process.stdin.resume();
+  process.stdin.on("data", function (chunk) { return code += chunk; });
+  process.stdin.on("end", function () { return run(code); });
+}

kitabcitab/node_modules/acorn-node/node_modules/acorn/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "acorn",
+  "description": "ECMAScript parser",
+  "homepage": "https://github.com/acornjs/acorn",
+  "main": "dist/acorn.js",
+  "types": "dist/acorn.d.ts",
+  "module": "dist/acorn.mjs",
+  "version": "7.4.1",
+  "engines": {"node": ">=0.4.0"},
+  "maintainers": [
+    {
+      "name": "Marijn Haverbeke",
+      "email": "marijnh@gmail.com",
+      "web": "https://marijnhaverbeke.nl"
+    },
+    {
+      "name": "Ingvar Stepanyan",
+      "email": "me@rreverser.com",
+      "web": "https://rreverser.com/"
+    },
+    {
+      "name": "Adrian Heine",
+      "web": "http://adrianheine.de"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/acornjs/acorn.git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "prepare": "cd ..; npm run build:main && npm run build:bin"
+  },
+  "bin": {"acorn": "./bin/acorn"}
+}

kitabcitab/node_modules/acorn-node/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "acorn-node",
+  "description": "the acorn javascript parser, preloaded with plugins for syntax parity with recent node versions",
+  "version": "1.8.2",
+  "author": "Renée Kooi <renee@kooi.me>",
+  "bugs": {
+    "url": "https://github.com/browserify/acorn-node/issues"
+  },
+  "dependencies": {
+    "acorn": "^7.0.0",
+    "acorn-walk": "^7.0.0",
+    "xtend": "^4.0.2"
+  },
+  "devDependencies": {
+    "acorn-bigint": "^0.4.0",
+    "acorn-class-fields": "^0.3.1",
+    "acorn-dynamic-import": "^4.0.0",
+    "acorn-export-ns-from": "^0.1.0",
+    "acorn-import-meta": "^0.3.0",
+    "acorn-numeric-separator": "^0.3.0",
+    "acorn-private-class-elements": "^0.1.1",
+    "acorn-static-class-features": "^0.2.0",
+    "buble": "^0.19.8",
+    "mkdirp": "^0.5.1",
+    "standard": "^13.1.0",
+    "tape": "^4.11.0"
+  },
+  "homepage": "https://github.com/browserify/acorn-node",
+  "keywords": [
+    "acorn",
+    "browserify",
+    "javascript",
+    "parser"
+  ],
+  "license": "Apache-2.0",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/browserify/acorn-node.git"
+  },
+  "scripts": {
+    "test": "standard && node test/index.js",
+    "prepublishOnly": "npm run build",
+    "build": "node build.js"
+  },
+  "standard": {
+    "ignore": [
+      "lib/*/*.js"
+    ]
+  }
+}

kitabcitab/node_modules/acorn-node/test/index.js

@@ -0,0 +1,154 @@
+var test = require('tape')
+var acorn = require('../')
+var walk = require('../walk')
+var baseAcorn = require('acorn')
+
+test('parses object spread syntax', function (t) {
+  var ast = acorn.parse('var a = { ...b }')
+  t.equal(ast.body[0].declarations[0].init.type, 'ObjectExpression')
+  t.equal(ast.body[0].declarations[0].init.properties[0].type, 'SpreadElement')
+
+  ast = acorn.parse('function a ({ ...b }) {}')
+  t.equal(ast.body[0].params[0].type, 'ObjectPattern')
+  t.equal(ast.body[0].params[0].properties[0].type, 'RestElement')
+
+  t.end()
+})
+
+test('does not change main acorn module', function (t) {
+  t.throws(function () {
+    baseAcorn.parse('var a = 10n')
+  })
+  t.end()
+})
+
+test('tokenizes object spread syntax', function (t) {
+  var tokenizer = acorn.tokenizer('var a = { ...b }')
+
+  t.doesNotThrow(function (t) {
+    while (tokenizer.getToken().type !== acorn.tokTypes.eof) {}
+  })
+  t.end()
+})
+
+test('allows hashbangs by default', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('#!/usr/bin/env node\nconsole.log("ok")')
+  })
+  t.end()
+})
+
+test('allows top level return by default', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('console.log("ok"); return; console.log("not ok")')
+  })
+  t.end()
+})
+
+test('supports async generators', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('async function* a () { await x; yield 1 }')
+  })
+  t.end()
+})
+
+test('supports async iteration', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('async function l (y) { for await (const x of y) {} }')
+  })
+  t.end()
+})
+
+test('supports optional catch', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('try { throw null } catch {}')
+  })
+  t.end()
+})
+
+test('supports bigint', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('50n ** 50n')
+  })
+  t.end()
+})
+
+test('supports numeric separators', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('50_000_000n ** 1n')
+  })
+  t.end()
+})
+
+test('supports import.meta with sourceType: module', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('console.log(import.meta.url)', { sourceType: 'module' })
+  })
+  t.end()
+})
+
+test('supports dynamic import() with sourceType: module', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('import("./whatever.mjs")', { sourceType: 'module' })
+  })
+  t.end()
+})
+
+test('supports dynamic import() with sourceType: script', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('import("./whatever.mjs")', { sourceType: 'script' })
+  })
+  t.end()
+})
+
+test('supports class instance properties', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('class X { x = y }', { sourceType: 'script' })
+  })
+  t.end()
+})
+
+test('supports private class instance properties', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('class X { #x = y }', { sourceType: 'script' })
+  })
+  t.end()
+})
+
+test('supports class static properties', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('class X { static x = y }', { sourceType: 'script' })
+  })
+  t.end()
+})
+
+test('supports private class static properties', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('class X { static #x = y }', { sourceType: 'script' })
+  })
+  t.end()
+})
+
+test('supports namespace export syntax with sourceType: module', function (t) {
+  t.doesNotThrow(function () {
+    acorn.parse('export * as x from "./x.mjs";', { sourceType: 'module' })
+  })
+  t.end()
+})
+
+test('walk supports plugin syntax', function (t) {
+  var ast = acorn.parse(
+    'async function* a() { try { await import(xyz); } catch { for await (x of null) {} } yield import.meta.url }',
+    { sourceType: 'module' }
+  )
+  t.plan(2)
+  walk.simple(ast, {
+    Import: function () {
+      t.pass('import()')
+    },
+    MetaProperty: function () {
+      t.pass('import.meta')
+    }
+  })
+  t.end()
+})

kitabcitab/node_modules/acorn-node/walk.js

@@ -0,0 +1,57 @@
+var xtend = require('xtend')
+var walk = require('acorn-walk')
+
+var base = xtend(walk.base)
+base.Import = function () {}
+
+function simple (node, visitors, baseVisitor, state, override) {
+  return walk.simple(node, visitors, baseVisitor || base, state, override)
+}
+
+function ancestor (node, visitors, baseVisitor, state) {
+  return walk.ancestor(node, visitors, baseVisitor || base, state)
+}
+
+function recursive (node, state, funcs, baseVisitor, override) {
+  return walk.recursive(node, state, funcs, baseVisitor || base, override)
+}
+
+function full (node, callback, baseVisitor, state, override) {
+  return walk.full(node, callback, baseVisitor || base, state, override)
+}
+
+function fullAncestor (node, callback, baseVisitor, state) {
+  return walk.fullAncestor(node, callback, baseVisitor || base, state)
+}
+
+function findNodeAt (node, start, end, test, baseVisitor, state) {
+  return walk.findNodeAt(node, start, end, test, baseVisitor || base, state)
+}
+
+function findNodeAround (node, pos, test, baseVisitor, state) {
+  return walk.findNodeAround(node, pos, test, baseVisitor || base, state)
+}
+
+function findNodeAfter (node, pos, test, baseVisitor, state) {
+  return walk.findNodeAfter(node, pos, test, baseVisitor || base, state)
+}
+
+function findNodeBefore (node, pos, test, baseVisitor, state) {
+  return walk.findNodeBefore(node, pos, test, baseVisitor || base, state)
+}
+
+function make (funcs, baseVisitor) {
+  return walk.make(funcs, baseVisitor || base)
+}
+
+exports.simple = simple
+exports.ancestor = ancestor
+exports.recursive = recursive
+exports.full = full
+exports.fullAncestor = fullAncestor
+exports.findNodeAt = findNodeAt
+exports.findNodeAround = findNodeAround
+exports.findNodeAfter = findNodeAfter
+exports.findNodeBefore = findNodeBefore
+exports.make = make
+exports.base = base