updated node_modules

1 files changed, 305 insertions, 113 deletions

diff --git a/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js b/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js
index 981cf0b3..66022633 100644
--- a/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js
+++ b/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js
@@ -7,6 +7,7 @@ exports.buildCheckInRHS = buildCheckInRHS;
 exports.buildFieldsInitNodes = buildFieldsInitNodes;
 exports.buildPrivateNamesMap = buildPrivateNamesMap;
 exports.buildPrivateNamesNodes = buildPrivateNamesNodes;
+exports.privateNameVisitorFactory = privateNameVisitorFactory;
 exports.transformPrivateNamesUsage = transformPrivateNamesUsage;
 var _core = require("@babel/core");
 var _helperReplaceSupers = require("@babel/helper-replace-supers");
@@ -16,23 +17,70 @@ var _helperOptimiseCallExpression = require("@babel/helper-optimise-call-express
 var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure");
 var _helperSkipTransparentExpressionWrappers = require("@babel/helper-skip-transparent-expression-wrappers");
 var ts = require("./typescript.js");
-function buildPrivateNamesMap(props) {
+{
+  var newHelpers = file => {
+    ;
+    return file.availableHelper("classPrivateFieldGet2");
+  };
+}
+function buildPrivateNamesMap(className, privateFieldsAsSymbolsOrProperties, props, file) {
   const privateNamesMap = new Map();
+  let classBrandId;
   for (const prop of props) {
     if (prop.isPrivate()) {
       const {
         name
       } = prop.node.key.id;
-      const update = privateNamesMap.has(name) ? privateNamesMap.get(name) : {
-        id: prop.scope.generateUidIdentifier(name),
-        static: prop.node.static,
-        method: !prop.isProperty()
-      };
+      let update = privateNamesMap.get(name);
+      if (!update) {
+        const isMethod = !prop.isProperty();
+        const isStatic = prop.node.static;
+        let initAdded = false;
+        let id;
+        if (!privateFieldsAsSymbolsOrProperties && newHelpers(file) && isMethod && !isStatic) {
+          var _classBrandId;
+          initAdded = !!classBrandId;
+          (_classBrandId = classBrandId) != null ? _classBrandId : classBrandId = prop.scope.generateUidIdentifier(`${className}_brand`);
+          id = classBrandId;
+        } else {
+          id = prop.scope.generateUidIdentifier(name);
+        }
+        update = {
+          id,
+          static: isStatic,
+          method: isMethod,
+          initAdded
+        };
+        privateNamesMap.set(name, update);
+      }
       if (prop.isClassPrivateMethod()) {
         if (prop.node.kind === "get") {
-          update.getId = prop.scope.generateUidIdentifier(`get_${name}`);
+          const {
+            body
+          } = prop.node.body;
+          let $;
+          if (body.length === 1 && _core.types.isReturnStatement($ = body[0]) && _core.types.isCallExpression($ = $.argument) && $.arguments.length === 1 && _core.types.isThisExpression($.arguments[0]) && _core.types.isIdentifier($ = $.callee)) {
+            update.getId = _core.types.cloneNode($);
+            update.getterDeclared = true;
+          } else {
+            update.getId = prop.scope.generateUidIdentifier(`get_${name}`);
+          }
         } else if (prop.node.kind === "set") {
-          update.setId = prop.scope.generateUidIdentifier(`set_${name}`);
+          const {
+            params
+          } = prop.node;
+          const {
+            body
+          } = prop.node.body;
+          let $;
+          if (body.length === 1 && _core.types.isExpressionStatement($ = body[0]) && _core.types.isCallExpression($ = $.expression) && $.arguments.length === 2 && _core.types.isThisExpression($.arguments[0]) && _core.types.isIdentifier($.arguments[1], {
+            name: params[0].name
+          }) && _core.types.isIdentifier($ = $.callee)) {
+            update.setId = _core.types.cloneNode($);
+            update.setterDeclared = true;
+          } else {
+            update.setId = prop.scope.generateUidIdentifier(`set_${name}`);
+          }
         } else if (prop.node.kind === "method") {
           update.methodId = prop.scope.generateUidIdentifier(name);
         }
@@ -44,6 +92,7 @@ function buildPrivateNamesMap(props) {
 }
 function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, privateFieldsAsSymbols, state) {
   const initNodes = [];
+  const injectedIds = new Set();
   for (const [name, value] of privateNamesMap) {
     const {
       static: isStatic,
@@ -51,7 +100,7 @@ function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, priv
       getId,
       setId
     } = value;
-    const isAccessor = getId || setId;
+    const isGetterOrSetter = getId || setId;
     const id = _core.types.cloneNode(value.id);
     let init;
     if (privateFieldsAsProperties) {
@@ -59,10 +108,14 @@ function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, priv
     } else if (privateFieldsAsSymbols) {
       init = _core.types.callExpression(_core.types.identifier("Symbol"), [_core.types.stringLiteral(name)]);
     } else if (!isStatic) {
-      init = _core.types.newExpression(_core.types.identifier(!isMethod || isAccessor ? "WeakMap" : "WeakSet"), []);
+      if (injectedIds.has(id.name)) continue;
+      injectedIds.add(id.name);
+      init = _core.types.newExpression(_core.types.identifier(isMethod && (!isGetterOrSetter || newHelpers(state)) ? "WeakSet" : "WeakMap"), []);
     }
     if (init) {
-      (0, _helperAnnotateAsPure.default)(init);
+      if (!privateFieldsAsSymbols) {
+        (0, _helperAnnotateAsPure.default)(init);
+      }
       initNodes.push(_core.template.statement.ast`var ${id} = ${init}`);
     }
   }
@@ -180,6 +233,20 @@ const privateInVisitor = privateNameVisitorFactory({
     path.replaceWith(_core.template.expression.ast`${_core.types.cloneNode(id)}.has(${buildCheckInRHS(right, file)})`);
   }
 });
+function readOnlyError(file, name) {
+  return _core.types.callExpression(file.addHelper("readOnlyError"), [_core.types.stringLiteral(`#${name}`)]);
+}
+function writeOnlyError(file, name) {
+  if (!file.availableHelper("writeOnlyError")) {
+    console.warn(`@babel/helpers is outdated, update it to silence this warning.`);
+    return _core.types.buildUndefinedNode();
+  }
+  return _core.types.callExpression(file.addHelper("writeOnlyError"), [_core.types.stringLiteral(`#${name}`)]);
+}
+function buildStaticPrivateFieldAccess(expr, noUninitializedPrivateFieldAccess) {
+  if (noUninitializedPrivateFieldAccess) return expr;
+  return _core.types.memberExpression(expr, _core.types.identifier("_"));
+}
 const privateNameHandlerSpec = {
   memoise(member, count) {
     const {
@@ -208,7 +275,8 @@ const privateNameHandlerSpec = {
       classRef,
       privateNamesMap,
       file,
-      innerBinding
+      innerBinding,
+      noUninitializedPrivateFieldAccess
     } = this;
     const {
       name
@@ -221,23 +289,52 @@ const privateNameHandlerSpec = {
       getId,
       setId
     } = privateNamesMap.get(name);
-    const isAccessor = getId || setId;
+    const isGetterOrSetter = getId || setId;
     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 (!newHelpers(file)) {
+        const helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodGet" : "classStaticPrivateFieldSpecGet";
+        return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]);
+      }
+      const receiver = this.receiver(member);
+      const skipCheck = _core.types.isIdentifier(receiver) && receiver.name === classRef.name;
+      if (!isMethod) {
+        if (skipCheck) {
+          return buildStaticPrivateFieldAccess(_core.types.cloneNode(id), noUninitializedPrivateFieldAccess);
+        }
+        return buildStaticPrivateFieldAccess(_core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, _core.types.cloneNode(id)]), noUninitializedPrivateFieldAccess);
+      }
+      if (getId) {
+        if (skipCheck) {
+          return _core.types.callExpression(_core.types.cloneNode(getId), [receiver]);
+        }
+        return _core.types.callExpression(file.addHelper("classPrivateGetter"), [_core.types.cloneNode(classRef), receiver, _core.types.cloneNode(getId)]);
+      }
+      if (setId) {
+        const err = _core.types.buildUndefinedNode();
+        if (skipCheck) return err;
+        return _core.types.sequenceExpression([_core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver]), err]);
+      }
+      if (skipCheck) return _core.types.cloneNode(id);
+      return _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, _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.`);
+      if (isGetterOrSetter) {
+        if (!getId) {
+          return _core.types.sequenceExpression([this.receiver(member), writeOnlyError(file, name)]);
         }
-        return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]);
+        if (!newHelpers(file)) {
+          return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]);
+        }
+        return _core.types.callExpression(file.addHelper("classPrivateGetter"), [_core.types.cloneNode(id), this.receiver(member), _core.types.cloneNode(getId)]);
+      }
+      if (!newHelpers(file)) {
+        return _core.types.callExpression(file.addHelper("classPrivateMethodGet"), [this.receiver(member), _core.types.cloneNode(id), _core.types.cloneNode(methodId)]);
       }
-      return _core.types.callExpression(file.addHelper("classPrivateMethodGet"), [this.receiver(member), _core.types.cloneNode(id), _core.types.cloneNode(methodId)]);
+      return _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(id), this.receiver(member), _core.types.cloneNode(methodId)]);
+    }
+    if (newHelpers(file)) {
+      return _core.types.callExpression(file.addHelper("classPrivateFieldGet2"), [_core.types.cloneNode(id), this.receiver(member)]);
     }
     return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]);
   },
@@ -249,7 +346,8 @@ const privateNameHandlerSpec = {
     const {
       classRef,
       privateNamesMap,
-      file
+      file,
+      noUninitializedPrivateFieldAccess
     } = this;
     const {
       name
@@ -261,16 +359,38 @@ const privateNameHandlerSpec = {
       setId,
       getId
     } = privateNamesMap.get(name);
-    const isAccessor = getId || setId;
+    const isGetterOrSetter = getId || setId;
     if (isStatic) {
-      const helperName = isMethod && !isAccessor ? "classStaticPrivateMethodSet" : "classStaticPrivateFieldSpecSet";
-      return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id), value]);
+      if (!newHelpers(file)) {
+        const helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodSet" : "classStaticPrivateFieldSpecSet";
+        return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id), value]);
+      }
+      const receiver = this.receiver(member);
+      const skipCheck = _core.types.isIdentifier(receiver) && receiver.name === classRef.name;
+      if (isMethod && !setId) {
+        const err = readOnlyError(file, name);
+        if (skipCheck) return _core.types.sequenceExpression([value, err]);
+        return _core.types.sequenceExpression([value, _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver]), readOnlyError(file, name)]);
+      }
+      if (setId) {
+        if (skipCheck) {
+          return _core.types.callExpression(_core.types.cloneNode(setId), [receiver, value]);
+        }
+        return _core.types.callExpression(file.addHelper("classPrivateSetter"), [_core.types.cloneNode(classRef), _core.types.cloneNode(setId), receiver, value]);
+      }
+      return _core.types.assignmentExpression("=", buildStaticPrivateFieldAccess(_core.types.cloneNode(id), noUninitializedPrivateFieldAccess), skipCheck ? value : _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, value]));
     }
     if (isMethod) {
       if (setId) {
-        return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]);
+        if (!newHelpers(file)) {
+          return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]);
+        }
+        return _core.types.callExpression(file.addHelper("classPrivateSetter"), [_core.types.cloneNode(id), _core.types.cloneNode(setId), this.receiver(member), value]);
       }
-      return _core.types.sequenceExpression([this.receiver(member), value, _core.types.callExpression(file.addHelper("readOnlyError"), [_core.types.stringLiteral(`#${name}`)])]);
+      return _core.types.sequenceExpression([this.receiver(member), value, readOnlyError(file, name)]);
+    }
+    if (newHelpers(file)) {
+      return _core.types.callExpression(file.addHelper("classPrivateFieldSet2"), [_core.types.cloneNode(id), this.receiver(member), value]);
     }
     return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]);
   },
