update

node_modules/@babel/helper-create-class-features-plugin/README.md

@@ -2,18 +2,18 @@
 
 > Compile class public and private fields, private methods and decorators to ES6
 
-See our website [@babel/helper-create-class-features-plugin](https://babeljs.io/docs/en/next/babel-helper-create-class-features-plugin.html) for more information.
+See our website [@babel/helper-create-class-features-plugin](https://babeljs.io/docs/en/babel-helper-create-class-features-plugin) for more information.
 
 ## Install
 
 Using npm:
 
 ```sh
-npm install --save-dev @babel/helper-create-class-features-plugin
+npm install --save @babel/helper-create-class-features-plugin
 ```
 
 or using yarn:
 
 ```sh
-yarn add @babel/helper-create-class-features-plugin --dev
+yarn add @babel/helper-create-class-features-plugin
 ```

node_modules/@babel/helper-create-class-features-plugin/lib/decorators.js

@@ -3,17 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.hasOwnDecorators = hasOwnDecorators;
-exports.hasDecorators = hasDecorators;
 exports.buildDecoratedClass = buildDecoratedClass;
+exports.hasDecorators = hasDecorators;
+exports.hasOwnDecorators = hasOwnDecorators;
 
 var _core = require("@babel/core");
 
-var _helperReplaceSupers = _interopRequireDefault(require("@babel/helper-replace-supers"));
+var _helperReplaceSupers = require("@babel/helper-replace-supers");
 
-var _helperFunctionName = _interopRequireDefault(require("@babel/helper-function-name"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _helperFunctionName = require("@babel/helper-function-name");
 
 function hasOwnDecorators(node) {
   return !!(node.decorators && node.decorators.length);
@@ -53,39 +51,45 @@ function getKey(node) {
   }
 }
 
-function extractElementDescriptor(classRef, superRef, path) {
-  const {
-    node,
-    scope
-  } = path;
+function extractElementDescriptor(file, classRef, superRef, path) {
   const isMethod = path.isClassMethod();
 
   if (path.isPrivate()) {
     throw path.buildCodeFrameError(`Private ${isMethod ? "methods" : "fields"} in decorated classes are not supported yet.`);
   }
 
+  if (path.node.type === "ClassAccessorProperty") {
+    throw path.buildCodeFrameError(`Accessor properties are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
+  }
+
+  if (path.node.type === "StaticBlock") {
+    throw path.buildCodeFrameError(`Static blocks are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
+  }
+
+  const {
+    node,
+    scope
+  } = path;
   new _helperReplaceSupers.default({
     methodPath: path,
-    methodNode: node,
     objectRef: classRef,
-    isStatic: node.static,
     superRef,
-    scope,
-    file: this
-  }, true).replace();
-  const properties = [prop("kind", _core.types.stringLiteral(isMethod ? node.kind : "field")), prop("decorators", takeDecorators(node)), prop("static", node.static && _core.types.booleanLiteral(true)), prop("key", getKey(node))].filter(Boolean);
+    file,
+    refToPreserve: classRef
+  }).replace();
+  const properties = [prop("kind", _core.types.stringLiteral(_core.types.isClassMethod(node) ? node.kind : "field")), prop("decorators", takeDecorators(node)), prop("static", node.static && _core.types.booleanLiteral(true)), prop("key", getKey(node))].filter(Boolean);
 
-  if (isMethod) {
+  if (_core.types.isClassMethod(node)) {
     const id = node.computed ? null : node.key;
 
-    _core.types.toExpression(node);
+    const transformed = _core.types.toExpression(node);
 
     properties.push(prop("value", (0, _helperFunctionName.default)({
-      node,
+      node: transformed,
       id,
       scope
-    }) || node));
-  } else if (node.value) {
+    }) || transformed));
+  } else if (_core.types.isClassProperty(node) && node.value) {
     properties.push(method("value", _core.template.statements.ast`return ${node.value}`));
   } else {
     properties.push(prop("value", scope.buildUndefinedNode()));
@@ -129,31 +133,33 @@ function buildDecoratedClass(ref, path, elements, file) {
 
   const classDecorators = takeDecorators(node);
 
-  const definitions = _core.types.arrayExpression(elements.filter(element => !element.node.abstract).map(extractElementDescriptor.bind(file, node.id, superId)));
+  const definitions = _core.types.arrayExpression(elements.filter(element => !element.node.abstract && element.node.type !== "TSIndexSignature").map(path => extractElementDescriptor(file, node.id, superId, path)));
 
-  let replacement = _core.template.expression.ast`
+  const wrapperCall = _core.template.expression.ast`
     ${addDecorateHelper(file)}(
       ${classDecorators || _core.types.nullLiteral()},
-      function (${initializeId}, ${superClass ? superId : null}) {
+      function (${initializeId}, ${superClass ? _core.types.cloneNode(superId) : null}) {
         ${node}
         return { F: ${_core.types.cloneNode(node.id)}, d: ${definitions} };
       },
       ${superClass}
     )
   `;
-  let classPathDesc = "arguments.1.body.body.0";
 
   if (!isStrict) {
-    replacement.arguments[1].body.directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
+    wrapperCall.arguments[1].body.directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
   }
 
+  let replacement = wrapperCall;
+  let classPathDesc = "arguments.1.body.body.0";
+
   if (isDeclaration) {
-    replacement = _core.template.ast`let ${ref} = ${replacement}`;
+    replacement = _core.template.statement.ast`let ${ref} = ${wrapperCall}`;
     classPathDesc = "declarations.0.init." + classPathDesc;
   }
 
   return {
-    instanceNodes: [_core.template.statement.ast`${initializeId}(this)`],
+    instanceNodes: [_core.template.statement.ast`${_core.types.cloneNode(initializeId)}(this)`],
 
     wrapClass(path) {
       path.replaceWith(replacement);

node_modules/@babel/helper-create-class-features-plugin/lib/features.js

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.FEATURES = void 0;
 exports.enableFeature = enableFeature;
 exports.isLoose = isLoose;
-exports.verifyUsedFeatures = verifyUsedFeatures;
-exports.FEATURES = void 0;
+exports.shouldTransform = shouldTransform;
 
 var _decorators = require("./decorators");
 
@@ -14,10 +14,11 @@ const FEATURES = Object.freeze({
   fields: 1 << 1,
   privateMethods: 1 << 2,
   decorators: 1 << 3,
-  privateIn: 1 << 4
+  privateIn: 1 << 4,
+  staticBlocks: 1 << 5
 });
 exports.FEATURES = FEATURES;
-const featuresSameLoose = new Map([[FEATURES.fields, "@babel/plugin-proposal-class-properties"], [FEATURES.privateMethods, "@babel/plugin-proposal-private-methods"], [FEATURES.privateIn, "@babel/plugin-proposal-private-private-property-in-object"]]);
+const featuresSameLoose = new Map([[FEATURES.fields, "@babel/plugin-proposal-class-properties"], [FEATURES.privateMethods, "@babel/plugin-proposal-private-methods"], [FEATURES.privateIn, "@babel/plugin-proposal-private-property-in-object"]]);
 const featuresKey = "@babel/plugin-class-features/featuresKey";
 const looseKey = "@babel/plugin-class-features/looseKey";
 const looseLowPriorityKey = "@babel/plugin-class-features/looseLowPriorityKey/#__internal__@babel/preset-env__please-overwrite-loose-instead-of-throwing";
@@ -81,35 +82,70 @@ function canIgnoreLoose(file, feature) {
   return !!(file.get(looseLowPriorityKey) & feature);
 }
 
-function verifyUsedFeatures(path, file) {
+function shouldTransform(path, file) {
+  let decoratorPath = null;
+  let publicFieldPath = null;
+  let privateFieldPath = null;
+  let privateMethodPath = null;
+  let staticBlockPath = null;
+
   if ((0, _decorators.hasOwnDecorators)(path.node)) {
-    if (!hasFeature(file, FEATURES.decorators)) {
-      throw path.buildCodeFrameError("Decorators are not enabled." + "\nIf you are using " + '["@babel/plugin-proposal-decorators", { "legacy": true }], ' + 'make sure it comes *before* "@babel/plugin-proposal-class-properties" ' + "and enable loose mode, like so:\n" + '\t["@babel/plugin-proposal-decorators", { "legacy": true }]\n' + '\t["@babel/plugin-proposal-class-properties", { "loose": true }]');
+    decoratorPath = path.get("decorators.0");
+  }
+
+  for (const el of path.get("body.body")) {
+    if (!decoratorPath && (0, _decorators.hasOwnDecorators)(el.node)) {
+      decoratorPath = el.get("decorators.0");
     }
 
-    if (path.isPrivate()) {
-      throw path.buildCodeFrameError(`Private ${path.isClassMethod() ? "methods" : "fields"} in decorated classes are not supported yet.`);
+    if (!publicFieldPath && el.isClassProperty()) {
+      publicFieldPath = el;
+    }
+
+    if (!privateFieldPath && el.isClassPrivateProperty()) {
+      privateFieldPath = el;
+    }
+
+    if (!privateMethodPath && el.isClassPrivateMethod != null && el.isClassPrivateMethod()) {
+      privateMethodPath = el;
+    }
+
+    if (!staticBlockPath && el.isStaticBlock != null && el.isStaticBlock()) {
+      staticBlockPath = el;
     }
   }
 
-  if (path.isPrivate() && path.isMethod()) {
-    if (!hasFeature(file, FEATURES.privateMethods)) {
-      throw path.buildCodeFrameError("Class private methods are not enabled.");
-    }
+  if (decoratorPath && privateFieldPath) {
+    throw privateFieldPath.buildCodeFrameError("Private fields in decorated classes are not supported yet.");
   }
 
-  if (path.isPrivateName() && path.parentPath.isBinaryExpression({
-    operator: "in",
-    left: path.node
-  })) {
-    if (!hasFeature(file, FEATURES.privateIn)) {
-      throw path.buildCodeFrameError("Private property in checks are not enabled.");
-    }
+  if (decoratorPath && privateMethodPath) {
+    throw privateMethodPath.buildCodeFrameError("Private methods in decorated classes are not supported yet.");
   }
 
-  if (path.isProperty()) {
-    if (!hasFeature(file, FEATURES.fields)) {
-      throw path.buildCodeFrameError("Class fields are not enabled.");
-    }
+  if (decoratorPath && !hasFeature(file, FEATURES.decorators)) {
+    throw path.buildCodeFrameError("Decorators are not enabled." + "\nIf you are using " + '["@babel/plugin-proposal-decorators", { "version": "legacy" }], ' + 'make sure it comes *before* "@babel/plugin-proposal-class-properties" ' + "and enable loose mode, like so:\n" + '\t["@babel/plugin-proposal-decorators", { "version": "legacy" }]\n' + '\t["@babel/plugin-proposal-class-properties", { "loose": true }]');
   }
+
+  if (privateMethodPath && !hasFeature(file, FEATURES.privateMethods)) {
+    throw privateMethodPath.buildCodeFrameError("Class private methods are not enabled. " + "Please add `@babel/plugin-proposal-private-methods` to your configuration.");
+  }
+
+  if ((publicFieldPath || privateFieldPath) && !hasFeature(file, FEATURES.fields) && !hasFeature(file, FEATURES.privateMethods)) {
+    throw path.buildCodeFrameError("Class fields are not enabled. " + "Please add `@babel/plugin-proposal-class-properties` to your configuration.");
+  }
+
+  if (staticBlockPath && !hasFeature(file, FEATURES.staticBlocks)) {
+    throw path.buildCodeFrameError("Static class blocks are not enabled. " + "Please add `@babel/plugin-proposal-class-static-block` to your configuration.");
+  }
+
+  if (decoratorPath || privateMethodPath || staticBlockPath) {
+    return true;
+  }
+
+  if ((publicFieldPath || privateFieldPath) && hasFeature(file, FEATURES.fields)) {
+    return true;
+  }
+
+  return false;
 }

node_modules/@babel/helper-create-class-features-plugin/lib/fields.js

@@ -3,51 +3,47 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.buildFieldsInitNodes = buildFieldsInitNodes;
 exports.buildPrivateNamesMap = buildPrivateNamesMap;
 exports.buildPrivateNamesNodes = buildPrivateNamesNodes;
 exports.transformPrivateNamesUsage = transformPrivateNamesUsage;
-exports.buildFieldsInitNodes = buildFieldsInitNodes;
 
 var _core = require("@babel/core");
 
-var _helperReplaceSupers = _interopRequireWildcard(require("@babel/helper-replace-supers"));
+var _helperReplaceSupers = require("@babel/helper-replace-supers");
 
-var _helperMemberExpressionToFunctions = _interopRequireDefault(require("@babel/helper-member-expression-to-functions"));
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
 
-var _helperOptimiseCallExpression = _interopRequireDefault(require("@babel/helper-optimise-call-expression"));
+var _helperMemberExpressionToFunctions = require("@babel/helper-member-expression-to-functions");
 
-var ts = _interopRequireWildcard(require("./typescript"));
+var _helperOptimiseCallExpression = require("@babel/helper-optimise-call-expression");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var ts = require("./typescript");
 
 function buildPrivateNamesMap(props) {
   const privateNamesMap = new Map();
 
   for (const prop of props) {
-    const isPrivate = prop.isPrivate();
-    const isMethod = !prop.isProperty();
-    const isInstance = !prop.node.static;
-
-    if (isPrivate) {
+    if (prop.isPrivate()) {
       const {
         name
       } = prop.node.key.id;
       const update = privateNamesMap.has(name) ? privateNamesMap.get(name) : {
         id: prop.scope.generateUidIdentifier(name),
-        static: !isInstance,
-        method: isMethod
+        static: prop.node.static,
+        method: !prop.isProperty()
       };
 
-      if (prop.node.kind === "get") {
-        update.getId = prop.scope.generateUidIdentifier(`get_${name}`);
-      } else if (prop.node.kind === "set") {
-        update.setId = prop.scope.generateUidIdentifier(`set_${name}`);
-      } else if (prop.node.kind === "method") {
-        update.methodId = prop.scope.generateUidIdentifier(name);
+      if (prop.isClassPrivateMethod()) {
+        if (prop.node.kind === "get") {
+          update.getId = prop.scope.generateUidIdentifier(`get_${name}`);
+        } else if (prop.node.kind === "set") {
+          update.setId = prop.scope.generateUidIdentifier(`set_${name}`);
+        } else if (prop.node.kind === "method") {
+          update.methodId = prop.scope.generateUidIdentifier(name);
+        }
       }
 
       privateNamesMap.set(name, update);
@@ -57,12 +53,11 @@ function buildPrivateNamesMap(props) {
   return privateNamesMap;
 }
 
-function buildPrivateNamesNodes(privateNamesMap, loose, state) {
+function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, state) {
   const initNodes = [];
 
   for (const [name, value] of privateNamesMap) {
     const {
-      id,
       static: isStatic,
       method: isMethod,
       getId,
@@ -70,18 +65,19 @@ function buildPrivateNamesNodes(privateNamesMap, loose, state) {
     } = value;
     const isAccessor = getId || setId;
 
-    if (loose) {
-      initNodes.push(_core.template.statement.ast`
-          var ${id} = ${state.addHelper("classPrivateFieldLooseKey")}("${name}")
-        `);
-    } else if (isMethod && !isStatic) {
-      if (isAccessor) {
-        initNodes.push(_core.template.statement.ast`var ${id} = new WeakMap();`);
-      } else {
-        initNodes.push(_core.template.statement.ast`var ${id} = new WeakSet();`);
-      }
+    const id = _core.types.cloneNode(value.id);
+
+    let init;
+
+    if (privateFieldsAsProperties) {
+      init = _core.types.callExpression(state.addHelper("classPrivateFieldLooseKey"), [_core.types.stringLiteral(name)]);
     } else if (!isStatic) {
-      initNodes.push(_core.template.statement.ast`var ${id} = new WeakMap();`);
+      init = _core.types.newExpression(_core.types.identifier(!isMethod || isAccessor ? "WeakMap" : "WeakSet"), []);
+    }
+
+    if (init) {
+      (0, _helperAnnotateAsPure.default)(init);
+      initNodes.push(_core.template.statement.ast`var ${id} = ${init}`);
     }
   }
 
@@ -122,13 +118,15 @@ function privateNameVisitorFactory(visitor) {
 
   });
 
-  const nestedVisitor = _core.traverse.visitors.merge([Object.assign({}, visitor), _helperReplaceSupers.environmentVisitor]);
+  const nestedVisitor = _core.traverse.visitors.merge([Object.assign({}, visitor), _helperEnvironmentVisitor.default]);
 
   return privateNameVisitor;
 }
 
 const privateNameVisitor = privateNameVisitorFactory({
-  PrivateName(path) {
+  PrivateName(path, {
+    noDocumentAll
+  }) {
     const {
       privateNamesMap,
       redeclared
@@ -151,10 +149,20 @@ const privateNameVisitor = privateNameVisitorFactory({
     } = node.id;
     if (!privateNamesMap.has(name)) return;
     if (redeclared && redeclared.includes(name)) return;
-    this.handle(parentPath);
+    this.handle(parentPath, noDocumentAll);
   }
 
 });
+
+function unshadow(name, scope, innerBinding) {
+  while ((_scope = scope) != null && _scope.hasBinding(name) && !scope.bindingIdentifierEquals(name, innerBinding)) {
+    var _scope;
+
+    scope.rename(name);
+    scope = scope.parent;
+  }
+}
+
 const privateInVisitor = privateNameVisitorFactory({
   BinaryExpression(path) {
     const {
@@ -163,9 +171,9 @@ const privateInVisitor = privateNameVisitorFactory({
       right
     } = path.node;
     if (operator !== "in") return;
-    if (!path.get("left").isPrivateName()) return;
+    if (!_core.types.isPrivateName(left)) return;
     const {
-      loose,
+      privateFieldsAsProperties,
       privateNamesMap,
       redeclared
     } = this;
@@ -174,13 +182,14 @@ const privateInVisitor = privateNameVisitorFactory({
     } = left.id;
     if (!privateNamesMap.has(name)) return;
     if (redeclared && redeclared.includes(name)) return;
+    unshadow(this.classRef.name, path.scope, this.innerBinding);
 
-    if (loose) {
+    if (privateFieldsAsProperties) {
       const {
         id
       } = privateNamesMap.get(name);
       path.replaceWith(_core.template.expression.ast`
-        Object.prototype.hasOwnProperty.call(${right}, ${id})
+        Object.prototype.hasOwnProperty.call(${right}, ${_core.types.cloneNode(id)})
       `);
       return;
     }
@@ -195,7 +204,7 @@ const privateInVisitor = privateNameVisitorFactory({
       return;
     }
 
-    path.replaceWith(_core.template.expression.ast`${id}.has(${right})`);
+    path.replaceWith(_core.template.expression.ast`${_core.types.cloneNode(id)}.has(${right})`);
   }
 
 });
@@ -232,7 +241,8 @@ const privateNameHandlerSpec = {
     const {
       classRef,
       privateNamesMap,
-      file
+      file,
+      innerBinding
     } = this;
     const {
       name
@@ -249,11 +259,20 @@ const privateNameHandlerSpec = {
 
     if (isStatic) {
       const helperName = isMethod && !isAccessor ? "classStaticPrivateMethodGet" : "classStaticPrivateFieldSpecGet";
+      unshadow(classRef.name, member.scope, innerBinding);
       return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]);
     }
 
     if (isMethod) {
       if (isAccessor) {
+        if (!getId && setId) {
+          if (file.availableHelper("writeOnlyError")) {
+            return _core.types.sequenceExpression([this.receiver(member), _core.types.callExpression(file.addHelper("writeOnlyError"), [_core.types.stringLiteral(`#${name}`)])]);
+          }
+
+          console.warn(`@babel/helpers is outdated, update it to silence this warning.`);
+        }
+
         return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]);
       }
 
