modified

node_modules/acorn-private-methods/.eslintignore

@@ -0,0 +1 @@
+dist/

node_modules/acorn-private-methods/.eslintrc.json

@@ -0,0 +1,298 @@
+{
+    "env": {
+        "es6": true,
+        "node": true
+    },
+    "extends": ["eslint:recommended", "plugin:node/recommended"],
+    "plugins": ["node"],
+    "overrides": [{
+      "files": ["rollup.config.js", "index.js"],
+      "parserOptions": { "sourceType": "module" }
+    }],
+    "rules": {
+        "accessor-pairs": "error",
+        "array-bracket-newline": "off",
+        "array-bracket-spacing": "off",
+        "array-callback-return": "error",
+        "array-element-newline": "off",
+        "arrow-body-style": "error",
+        "arrow-parens": [
+            "error",
+            "as-needed"
+        ],
+        "arrow-spacing": [
+            "error",
+            {
+                "after": true,
+                "before": true
+            }
+        ],
+        "block-scoped-var": "error",
+        "block-spacing": "off",
+        "brace-style": [
+            "error",
+            "1tbs",
+            {
+                "allowSingleLine": true
+            }
+        ],
+        "callback-return": "error",
+        "camelcase": "error",
+        "capitalized-comments": "off",
+        "class-methods-use-this": "error",
+        "comma-dangle": "off",
+        "comma-spacing": [
+            "error",
+            {
+                "after": true,
+                "before": false
+            }
+        ],
+        "comma-style": [
+            "error",
+            "last"
+        ],
+        "complexity": "off",
+        "computed-property-spacing": [
+            "error",
+            "never"
+        ],
+        "consistent-return": "error",
+        "consistent-this": "error",
+        "curly": [ "error", "multi-line" ],
+        "default-case": "error",
+        "dot-location": "error",
+        "dot-notation": [
+            "error",
+            {
+                "allowKeywords": true
+            }
+        ],
+        "eol-last": "error",
+        "eqeqeq": "off",
+        "for-direction": "error",
+        "func-call-spacing": "error",
+        "func-name-matching": "error",
+        "func-names": [
+            "error",
+            "never"
+        ],
+        "func-style": [
+            "error",
+            "declaration",
+            { "allowArrowFunctions": true }
+        ],
+        "function-paren-newline": "off",
+        "generator-star-spacing": "error",
+        "getter-return": "error",
+        "global-require": "error",
+        "guard-for-in": "error",
+        "handle-callback-err": "error",
+        "id-blacklist": "error",
+        "id-length": "off",
+        "id-match": "error",
+        "implicit-arrow-linebreak": [
+            "error",
+            "beside"
+        ],
+        "indent": ["error", 2],
+        "indent-legacy": "off",
+        "init-declarations": "off",
+        "jsx-quotes": "error",
+        "key-spacing": "error",
+        "keyword-spacing": [
+            "error",
+            {
+                "after": true,
+                "before": true
+            }
+        ],
+        "line-comment-position": "off",
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "lines-around-comment": "error",
+        "lines-around-directive": "error",
+        "lines-between-class-members": "error",
+        "max-depth": "error",
+        "max-len": "off",
+        "max-lines": "off",
+        "max-nested-callbacks": "error",
+        "max-params": "off",
+        "max-statements": "off",
+        "max-statements-per-line": "off",
+        "multiline-comment-style": [
+            "error",
+            "separate-lines"
+        ],
+        "new-cap": "error",
+        "new-parens": "error",
+        "newline-after-var": "off",
+        "newline-before-return": "off",
+        "newline-per-chained-call": "off",
+        "no-alert": "error",
+        "no-array-constructor": "error",
+        "no-await-in-loop": "error",
+        "no-bitwise": "error",
+        "no-buffer-constructor": "error",
+        "no-caller": "error",
+        "no-catch-shadow": "error",
+        "no-confusing-arrow": "error",
+        "no-continue": "off",
+        "no-div-regex": "error",
+        "no-duplicate-imports": "error",
+        "no-else-return": "error",
+        "no-empty-function": "error",
+        "no-eq-null": "error",
+        "no-eval": "error",
+        "no-extend-native": "error",
+        "no-extra-bind": "error",
+        "no-extra-label": "error",
+        "no-extra-parens": "off",
+        "no-floating-decimal": "error",
+        "no-implicit-coercion": "error",
+        "no-implicit-globals": "error",
+        "no-implied-eval": "error",
+        "no-inline-comments": "off",
+        "no-invalid-this": "off",
+        "no-iterator": "error",
+        "no-label-var": "error",
+        "no-labels": "error",
+        "no-lone-blocks": "error",
+        "no-lonely-if": "off",
+        "no-loop-func": "error",
+        "no-magic-numbers": "off",
+        "no-mixed-operators": "off",
+        "no-mixed-requires": "error",
+        "no-multi-assign": "error",
+        "no-multi-spaces": "error",
+        "no-multi-str": "error",
+        "no-multiple-empty-lines": ["error", { "max": 1, "maxEOF": 0, "maxBOF": 0 }],
+        "no-native-reassign": "error",
+        "no-negated-condition": "off",
+        "no-negated-in-lhs": "error",
+        "no-nested-ternary": "error",
+        "no-new": "error",
+        "no-new-func": "error",
+        "no-new-object": "error",
+        "no-new-require": "error",
+        "no-new-wrappers": "error",
+        "no-octal-escape": "error",
+        "no-param-reassign": "off",
+        "no-path-concat": "error",
+        "no-plusplus": "off",
+        "no-process-env": "error",
+        "no-process-exit": "error",
+        "no-proto": "error",
+        "no-prototype-builtins": "error",
+        "no-restricted-globals": "error",
+        "no-restricted-imports": "error",
+        "no-restricted-modules": "error",
+        "no-restricted-properties": "error",
+        "no-restricted-syntax": "error",
+        "no-return-assign": "error",
+        "no-return-await": "error",
+        "no-script-url": "error",
+        "no-self-compare": "error",
+        "no-sequences": "error",
+        "no-shadow": "error",
+        "no-shadow-restricted-names": "error",
+        "no-spaced-func": "error",
+        "no-sync": [
+            "error",
+            {
+                "allowAtRootLevel": true
+            }
+        ],
+        "no-tabs": "error",
+        "no-template-curly-in-string": "error",
+        "no-ternary": "off",
+        "no-throw-literal": "error",
+        "no-trailing-spaces": "error",
+        "no-undef-init": "error",
+        "no-undefined": "error",
+        "no-underscore-dangle": "off",
+        "no-unmodified-loop-condition": "error",
+        "no-unneeded-ternary": "error",
+        "no-unused-expressions": "error",
+        "no-unused-vars": ["error", {"argsIgnorePattern": "^_"}],
+        "no-use-before-define": "error",
+        "no-useless-call": "error",
+        "no-useless-computed-key": "error",
+        "no-useless-concat": "error",
+        "no-useless-constructor": "error",
+        "no-useless-rename": "error",
+        "no-useless-return": "error",
+        "no-var": "error",
+        "no-void": "error",
+        "no-warning-comments": "warn",
+        "no-whitespace-before-property": "error",
+        "no-with": "error",
+        "nonblock-statement-body-position": [
+            "error",
+            "any"
+        ],
+        "object-curly-newline": "off",
+        "object-curly-spacing": "off",
+        "object-property-newline": "off",
+        "object-shorthand": "off",
+        "one-var": "off",
+        "one-var-declaration-per-line": "off",
+        "operator-assignment": "error",
+        "operator-linebreak": "error",
+        "padded-blocks": "off",
+        "padding-line-between-statements": "error",
+        "prefer-arrow-callback": "off",
+        "prefer-const": "off",
+        "prefer-destructuring": "off",
+        "prefer-numeric-literals": "error",
+        "prefer-promise-reject-errors": "error",
+        "prefer-reflect": "off",
+        "prefer-rest-params": "off",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        "quote-props": ["error", "as-needed"],
+        "quotes": ["error", "double"],
+        "radix": "error",
+        "require-await": "error",
+        "require-jsdoc": "off",
+        "rest-spread-spacing": "error",
+        "semi": ["error", "never"],
+        "semi-spacing": "error",
+        "semi-style": [
+            "error",
+            "last"
+        ],
+        "sort-imports": "error",
+        "sort-keys": "off",
+        "sort-vars": "off",
+        "space-before-blocks": "error",
+        "space-before-function-paren": "off",
+        "space-in-parens": [
+            "error",
+            "never"
+        ],
+        "space-infix-ops": "error",
+        "space-unary-ops": "error",
+        "spaced-comment": "off",
+        "strict": "error",
+        "switch-colon-spacing": "error",
+        "symbol-description": "error",
+        "template-curly-spacing": "error",
+        "template-tag-spacing": "error",
+        "unicode-bom": [
+            "error",
+            "never"
+        ],
+        "valid-jsdoc": "error",
+        "vars-on-top": "off",
+        "wrap-regex": "error",
+        "yield-star-spacing": "error",
+        "yoda": [
+            "error",
+            "never"
+        ],
+        "node/no-unpublished-require": "off"
+    }
+}