@@ -278,24 +398,56 @@ const privateNameHandlerSpec = {
     const {
       classRef,
       privateNamesMap,
-      file
+      file,
+      noUninitializedPrivateFieldAccess
     } = this;
     const {
       name
     } = member.node.property.id;
     const {
       id,
-      static: isStatic
+      static: isStatic,
+      method: isMethod,
+      setId
     } = 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.");
+    if (!newHelpers(file)) {
+      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"));
+    }
+    if (isMethod && !setId) {
+      return _core.types.memberExpression(_core.types.sequenceExpression([member.node.object, readOnlyError(file, name)]), _core.types.identifier("_"));
+    }
+    if (isStatic && !isMethod) {
+      const getCall = this.get(member);
+      if (!noUninitializedPrivateFieldAccess || !_core.types.isCallExpression(getCall)) {
+        return getCall;
       }
-      return _core.types.memberExpression(_core.types.callExpression(helper, [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]), _core.types.identifier("value"));
+      const ref = getCall.arguments.pop();
+      getCall.arguments.push(_core.template.expression.ast`(_) => ${ref} = _`);
+      return _core.types.memberExpression(_core.types.callExpression(file.addHelper("toSetter"), [getCall]), _core.types.identifier("_"));
+    }
+    const setCall = this.set(member, _core.types.identifier("_"));
+    if (!_core.types.isCallExpression(setCall) || !_core.types.isIdentifier(setCall.arguments[setCall.arguments.length - 1], {
+      name: "_"
+    })) {
+      throw member.buildCodeFrameError("Internal Babel error while compiling this code. This is a Babel bug. " + "Please report it at https://github.com/babel/babel/issues.");
     }
-    return _core.types.memberExpression(_core.types.callExpression(file.addHelper("classPrivateFieldDestructureSet"), [this.receiver(member), _core.types.cloneNode(id)]), _core.types.identifier("value"));
+    let args;
+    if (_core.types.isMemberExpression(setCall.callee, {
+      computed: false
+    }) && _core.types.isIdentifier(setCall.callee.property) && setCall.callee.property.name === "call") {
+      args = [setCall.callee.object, _core.types.arrayExpression(setCall.arguments.slice(1, -1)), setCall.arguments[0]];
+    } else {
+      args = [setCall.callee, _core.types.arrayExpression(setCall.arguments.slice(0, -1))];
+    }
+    return _core.types.memberExpression(_core.types.callExpression(file.addHelper("toSetter"), args), _core.types.identifier("_"));
   },
   call(member, args) {
     this.memoise(member, 1);
@@ -351,6 +503,7 @@ const privateNameHandlerLoose = {
 };
 function transformPrivateNamesUsage(ref, path, privateNamesMap, {
   privateFieldsAsProperties,
+  noUninitializedPrivateFieldAccess,
   noDocumentAll,
   innerBinding
 }, state) {
@@ -363,6 +516,7 @@ function transformPrivateNamesUsage(ref, path, privateNamesMap, {
     file: state
   }, handler, {
     noDocumentAll,
+    noUninitializedPrivateFieldAccess,
     innerBinding
   }));
   body.traverse(privateInVisitor, {
@@ -403,48 +557,50 @@ function buildPrivateInstanceFieldInitSpec(ref, prop, privateNamesMap, state) {
     }
   }
   const helper = state.addHelper("classPrivateFieldInitSpec");
-  return inheritPropComments(_core.template.statement.ast`${helper}(
-      ${_core.types.thisExpression()},
-      ${_core.types.cloneNode(id)},
-      {
-        writable: true,
-        value: ${value}
-      },
-    )`, prop);
+  return inheritPropComments(_core.types.expressionStatement(_core.types.callExpression(helper, [_core.types.thisExpression(), _core.types.cloneNode(id), newHelpers(state) ? value : _core.template.expression.ast`{ writable: true, value: ${value} }`])), prop);
 }
-function buildPrivateStaticFieldInitSpec(prop, privateNamesMap) {
+function buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
-  const {
-    id,
-    getId,
-    setId,
-    initAdded
-  } = privateName;
-  const isAccessor = getId || setId;
-  if (!prop.isProperty() && (initAdded || !isAccessor)) return;
-  if (isAccessor) {
-    privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
-      initAdded: true
-    }));
+  const value = noUninitializedPrivateFieldAccess ? prop.node.value : _core.template.expression.ast`{
+        _: ${prop.node.value || _core.types.buildUndefinedNode()}
+      }`;
+  return inheritPropComments(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.cloneNode(privateName.id), value)]), prop);
+}
+{
+  var buildPrivateStaticFieldInitSpecOld = function (prop, privateNamesMap) {
+    const privateName = privateNamesMap.get(prop.node.key.id.name);
+    const {
+      id,
+      getId,
+      setId,
+      initAdded
+    } = privateName;
+    const isGetterOrSetter = getId || setId;
+    if (!prop.isProperty() && (initAdded || !isGetterOrSetter)) return;
+    if (isGetterOrSetter) {
+      privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
+        initAdded: true
+      }));
+      return inheritPropComments(_core.template.statement.ast`
+          var ${_core.types.cloneNode(id)} = {
+            // configurable is false by default
+            // enumerable is false by default
+            // writable is false by default
+            get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
+            set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
+          }
+        `, prop);
+    }
+    const value = prop.node.value || prop.scope.buildUndefinedNode();
     return inheritPropComments(_core.template.statement.ast`
         var ${_core.types.cloneNode(id)} = {
           // configurable is false by default
           // enumerable is false by default
-          // writable is false by default
-          get: ${getId ? getId.name : prop.scope.buildUndefinedNode()},
-          set: ${setId ? setId.name : prop.scope.buildUndefinedNode()}
-        }
+          writable: true,
+          value: ${value}
+        };
       `, prop);