@@ -296,7 +315,7 @@ const privateNameHandlerSpec = {
         return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]);
       }
 
-      return _core.types.callExpression(file.addHelper("classPrivateMethodSet"), []);
+      return _core.types.sequenceExpression([this.receiver(member), value, _core.types.callExpression(file.addHelper("readOnlyError"), [_core.types.stringLiteral(`#${name}`)])]);
     }
 
     return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]);
@@ -304,6 +323,7 @@ const privateNameHandlerSpec = {
 
   destructureSet(member) {
     const {
+      classRef,
       privateNamesMap,
       file
     } = this;
@@ -311,8 +331,20 @@ const privateNameHandlerSpec = {
       name
     } = member.node.property.id;
     const {
-      id
+      id,
+      static: isStatic
     } = privateNamesMap.get(name);
+
+    if (isStatic) {
+      try {
+        var helper = file.addHelper("classStaticPrivateFieldDestructureSet");
+      } catch (_unused) {
+        throw new Error("Babel can not transpile `[C.#p] = [0]` with @babel/helpers < 7.13.10, \n" + "please update @babel/helpers to the latest version.");
+      }
+
+      return _core.types.memberExpression(_core.types.callExpression(helper, [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]), _core.types.identifier("value"));
+    }
+
     return _core.types.memberExpression(_core.types.callExpression(file.addHelper("classPrivateFieldDestructureSet"), [this.receiver(member), _core.types.cloneNode(id)]), _core.types.identifier("value"));
   },
 
@@ -341,11 +373,15 @@ const privateNameHandlerLoose = {
     } = member.node.property.id;
     return _core.template.expression`BASE(REF, PROP)[PROP]`({
       BASE: file.addHelper("classPrivateFieldLooseBase"),
-      REF: object,
-      PROP: privateNamesMap.get(name).id
+      REF: _core.types.cloneNode(object),
+      PROP: _core.types.cloneNode(privateNamesMap.get(name).id)
     });
   },
 
