@jsenv/core 30.3.1 → 30.3.3

package/dist/babel_helpers/{applyDecoratorDescriptor → applyDecoratedDescriptor}/applyDecoratorDescriptor.js

@@ -1,12 +1,11 @@
-/* eslint-disable no-void */
 export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
   var desc = {};
   Object.keys(descriptor).forEach(function (key) {
     desc[key] = descriptor[key];
   });
-  desc.enumerable = Boolean(desc.enumerable);
-  desc.configurable = Boolean(desc.configurable);
-  if ("value" in desc || desc.initializer) {
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+  if ('value' in desc || desc.initializer) {
     desc.writable = true;
   }
   desc = decorators.slice().reverse().reduce(function (desc, decorator) {

package/dist/babel_helpers/applyDecs/applyDecs.js

@@ -2,7 +2,7 @@
 
 /**
  * NOTE: This is an old version of the helper, used for 2021-12 decorators.
- * Updates should be done in applyDecs2203.js.
+ * Updates should be done in applyDecs2203R.js.
  */
 
 /**

package/dist/babel_helpers/applyDecs2203/applyDecs2203.js

@@ -0,0 +1,494 @@
+/* @minVersion 7.19.0 */
+
+/**
+ * NOTE: This is an old version of the helper, used for 2022-03 decorators.
+ * Updates should be done in applyDecs2203R.js.
+ */
+
+/**
+  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 applyDecs2203Factory() {
+  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);
+  */
+
+  return function applyDecs2203Impl(targetClass, memberDecs, classDecs) {
+    var ret = [];
+    applyMemberDecs(ret, targetClass, memberDecs);
+    applyClassDecs(ret, targetClass, classDecs);
+    return ret;
+  };
+}
+var applyDecs2203Impl;
+export default function applyDecs2203(targetClass, memberDecs, classDecs) {
+  applyDecs2203Impl = applyDecs2203Impl || applyDecs2203Factory();
+  return applyDecs2203Impl(targetClass, memberDecs, classDecs);
+}

package/dist/babel_helpers/{applyDecs2023/applyDecs2023.js → applyDecs2203R/applyDecs2203R.js}

@@ -1,4 +1,4 @@
-/* @minVersion 7.19.0 */
+/* @minVersion 7.20.0 */
 
 /**
   Enums are used in this file, but not assigned to vars to avoid non-hoistable values
@@ -278,7 +278,8 @@ function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, ini
     }
   }
 }
-function applyMemberDecs(ret, Class, decInfos) {
+function applyMemberDecs(Class, decInfos) {
+  var ret = [];
   var protoInitializers;
   var staticInitializers;
   var existingProtoNonFields = new Map();
@@ -325,6 +326,7 @@ function applyMemberDecs(ret, Class, decInfos) {
   }
   pushInitializers(ret, protoInitializers);
   pushInitializers(ret, staticInitializers);
+  return ret;
 }
 function pushInitializers(ret, initializers) {
   if (initializers) {
@@ -336,7 +338,7 @@ function pushInitializers(ret, initializers) {
     });
   }
 }
-function applyClassDecs(ret, targetClass, classDecs) {
+function applyClassDecs(targetClass, classDecs) {
   if (classDecs.length > 0) {
     var initializers = [];
     var newClass = targetClass;
@@ -359,12 +361,14 @@ function applyClassDecs(ret, targetClass, classDecs) {
         newClass = nextNewClass;
       }
     }
-    ret.push(newClass, function () {
+    return [newClass, function () {
       for (var i = 0; i < initializers.length; i++) {
         initializers[i].call(newClass);
       }
-    });
+    }];
   }
+  // The transformer will not emit assignment when there are no class decorators,
+  // so we don't have to return an empty array here.
 }
 
 /**
@@ -512,9 +516,12 @@ function applyClassDecs(ret, targetClass, classDecs) {
 
   initializeClass(Class);
  */
-export default function applyDecs2203(targetClass, memberDecs, classDecs) {
-  var ret = [];
-  applyMemberDecs(ret, targetClass, memberDecs);
-  applyClassDecs(ret, targetClass, classDecs);
-  return ret;
+export default function applyDecs2203R(targetClass, memberDecs, classDecs) {
+  return {
+    e: applyMemberDecs(targetClass, memberDecs),
+    // Lazily apply class decorations so that member init locals can be properly bound.
+    get c() {
+      return applyClassDecs(targetClass, classDecs);
+    }
+  };
 }

package/dist/main.js

@@ -16,14 +16,14 @@ import { Readable, Stream, Writable } from "node:stream";
 import { Http2ServerResponse } from "node:http2";
 import { lookup } from "node:dns";
 import { SOURCEMAP, generateSourcemapFileUrl, composeTwoSourcemaps, generateSourcemapDataUrl, createMagicSource, getOriginalPosition } from "@jsenv/sourcemap";
-import { parseHtmlString, stringifyHtmlAst, getHtmlNodeAttribute, visitHtmlNodes, analyzeScriptNode, setHtmlNodeAttributes, parseSrcSet, getHtmlNodePosition, getHtmlNodeAttributePosition, applyPostCss, postCssPluginUrlVisitor, parseJsUrls, getHtmlNodeText, setHtmlNodeText, applyBabelPlugins, injectScriptNodeAsEarlyAsPossible, createHtmlNode, findHtmlNode, removeHtmlNode, removeHtmlNodeText, injectJsImport, analyzeLinkNode, injectHtmlNode, insertHtmlNodeAfter } from "@jsenv/ast";
+import { parseHtmlString, stringifyHtmlAst, getHtmlNodeAttribute, visitHtmlNodes, analyzeScriptNode, setHtmlNodeAttributes, parseSrcSet, getHtmlNodePosition, getHtmlNodeAttributePosition, parseCssUrls, parseJsUrls, getHtmlNodeText, setHtmlNodeText, applyBabelPlugins, injectScriptNodeAsEarlyAsPossible, createHtmlNode, findHtmlNode, removeHtmlNode, removeHtmlNodeText, injectJsImport, analyzeLinkNode, injectHtmlNode, insertHtmlNodeAfter } from "@jsenv/ast";
 import { createRequire } from "node:module";
 import babelParser from "@babel/parser";
 import { bundleJsModules } from "@jsenv/plugin-bundling";
 import v8, { takeCoverage } from "node:v8";
 import wrapAnsi from "wrap-ansi";
 import stripAnsi from "strip-ansi";
-import cuid from "cuid";
+import { createId } from "@paralleldrive/cuid2";
 import { runInNewContext } from "node:vm";
 import { fork } from "node:child_process";
 
@@ -9668,21 +9668,22 @@ const parseAndTransformHtmlUrls = async (urlInfo, context) => {
     url,
     htmlAst
   });
-  const actions = [];
   const mutations = [];
-  mentions.forEach(({
-    type,
-    subtype,
-    expectedType,
-    line,
-    column,
-    originalLine,
-    originalColumn,
-    node,
-    attributeName,
-    debug,
-    specifier
-  }) => {
+  const actions = [];
+  for (const mention of mentions) {
+    const {
+      type,
+      subtype,
+      expectedType,
+      line,
+      column,
+      originalLine,
+      originalColumn,
+      node,
+      attributeName,
+      debug,
+      specifier
+    } = mention;
     const {
       crossorigin,
       integrity
@@ -9704,13 +9705,13 @@ const parseAndTransformHtmlUrls = async (urlInfo, context) => {
     });
     actions.push(async () => {
       await context.referenceUtils.readGeneratedSpecifier(reference);
-    });
-    mutations.push(() => {
-      setHtmlNodeAttributes(node, {
-        [attributeName]: reference.generatedSpecifier
+      mutations.push(() => {
+        setHtmlNodeAttributes(node, {
+          [attributeName]: reference.generatedSpecifier
+        });
       });
     });
-  });
+  }
   if (actions.length > 0) {
     await Promise.all(actions.map(action => action()));
   }
@@ -9958,40 +9959,33 @@ const decideLinkExpectedType = (linkMention, mentions) => {
  * https://github.com/parcel-bundler/parcel/blob/v2/packages/transformers/css/src/CSSTransformer.js
  */
 const parseAndTransformCssUrls = async (urlInfo, context) => {
+  const cssUrls = await parseCssUrls({
+    css: urlInfo.content,
+    url: urlInfo.originalUrl
+  });
   const actions = [];
   const magicSource = createMagicSource(urlInfo.content);
-  await applyPostCss({
-    sourcemaps: false,
-    plugins: [postCssPluginUrlVisitor({
-      urlVisitor: ({
-        type,
-        specifier,
-        specifierStart,
-        specifierEnd,
-        specifierLine,
-        specifierColumn
-      }) => {
-        const [reference] = context.referenceUtils.found({
-          type: `css_${type}`,
-          specifier,
-          specifierStart,
-          specifierEnd,
-          specifierLine,
-          specifierColumn
-        });
-        actions.push(async () => {
-          magicSource.replace({
-            start: specifierStart,
-            end: specifierEnd,
-            replacement: await context.referenceUtils.readGeneratedSpecifier(reference)
-          });
-        });
-      }
-    })],
-    url: urlInfo.originalUrl,
-    content: urlInfo.content
-  });
-  await Promise.all(actions.map(action => action()));
+  for (const cssUrl of cssUrls) {
+    const [reference] = context.referenceUtils.found({
+      type: cssUrl.type,
+      specifier: cssUrl.specifier,
+      specifierStart: cssUrl.start,
+      specifierEnd: cssUrl.end,
+      specifierLine: cssUrl.line,
+      specifierColumn: cssUrl.column
+    });
+    actions.push(async () => {
+      const replacement = await context.referenceUtils.readGeneratedSpecifier(reference);
+      magicSource.replace({
+        start: cssUrl.start,
+        end: cssUrl.end,
+        replacement
+      });
+    });
+  }
+  if (actions.length > 0) {
+    await Promise.all(actions.map(action => action()));
+  }
   return magicSource.toContentAndSourcemap();
 };
 
@@ -10004,7 +9998,7 @@ const parseAndTransformJsUrls = async (urlInfo, context) => {
   });
   const actions = [];
   const magicSource = createMagicSource(urlInfo.content);
-  jsMentions.forEach(jsMention => {
+  for (const jsMention of jsMentions) {
     if (jsMention.subtype === "import_static" || jsMention.subtype === "import_dynamic") {
       urlInfo.data.usesImport = true;
     }
@@ -10015,10 +10009,10 @@ const parseAndTransformJsUrls = async (urlInfo, context) => {
       expectedType: jsMention.expectedType,
       expectedSubtype: jsMention.expectedSubtype || urlInfo.subtype,
       specifier: jsMention.specifier,
-      specifierStart: jsMention.specifierStart,
-      specifierEnd: jsMention.specifierEnd,
-      specifierLine: jsMention.specifierLine,
-      specifierColumn: jsMention.specifierColumn,
+      specifierStart: jsMention.start,
+      specifierEnd: jsMention.end,
+      specifierLine: jsMention.line,
+      specifierColumn: jsMention.column,
       data: jsMention.data,
       baseUrl: {
         "StringLiteral": jsMention.baseUrl,
@@ -10035,16 +10029,18 @@ const parseAndTransformJsUrls = async (urlInfo, context) => {
     actions.push(async () => {
       const replacement = await context.referenceUtils.readGeneratedSpecifier(reference);
       magicSource.replace({
-        start: jsMention.specifierStart,
-        end: jsMention.specifierEnd,
+        start: jsMention.start,
+        end: jsMention.end,
         replacement
       });
       if (reference.mutation) {
         reference.mutation(magicSource);
       }
     });
-  });
-  await Promise.all(actions.map(action => action()));
+  }
+  if (actions.length > 0) {
+    await Promise.all(actions.map(action => action()));
+  }
   const {
     content,
     sourcemap
@@ -21735,6 +21731,9 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
     const getBuildRelativeUrl = url => {
       const urlObject = new URL(url);
       urlObject.searchParams.delete("as_js_classic");
+      urlObject.searchParams.delete("as_css_module");
+      urlObject.searchParams.delete("as_json_module");
+      urlObject.searchParams.delete("as_text_module");
       url = urlObject.href;
       const buildRelativeUrl = urlToRelativeUrl(url, buildDirectoryUrl);
       return buildRelativeUrl;
@@ -23385,7 +23384,7 @@ const run = async ({
   // and they can be read later at "coverageFileUrl"
   let coverageFileUrl;
   if (coverageEnabled) {
-    coverageFileUrl = new URL(`./${runtime.name}/${cuid()}.json`, coverageTempDirectoryUrl).href;
+    coverageFileUrl = new URL(`./${runtime.name}/${createId()}.json`, coverageTempDirectoryUrl).href;
     await ensureParentDirectories(coverageFileUrl);
     if (coverageEnabled) {
       result.coverageFileUrl = coverageFileUrl;
@@ -25014,7 +25013,7 @@ const registerEvent = ({
 
 const chromium = createRuntimeFromPlaywright({
   browserName: "chromium",
-  browserVersion: "109.0.5414.46",
+  browserVersion: "110.0.5481.38",
   // to update, check https://github.com/microsoft/playwright/releases
   coveragePlaywrightAPIAvailable: true
 });
@@ -25022,7 +25021,7 @@ const chromiumIsolatedTab = chromium.isolatedTab;
 
 const firefox = createRuntimeFromPlaywright({
   browserName: "firefox",
-  browserVersion: "107.0" // to update, check https://github.com/microsoft/playwright/releases
+  browserVersion: "108.0.2" // to update, check https://github.com/microsoft/playwright/releases
 });
 
 const firefoxIsolatedTab = firefox.isolatedTab;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "30.3.1",
+  "version": "30.3.3",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -67,7 +67,7 @@
     "@c88/v8-coverage": "0.1.1",
     "@financial-times/polyfill-useragent-normaliser": "1.10.2",
     "@jsenv/abort": "4.2.4",
-    "@jsenv/ast": "2.0.1",
+    "@jsenv/ast": "3.0.0",
     "@jsenv/babel-plugins": "1.1.2",
     "@jsenv/plugin-bundling": "1.1.1",
     "@jsenv/filesystem": "4.1.9",
@@ -81,8 +81,8 @@
     "@jsenv/url-meta": "7.0.2",
     "@jsenv/urls": "1.2.8",
     "@jsenv/utils": "2.0.1",
+    "@paralleldrive/cuid2": "2.0.1",
     "construct-style-sheets-polyfill": "3.1.0",
-    "cuid": "2.1.8",
     "istanbul-lib-coverage": "3.2.0",
     "istanbul-lib-instrument": "5.2.1",
     "istanbul-lib-report": "3.0.0",
@@ -93,25 +93,25 @@
     "string-width": "5.1.2",
     "strip-ansi": "7.0.1",
     "v8-to-istanbul": "9.0.1",
-    "wrap-ansi": "8.0.1"
+    "wrap-ansi": "8.1.0"
   },
   "devDependencies": {
     "@babel/eslint-parser": "7.19.1",
     "@babel/plugin-syntax-import-assertions": "7.20.0",
     "@jsenv/assert": "./packages/assert/",
     "@jsenv/eslint-config": "./packages/eslint-config/",
-    "@jsenv/file-size-impact": "13.0.2",
-    "@jsenv/https-local": "3.0.5",
+    "@jsenv/file-size-impact": "14.0.0",
+    "@jsenv/https-local": "3.0.6",
     "@jsenv/package-workspace": "0.5.1",
     "@jsenv/plugin-minification": "./packages/jsenv-plugin-minification/",
     "@jsenv/plugin-globals": "./packages/jsenv-plugin-globals/",
     "@jsenv/plugin-placeholders": "./packages/jsenv-plugin-placeholders/",
     "@jsenv/performance-impact": "4.1.0",
-    "eslint": "8.31.0",
+    "eslint": "8.32.0",
     "eslint-plugin-html": "7.1.0",
-    "eslint-plugin-import": "2.26.0",
-    "eslint-plugin-react": "7.31.11",
-    "playwright": "1.29.2",
-    "prettier": "2.8.2"
+    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-react": "7.32.1",
+    "playwright": "1.30.0",
+    "prettier": "2.8.3"
   }
 }

package/src/build/build.js

@@ -1539,6 +1539,9 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
     const getBuildRelativeUrl = (url) => {
       const urlObject = new URL(url)
       urlObject.searchParams.delete("as_js_classic")
+      urlObject.searchParams.delete("as_css_module")
+      urlObject.searchParams.delete("as_json_module")
+      urlObject.searchParams.delete("as_text_module")
       url = urlObject.href
       const buildRelativeUrl = urlToRelativeUrl(url, buildDirectoryUrl)
       return buildRelativeUrl

package/src/execute/run.js

@@ -1,4 +1,4 @@
-import cuid from "cuid"
+import { createId } from "@paralleldrive/cuid2"
 import { Abort, raceCallbacks } from "@jsenv/abort"
 import { ensureParentDirectories } from "@jsenv/filesystem"
 
@@ -62,7 +62,7 @@ export const run = async ({
   let coverageFileUrl
   if (coverageEnabled) {
     coverageFileUrl = new URL(
-      `./${runtime.name}/${cuid()}.json`,
+      `./${runtime.name}/${createId()}.json`,
       coverageTempDirectoryUrl,
     ).href
     await ensureParentDirectories(coverageFileUrl)

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

@@ -2,7 +2,7 @@ import { createRuntimeFromPlaywright } from "./from_playwright.js"
 
 export const chromium = createRuntimeFromPlaywright({
   browserName: "chromium",
-  browserVersion: "109.0.5414.46", // to update, check https://github.com/microsoft/playwright/releases
+  browserVersion: "110.0.5481.38", // 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: "107.0", // to update, check https://github.com/microsoft/playwright/releases
+  browserVersion: "108.0.2", // to update, check https://github.com/microsoft/playwright/releases
 })
 export const firefoxIsolatedTab = firefox.isolatedTab

package/src/plugins/url_analysis/css/css_urls.js

@@ -2,47 +2,38 @@
  * https://github.com/parcel-bundler/parcel/blob/v2/packages/transformers/css/src/CSSTransformer.js
  */
 
+import { parseCssUrls } from "@jsenv/ast"
 import { createMagicSource } from "@jsenv/sourcemap"
-import { applyPostCss, postCssPluginUrlVisitor } from "@jsenv/ast"
 
 export const parseAndTransformCssUrls = async (urlInfo, context) => {
-  const actions = []
-  const magicSource = createMagicSource(urlInfo.content)
-  await applyPostCss({
-    sourcemaps: false,
-    plugins: [
-      postCssPluginUrlVisitor({
-        urlVisitor: ({
-          type,
-          specifier,
-          specifierStart,
-          specifierEnd,
-          specifierLine,
-          specifierColumn,
-        }) => {
-          const [reference] = context.referenceUtils.found({
-            type: `css_${type}`,
-            specifier,
-            specifierStart,
-            specifierEnd,
-            specifierLine,
-            specifierColumn,
-          })
-          actions.push(async () => {
-            magicSource.replace({
-              start: specifierStart,
-              end: specifierEnd,
-              replacement: await context.referenceUtils.readGeneratedSpecifier(
-                reference,
-              ),
-            })
-          })
-        },
-      }),
-    ],
+  const cssUrls = await parseCssUrls({
+    css: urlInfo.content,
     url: urlInfo.originalUrl,
-    content: urlInfo.content,
   })
-  await Promise.all(actions.map((action) => action()))
+  const actions = []
+  const magicSource = createMagicSource(urlInfo.content)
+  for (const cssUrl of cssUrls) {
+    const [reference] = context.referenceUtils.found({
+      type: cssUrl.type,
+      specifier: cssUrl.specifier,
+      specifierStart: cssUrl.start,
+      specifierEnd: cssUrl.end,
+      specifierLine: cssUrl.line,
+      specifierColumn: cssUrl.column,
+    })
+    actions.push(async () => {
+      const replacement = await context.referenceUtils.readGeneratedSpecifier(
+        reference,
+      )
+      magicSource.replace({
+        start: cssUrl.start,
+        end: cssUrl.end,
+        replacement,
+      })
+    })
+  }
+  if (actions.length > 0) {
+    await Promise.all(actions.map((action) => action()))
+  }
   return magicSource.toContentAndSourcemap()
 }

package/src/plugins/url_analysis/html/html_urls.js

@@ -20,10 +20,10 @@ export const parseAndTransformHtmlUrls = async (urlInfo, context) => {
     url,
     htmlAst,
   })
-  const actions = []
   const mutations = []
-  mentions.forEach(
-    ({
+  const actions = []
+  for (const mention of mentions) {
+    const {
       type,
       subtype,
       expectedType,
@@ -35,39 +35,38 @@ export const parseAndTransformHtmlUrls = async (urlInfo, context) => {
       attributeName,
       debug,
       specifier,
-    }) => {
-      const { crossorigin, integrity } = readFetchMetas(node)
-      const isResourceHint = [
-        "preconnect",
-        "dns-prefetch",
-        "prefetch",
-        "preload",
-        "modulepreload",
-      ].includes(subtype)
-      const [reference] = context.referenceUtils.found({
-        type,
-        subtype,
-        expectedType,
-        originalLine,
-        originalColumn,
-        specifier,
-        specifierLine: line,
-        specifierColumn: column,
-        isResourceHint,
-        crossorigin,
-        integrity,
-        debug,
-      })
-      actions.push(async () => {
-        await context.referenceUtils.readGeneratedSpecifier(reference)
-      })
+    } = mention
+    const { crossorigin, integrity } = readFetchMetas(node)
+    const isResourceHint = [
+      "preconnect",
+      "dns-prefetch",
+      "prefetch",
+      "preload",
+      "modulepreload",
+    ].includes(subtype)
+    const [reference] = context.referenceUtils.found({
+      type,
+      subtype,
+      expectedType,
+      originalLine,
+      originalColumn,
+      specifier,
+      specifierLine: line,
+      specifierColumn: column,
+      isResourceHint,
+      crossorigin,
+      integrity,
+      debug,
+    })
+    actions.push(async () => {
+      await context.referenceUtils.readGeneratedSpecifier(reference)
       mutations.push(() => {
         setHtmlNodeAttributes(node, {
           [attributeName]: reference.generatedSpecifier,
         })
       })
-    },
-  )
+    })
+  }
   if (actions.length > 0) {
     await Promise.all(actions.map((action) => action()))
   }

package/src/plugins/url_analysis/js/js_urls.js

@@ -12,7 +12,7 @@ export const parseAndTransformJsUrls = async (urlInfo, context) => {
   })
   const actions = []
   const magicSource = createMagicSource(urlInfo.content)
-  jsMentions.forEach((jsMention) => {
+  for (const jsMention of jsMentions) {
     if (
       jsMention.subtype === "import_static" ||
       jsMention.subtype === "import_dynamic"
@@ -26,10 +26,10 @@ export const parseAndTransformJsUrls = async (urlInfo, context) => {
       expectedType: jsMention.expectedType,
       expectedSubtype: jsMention.expectedSubtype || urlInfo.subtype,
       specifier: jsMention.specifier,
-      specifierStart: jsMention.specifierStart,
-      specifierEnd: jsMention.specifierEnd,
-      specifierLine: jsMention.specifierLine,
-      specifierColumn: jsMention.specifierColumn,
+      specifierStart: jsMention.start,
+      specifierEnd: jsMention.end,
+      specifierLine: jsMention.line,
+      specifierColumn: jsMention.column,
       data: jsMention.data,
       baseUrl: {
         "StringLiteral": jsMention.baseUrl,
@@ -48,16 +48,18 @@ export const parseAndTransformJsUrls = async (urlInfo, context) => {
         reference,
       )
       magicSource.replace({
-        start: jsMention.specifierStart,
-        end: jsMention.specifierEnd,
+        start: jsMention.start,
+        end: jsMention.end,
         replacement,
       })
       if (reference.mutation) {
         reference.mutation(magicSource)
       }
     })
-  })
-  await Promise.all(actions.map((action) => action()))
+  }
+  if (actions.length > 0) {
+    await Promise.all(actions.map((action) => action()))
+  }
   const { content, sourcemap } = magicSource.toContentAndSourcemap()
   return { content, sourcemap }
 }