text: function _checkPrivateRedeclaration(obj, privateCollection) {
      if (privateCollection.has(obj)) {
          throw new TypeError("Cannot initialize the same private elements twice on an object");
      }
  }
  function _classApplyDescriptorGet(receiver, descriptor) {
      if (descriptor.get) {
          return descriptor.get.call(receiver);
      }
      return descriptor.value;
  }
  function _classApplyDescriptorSet(receiver, descriptor, value) {
      if (descriptor.set) {
          descriptor.set.call(receiver, value);
      } else {
          if (!descriptor.writable) {
              throw new TypeError("attempted to set read only private field");
          }
          descriptor.value = value;
      }
  }
  function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
      if (descriptor === undefined) {
          throw new TypeError("attempted to " + action + " private static field before its declaration");
      }
  }
  function _classExtractFieldDescriptor(receiver, privateMap, action) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to " + action + " private field on non-instance");
      }
      return privateMap.get(receiver);
  }
  function _classPrivateFieldGet(receiver, privateMap) {
      var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
      return _classApplyDescriptorGet(receiver, descriptor);
  }
  function _classPrivateFieldInit(obj, privateMap, value) {
      _checkPrivateRedeclaration(obj, privateMap);
      privateMap.set(obj, value);
  }
  function _classPrivateFieldSet(receiver, privateMap, value) {
      var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
      _classApplyDescriptorSet(receiver, descriptor, value);
      return value;
  }
  function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
      _classCheckPrivateStaticAccess(receiver, classConstructor);
      _classCheckPrivateStaticFieldDescriptor(descriptor, "get");
      return _classApplyDescriptorGet(receiver, descriptor);
  }
  function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
      _classCheckPrivateStaticAccess(receiver, classConstructor);
      _classCheckPrivateStaticFieldDescriptor(descriptor, "set");
      _classApplyDescriptorSet(receiver, descriptor, value);
      return value;
  }
  function _classCheckPrivateStaticAccess(receiver, classConstructor) {
      if (receiver !== classConstructor) {
          throw new TypeError("Private static access of wrong provenance");
      }
  }
  var _a = new WeakMap(), _b = new WeakMap(), _something = new WeakMap();
  // @target: esnext, es2022
  // @useDefineForClassFields: false
  class C {
      method() {
          console.log(_classPrivateFieldGet(this, _a));
          _classPrivateFieldSet(this, _a, "hello");
          console.log(_classPrivateFieldGet(this, _b));
      }
      static test() {
          console.log(_classStaticPrivateFieldSpecGet(this, C, _m));
          console.log(_classStaticPrivateFieldSpecSet(this, C, _x, "test"));
      }
      constructor(){
          _classPrivateFieldInit(this, _a, {
              writable: true,
              value: 10
          });
          _classPrivateFieldInit(this, _b, {
              writable: true,
              value: void 0
          });
          _classPrivateFieldInit(this, _something, {
              writable: true,
              value: ()=>1234
          });
          this.a = 123;
          this.c = "hello";
      }
  }
  var _m = {
      writable: true,
      value: "test"
  };
  var _x = {
      writable: true,
      value: void 0
  };
  