+  set() {
+    throw new Error("private name handler with loose = true don't need set()");
+  },
+
   boundGet(member) {
     return _core.types.callExpression(_core.types.memberExpression(this.get(member), _core.types.identifier("bind")), [_core.types.cloneNode(member.node.object)]);
   },
@@ -368,20 +404,28 @@ const privateNameHandlerLoose = {
 
 };
 
-function transformPrivateNamesUsage(ref, path, privateNamesMap, loose, state) {
+function transformPrivateNamesUsage(ref, path, privateNamesMap, {
+  privateFieldsAsProperties,
+  noDocumentAll,
+  innerBinding
+}, state) {
   if (!privateNamesMap.size) return;
   const body = path.get("body");
-  const handler = loose ? privateNameHandlerLoose : privateNameHandlerSpec;
+  const handler = privateFieldsAsProperties ? privateNameHandlerLoose : privateNameHandlerSpec;
   (0, _helperMemberExpressionToFunctions.default)(body, privateNameVisitor, Object.assign({
     privateNamesMap,
     classRef: ref,
     file: state
-  }, handler));
+  }, handler, {
+    noDocumentAll,
+    innerBinding
+  }));
   body.traverse(privateInVisitor, {
     privateNamesMap,
     classRef: ref,
     file: state,
-    loose
+    privateFieldsAsProperties,
+    innerBinding
   });
 }
 