node_modules/acorn-private-methods/CHANGELOG.md

@@ -0,0 +1,50 @@
+## 1.0.0 (2021-02-08)
+
+* Update AST node names to match [ESTree](https://github.com/estree/estree/blob/master/experimental/class-features.md)
+
+## 0.3.3 (2020-08-13)
+
+* Migrate to ESM
+* Mark as compatible with acorn@8
+
+## 0.3.2 (2020-06-11)
+
+* Don't break acorn's optional chaining support
+
+## 0.3.1 (2020-04-22)
+
+* Don't parse static private methods
+* Don't allow private method access on `super`
+* Use injected acorn instance if available
+* Uses `Object.getPrototypeOf` if available instead of `__proto__`
+* Mark as compatible with acorn v7
+
+## 0.3.0 (2019-02-09)
+
+* Require acorn >= 6.1.0
+
+## 0.2.3 (2019-02-09)
+
+* Forbid binding await in async arrow function's parameter list
+
+## 0.2.2 (2019-01-30)
+
+* Fix parsing of chained subscripts
+
+## 0.2.1 (2018-11-06)
+
+* Adapt to changes in acorn 6.0.3
+
+## 0.2.0 (2018-09-14)
+
+* Update to new acorn 6 interface
+* Change license to MIT
+* Don't allow direct super() calls in private methods
+
+## 0.1.1 (2018-02-09)
+
+* Don't accept whitespace between hash and private name
+
+## 0.1.0 (2018-01-13)
+
+Initial release

node_modules/acorn-private-methods/LICENSE

@@ -0,0 +1,19 @@
+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.

node_modules/acorn-private-methods/README.md

@@ -0,0 +1,29 @@
+# Private methods and getter/setters support for Acorn
+
+[![NPM version](https://img.shields.io/npm/v/acorn-private-methods.svg)](https://www.npmjs.org/package/acorn-private-methods)
+
+This is a plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
+
+It implements support for private methods, getters and setters as defined in the stage 3 proposal [Private methods and getter/setters for JavaScript classes](https://github.com/tc39/proposal-private-methods). The emitted AST follows the [ESTree experimental Class Features design](https://github.com/estree/estree/blob/master/experimental/class-features.md).
+
+## Usage
+
+This module provides a plugin that can be used to extend the Acorn `Parser` class:
+
+```javascript
+const {Parser} = require('acorn');
+const privateMethods = require('acorn-private-methods');
+Parser.extend(privateMethods).parse('class X { #a() {} }');
+```
+
+or as an ECMAScript Module:
+
+```javascript
+import {Parser} from 'acorn';
+import privateMethods from 'acorn-private-methods';
+Parser.extend(privateMethods).parse('class X { #a() {} }');
+```
+
+## License
+
+This plugin is released under an [MIT License](./LICENSE).

node_modules/acorn-private-methods/dist/acorn-private-methods.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var privateClassElements = require('acorn-private-class-elements');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var privateClassElements__default = /*#__PURE__*/_interopDefaultLegacy(privateClassElements);
+
+// eslint-disable-next-line node/no-unsupported-features/es-syntax
+
+// eslint-disable-next-line node/no-unsupported-features/es-syntax
+function privateMethods(Parser) {
+  const ExtendedParser = privateClassElements__default['default'](Parser);
+
+  return class extends ExtendedParser {
+    // Parse private methods
+    parseClassElement(_constructorAllowsSuper) {
+      const oldInClassMemberName = this._inClassMemberName;
+      this._inClassMemberName = true;
+      const result = super.parseClassElement.apply(this, arguments);
+      this._inClassMemberName = oldInClassMemberName;
+      return result
+    }
+
+    parsePropertyName(prop) {
+      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateIdentifierToken && !prop.static;
+      this._inClassMemberName = false;
+      if (!isPrivate) return super.parsePropertyName(prop)
+      return this.parsePrivateClassElementName(prop)
+    }
+  }
+}
+
+module.exports = privateMethods;
+//# sourceMappingURL=acorn-private-methods.js.map

node_modules/acorn-private-methods/dist/acorn-private-methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acorn-private-methods.js","sources":["../index.js"],"sourcesContent":["// eslint-disable-next-line node/no-unsupported-features/es-syntax\nimport privateClassElements from \"acorn-private-class-elements\"\n\n// eslint-disable-next-line node/no-unsupported-features/es-syntax\nexport default function privateMethods(Parser) {\n  const ExtendedParser = privateClassElements(Parser)\n\n  return class extends ExtendedParser {\n    // Parse private methods\n    parseClassElement(_constructorAllowsSuper) {\n      const oldInClassMemberName = this._inClassMemberName\n      this._inClassMemberName = true\n      const result = super.parseClassElement.apply(this, arguments)\n      this._inClassMemberName = oldInClassMemberName\n      return result\n    }\n\n    parsePropertyName(prop) {\n      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateIdentifierToken && !prop.static\n      this._inClassMemberName = false\n      if (!isPrivate) return super.parsePropertyName(prop)\n      return this.parsePrivateClassElementName(prop)\n    }\n  }\n}\n"],"names":["privateClassElements"],"mappings":";;;;;;;;AAAA;AAEA;AACA;AACe,SAAS,cAAc,CAAC,MAAM,EAAE;AAC/C,EAAE,MAAM,cAAc,GAAGA,wCAAoB,CAAC,MAAM,EAAC;AACrD;AACA,EAAE,OAAO,cAAc,cAAc,CAAC;AACtC;AACA,IAAI,iBAAiB,CAAC,uBAAuB,EAAE;AAC/C,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,mBAAkB;AAC1D,MAAM,IAAI,CAAC,kBAAkB,GAAG,KAAI;AACpC,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAC;AACnE,MAAM,IAAI,CAAC,kBAAkB,GAAG,qBAAoB;AACpD,MAAM,OAAO,MAAM;AACnB,KAAK;AACL;AACA,IAAI,iBAAiB,CAAC,IAAI,EAAE;AAC5B,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,IAAI,CAAC,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,sBAAsB,IAAI,CAAC,IAAI,CAAC,OAAM;AAC5I,MAAM,IAAI,CAAC,kBAAkB,GAAG,MAAK;AACrC,MAAM,IAAI,CAAC,SAAS,EAAE,OAAO,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC;AAC1D,MAAM,OAAO,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC;AACpD,KAAK;AACL,GAAG;AACH;;;;"}

node_modules/acorn-private-methods/dist/acorn-private-methods.mjs

@@ -0,0 +1,29 @@
+import privateClassElements from 'acorn-private-class-elements';
+
+// eslint-disable-next-line node/no-unsupported-features/es-syntax
+
+// eslint-disable-next-line node/no-unsupported-features/es-syntax
+function privateMethods(Parser) {
+  const ExtendedParser = privateClassElements(Parser);
+
+  return class extends ExtendedParser {
+    // Parse private methods
+    parseClassElement(_constructorAllowsSuper) {
+      const oldInClassMemberName = this._inClassMemberName;
+      this._inClassMemberName = true;
+      const result = super.parseClassElement.apply(this, arguments);
+      this._inClassMemberName = oldInClassMemberName;
+      return result
+    }
+
+    parsePropertyName(prop) {
+      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateIdentifierToken && !prop.static;
+      this._inClassMemberName = false;
+      if (!isPrivate) return super.parsePropertyName(prop)
+      return this.parsePrivateClassElementName(prop)
+    }
+  }
+}
+
+export default privateMethods;
+//# sourceMappingURL=acorn-private-methods.mjs.map

node_modules/acorn-private-methods/dist/acorn-private-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"acorn-private-methods.mjs","sources":["../index.js"],"sourcesContent":["// eslint-disable-next-line node/no-unsupported-features/es-syntax\nimport privateClassElements from \"acorn-private-class-elements\"\n\n// eslint-disable-next-line node/no-unsupported-features/es-syntax\nexport default function privateMethods(Parser) {\n  const ExtendedParser = privateClassElements(Parser)\n\n  return class extends ExtendedParser {\n    // Parse private methods\n    parseClassElement(_constructorAllowsSuper) {\n      const oldInClassMemberName = this._inClassMemberName\n      this._inClassMemberName = true\n      const result = super.parseClassElement.apply(this, arguments)\n      this._inClassMemberName = oldInClassMemberName\n      return result\n    }\n\n    parsePropertyName(prop) {\n      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateIdentifierToken && !prop.static\n      this._inClassMemberName = false\n      if (!isPrivate) return super.parsePropertyName(prop)\n      return this.parsePrivateClassElementName(prop)\n    }\n  }\n}\n"],"names":[],"mappings":";;AAAA;AAEA;AACA;AACe,SAAS,cAAc,CAAC,MAAM,EAAE;AAC/C,EAAE,MAAM,cAAc,GAAG,oBAAoB,CAAC,MAAM,EAAC;AACrD;AACA,EAAE,OAAO,cAAc,cAAc,CAAC;AACtC;AACA,IAAI,iBAAiB,CAAC,uBAAuB,EAAE;AAC/C,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,mBAAkB;AAC1D,MAAM,IAAI,CAAC,kBAAkB,GAAG,KAAI;AACpC,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAC;AACnE,MAAM,IAAI,CAAC,kBAAkB,GAAG,qBAAoB;AACpD,MAAM,OAAO,MAAM;AACnB,KAAK;AACL;AACA,IAAI,iBAAiB,CAAC,IAAI,EAAE;AAC5B,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,IAAI,CAAC,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,sBAAsB,IAAI,CAAC,IAAI,CAAC,OAAM;AAC5I,MAAM,IAAI,CAAC,kBAAkB,GAAG,MAAK;AACrC,MAAM,IAAI,CAAC,SAAS,EAAE,OAAO,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC;AAC1D,MAAM,OAAO,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC;AACpD,KAAK;AACL,GAAG;AACH;;;;"}

node_modules/acorn-private-methods/index.js

@@ -0,0 +1,25 @@
+// eslint-disable-next-line node/no-unsupported-features/es-syntax
+import privateClassElements from "acorn-private-class-elements"
+
+// eslint-disable-next-line node/no-unsupported-features/es-syntax
+export default function privateMethods(Parser) {
+  const ExtendedParser = privateClassElements(Parser)
+
+  return class extends ExtendedParser {
+    // Parse private methods
+    parseClassElement(_constructorAllowsSuper) {
+      const oldInClassMemberName = this._inClassMemberName
+      this._inClassMemberName = true
+      const result = super.parseClassElement.apply(this, arguments)
+      this._inClassMemberName = oldInClassMemberName
+      return result
+    }
+
+    parsePropertyName(prop) {
+      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateIdentifierToken && !prop.static
+      this._inClassMemberName = false
+      if (!isPrivate) return super.parsePropertyName(prop)
+      return this.parsePrivateClassElementName(prop)
+    }
+  }
+}

node_modules/acorn-private-methods/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "acorn-private-methods",
+  "description": "Support for private methods in acorn",
+  "homepage": "https://github.com/acornjs/acorn-private-methods",
+  "contributors": [
+    "Adrian Heine <mail@adrianheine.de>"
+  ],
+  "main": "dist/acorn-private-methods.js",
+  "module": "dist/acorn-private-methods.mjs",
+  "engines": {
+    "node": ">=4.8.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/acornjs/acorn-private-methods"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "rollup -c rollup.config.js",
+    "test": "mocha",
+    "test:test262": "node run_test262.js",
+    "lint": "eslint -c .eslintrc.json ."
+  },
+  "peerDependencies": {
+    "acorn": "^6 || ^7 || ^8"
+  },
+  "dependencies": {
+    "acorn-private-class-elements": "^1.0.0"
+  },
+  "version": "1.0.0",
+  "devDependencies": {
+    "acorn": "^8",
+    "eslint": "^7",
+    "eslint-plugin-node": "^11",
+    "mocha": "^8",
+    "rollup": "^2.10.0",
+    "test262": "git+https://github.com/tc39/test262.git#fd27d1f5d00dcccc5f763252fc11b575ee0bdd2f",
+    "test262-parser-runner": "^0.5.0"
+  }
+}

node_modules/acorn-private-methods/rollup.config.js

@@ -0,0 +1,16 @@
+// eslint-disable-next-line node/no-unsupported-features/es-syntax
+export default {
+  input: "index.js",
+  output: [
+    {
+      file: "dist/acorn-private-methods.js",
+      format: "cjs",
+      sourcemap: true
+    },
+    {
+      file: "dist/acorn-private-methods.mjs",
+      format: "es",
+      sourcemap: true
+    }
+  ]
+}

node_modules/acorn-private-methods/run_test262.js

@@ -0,0 +1,28 @@
+"use strict"
+
+const path = require("path")
+const run = require("test262-parser-runner")
+const acorn = require("acorn")
+const privateMethods = require(".")
+const Parser = acorn.Parser.extend(privateMethods)
+
+const unsupportedFeatures = [
+  "class-fields-private",
+  "class-fields-public",
+  "class-static-fields-public",
+  "class-static-fields-private",
+  "class-static-methods-private"
+]
+
+const implementedFeatures = [
+  "class-methods-private"
+]
+
+run(
+  (content, options) => Parser.parse(content, {sourceType: options.sourceType, ecmaVersion: 11}),
+  {
+    testsDirectory: path.dirname(require.resolve("test262/package.json")),
+    skip: test => (!test.attrs.features || !implementedFeatures.some(f => test.attrs.features.includes(f)) || unsupportedFeatures.some(f => test.attrs.features.includes(f))),
+    whitelist: [],
+  }
+)

node_modules/acorn-private-methods/test/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+    "env": {
+        "mocha": true
+    }
+}

node_modules/acorn-private-methods/test/test.js

@@ -0,0 +1,286 @@
+"use strict"
+
+const assert = require("assert")
+const acorn = require("acorn")
+const privateMethods = require("..")
+const Parser = acorn.Parser.extend(privateMethods)
+
+function test(text, expectedResult, additionalOptions) {
+  it(text, function () {
+    const result = Parser.parse(text, Object.assign({ ecmaVersion: 9 }, additionalOptions))
+    if (expectedResult) assert.deepStrictEqual(result.body[0], expectedResult)
+  })
+}
+function testFail(text, expectedError, additionalOptions) {
+  it(text, function () {
+    let failed = false
+    try {
+      Parser.parse(text, Object.assign({ ecmaVersion: 9, plugins: { privateMethods: true } }, additionalOptions))
+    } catch (e) {
+      assert.strictEqual(e.message, expectedError)
+      failed = true
+    }
+    assert(failed)
+  })
+}
+
+const newNode = (start, props) => Object.assign(new acorn.Node({options: {}}, start), props)
+describe("acorn-private-methods", function () {
+  test("class A { a() { this.#a }; #a() {} }")
+  test(`var C = class {
+  #m() { return 42; }
+  constructor() {
+    (() => this)().#m
+  }
+}`)
+
+  testFail("class A { #a() {}; f() { delete this.#a } }", "Private elements may not be deleted (1:25)")
+  testFail("class A { #a() {}; #a() {} }", "Duplicate private element (1:19)")
+  test("class A { get #a() {}; set #a(newA) {} }")
+  testFail("class A { a() { this.#a } }", "Usage of undeclared private name (1:21)")
+  testFail("class A { a() { this.#a } b() { this.#b } }", "Usage of undeclared private name (1:21)")
+  testFail("class A { #constructor() {} }", "Classes may not have a private element named constructor (1:10)")
+  testFail("class A { #[ab]() {} }", "Unexpected token (1:11)")
+  testFail("a = { #ab() {} }", "Unexpected token (1:6)")
+  testFail("class A { [{#ab() {}}]() {} }", "Unexpected token (1:12)")
+  testFail("class A{ # a() {}}", "Unexpected token (1:11)")
+  testFail("class C{ #method() { super(); } };", "super() call outside constructor of a subclass (1:21)")
+  test("class C{ #method() { super.y(); } };")
+
+  const classes = [
+    { text: "class A { %s }", ast: getBody => {
+      const body = getBody(10)
+      return newNode(0, {
+        type: "ClassDeclaration",
+        end: body.end + 2,
+        id: newNode(6, {
+          type: "Identifier",
+          end: 7,
+          name: "A"
+        }),
+        superClass: null,
+        body: newNode(8, {
+          type: "ClassBody",
+          end: body.end + 2,
+          body: [body]
+        })
+      })
+    } },
+    { text: "class A { %s; }", ast: getBody => {
+      const body = getBody(10)
+      return newNode(0, {
+        type: "ClassDeclaration",
+        end: body.end + 3,
+        id: newNode(6, {
+          type: "Identifier",
+          end: 7,
+          name: "A"
+        }),
+        superClass: null,
+        body: newNode(8, {
+          type: "ClassBody",
+          end: body.end + 3,
+          body: [body]
+        })
+      })
+    } },
+    { text: "class A { %s; #y() {} }", ast: getBody => {
+      const body = getBody(10)
+      return newNode(0, {
+        type: "ClassDeclaration",
+        end: body.end + 11,
+        id: newNode(6, {
+          type: "Identifier",
+          end: 7,
+          name: "A"
+        }),
+        superClass: null,
+        body: newNode(8, {
+          type: "ClassBody",
+          end: body.end + 11,
+          body: [body, newNode(body.end + 2, {
+            type: "MethodDefinition",
+            end: body.end + 9,
+            kind: "method",
+            static: false,
+            computed: false,
+            key: newNode(body.end + 2, {
+              type: "PrivateIdentifier",
+              end: body.end + 4,
+              name: "y"
+            }),
+            value: newNode(body.end + 4, {
+              type: "FunctionExpression",
+              end: body.end + 9,
+              id: null,
+              generator: false,
+              expression: false,
+              async: false,
+              params: [],
+              body: newNode(body.end + 7, {
+                type: "BlockStatement",
+                end: body.end + 9,
+                body: []
+              })
+            })
+          }) ]
+        })
+      })
+    } },
+    { text: "class A { %s;a() {} }", ast: getBody => {
+      const body = getBody(10)
+      return newNode(0, {
+        type: "ClassDeclaration",
+        end: body.end + 9,
+        id: newNode(6, {
+          type: "Identifier",
+          end: 7,
+          name: "A"
+        }),
+        superClass: null,
+        body: newNode(8, {
+          type: "ClassBody",
+          end: body.end + 9,
+          body: [ body, newNode(body.end + 1, {
+            type: "MethodDefinition",
+            end: body.end + 7,
+            kind: "method",
+            static: false,
+            computed: false,
+            key: newNode(body.end + 1, {
+              type: "Identifier",
+              end: body.end + 2,
+              name: "a"
+            }),
+            value: newNode(body.end + 2, {
+              type: "FunctionExpression",
+              end: body.end + 7,
+              id: null,
+              generator: false,
+              expression: false,
+              async: false,
+              params: [],
+              body: newNode(body.end + 5, {
+                type: "BlockStatement",
+                end: body.end + 7,
+                body: []
+              })
+            })
+          }) ]
+        })
+      })
+    } },
+    { text: "class A { %s\na() {} }", ast: getBody => {
+      const body = getBody(10)
+      return newNode(0, {
+        type: "ClassDeclaration",
+        end: body.end + 9,
+        id: newNode(6, {
+          type: "Identifier",
+          end: 7,
+          name: "A"
+        }),
+        superClass: null,
+        body: newNode(8, {
+          type: "ClassBody",
+          end: body.end + 9,
+          body: [
+            body,
+            newNode(body.end + 1, {
+              type: "MethodDefinition",
+              end: body.end + 7,
+              kind: "method",
+              static: false,
+              computed: false,
+              key: newNode(body.end + 1, {
+                type: "Identifier",
+                end: body.end + 2,
+                name: "a"
+              }),
+              value: newNode(body.end + 2, {
+                type: "FunctionExpression",
+                end: body.end + 7,
+                id: null,
+                generator: false,
+                expression: false,
+                async: false,
+                params: [],
+                body: newNode(body.end + 5, {
+                  type: "BlockStatement",
+                  end: body.end + 7,
+                  body: []
+                })
+              })
+            })
+          ]
+        })
+      })
+    } },
+  ];
+
+  [
+    { body: "#x() {}", passes: true, ast: start => newNode(start, {
+      type: "MethodDefinition",
+      end: start + 7,
+      computed: false,
+      key: newNode(start, {
+        type: "PrivateIdentifier",
+        end: start + 2,
+        name: "x"
+      }),
+      kind: "method",
+      static: false,
+      value: newNode(start + 2, {
+        type: "FunctionExpression",
+        end: start + 7,
+        async: false,
+        body: newNode(start + 5, {
+          type: "BlockStatement",
+          body: [],
+          end: start + 7,
+        }),
+        expression: false,
+        generator: false,
+        id: null,
+        params: [],
+      })
+    }) },
+    { body: "get #x() {}", passes: true, ast: start => newNode(start, {
+      type: "MethodDefinition",
+      end: start + 11,
+      computed: false,
+      key: newNode(start + 4, {
+        type: "PrivateIdentifier",
+        end: start + 6,
+        name: "x"
+      }),
+      kind: "get",
+      static: false,
+      value: newNode(start + 6, {
+        type: "FunctionExpression",
+        end: start + 11,
+        async: false,
+        body: newNode(start + 9, {
+          body: [],
+          end: start + 11,
+          type: "BlockStatement"
+        }),
+        expression: false,
+        generator: false,
+        id: null,
+        params: [],
+      })
+    }) },
+
+  ].forEach(bodyInput => {
+    const body = bodyInput.body, passes = bodyInput.passes, bodyAst = bodyInput.ast
+    classes.forEach(input => {
+      const text = input.text, options = input.options || {}, ast = input.ast;
+      (passes ? test : testFail)(text.replace("%s", body), ast(bodyAst), options)
+    })
+  })
+
+  testFail("class C { \\u0061sync m(){} };", "Unexpected token (1:21)")
+  test("class A extends B { constructor() { super() } }")
+  testFail("class X { static #private() {} }", "Unexpected token (1:17)")
+})