-  }
-  const value = prop.node.value || prop.scope.buildUndefinedNode();
-  return inheritPropComments(_core.template.statement.ast`
-      var ${_core.types.cloneNode(id)} = {
-        // configurable is false by default
-        // enumerable is false by default
-        writable: true,
-        value: ${value}
-      };
-    `, prop);
+  };
 }
 function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
@@ -466,8 +622,8 @@ function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) {
         });
       `, prop);
   }
-  const isAccessor = getId || setId;
-  if (isAccessor) {
+  const isGetterOrSetter = getId || setId;
+  if (isGetterOrSetter) {
     privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
       initAdded: true
     }));
@@ -484,15 +640,12 @@ function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) {
 }
 function buildPrivateInstanceMethodInitSpec(ref, prop, privateNamesMap, state) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
-  const {
-    getId,
-    setId,
-    initAdded
-  } = privateName;
-  if (initAdded) return;
-  const isAccessor = getId || setId;
-  if (isAccessor) {
-    return buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state);
+  if (privateName.initAdded) return;
+  if (!newHelpers(state)) {
+    const isGetterOrSetter = privateName.getId || privateName.setId;
+    if (isGetterOrSetter) {
+      return buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state);
+    }
   }
   return buildPrivateInstanceMethodInitialization(ref, prop, privateNamesMap, state);
 }
@@ -568,8 +721,8 @@ function buildPrivateStaticMethodInitLoose(ref, prop, state, privateNamesMap) {
     initAdded
   } = privateName;
   if (initAdded) return;
-  const isAccessor = getId || setId;
-  if (isAccessor) {
+  const isGetterOrSetter = getId || setId;
+  if (isGetterOrSetter) {
     privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
       initAdded: true
     }));
@@ -592,7 +745,7 @@ function buildPrivateStaticMethodInitLoose(ref, prop, state, privateNamesMap) {
       });
     `, prop);
 }