@@ -391,7 +435,7 @@ function buildPrivateFieldInitLoose(ref, prop, privateNamesMap) {
   } = privateNamesMap.get(prop.node.key.id.name);
   const value = prop.node.value || prop.scope.buildUndefinedNode();
   return _core.template.statement.ast`
-    Object.defineProperty(${ref}, ${id}, {
+    Object.defineProperty(${ref}, ${_core.types.cloneNode(id)}, {
       // configurable is false by default
       // enumerable is false by default
       writable: true,
@@ -400,17 +444,30 @@ function buildPrivateFieldInitLoose(ref, prop, privateNamesMap) {
   `;
 }
 
-function buildPrivateInstanceFieldInitSpec(ref, prop, privateNamesMap) {
+function buildPrivateInstanceFieldInitSpec(ref, prop, privateNamesMap, state) {
   const {
     id
   } = privateNamesMap.get(prop.node.key.id.name);
   const value = prop.node.value || prop.scope.buildUndefinedNode();
-  return _core.template.statement.ast`${id}.set(${ref}, {
-    // configurable is always false for private elements
-    // enumerable is always false for private elements
-    writable: true,
-    value: ${value},
-  })`;
+  {
+    if (!state.availableHelper("classPrivateFieldInitSpec")) {
+      return _core.template.statement.ast`${_core.types.cloneNode(id)}.set(${ref}, {
+        // configurable is always false for private elements
+        // enumerable is always false for private elements
+        writable: true,
+        value: ${value},
+      })`;
+    }
+  }
+  const helper = state.addHelper("classPrivateFieldInitSpec");
+  return _core.template.statement.ast`${helper}(
+    ${_core.types.thisExpression()},
+    ${_core.types.cloneNode(id)},
+    {
+      writable: true,
+      value: ${value}
+    },
+  )`;
 }
 
 function buildPrivateStaticFieldInitSpec(prop, privateNamesMap) {
@@ -429,7 +486,7 @@ function buildPrivateStaticFieldInitSpec(prop, privateNamesMap) {
       initAdded: true
     }));
     return _core.template.statement.ast`
-      var ${id.name} = {
+      var ${_core.types.cloneNode(id)} = {
         // configurable is false by default
         // enumerable is false by default
         // writable is false by default
@@ -441,7 +498,7 @@ function buildPrivateStaticFieldInitSpec(prop, privateNamesMap) {
 
   const value = prop.node.value || prop.scope.buildUndefinedNode();
   return _core.template.statement.ast`
-    var ${id} = {
+    var ${_core.types.cloneNode(id)} = {
       // configurable is false by default
       // enumerable is false by default
       writable: true,
@@ -490,10 +547,9 @@ function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) {
   }
 }
 
-function buildPrivateInstanceMethodInitSpec(ref, prop, privateNamesMap) {
+function buildPrivateInstanceMethodInitSpec(ref, prop, privateNamesMap, state) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
   const {
-    id,
     getId,
     setId,
     initAdded
@@ -502,18 +558,58 @@ function buildPrivateInstanceMethodInitSpec(ref, prop, privateNamesMap) {
   const isAccessor = getId || setId;
 
   if (isAccessor) {
-    privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
-      initAdded: true
-    }));
-    return _core.template.statement.ast`
+    return buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state);
+  }
+
+  return buildPrivateInstanceMethodInitalization(ref, prop, privateNamesMap, state);
+}
+
+function buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state) {
+  const privateName = privateNamesMap.get(prop.node.key.id.name);
+  const {
+    id,
+    getId,
+    setId
+  } = privateName;
+  privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
+    initAdded: true
+  }));
+  {
+    if (!state.availableHelper("classPrivateFieldInitSpec")) {
+      return _core.template.statement.ast`
       ${id}.set(${ref}, {
         get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
         set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
       });
     `;
+    }
   }
+  const helper = state.addHelper("classPrivateFieldInitSpec");
+  return _core.template.statement.ast`${helper}(
+    ${_core.types.thisExpression()},
+    ${_core.types.cloneNode(id)},
+    {
+      get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
+      set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
+    },
+  )`;
+}
 
-  return _core.template.statement.ast`${id}.add(${ref})`;
+function buildPrivateInstanceMethodInitalization(ref, prop, privateNamesMap, state) {
+  const privateName = privateNamesMap.get(prop.node.key.id.name);
+  const {
+    id
+  } = privateName;
+  {
+    if (!state.availableHelper("classPrivateMethodInitSpec")) {
+      return _core.template.statement.ast`${id}.add(${ref})`;
+    }
+  }
+  const helper = state.addHelper("classPrivateMethodInitSpec");
+  return _core.template.statement.ast`${helper}(
+    ${_core.types.thisExpression()},
+    ${_core.types.cloneNode(id)}
+  )`;
 }
 
 function buildPublicFieldInitLoose(ref, prop) {
@@ -571,7 +667,7 @@ function buildPrivateStaticMethodInitLoose(ref, prop, state, privateNamesMap) {
   `;
 }
 
-function buildPrivateMethodDeclaration(prop, privateNamesMap, loose = false) {
+function buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties = false) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
   const {
     id,
@@ -588,142 +684,209 @@ function buildPrivateMethodDeclaration(prop, privateNamesMap, loose = false) {
     generator,
     async
   } = prop.node;
-
-  const methodValue = _core.types.functionExpression(methodId, params, body, generator, async);
-
   const isGetter = getId && !getterDeclared && params.length === 0;
   const isSetter = setId && !setterDeclared && params.length > 0;
+  let declId = methodId;
 
   if (isGetter) {
     privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
       getterDeclared: true
     }));
