@jsenv/core 28.3.5 → 28.3.6

package/dist/babel_helpers/AsyncGenerator/AsyncGenerator.js

@@ -1,4 +1,5 @@
-import AwaitValue from "../AwaitValue/AwaitValue.js";
+/* @minVersion 7.0.0-beta.0 */
+import OverloadYield from "../overloadYield/overloadYield.js";
 export default function AsyncGenerator(gen) {
   var front, back;
 
@@ -25,11 +26,30 @@ export default function AsyncGenerator(gen) {
     try {
       var result = gen[key](arg);
       var value = result.value;
-      var wrappedAwait = value instanceof AwaitValue;
-      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
-        if (wrappedAwait) {
-          resume(key === "return" ? "return" : "next", arg);
-          return;
+      var overloaded = value instanceof OverloadYield;
+      Promise.resolve(overloaded ? value.v : value).then(function (arg) {
+        if (overloaded) {
+          // Overloaded yield requires calling into the generator twice:
+          //  - first we get the iterator result wrapped in a promise
+          //    (the gen[key](arg) call above)
+          //  - then we await it (the Promise.resolve call above)
+          //  - then we give the result back to the iterator, so that it can:
+          //    * if it was an await, use its result
+          //    * if it was a yield*, possibly return the `done: true` signal
+          //      so that yield* knows that the iterator is finished.
+          //      This needs to happen in the second call, because in the
+          //      first one `done: true` was hidden in the promise and thus
+          //      not visible to the (sync) yield*.
+          //      The other part of this implementation is in asyncGeneratorDelegate.
+          var nextKey = key === "return" ? "return" : "next";
+
+          if (!value.k || arg.done) {
+            // await or end of yield*
+            return resume(nextKey, arg);
+          } else {
+            // yield*, not done
+            arg = gen[nextKey](arg).value;
+          }
         }
 
         settle(result.done ? "return" : "normal", arg);

package/dist/babel_helpers/applyDecs/applyDecs.js

@@ -1,4 +1,9 @@
-/* @minVersion 7.16.6 */
+/* @minVersion 7.17.8 */
+
+/**
+ * NOTE: This is an old version of the helper, used for 2021-12 decorators.
+ * Updates should be done in applyDecs2203.js.
+ */
 
 /**
   Enums are used in this file, but not assigned to vars to avoid non-hoistable values
@@ -14,14 +19,14 @@
   SETTER = 4;
 
   STATIC = 5;
+
+  CLASS = 10; // only used in assertValidReturnValue
 */
-function createMetadataMethodsForProperty(metadataMap, kind, property) {
+function old_createMetadataMethodsForProperty(metadataMap, kind, property, decoratorFinishedRef) {
   return {
-    getMetadata(key) {
-      if (typeof key !== "symbol") {
-        throw new TypeError("Metadata keys must be symbols, received: " + key);
-      }
-
+    getMetadata: function (key) {
+      old_assertNotFinished(decoratorFinishedRef, "getMetadata");
+      old_assertMetadataKey(key);
       var metadataForKey = metadataMap[key];
       if (metadataForKey === void 0) return void 0;
 
@@ -45,12 +50,9 @@ function createMetadataMethodsForProperty(metadataMap, kind, property) {
         return metadataForKey.constructor;
       }
     },
-
-    setMetadata(key, value) {
-      if (typeof key !== "symbol") {
-        throw new TypeError("Metadata keys must be symbols, received: " + key);
-      }
-
+    setMetadata: function (key, value) {
+      old_assertNotFinished(decoratorFinishedRef, "setMetadata");
+      old_assertMetadataKey(key);
       var metadataForKey = metadataMap[key];
 
       if (metadataForKey === void 0) {
@@ -81,11 +83,10 @@ function createMetadataMethodsForProperty(metadataMap, kind, property) {
         metadataForKey.constructor = value;
       }
     }
-
   };
 }
 
-function convertMetadataMapToFinal(obj, metadataMap) {
+function old_convertMetadataMapToFinal(obj, metadataMap) {
   var parentMetadataMap = obj[Symbol.metadata || Symbol.for("Symbol.metadata")];
   var metadataKeys = Object.getOwnPropertySymbols(metadataMap);
   if (metadataKeys.length === 0) return;
@@ -126,14 +127,15 @@ function convertMetadataMapToFinal(obj, metadataMap) {
   obj[Symbol.metadata || Symbol.for("Symbol.metadata")] = metadataMap;
 }
 
-function createAddInitializerMethod(initializers) {
+function old_createAddInitializerMethod(initializers, decoratorFinishedRef) {
   return function addInitializer(initializer) {
-    assertValidInitializer(initializer);
+    old_assertNotFinished(decoratorFinishedRef, "addInitializer");
+    old_assertCallable(initializer, "An initializer");
     initializers.push(initializer);
   };
 }
 
-function memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStatic, isPrivate) {
+function old_memberDec(dec, name, desc, metadataMap, initializers, kind, isStatic, isPrivate, value) {
   var kindStr;
 
   switch (kind) {
@@ -171,11 +173,14 @@ function memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStati
     isStatic: isStatic,
     isPrivate: isPrivate
   };
+  var decoratorFinishedRef = {
+    v: false
+  };
 
   if (kind !== 0
   /* FIELD */
   ) {
-    ctx.addInitializer = createAddInitializerMethod(initializers);
+    ctx.addInitializer = old_createAddInitializerMethod(initializers, decoratorFinishedRef);
   }
 
   var metadataKind, metadataName;
@@ -229,36 +234,86 @@ function memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStati
     metadataName = name;
   }
 
-  return Object.assign(ctx, createMetadataMethodsForProperty(metadataMap, metadataKind, metadataName));
+  try {
+    return dec(value, Object.assign(ctx, old_createMetadataMethodsForProperty(metadataMap, metadataKind, metadataName, decoratorFinishedRef)));
+  } finally {
+    decoratorFinishedRef.v = true;
+  }
+}
+
+function old_assertNotFinished(decoratorFinishedRef, fnName) {
+  if (decoratorFinishedRef.v) {
+    throw new Error("attempted to call " + fnName + " after decoration was finished");
+  }
+}
+
+function old_assertMetadataKey(key) {
+  if (typeof key !== "symbol") {
+    throw new TypeError("Metadata keys must be symbols, received: " + key);
+  }
 }
 
-function assertValidInitializer(initializer) {
-  if (typeof initializer !== "function") {
-    throw new Error("initializers must be functions");
+function old_assertCallable(fn, hint) {
+  if (typeof fn !== "function") {
+    throw new TypeError(hint + " must be a function");
   }
 }
 
-function assertValidReturnValue(kind, value) {
+function old_assertValidReturnValue(kind, value) {
   var type = typeof value;
 
   if (kind === 1
   /* ACCESSOR */
   ) {
     if (type !== "object" || value === null) {
-      throw new Error("accessor decorators must return an object with get, set, or initializer properties or void 0");
+      throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+    }
+
+    if (value.get !== undefined) {
+      old_assertCallable(value.get, "accessor.get");
+    }
+
+    if (value.set !== undefined) {
+      old_assertCallable(value.set, "accessor.set");
+    }
+
+    if (value.init !== undefined) {
+      old_assertCallable(value.init, "accessor.init");
+    }
+
+    if (value.initializer !== undefined) {
+      old_assertCallable(value.initializer, "accessor.initializer");
     }
   } else if (type !== "function") {
+    var hint;
+
     if (kind === 0
     /* FIELD */
     ) {
-      throw new Error("field decorators must return a initializer function or void 0");
+      hint = "field";
+    } else if (kind === 10
+    /* CLASS */
+    ) {
+      hint = "class";
     } else {
-      throw new Error("method decorators must return a function or void 0");
+      hint = "method";
     }
+
+    throw new TypeError(hint + " decorators must return a function or void 0");
+  }
+}
+
+function old_getInit(desc) {
+  var initializer;
+
+  if ((initializer = desc.init) == null && (initializer = desc.initializer) && typeof console !== "undefined") {
+    console.warn(".initializer has been renamed to .init as of March 2022");
   }
+
+  return initializer;
 }
 
-function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers) {
+function old_applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers) {
   var decs = decInfo[0];
   var desc, initializer, value;
 
@@ -316,14 +371,13 @@ function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, met
     value = desc.set;
   }
 
-  var ctx = memberDecCtx(base, name, desc, metadataMap, initializers, kind, isStatic, isPrivate);
   var newValue, get, set;
 
   if (typeof decs === "function") {
-    newValue = decs(value, ctx);
+    newValue = old_memberDec(decs, name, desc, metadataMap, initializers, kind, isStatic, isPrivate, value);
 
     if (newValue !== void 0) {
-      assertValidReturnValue(kind, newValue);
+      old_assertValidReturnValue(kind, newValue);
 
       if (kind === 0
       /* FIELD */
@@ -332,7 +386,7 @@ function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, met
       } else if (kind === 1
       /* ACCESSOR */
       ) {
-        initializer = newValue.initializer;
+        initializer = old_getInit(newValue);
         get = newValue.get || value.get;
         set = newValue.set || value.set;
         value = {
@@ -344,12 +398,12 @@ function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, met
       }
     }
   } else {
-    for (var i = 0; i < decs.length; i++) {
+    for (var i = decs.length - 1; i >= 0; i--) {
       var dec = decs[i];
-      newValue = dec(value, ctx);
+      newValue = old_memberDec(dec, name, desc, metadataMap, initializers, kind, isStatic, isPrivate, value);
 
       if (newValue !== void 0) {
-        assertValidReturnValue(kind, newValue);
+        old_assertValidReturnValue(kind, newValue);
         var newInit;
 
         if (kind === 0
@@ -359,7 +413,7 @@ function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, met
         } else if (kind === 1
         /* ACCESSOR */
         ) {
-          newInit = newValue.initializer;
+          newInit = old_getInit(newValue);
           get = newValue.get || value.get;
           set = newValue.set || value.set;
           value = {
@@ -463,7 +517,7 @@ function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, met
   }
 }
 
-function applyMemberDecs(ret, Class, protoMetadataMap, staticMetadataMap, decInfos) {
+function old_applyMemberDecs(ret, Class, protoMetadataMap, staticMetadataMap, decInfos) {
   var protoInitializers;
   var staticInitializers;
   var existingProtoNonFields = new Map();
@@ -488,22 +542,24 @@ function applyMemberDecs(ret, Class, protoMetadataMap, staticMetadataMap, decInf
       metadataMap = staticMetadataMap;
       kind = kind - 5
       /* STATIC */
-      ;
+      ; // initialize staticInitializers when we see a non-field static member
 
-      if (!staticInitializers) {
-        staticInitializers = [];
+      if (kind !== 0
+      /* FIELD */
+      ) {
+        staticInitializers = staticInitializers || [];
+        initializers = staticInitializers;
       }
-
-      initializers = staticInitializers;
     } else {
       base = Class.prototype;
-      metadataMap = protoMetadataMap;
+      metadataMap = protoMetadataMap; // initialize protoInitializers when we see a non-field member
 
-      if (!protoInitializers) {
-        protoInitializers = [];
+      if (kind !== 0
+      /* FIELD */
+      ) {
+        protoInitializers = protoInitializers || [];
+        initializers = protoInitializers;
       }
-
-      initializers = protoInitializers;
     }
 
     if (kind !== 0
@@ -531,63 +587,62 @@ function applyMemberDecs(ret, Class, protoMetadataMap, staticMetadataMap, decInf
       }
     }
 
-    applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers);
-  }
-
-  if (protoInitializers) {
-    pushInitializers(ret, protoInitializers);
+    old_applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, metadataMap, initializers);
   }
 
-  if (staticInitializers) {
-    pushInitializers(ret, staticInitializers);
-  }
+  old_pushInitializers(ret, protoInitializers);
+  old_pushInitializers(ret, staticInitializers);
 }
 
-function pushInitializers(ret, initializers) {
-  if (initializers.length > 0) {
-    // Slice the array, which means that `addInitializer` can no longer add
-    // additional initializers to the array
-    initializers = initializers.slice();
+function old_pushInitializers(ret, initializers) {
+  if (initializers) {
     ret.push(function (instance) {
       for (var i = 0; i < initializers.length; i++) {
-        initializers[i].call(instance, instance);
+        initializers[i].call(instance);
       }
 
-      return instance;
-    });
-  } else {
-    ret.push(function (instance) {
       return instance;
     });
   }
 }
 
-function applyClassDecs(ret, targetClass, metadataMap, classDecs) {
-  var initializers = [];
-  var newClass = targetClass;
-  var name = targetClass.name;
-  var ctx = Object.assign({
-    kind: "class",
-    name: name,
-    addInitializer: createAddInitializerMethod(initializers)
-  }, createMetadataMethodsForProperty(metadataMap, 0
-  /* CONSTRUCTOR */
-  , name));
-
-  for (var i = 0; i < classDecs.length; i++) {
-    newClass = classDecs[i](newClass, ctx) || newClass;
-  }
+function old_applyClassDecs(ret, targetClass, metadataMap, classDecs) {
+  if (classDecs.length > 0) {
+    var initializers = [];
+    var newClass = targetClass;
+    var name = targetClass.name;
+
+    for (var i = classDecs.length - 1; i >= 0; i--) {
+      var decoratorFinishedRef = {
+        v: false
+      };
 
-  ret.push(newClass);
+      try {
+        var ctx = Object.assign({
+          kind: "class",
+          name: name,
+          addInitializer: old_createAddInitializerMethod(initializers, decoratorFinishedRef)
+        }, old_createMetadataMethodsForProperty(metadataMap, 0
+        /* CONSTRUCTOR */
+        , name, decoratorFinishedRef));
+        var nextNewClass = classDecs[i](newClass, ctx);
+      } finally {
+        decoratorFinishedRef.v = true;
+      }
 
-  if (initializers.length > 0) {
-    ret.push(function () {
+      if (nextNewClass !== undefined) {
+        old_assertValidReturnValue(10
+        /* CLASS */
+        , nextNewClass);
+        newClass = nextNewClass;
+      }
+    }
+
+    ret.push(newClass, function () {
       for (var i = 0; i < initializers.length; i++) {
-        initializers[i].call(newClass, newClass);
+        initializers[i].call(newClass);
       }
     });
-  } else {
-    ret.push(function () {});
   }
 }
 /**
@@ -740,17 +795,10 @@ function applyClassDecs(ret, targetClass, metadataMap, classDecs) {
 export default function applyDecs(targetClass, memberDecs, classDecs) {
   var ret = [];
   var staticMetadataMap = {};
-
-  if (memberDecs) {
-    var protoMetadataMap = {};
-    applyMemberDecs(ret, targetClass, protoMetadataMap, staticMetadataMap, memberDecs);
-    convertMetadataMapToFinal(targetClass.prototype, protoMetadataMap);
-  }
-
-  if (classDecs) {
-    applyClassDecs(ret, targetClass, staticMetadataMap, classDecs);
-  }
-
-  convertMetadataMapToFinal(targetClass, staticMetadataMap);
+  var protoMetadataMap = {};
+  old_applyMemberDecs(ret, targetClass, protoMetadataMap, staticMetadataMap, memberDecs);
+  old_convertMetadataMapToFinal(targetClass.prototype, protoMetadataMap);
+  old_applyClassDecs(ret, targetClass, staticMetadataMap, classDecs);
+  old_convertMetadataMapToFinal(targetClass, staticMetadataMap);
   return ret;
 }

package/dist/babel_helpers/applyDecs2023/applyDecs2023.js

@@ -0,0 +1,668 @@
+/* @minVersion 7.19.0 */
+
+/**
+  Enums are used in this file, but not assigned to vars to avoid non-hoistable values
+
+  CONSTRUCTOR = 0;
+  PUBLIC = 1;
+  PRIVATE = 2;
+
+  FIELD = 0;
+  ACCESSOR = 1;
+  METHOD = 2;
+  GETTER = 3;
+  SETTER = 4;
+
+  STATIC = 5;
+
+  CLASS = 10; // only used in assertValidReturnValue
+*/
+function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+  return function addInitializer(initializer) {
+    assertNotFinished(decoratorFinishedRef, "addInitializer");
+    assertCallable(initializer, "An initializer");
+    initializers.push(initializer);
+  };
+}
+
+function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value) {
+  var kindStr;
+
+  switch (kind) {
+    case 1
+    /* ACCESSOR */
+    :
+      kindStr = "accessor";
+      break;
+
+    case 2
+    /* METHOD */
+    :
+      kindStr = "method";
+      break;
+
+    case 3
+    /* GETTER */
+    :
+      kindStr = "getter";
+      break;
+
+    case 4
+    /* SETTER */
+    :
+      kindStr = "setter";
+      break;
+
+    default:
+      kindStr = "field";
+  }
+
+  var ctx = {
+    kind: kindStr,
+    name: isPrivate ? "#" + name : name,
+    static: isStatic,
+    private: isPrivate
+  };
+  var decoratorFinishedRef = {
+    v: false
+  };
+
+  if (kind !== 0
+  /* FIELD */
+  ) {
+    ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+  }
+
+  var get, set;
+
+  if (kind === 0
+  /* FIELD */
+  ) {
+    if (isPrivate) {
+      get = desc.get;
+      set = desc.set;
+    } else {
+      get = function () {
+        return this[name];
+      };
+
+      set = function (v) {
+        this[name] = v;
+      };
+    }
+  } else if (kind === 2
+  /* METHOD */
+  ) {
+    get = function () {
+      return desc.value;
+    };
+  } else {
+    // replace with values that will go through the final getter and setter
+    if (kind === 1
+    /* ACCESSOR */
+    || kind === 3
+    /* GETTER */
+    ) {
+      get = function () {
+        return desc.get.call(this);
+      };
+    }
+
+    if (kind === 1
+    /* ACCESSOR */
+    || kind === 4
+    /* SETTER */
+    ) {
+      set = function (v) {
+        desc.set.call(this, v);
+      };
+    }
+  }
+
+  ctx.access = get && set ? {
+    get: get,
+    set: set
+  } : get ? {
+    get: get
+  } : {
+    set: set
+  };
+
+  try {
+    return dec(value, ctx);
+  } finally {
+    decoratorFinishedRef.v = true;
+  }
+}
+
+function assertNotFinished(decoratorFinishedRef, fnName) {
+  if (decoratorFinishedRef.v) {
+    throw new Error("attempted to call " + fnName + " after decoration was finished");
+  }
+}
+
+function assertCallable(fn, hint) {
+  if (typeof fn !== "function") {
+    throw new TypeError(hint + " must be a function");
+  }
+}
+
+function assertValidReturnValue(kind, value) {
+  var type = typeof value;
+
+  if (kind === 1
+  /* ACCESSOR */
+  ) {
+    if (type !== "object" || value === null) {
+      throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+    }
+
+    if (value.get !== undefined) {
+      assertCallable(value.get, "accessor.get");
+    }
+
+    if (value.set !== undefined) {
+      assertCallable(value.set, "accessor.set");
+    }
+
+    if (value.init !== undefined) {
+      assertCallable(value.init, "accessor.init");
+    }
+  } else if (type !== "function") {
+    var hint;
+
+    if (kind === 0
+    /* FIELD */
+    ) {
+      hint = "field";
+    } else if (kind === 10
+    /* CLASS */
+    ) {
+      hint = "class";
+    } else {
+      hint = "method";
+    }
+
+    throw new TypeError(hint + " decorators must return a function or void 0");
+  }
+}
+
+function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers) {
+  var decs = decInfo[0];
+  var desc, init, value;
+
+  if (isPrivate) {
+    if (kind === 0
+    /* FIELD */
+    || kind === 1
+    /* ACCESSOR */
+    ) {
+      desc = {
+        get: decInfo[3],
+        set: decInfo[4]
+      };
+    } else if (kind === 3
+    /* GETTER */
+    ) {
+      desc = {
+        get: decInfo[3]
+      };
+    } else if (kind === 4
+    /* SETTER */
+    ) {
+      desc = {
+        set: decInfo[3]
+      };
+    } else {
+      desc = {
+        value: decInfo[3]
+      };
+    }
+  } else if (kind !== 0
+  /* FIELD */
+  ) {
+    desc = Object.getOwnPropertyDescriptor(base, name);
+  }
+
+  if (kind === 1
+  /* ACCESSOR */
+  ) {
+    value = {
+      get: desc.get,
+      set: desc.set
+    };
+  } else if (kind === 2
+  /* METHOD */
+  ) {
+    value = desc.value;
+  } else if (kind === 3
+  /* GETTER */
+  ) {
+    value = desc.get;
+  } else if (kind === 4
+  /* SETTER */
+  ) {
+    value = desc.set;
+  }
+
+  var newValue, get, set;
+
+  if (typeof decs === "function") {
+    newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, value);
+
+    if (newValue !== void 0) {
+      assertValidReturnValue(kind, newValue);
+
+      if (kind === 0
+      /* FIELD */
+      ) {
+        init = newValue;
+      } else if (kind === 1
+      /* ACCESSOR */
+      ) {
+        init = newValue.init;
+        get = newValue.get || value.get;
+        set = newValue.set || value.set;
+        value = {
+          get: get,
+          set: set
+        };
+      } else {
+        value = newValue;
+      }
+    }
+  } else {
+    for (var i = decs.length - 1; i >= 0; i--) {
+      var dec = decs[i];
+      newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, value);
+
+      if (newValue !== void 0) {
+        assertValidReturnValue(kind, newValue);
+        var newInit;
+
+        if (kind === 0
+        /* FIELD */
+        ) {
+          newInit = newValue;
+        } else if (kind === 1
+        /* ACCESSOR */
+        ) {
+          newInit = newValue.init;
+          get = newValue.get || value.get;
+          set = newValue.set || value.set;
+          value = {
+            get: get,
+            set: set
+          };
+        } else {
+          value = newValue;
+        }
+
+        if (newInit !== void 0) {
+          if (init === void 0) {
+            init = newInit;
+          } else if (typeof init === "function") {
+            init = [init, newInit];
+          } else {
+            init.push(newInit);
+          }
+        }
+      }
+    }
+  }
+
+  if (kind === 0
+  /* FIELD */
+  || kind === 1
+  /* ACCESSOR */
+  ) {
+    if (init === void 0) {
+      // If the initializer was void 0, sub in a dummy initializer
+      init = function (instance, init) {
+        return init;
+      };
+    } else if (typeof init !== "function") {
+      var ownInitializers = init;
+
+      init = function (instance, init) {
+        var value = init;
+
+        for (var i = 0; i < ownInitializers.length; i++) {
+          value = ownInitializers[i].call(instance, value);
+        }
+
+        return value;
+      };
+    } else {
+      var originalInitializer = init;
+
+      init = function (instance, init) {
+        return originalInitializer.call(instance, init);
+      };
+    }
+
+    ret.push(init);
+  }
+
+  if (kind !== 0
+  /* FIELD */
+  ) {
+    if (kind === 1
+    /* ACCESSOR */
+    ) {
+      desc.get = value.get;
+      desc.set = value.set;
+    } else if (kind === 2
+    /* METHOD */
+    ) {
+      desc.value = value;
+    } else if (kind === 3
+    /* GETTER */
+    ) {
+      desc.get = value;
+    } else if (kind === 4
+    /* SETTER */
+    ) {
+      desc.set = value;
+    }
+
+    if (isPrivate) {
+      if (kind === 1
+      /* ACCESSOR */
+      ) {
+        ret.push(function (instance, args) {
+          return value.get.call(instance, args);
+        });
+        ret.push(function (instance, args) {
+          return value.set.call(instance, args);
+        });
+      } else if (kind === 2
+      /* METHOD */
+      ) {
+        ret.push(value);
+      } else {
+        ret.push(function (instance, args) {
+          return value.call(instance, args);
+        });
+      }
+    } else {
+      Object.defineProperty(base, name, desc);
+    }
+  }
+}
+
+function applyMemberDecs(ret, Class, decInfos) {
+  var protoInitializers;
+  var staticInitializers;
+  var existingProtoNonFields = new Map();
+  var existingStaticNonFields = new Map();
+
+  for (var i = 0; i < decInfos.length; i++) {
+    var decInfo = decInfos[i]; // skip computed property names
+
+    if (!Array.isArray(decInfo)) continue;
+    var kind = decInfo[1];
+    var name = decInfo[2];
+    var isPrivate = decInfo.length > 3;
+    var isStatic = kind >= 5;
+    /* STATIC */
+
+    var base;
+    var initializers;
+
+    if (isStatic) {
+      base = Class;
+      kind = kind - 5
+      /* STATIC */
+      ; // initialize staticInitializers when we see a non-field static member
+
+      if (kind !== 0
+      /* FIELD */
+      ) {
+        staticInitializers = staticInitializers || [];
+        initializers = staticInitializers;
+      }
+    } else {
+      base = Class.prototype; // initialize protoInitializers when we see a non-field member
+
+      if (kind !== 0
+      /* FIELD */
+      ) {
+        protoInitializers = protoInitializers || [];
+        initializers = protoInitializers;
+      }
+    }
+
+    if (kind !== 0
+    /* FIELD */
+    && !isPrivate) {
+      var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+      var existingKind = existingNonFields.get(name) || 0;
+
+      if (existingKind === true || existingKind === 3
+      /* GETTER */
+      && kind !== 4
+      /* SETTER */
+      || existingKind === 4
+      /* SETTER */
+      && kind !== 3
+      /* GETTER */
+      ) {
+        throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+      } else if (!existingKind && kind > 2
+      /* METHOD */
+      ) {
+        existingNonFields.set(name, kind);
+      } else {
+        existingNonFields.set(name, true);
+      }
+    }
+
+    applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers);
+  }
+
+  pushInitializers(ret, protoInitializers);
+  pushInitializers(ret, staticInitializers);
+}
+
+function pushInitializers(ret, initializers) {
+  if (initializers) {
+    ret.push(function (instance) {
+      for (var i = 0; i < initializers.length; i++) {
+        initializers[i].call(instance);
+      }
+
+      return instance;
+    });
+  }
+}
+
+function applyClassDecs(ret, targetClass, classDecs) {
+  if (classDecs.length > 0) {
+    var initializers = [];
+    var newClass = targetClass;
+    var name = targetClass.name;
+
+    for (var i = classDecs.length - 1; i >= 0; i--) {
+      var decoratorFinishedRef = {
+        v: false
+      };
+
+      try {
+        var nextNewClass = classDecs[i](newClass, {
+          kind: "class",
+          name: name,
+          addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef)
+        });
+      } finally {
+        decoratorFinishedRef.v = true;
+      }
+
+      if (nextNewClass !== undefined) {
+        assertValidReturnValue(10
+        /* CLASS */
+        , nextNewClass);
+        newClass = nextNewClass;
+      }
+    }
+
+    ret.push(newClass, function () {
+      for (var i = 0; i < initializers.length; i++) {
+        initializers[i].call(newClass);
+      }
+    });
+  }
+}
+/**
+  Basic usage:
+
+  applyDecs(
+    Class,
+    [
+      // member decorators
+      [
+        dec,                // dec or array of decs
+        0,                  // kind of value being decorated
+        'prop',             // name of public prop on class containing the value being decorated,
+        '#p',               // the name of the private property (if is private, void 0 otherwise),
+      ]
+    ],
+    [
+      // class decorators
+      dec1, dec2
+    ]
+  )
+  ```
+
+  Fully transpiled example:
+
+  ```js
+  @dec
+  class Class {
+    @dec
+    a = 123;
+
+    @dec
+    #a = 123;
+
+    @dec
+    @dec2
+    accessor b = 123;
+
+    @dec
+    accessor #b = 123;
+
+    @dec
+    c() { console.log('c'); }
+
+    @dec
+    #c() { console.log('privC'); }
+
+    @dec
+    get d() { console.log('d'); }
+
+    @dec
+    get #d() { console.log('privD'); }
+
+    @dec
+    set e(v) { console.log('e'); }
+
+    @dec
+    set #e(v) { console.log('privE'); }
+  }
+
+
+  // becomes
+  let initializeInstance;
+  let initializeClass;
+
+  let initA;
+  let initPrivA;
+
+  let initB;
+  let initPrivB, getPrivB, setPrivB;
+
+  let privC;
+  let privD;
+  let privE;
+
+  let Class;
+  class _Class {
+    static {
+      let ret = applyDecs(
+        this,
+        [
+          [dec, 0, 'a'],
+          [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],
+          [[dec, dec2], 1, 'b'],
+          [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],
+          [dec, 2, 'c'],
+          [dec, 2, 'c', () => console.log('privC')],
+          [dec, 3, 'd'],
+          [dec, 3, 'd', () => console.log('privD')],
+          [dec, 4, 'e'],
+          [dec, 4, 'e', () => console.log('privE')],
+        ],
+        [
+          dec
+        ]
+      )
+
+      initA = ret[0];
+
+      initPrivA = ret[1];
+
+      initB = ret[2];
+
+      initPrivB = ret[3];
+      getPrivB = ret[4];
+      setPrivB = ret[5];
+
+      privC = ret[6];
+
+      privD = ret[7];
+
+      privE = ret[8];
+
+      initializeInstance = ret[9];
+
+      Class = ret[10]
+
+      initializeClass = ret[11];
+    }
+
+    a = (initializeInstance(this), initA(this, 123));
+
+    #a = initPrivA(this, 123);
+
+    #bData = initB(this, 123);
+    get b() { return this.#bData }
+    set b(v) { this.#bData = v }
+
+    #privBData = initPrivB(this, 123);
+    get #b() { return getPrivB(this); }
+    set #b(v) { setPrivB(this, v); }
+
+    c() { console.log('c'); }
+
+    #c(...args) { return privC(this, ...args) }
+
+    get d() { console.log('d'); }
+
+    get #d() { return privD(this); }
+
+    set e(v) { console.log('e'); }
+
+    set #e(v) { privE(this, v); }
+  }
+
+  initializeClass(Class);
+ */
+
+
+export default function applyDecs2203(targetClass, memberDecs, classDecs) {
+  var ret = [];
+  applyMemberDecs(ret, targetClass, memberDecs);
+  applyClassDecs(ret, targetClass, classDecs);
+  return ret;
+}

package/dist/babel_helpers/asyncGeneratorDelegate/asyncGeneratorDelegate.js

@@ -1,6 +1,9 @@
-export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+/* @minVersion 7.0.0-beta.0 */
+import OverloadYield from "../overloadYield/overloadYield.js";
+export default function _asyncGeneratorDelegate(inner) {
   var iter = {},
-      waiting = false;
+      // See the comment in AsyncGenerator to understand what this is.
+  waiting = false;
 
   function pump(key, value) {
     waiting = true;
@@ -9,7 +12,9 @@ export default function _asyncGeneratorDelegate(inner, awaitWrap) {
     });
     return {
       done: false,
-      value: awaitWrap(value)
+      value: new OverloadYield(value,
+      /* kind: delegate */
+      1)
     };
   }
 

package/dist/babel_helpers/awaitAsyncGenerator/awaitAsyncGenerator.js

@@ -1,4 +1,6 @@
-import AwaitValue from "../AwaitValue/AwaitValue.js";
-export default function (value) {
-  return new AwaitValue(value);
+import OverloadYield from "../overloadYield/overloadYield.js";
+export default function _awaitAsyncGenerator(value) {
+  return new OverloadYield(value,
+  /* kind: await */
+  0);
 }

package/dist/babel_helpers/overloadYield/overloadYield.js

@@ -0,0 +1,11 @@
+/* @minVersion 7.18.14 */
+
+/*
+ * 'kind' is an enum:
+ *   0 => This yield was an await expression
+ *   1 => This yield comes from yield*
+ */
+export default function _OverloadYield(value, kind) {
+  this.v = value;
+  this.k = kind;
+}

package/dist/main.js

@@ -28464,7 +28464,7 @@ const registerEvent = ({
 
 const chromium = createRuntimeFromPlaywright({
   browserName: "chromium",
-  browserVersion: "104.0.5112.48",
+  browserVersion: "105.0.5195.19",
   // to update, check https://github.com/microsoft/playwright/releases
   coveragePlaywrightAPIAvailable: true
 });
@@ -28472,7 +28472,7 @@ const chromiumIsolatedTab = chromium.isolatedTab;
 
 const firefox = createRuntimeFromPlaywright({
   browserName: "firefox",
-  browserVersion: "102.0" // to update, check https://github.com/microsoft/playwright/releases
+  browserVersion: "103.0" // to update, check https://github.com/microsoft/playwright/releases
 
 });
 const firefoxIsolatedTab = firefox.isolatedTab;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "28.3.5",
+  "version": "28.3.6",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -61,20 +61,20 @@
   },
   "dependencies": {
     "@babel/plugin-proposal-dynamic-import": "7.18.6",
-    "@babel/plugin-transform-modules-systemjs": "7.18.6",
+    "@babel/plugin-transform-modules-systemjs": "7.19.0",
     "@babel/plugin-transform-modules-umd": "7.18.6",
     "@c88/v8-coverage": "0.1.1",
-    "@financial-times/polyfill-useragent-normaliser": "2.0.1",
+    "@financial-times/polyfill-useragent-normaliser": "1.10.2",
     "@jsenv/abort": "4.2.4",
-    "@jsenv/ast": "1.2.1",
-    "@jsenv/babel-plugins": "1.0.6",
+    "@jsenv/ast": "1.2.2",
+    "@jsenv/babel-plugins": "1.0.7",
     "@jsenv/filesystem": "4.1.3",
     "@jsenv/importmap": "1.2.1",
     "@jsenv/integrity": "0.0.1",
     "@jsenv/log": "3.3.0",
     "@jsenv/node-esm-resolution": "0.1.0",
     "@jsenv/server": "14.1.3",
-    "@jsenv/sourcemap": "1.0.4",
+    "@jsenv/sourcemap": "1.0.5",
     "@jsenv/uneval": "1.6.0",
     "@jsenv/url-meta": "7.0.0",
     "@jsenv/urls": "1.2.7",
@@ -87,12 +87,12 @@
     "istanbul-lib-instrument": "5.2.0",
     "istanbul-lib-report": "3.0.0",
     "istanbul-reports": "3.1.5",
-    "launch-editor": "2.5.0",
+    "launch-editor": "2.6.0",
     "pidtree": "0.6.0",
-    "rollup": "2.77.2",
+    "rollup": "2.79.0",
     "string-width": "5.1.2",
     "strip-ansi": "7.0.1",
-    "terser": "5.14.2",
+    "terser": "5.15.0",
     "v8-to-istanbul": "9.0.1",
     "wrap-ansi": "8.0.1"
   },
@@ -105,11 +105,11 @@
     "@jsenv/https-local": "3.0.1",
     "@jsenv/package-workspace": "0.5.0",
     "@jsenv/performance-impact": "3.0.1",
-    "eslint": "8.21.0",
+    "eslint": "8.23.0",
     "eslint-plugin-html": "7.1.0",
     "eslint-plugin-import": "2.26.0",
-    "eslint-plugin-react": "7.30.1",
-    "playwright": "1.24.2",
+    "eslint-plugin-react": "7.31.7",
+    "playwright": "1.25.1",
     "prettier": "2.7.1"
   }
 }

package/src/execute/runtimes/browsers/chromium.js

@@ -2,7 +2,7 @@ import { createRuntimeFromPlaywright } from "./from_playwright.js"
 
 export const chromium = createRuntimeFromPlaywright({
   browserName: "chromium",
-  browserVersion: "104.0.5112.48", // to update, check https://github.com/microsoft/playwright/releases
+  browserVersion: "105.0.5195.19", // to update, check https://github.com/microsoft/playwright/releases
   coveragePlaywrightAPIAvailable: true,
 })
 export const chromiumIsolatedTab = chromium.isolatedTab

package/src/execute/runtimes/browsers/firefox.js

@@ -2,6 +2,6 @@ import { createRuntimeFromPlaywright } from "./from_playwright.js"
 
 export const firefox = createRuntimeFromPlaywright({
   browserName: "firefox",
-  browserVersion: "102.0", // to update, check https://github.com/microsoft/playwright/releases
+  browserVersion: "103.0", // to update, check https://github.com/microsoft/playwright/releases
 })
 export const firefoxIsolatedTab = firefox.isolatedTab