-function buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties = false) {
+function buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties = false) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
   const {
     id,
@@ -609,25 +762,58 @@ function buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsPro
     generator,
     async
   } = prop.node;
-  const isGetter = getId && !getterDeclared && params.length === 0;
-  const isSetter = setId && !setterDeclared && params.length > 0;
+  const isGetter = getId && params.length === 0;
+  const isSetter = setId && params.length > 0;
+  if (isGetter && getterDeclared || isSetter && setterDeclared) {
+    privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
+      initAdded: true
+    }));
+    return null;
+  }
+  if (newHelpers(file) && (isGetter || isSetter) && !privateFieldsAsSymbolsOrProperties) {
+    const scope = prop.get("body").scope;
+    const thisArg = scope.generateUidIdentifier("this");
+    const state = {
+      thisRef: thisArg,
+      argumentsPath: []
+    };
+    prop.traverse(thisContextVisitor, state);
+    if (state.argumentsPath.length) {
+      const argumentsId = scope.generateUidIdentifier("arguments");
+      scope.push({
+        id: argumentsId,
+        init: _core.template.expression.ast`[].slice.call(arguments, 1)`
+      });
+      for (const path of state.argumentsPath) {
+        path.replaceWith(_core.types.cloneNode(argumentsId));
+      }
+    }
+    params.unshift(_core.types.cloneNode(thisArg));
+  }
   let declId = methodId;
   if (isGetter) {
     privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
-      getterDeclared: true
+      getterDeclared: true,
+      initAdded: true
     }));
     declId = getId;
   } else if (isSetter) {
     privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, {
-      setterDeclared: true
+      setterDeclared: true,
+      initAdded: true
     }));
     declId = setId;