-    return _core.types.variableDeclaration("var", [_core.types.variableDeclarator(getId, methodValue)]);
-  }
-
-  if (isSetter) {
+    declId = getId;
+  } else if (isSetter) {
     privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
       setterDeclared: true
     }));
-    return _core.types.variableDeclaration("var", [_core.types.variableDeclarator(setId, methodValue)]);
+    declId = setId;
+  } else if (isStatic && !privateFieldsAsProperties) {
+    declId = id;
   }
 
-  if (isStatic && !loose) {
-    return _core.types.variableDeclaration("var", [_core.types.variableDeclarator(id, _core.types.functionExpression(id, params, body, generator, async))]);
-  }
-
-  return _core.types.variableDeclaration("var", [_core.types.variableDeclarator(methodId, methodValue)]);
+  return _core.types.functionDeclaration(_core.types.cloneNode(declId), params, body, generator, async);
 }
 
 const thisContextVisitor = _core.traverse.visitors.merge([{
   ThisExpression(path, state) {
     state.needsClassRef = true;
     path.replaceWith(_core.types.cloneNode(state.classRef));
+  },
+
+  MetaProperty(path) {
+    const meta = path.get("meta");
+    const property = path.get("property");
+    const {
+      scope
+    } = path;
+
+    if (meta.isIdentifier({
+      name: "new"
+    }) && property.isIdentifier({
+      name: "target"
+    })) {
+      path.replaceWith(scope.buildUndefinedNode());
+    }
   }
 
-}, _helperReplaceSupers.environmentVisitor]);
+}, _helperEnvironmentVisitor.default]);
+
+const innerReferencesVisitor = {
+  ReferencedIdentifier(path, state) {
+    if (path.scope.bindingIdentifierEquals(path.node.name, state.innerBinding)) {
+      state.needsClassRef = true;
+      path.node.name = state.classRef.name;
+    }
+  }
+
+};
+
+function replaceThisContext(path, ref, getSuperRef, file, isStaticBlock, constantSuper, innerBindingRef) {
+  var _state$classRef;
 
-function replaceThisContext(path, ref, superRef, file, loose) {
   const state = {
     classRef: ref,
-    needsClassRef: false
+    needsClassRef: false,
+    innerBinding: innerBindingRef
   };
   const replacer = new _helperReplaceSupers.default({
     methodPath: path,
-    isLoose: loose,
-    superRef,
+    constantSuper,
     file,
+    refToPreserve: ref,
+    getSuperRef,
 
     getObjectRef() {
       state.needsClassRef = true;
-      return path.node.static ? ref : _core.types.memberExpression(ref, _core.types.identifier("prototype"));
+      return _core.types.isStaticBlock != null && _core.types.isStaticBlock(path.node) || path.node.static ? ref : _core.types.memberExpression(ref, _core.types.identifier("prototype"));
     }
 
   });
   replacer.replace();
 
-  if (path.isProperty()) {
+  if (isStaticBlock || path.isProperty()) {
     path.traverse(thisContextVisitor, state);
   }
 
+  if (innerBindingRef != null && (_state$classRef = state.classRef) != null && _state$classRef.name && state.classRef.name !== (innerBindingRef == null ? void 0 : innerBindingRef.name)) {
+    path.traverse(innerReferencesVisitor, state);
+  }
+
   return state.needsClassRef;
 }
 
-function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, state, loose) {
+function isNameOrLength({
+  key,
+  computed
+}) {
+  if (key.type === "Identifier") {
+    return !computed && (key.name === "name" || key.name === "length");
+  }
+
+  if (key.type === "StringLiteral") {
+    return key.value === "name" || key.value === "length";
+  }
+
+  return false;
+}
+
+function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, state, setPublicClassFields, privateFieldsAsProperties, constantSuper, innerBindingRef) {
+  let needsClassRef = false;
+  let injectSuperRef;
   const staticNodes = [];
   const instanceNodes = [];
-  let needsClassRef = false;
+  const pureStaticNodes = [];
+  const getSuperRef = _core.types.isIdentifier(superRef) ? () => superRef : () => {
+    var _injectSuperRef;
+
+    (_injectSuperRef = injectSuperRef) != null ? _injectSuperRef : injectSuperRef = props[0].scope.generateUidIdentifierBasedOnNode(superRef);
+    return injectSuperRef;
+  };
 
   for (const prop of props) {
-    ts.assertFieldTransformed(prop);
-    const isStatic = prop.node.static;
+    prop.isClassProperty() && ts.assertFieldTransformed(prop);
+    const isStatic = !(_core.types.isStaticBlock != null && _core.types.isStaticBlock(prop.node)) && prop.node.static;
     const isInstance = !isStatic;
     const isPrivate = prop.isPrivate();
     const isPublic = !isPrivate;
     const isField = prop.isProperty();
     const isMethod = !isField;
+    const isStaticBlock = prop.isStaticBlock == null ? void 0 : prop.isStaticBlock();
 
-    if (isStatic || isMethod && isPrivate) {
-      const replaced = replaceThisContext(prop, ref, superRef, state, loose);
+    if (isStatic || isMethod && isPrivate || isStaticBlock) {
+      const replaced = replaceThisContext(prop, ref, getSuperRef, state, isStaticBlock, constantSuper, innerBindingRef);
       needsClassRef = needsClassRef || replaced;
     }
 
     switch (true) {
-      case isStatic && isPrivate && isField && loose:
+      case isStaticBlock:
+        {
+          const blockBody = prop.node.body;
+
+          if (blockBody.length === 1 && _core.types.isExpressionStatement(blockBody[0])) {
+            staticNodes.push(blockBody[0]);
+          } else {
+            staticNodes.push(_core.template.statement.ast`(() => { ${blockBody} })()`);
+          }
+
+          break;
+        }
+
+      case isStatic && isPrivate && isField && privateFieldsAsProperties:
         needsClassRef = true;
         staticNodes.push(buildPrivateFieldInitLoose(_core.types.cloneNode(ref), prop, privateNamesMap));
         break;
 
-      case isStatic && isPrivate && isField && !loose:
+      case isStatic && isPrivate && isField && !privateFieldsAsProperties:
         needsClassRef = true;
         staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap));
         break;
 
-      case isStatic && isPublic && isField && loose:
-        needsClassRef = true;
-        staticNodes.push(buildPublicFieldInitLoose(_core.types.cloneNode(ref), prop));
-        break;
+      case isStatic && isPublic && isField && setPublicClassFields:
+        if (!isNameOrLength(prop.node)) {
+          needsClassRef = true;
+          staticNodes.push(buildPublicFieldInitLoose(_core.types.cloneNode(ref), prop));
+          break;
+        }
 
-      case isStatic && isPublic && isField && !loose:
+      case isStatic && isPublic && isField && !setPublicClassFields:
         needsClassRef = true;
         staticNodes.push(buildPublicFieldInitSpec(_core.types.cloneNode(ref), prop, state));
         break;
 
-      case isInstance && isPrivate && isField && loose:
+      case isInstance && isPrivate && isField && privateFieldsAsProperties:
         instanceNodes.push(buildPrivateFieldInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
         break;
 
-      case isInstance && isPrivate && isField && !loose:
-        instanceNodes.push(buildPrivateInstanceFieldInitSpec(_core.types.thisExpression(), prop, privateNamesMap));
+      case isInstance && isPrivate && isField && !privateFieldsAsProperties:
+        instanceNodes.push(buildPrivateInstanceFieldInitSpec(_core.types.thisExpression(), prop, privateNamesMap, state));
         break;
 
-      case isInstance && isPrivate && isMethod && loose:
+      case isInstance && isPrivate && isMethod && privateFieldsAsProperties:
         instanceNodes.unshift(buildPrivateMethodInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
-        staticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, loose));
+        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
         break;
 
-      case isInstance && isPrivate && isMethod && !loose:
-        instanceNodes.unshift(buildPrivateInstanceMethodInitSpec(_core.types.thisExpression(), prop, privateNamesMap));
-        staticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, loose));
+      case isInstance && isPrivate && isMethod && !privateFieldsAsProperties:
+        instanceNodes.unshift(buildPrivateInstanceMethodInitSpec(_core.types.thisExpression(), prop, privateNamesMap, state));
+        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
         break;
 
-      case isStatic && isPrivate && isMethod && !loose:
+      case isStatic && isPrivate && isMethod && !privateFieldsAsProperties:
         needsClassRef = true;
-        staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap));
-        staticNodes.unshift(buildPrivateMethodDeclaration(prop, privateNamesMap, loose));
+        staticNodes.unshift(buildPrivateStaticFieldInitSpec(prop, privateNamesMap));
+        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
         break;
 
-      case isStatic && isPrivate && isMethod && loose:
+      case isStatic && isPrivate && isMethod && privateFieldsAsProperties:
         needsClassRef = true;
-        staticNodes.push(buildPrivateStaticMethodInitLoose(_core.types.cloneNode(ref), prop, state, privateNamesMap));
-        staticNodes.unshift(buildPrivateMethodDeclaration(prop, privateNamesMap, loose));
+        staticNodes.unshift(buildPrivateStaticMethodInitLoose(_core.types.cloneNode(ref), prop, state, privateNamesMap));
+        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
         break;
 
-      case isInstance && isPublic && isField && loose:
+      case isInstance && isPublic && isField && setPublicClassFields:
         instanceNodes.push(buildPublicFieldInitLoose(_core.types.thisExpression(), prop));
         break;
 
-      case isInstance && isPublic && isField && !loose:
+      case isInstance && isPublic && isField && !setPublicClassFields:
         instanceNodes.push(buildPublicFieldInitSpec(_core.types.thisExpression(), prop, state));
         break;
 
@@ -735,12 +898,20 @@ function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, state, loos
   return {
     staticNodes: staticNodes.filter(Boolean),
     instanceNodes: instanceNodes.filter(Boolean),
+    pureStaticNodes: pureStaticNodes.filter(Boolean),
 
     wrapClass(path) {
       for (const prop of props) {
         prop.remove();
       }
 
+      if (injectSuperRef) {
+        path.scope.push({
+          id: _core.types.cloneNode(injectSuperRef)
+        });
+        path.set("superClass", _core.types.assignmentExpression("=", injectSuperRef, path.node.superClass));
+      }
+
       if (!needsClassRef) return path;
 
       if (path.isClassExpression()) {

node_modules/@babel/helper-create-class-features-plugin/lib/index.js

@@ -3,23 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createClassFeaturePlugin = createClassFeaturePlugin;
-Object.defineProperty(exports, "injectInitialization", {
-  enumerable: true,
-  get: function () {
-    return _misc.injectInitialization;
-  }
-});
 Object.defineProperty(exports, "FEATURES", {
   enumerable: true,
   get: function () {
     return _features.FEATURES;
   }
 });
+exports.createClassFeaturePlugin = createClassFeaturePlugin;
+Object.defineProperty(exports, "enableFeature", {
+  enumerable: true,
+  get: function () {
+    return _features.enableFeature;
+  }
+});
+Object.defineProperty(exports, "injectInitialization", {
+  enumerable: true,
+  get: function () {
+    return _misc.injectInitialization;
+  }
+});
 
-var _helperFunctionName = _interopRequireDefault(require("@babel/helper-function-name"));
+var _core = require("@babel/core");
 
-var _helperSplitExportDeclaration = _interopRequireDefault(require("@babel/helper-split-export-declaration"));
+var _helperFunctionName = require("@babel/helper-function-name");
+
+var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration");
 
 var _fields = require("./fields");
 
@@ -29,39 +37,65 @@ var _misc = require("./misc");
 
 var _features = require("./features");
 
-var _package = _interopRequireDefault(require("../package.json"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const version = _package.default.version.split(".").reduce((v, x) => v * 1e5 + +x, 0);
+var _typescript = require("./typescript");
 
+const version = "7.18.6".split(".").reduce((v, x) => v * 1e5 + +x, 0);
 const versionKey = "@babel/plugin-class-features/version";
 
 function createClassFeaturePlugin({
   name,
   feature,
   loose,
-  manipulateOptions
+  manipulateOptions,
+  api = {
+    assumption: () => void 0
+  },
+  inherits
 }) {
+  const setPublicClassFields = api.assumption("setPublicClassFields");
+  const privateFieldsAsProperties = api.assumption("privateFieldsAsProperties");
+  const constantSuper = api.assumption("constantSuper");
+  const noDocumentAll = api.assumption("noDocumentAll");
+
+  if (loose === true) {
+    const explicit = [];
+
+    if (setPublicClassFields !== undefined) {
+      explicit.push(`"setPublicClassFields"`);
+    }
+
+    if (privateFieldsAsProperties !== undefined) {
+      explicit.push(`"privateFieldsAsProperties"`);
+    }
+
+    if (explicit.length !== 0) {
+      console.warn(`[${name}]: You are using the "loose: true" option and you are` + ` explicitly setting a value for the ${explicit.join(" and ")}` + ` assumption${explicit.length > 1 ? "s" : ""}. The "loose" option` + ` can cause incompatibilities with the other class features` + ` plugins, so it's recommended that you replace it with the` + ` following top-level option:\n` + `\t"assumptions": {\n` + `\t\t"setPublicClassFields": true,\n` + `\t\t"privateFieldsAsProperties": true\n` + `\t}`);
+    }
+  }
+
   return {
     name,
     manipulateOptions,
+    inherits,
 
-    pre() {
-      (0, _features.enableFeature)(this.file, feature, loose);
+    pre(file) {
+      (0, _features.enableFeature)(file, feature, loose);
 
-      if (!this.file.get(versionKey) || this.file.get(versionKey) < version) {
-        this.file.set(versionKey, version);
+      if (!file.get(versionKey) || file.get(versionKey) < version) {
+        file.set(versionKey, version);
       }
     },
 
     visitor: {
-      Class(path, state) {
-        if (this.file.get(versionKey) !== version) return;
-        (0, _features.verifyUsedFeatures)(path, this.file);
-        const loose = (0, _features.isLoose)(this.file, feature);
+      Class(path, {
+        file
+      }) {
+        if (file.get(versionKey) !== version) return;
+        if (!(0, _features.shouldTransform)(path, file)) return;
+        if (path.isClassDeclaration()) (0, _typescript.assertFieldTransformed)(path);
+        const loose = (0, _features.isLoose)(file, feature);
         let constructor;
-        let isDecorated = (0, _decorators.hasOwnDecorators)(path.node);
+        const isDecorated = (0, _decorators.hasDecorators)(path.node);
         const props = [];
         const elements = [];
         const computedPaths = [];
@@ -69,9 +103,7 @@ function createClassFeaturePlugin({
         const body = path.get("body");
 
         for (const path of body.get("body")) {
-          (0, _features.verifyUsedFeatures)(path, this.file);
-
-          if (path.node.computed) {
+          if ((path.isClassProperty() || path.isClassMethod()) && path.node.computed) {
             computedPaths.push(path);
           }
 
@@ -82,18 +114,20 @@ function createClassFeaturePlugin({
             const getName = `get ${name}`;
             const setName = `set ${name}`;
 
-            if (path.node.kind === "get") {
-              if (privateNames.has(getName) || privateNames.has(name) && !privateNames.has(setName)) {
-                throw path.buildCodeFrameError("Duplicate private field");
-              }
+            if (path.isClassPrivateMethod()) {
+              if (path.node.kind === "get") {
+                if (privateNames.has(getName) || privateNames.has(name) && !privateNames.has(setName)) {
+                  throw path.buildCodeFrameError("Duplicate private field");
+                }
 
-              privateNames.add(getName).add(name);
-            } else if (path.node.kind === "set") {
-              if (privateNames.has(setName) || privateNames.has(name) && !privateNames.has(getName)) {
-                throw path.buildCodeFrameError("Duplicate private field");
-              }
+                privateNames.add(getName).add(name);
+              } else if (path.node.kind === "set") {
+                if (privateNames.has(setName) || privateNames.has(name) && !privateNames.has(getName)) {
+                  throw path.buildCodeFrameError("Duplicate private field");
+                }
 
-              privateNames.add(setName).add(name);
+                privateNames.add(setName).add(name);
+              }
             } else {
               if (privateNames.has(name) && !privateNames.has(getName) && !privateNames.has(setName) || privateNames.has(name) && (privateNames.has(getName) || privateNames.has(setName))) {
                 throw path.buildCodeFrameError("Duplicate private field");
@@ -110,74 +144,89 @@ function createClassFeaturePlugin({
           } else {
             elements.push(path);
 
-            if (path.isProperty() || path.isPrivate()) {
+            if (path.isProperty() || path.isPrivate() || path.isStaticBlock != null && path.isStaticBlock()) {
               props.push(path);
             }
           }
-
-          if (!isDecorated) isDecorated = (0, _decorators.hasOwnDecorators)(path.node);
         }
 
-        if (!props.length && !isDecorated) return;
+        {
+          if (!props.length && !isDecorated) return;
+        }
+        const innerBinding = path.node.id;
         let ref;
 
-        if (path.isClassExpression() || !path.node.id) {
+        if (!innerBinding || path.isClassExpression()) {
           (0, _helperFunctionName.default)(path);
           ref = path.scope.generateUidIdentifier("class");
         } else {
-          ref = path.node.id;
+          ref = _core.types.cloneNode(path.node.id);
         }
 
         const privateNamesMap = (0, _fields.buildPrivateNamesMap)(props);
-        const privateNamesNodes = (0, _fields.buildPrivateNamesNodes)(privateNamesMap, loose, state);
-        (0, _fields.transformPrivateNamesUsage)(ref, path, privateNamesMap, loose, state);
-        let keysNodes, staticNodes, instanceNodes, wrapClass;
-
-        if (isDecorated) {
-          staticNodes = keysNodes = [];
-          ({
-            instanceNodes,
-            wrapClass
-          } = (0, _decorators.buildDecoratedClass)(ref, path, elements, this.file));
-        } else {
-          keysNodes = (0, _misc.extractComputedKeys)(ref, path, computedPaths, this.file);
-          ({
-            staticNodes,
-            instanceNodes,
-            wrapClass
-          } = (0, _fields.buildFieldsInitNodes)(ref, path.node.superClass, props, privateNamesMap, state, loose));
+        const privateNamesNodes = (0, _fields.buildPrivateNamesNodes)(privateNamesMap, privateFieldsAsProperties != null ? privateFieldsAsProperties : loose, file);
+        (0, _fields.transformPrivateNamesUsage)(ref, path, privateNamesMap, {
+          privateFieldsAsProperties: privateFieldsAsProperties != null ? privateFieldsAsProperties : loose,
+          noDocumentAll,
+          innerBinding
+        }, file);
+        let keysNodes, staticNodes, instanceNodes, pureStaticNodes, wrapClass;
+        {
+          if (isDecorated) {
+            staticNodes = pureStaticNodes = keysNodes = [];
+            ({
+              instanceNodes,
+              wrapClass
+            } = (0, _decorators.buildDecoratedClass)(ref, path, elements, file));
+          } else {
+            keysNodes = (0, _misc.extractComputedKeys)(path, computedPaths, file);
+            ({
+              staticNodes,
+              pureStaticNodes,
+              instanceNodes,
+              wrapClass
+            } = (0, _fields.buildFieldsInitNodes)(ref, path.node.superClass, props, privateNamesMap, file, setPublicClassFields != null ? setPublicClassFields : loose, privateFieldsAsProperties != null ? privateFieldsAsProperties : loose, constantSuper != null ? constantSuper : loose, innerBinding));
+          }
         }
 
         if (instanceNodes.length > 0) {
           (0, _misc.injectInitialization)(path, constructor, instanceNodes, (referenceVisitor, state) => {
-            if (isDecorated) return;
+            {
+              if (isDecorated) return;
+            }
 
             for (const prop of props) {
-              if (prop.node.static) continue;
+              if (_core.types.isStaticBlock != null && _core.types.isStaticBlock(prop.node) || prop.node.static) continue;
               prop.traverse(referenceVisitor, state);
             }
           });
         }
 
-        path = wrapClass(path);
-        path.insertBefore([...privateNamesNodes, ...keysNodes]);
-        path.insertAfter(staticNodes);
+        const wrappedPath = wrapClass(path);
+        wrappedPath.insertBefore([...privateNamesNodes, ...keysNodes]);
+
+        if (staticNodes.length > 0) {
+          wrappedPath.insertAfter(staticNodes);
+        }
+
+        if (pureStaticNodes.length > 0) {
+          wrappedPath.find(parent => parent.isStatement() || parent.isDeclaration()).insertAfter(pureStaticNodes);
+        }
       },
 
-      PrivateName(path) {
-        if (this.file.get(versionKey) !== version) return;
-        throw path.buildCodeFrameError(`Unknown PrivateName "${path}"`);
-      },
+      ExportDefaultDeclaration(path, {
+        file
+      }) {
+        {
+          if (file.get(versionKey) !== version) return;
+          const decl = path.get("declaration");
 
-      ExportDefaultDeclaration(path) {
-        if (this.file.get(versionKey) !== version) return;
-        const decl = path.get("declaration");
-
-        if (decl.isClassDeclaration() && (0, _decorators.hasDecorators)(decl.node)) {
-          if (decl.node.id) {
-            (0, _helperSplitExportDeclaration.default)(path);
-          } else {
-            decl.node.type = "ClassExpression";
+          if (decl.isClassDeclaration() && (0, _decorators.hasDecorators)(decl.node)) {
+            if (decl.node.id) {
+              (0, _helperSplitExportDeclaration.default)(path);
+            } else {
+              decl.node.type = "ClassExpression";
+            }
           }
         }
       }

node_modules/@babel/helper-create-class-features-plugin/lib/misc.js

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.injectInitialization = injectInitialization;
 exports.extractComputedKeys = extractComputedKeys;
+exports.injectInitialization = injectInitialization;
 
 var _core = require("@babel/core");
 
-var _helperReplaceSupers = require("@babel/helper-replace-supers");
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
 
 const findBareSupers = _core.traverse.visitors.merge([{
   Super(path) {
@@ -24,16 +24,18 @@ const findBareSupers = _core.traverse.visitors.merge([{
     }
   }
 
-}, _helperReplaceSupers.environmentVisitor]);
+}, _helperEnvironmentVisitor.default]);
 
 const referenceVisitor = {
   "TSTypeAnnotation|TypeAnnotation"(path) {
     path.skip();
   },
 
-  ReferencedIdentifier(path) {
-    if (this.scope.hasOwnBinding(path.node.name)) {
-      this.scope.rename(path.node.name);
+  ReferencedIdentifier(path, {
+    scope
+  }) {
+    if (scope.hasOwnBinding(path.node.name)) {
+      scope.rename(path.node.name);
       path.skip();
     }
   }
@@ -79,16 +81,22 @@ function injectInitialization(path, constructor, nodes, renamer) {
   if (isDerived) {
     const bareSupers = [];
     constructor.traverse(findBareSupers, bareSupers);
+    let isFirst = true;
 
     for (const bareSuper of bareSupers) {
-      bareSuper.insertAfter(nodes);
+      if (isFirst) {
+        bareSuper.insertAfter(nodes);
+        isFirst = false;
+      } else {
+        bareSuper.insertAfter(nodes.map(n => _core.types.cloneNode(n)));
+      }
     }
   } else {
     constructor.get("body").unshiftContainer("body", nodes);
   }
 }
 
-function extractComputedKeys(ref, path, computedPaths, file) {
+function extractComputedKeys(path, computedPaths, file) {
   const declarations = [];
   const state = {
     classBinding: path.node.id && path.scope.getBinding(path.node.id.name),

node_modules/@babel/helper-create-class-features-plugin/package.json

@@ -1,63 +1,70 @@
 {
   "_args": [
     [
-      "@babel/helper-create-class-features-plugin@7.10.4",
-      "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series"
+      "@babel/helper-create-class-features-plugin@7.18.6",
+      "/home/node/nuxt"
     ]
   ],
-  "_from": "@babel/helper-create-class-features-plugin@7.10.4",
-  "_id": "@babel/helper-create-class-features-plugin@7.10.4",
+  "_from": "@babel/helper-create-class-features-plugin@7.18.6",
+  "_id": "@babel/helper-create-class-features-plugin@7.18.6",
   "_inBundle": false,
-  "_integrity": "sha512-9raUiOsXPxzzLjCXeosApJItoMnX3uyT4QdM2UldffuGApNrF8e938MwNpDCK9CPoyxrEoCgT+hObJc3mZa6lQ==",
+  "_integrity": "sha512-YfDzdnoxHGV8CzqHGyCbFvXg5QESPFkXlHtvdCkesLjjVMT2Adxe4FGUR5ChIb3DxSaXO12iIOCWoXdsUVwnqw==",
   "_location": "/@babel/helper-create-class-features-plugin",
   "_phantomChildren": {},
   "_requested": {
     "type": "version",
     "registry": true,
-    "raw": "@babel/helper-create-class-features-plugin@7.10.4",
+    "raw": "@babel/helper-create-class-features-plugin@7.18.6",
     "name": "@babel/helper-create-class-features-plugin",
     "escapedName": "@babel%2fhelper-create-class-features-plugin",
     "scope": "@babel",
-    "rawSpec": "7.10.4",
+    "rawSpec": "7.18.6",
     "saveSpec": null,
-    "fetchSpec": "7.10.4"
+    "fetchSpec": "7.18.6"
   },
   "_requiredBy": [
     "/@babel/plugin-proposal-class-properties",
+    "/@babel/plugin-proposal-class-static-block",
     "/@babel/plugin-proposal-decorators",
-    "/@babel/plugin-proposal-private-methods"
+    "/@babel/plugin-proposal-private-methods",
+    "/@babel/plugin-proposal-private-property-in-object"
   ],
-  "_resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.10.4.tgz",
-  "_spec": "7.10.4",
-  "_where": "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series",
+  "_resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.18.6.tgz",
+  "_spec": "7.18.6",
+  "_where": "/home/node/nuxt",
   "author": {
     "name": "The Babel Team",
-    "url": "https://babeljs.io/team"
+    "url": "https://babel.dev/team"
   },
   "bugs": {
     "url": "https://github.com/babel/babel/issues"
   },
   "dependencies": {
-    "@babel/helper-function-name": "^7.10.4",
-    "@babel/helper-member-expression-to-functions": "^7.10.4",
-    "@babel/helper-optimise-call-expression": "^7.10.4",
-    "@babel/helper-plugin-utils": "^7.10.4",
-    "@babel/helper-replace-supers": "^7.10.4",
-    "@babel/helper-split-export-declaration": "^7.10.4"
+    "@babel/helper-annotate-as-pure": "^7.18.6",
+    "@babel/helper-environment-visitor": "^7.18.6",
+    "@babel/helper-function-name": "^7.18.6",
+    "@babel/helper-member-expression-to-functions": "^7.18.6",
+    "@babel/helper-optimise-call-expression": "^7.18.6",
+    "@babel/helper-replace-supers": "^7.18.6",
+    "@babel/helper-split-export-declaration": "^7.18.6"
   },
   "description": "Compile class public and private fields, private methods and decorators to ES6",
   "devDependencies": {
-    "@babel/core": "^7.10.4",
-    "@babel/helper-plugin-test-runner": "^7.10.4"
+    "@babel/core": "^7.18.6",
+    "@babel/helper-plugin-test-runner": "^7.18.6",
+    "@babel/plugin-syntax-class-static-block": "^7.14.5",
+    "@babel/preset-env": "^7.18.6"
+  },
+  "engines": {
+    "node": ">=6.9.0"
   },
-  "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df",
   "homepage": "https://github.com/babel/babel#readme",
   "keywords": [
     "babel",
     "babel-plugin"
   ],
   "license": "MIT",
-  "main": "lib/index.js",
+  "main": "./lib/index.js",
   "name": "@babel/helper-create-class-features-plugin",
   "peerDependencies": {
     "@babel/core": "^7.0.0"
@@ -70,5 +77,6 @@
     "url": "git+https://github.com/babel/babel.git",
     "directory": "packages/babel-helper-create-class-features-plugin"
   },
-  "version": "7.10.4"
+  "type": "commonjs",
+  "version": "7.18.6"
 }