-  } else if (isStatic && !privateFieldsAsProperties) {
+  } else if (isStatic && !privateFieldsAsSymbolsOrProperties) {
     declId = id;
   }
   return inheritPropComments(_core.types.functionDeclaration(_core.types.cloneNode(declId), params, body, generator, async), prop);
 }
 const thisContextVisitor = _core.traverse.visitors.merge([{
+  Identifier(path, state) {
+    if (state.argumentsPath && path.node.name === "arguments") {
+      state.argumentsPath.push(path);
+    }
+  },
   UnaryExpression(path) {
     const {
       node
@@ -641,7 +827,7 @@ const thisContextVisitor = _core.traverse.visitors.merge([{
   },
   ThisExpression(path, state) {
     state.needsClassRef = true;
-    path.replaceWith(_core.types.cloneNode(state.classRef));
+    path.replaceWith(_core.types.cloneNode(state.thisRef));
   },
   MetaProperty(path) {
     const {
@@ -657,21 +843,21 @@ const innerReferencesVisitor = {
   ReferencedIdentifier(path, state) {
     if (path.scope.bindingIdentifierEquals(path.node.name, state.innerBinding)) {
       state.needsClassRef = true;
-      path.node.name = state.classRef.name;
+      path.node.name = state.thisRef.name;
     }
   }
 };
 function replaceThisContext(path, ref, innerBindingRef) {
-  var _state$classRef;
+  var _state$thisRef;
   const state = {
-    classRef: ref,
+    thisRef: ref,
     needsClassRef: false,
     innerBinding: innerBindingRef
   };
   if (!path.isMethod()) {
     path.traverse(thisContextVisitor, state);
   }
-  if (innerBindingRef != null && (_state$classRef = state.classRef) != null && _state$classRef.name && state.classRef.name !== innerBindingRef.name) {
+  if (innerBindingRef != null && (_state$thisRef = state.thisRef) != null && _state$thisRef.name && state.thisRef.name !== innerBindingRef.name) {
     path.traverse(innerReferencesVisitor, state);
   }
   return state.needsClassRef;
@@ -693,7 +879,7 @@ function inheritPropComments(node, prop) {
   _core.types.inheritInnerComments(node, prop.node);
   return node;
 }
-function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPublicClassFields, privateFieldsAsProperties, constantSuper, innerBindingRef) {
+function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPublicClassFields, privateFieldsAsSymbolsOrProperties, noUninitializedPrivateFieldAccess, constantSuper, innerBindingRef) {
   var _ref, _ref2;
   let classRefFlags = 0;
   let injectSuperRef;
@@ -707,7 +893,7 @@ function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPu
     (_injectSuperRef = injectSuperRef) != null ? _injectSuperRef : injectSuperRef = props[0].scope.generateUidIdentifierBasedOnNode(superRef);
     return injectSuperRef;
   };
-  const classRefForInnerBinding = (_ref = ref) != null ? _ref : props[0].scope.generateUidIdentifier("class");
+  const classRefForInnerBinding = (_ref = ref) != null ? _ref : props[0].scope.generateUidIdentifier((innerBindingRef == null ? void 0 : innerBindingRef.name) || "Class");
   (_ref2 = ref) != null ? _ref2 : ref = _core.types.cloneNode(innerBindingRef);
   for (const prop of props) {
     prop.isClassProperty() && ts.assertFieldTransformed(prop);
@@ -752,11 +938,15 @@ function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPu
           }
           break;
         }
-      case isStatic && isPrivate && isField && privateFieldsAsProperties:
+      case isStatic && isPrivate && isField && privateFieldsAsSymbolsOrProperties:
         staticNodes.push(buildPrivateFieldInitLoose(_core.types.cloneNode(ref), prop, privateNamesMap));
         break;
-      case isStatic && isPrivate && isField && !privateFieldsAsProperties:
-        staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap));
+      case isStatic && isPrivate && isField && !privateFieldsAsSymbolsOrProperties:
+        if (!newHelpers(file)) {
+          staticNodes.push(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap));
+        } else {
+          staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess));
+        }
         break;
       case isStatic && isPublic && isField && setPublicClassFields:
         if (!isNameOrLength(prop.node)) {
@@ -766,27 +956,29 @@ function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPu
       case isStatic && isPublic && isField && !setPublicClassFields:
         staticNodes.push(buildPublicFieldInitSpec(_core.types.cloneNode(ref), prop, file));
         break;
-      case isInstance && isPrivate && isField && privateFieldsAsProperties:
+      case isInstance && isPrivate && isField && privateFieldsAsSymbolsOrProperties:
         instanceNodes.push(buildPrivateFieldInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
         break;
-      case isInstance && isPrivate && isField && !privateFieldsAsProperties:
+      case isInstance && isPrivate && isField && !privateFieldsAsSymbolsOrProperties:
         instanceNodes.push(buildPrivateInstanceFieldInitSpec(_core.types.thisExpression(), prop, privateNamesMap, file));
         break;
-      case isInstance && isPrivate && isMethod && privateFieldsAsProperties:
+      case isInstance && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties:
         instanceNodes.unshift(buildPrivateMethodInitLoose(_core.types.thisExpression(), prop, privateNamesMap));
-        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
+        pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
         break;
-      case isInstance && isPrivate && isMethod && !privateFieldsAsProperties:
+      case isInstance && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties:
         instanceNodes.unshift(buildPrivateInstanceMethodInitSpec(_core.types.thisExpression(), prop, privateNamesMap, file));
-        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
+        pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
         break;
-      case isStatic && isPrivate && isMethod && !privateFieldsAsProperties:
-        staticNodes.unshift(buildPrivateStaticFieldInitSpec(prop, privateNamesMap));
-        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
+      case isStatic && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties:
+        if (!newHelpers(file)) {
+          staticNodes.unshift(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap));
+        }
+        pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
         break;
-      case isStatic && isPrivate && isMethod && privateFieldsAsProperties:
+      case isStatic && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties:
         staticNodes.unshift(buildPrivateStaticMethodInitLoose(_core.types.cloneNode(ref), prop, file, privateNamesMap));
-        pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties));
+        pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties));
         break;
       case isInstance && isPublic && isField && setPublicClassFields:
         instanceNodes.push(buildPublicFieldInitLoose(_core.types.thisExpression(), prop));