@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/transpilation/babel/new_stylesheet/client/new_stylesheet.js

@@ -2,50 +2,50 @@
 // construct-style-sheets-polyfill@3.1.0
 // to keep in sync with https://github.com/calebdwilliams/construct-style-sheets
 // copy pasted into jsenv codebase to inject this code with more ease
-;(function () {
-  "use strict"
+(function () {
+  "use strict";
 
   if (typeof document === "undefined" || "adoptedStyleSheets" in document) {
-    return
+    return;
   }
 
-  var hasShadyCss = "ShadyCSS" in window && !ShadyCSS.nativeShadow
-  var bootstrapper = document.implementation.createHTMLDocument("")
-  var closedShadowRootRegistry = new WeakMap()
-  var _DOMException = typeof DOMException === "object" ? Error : DOMException
-  var defineProperty = Object.defineProperty
-  var forEach = Array.prototype.forEach
+  var hasShadyCss = "ShadyCSS" in window && !ShadyCSS.nativeShadow;
+  var bootstrapper = document.implementation.createHTMLDocument("");
+  var closedShadowRootRegistry = new WeakMap();
+  var _DOMException = typeof DOMException === "object" ? Error : DOMException;
+  var defineProperty = Object.defineProperty;
+  var forEach = Array.prototype.forEach;
 
-  var importPattern = /@import.+?;?$/gm
+  var importPattern = /@import.+?;?$/gm;
   function rejectImports(contents) {
-    var _contents = contents.replace(importPattern, "")
+    var _contents = contents.replace(importPattern, "");
     if (_contents !== contents) {
       console.warn(
         "@import rules are not allowed here. See https://github.com/WICG/construct-stylesheets/issues/119#issuecomment-588352418",
-      )
+      );
     }
-    return _contents.trim()
+    return _contents.trim();
   }
   function isElementConnected(element) {
     return "isConnected" in element
       ? element.isConnected
-      : document.contains(element)
+      : document.contains(element);
   }
   function unique(arr) {
     return arr.filter(function (value, index) {
-      return arr.indexOf(value) === index
-    })
+      return arr.indexOf(value) === index;
+    });
   }
   function diff(arr1, arr2) {
     return arr1.filter(function (value) {
-      return arr2.indexOf(value) === -1
-    })
+      return arr2.indexOf(value) === -1;
+    });
   }
   function removeNode(node) {
-    node.parentNode.removeChild(node)
+    node.parentNode.removeChild(node);
   }
   function getShadowRoot(element) {
-    return element.shadowRoot || closedShadowRootRegistry.get(element)
+    return element.shadowRoot || closedShadowRootRegistry.get(element);
   }
 
   var cssStyleSheetMethods = [
@@ -53,159 +53,159 @@
     "deleteRule",
     "insertRule",
     "removeRule",
-  ]
-  var NonConstructedStyleSheet = CSSStyleSheet
-  var nonConstructedProto = NonConstructedStyleSheet.prototype
+  ];
+  var NonConstructedStyleSheet = CSSStyleSheet;
+  var nonConstructedProto = NonConstructedStyleSheet.prototype;
   nonConstructedProto.replace = function () {
     return Promise.reject(
       new _DOMException(
         "Can't call replace on non-constructed CSSStyleSheets.",
       ),
-    )
-  }
+    );
+  };
   nonConstructedProto.replaceSync = function () {
     throw new _DOMException(
       "Failed to execute 'replaceSync' on 'CSSStyleSheet': Can't call replaceSync on non-constructed CSSStyleSheets.",
-    )
-  }
+    );
+  };
   function isCSSStyleSheetInstance(instance) {
     return typeof instance === "object"
       ? proto$1.isPrototypeOf(instance) ||
           nonConstructedProto.isPrototypeOf(instance)
-      : false
+      : false;
   }
   function isNonConstructedStyleSheetInstance(instance) {
     return typeof instance === "object"
       ? nonConstructedProto.isPrototypeOf(instance)
-      : false
+      : false;
   }
-  var $basicStyleElement = new WeakMap()
-  var $locations = new WeakMap()
-  var $adoptersByLocation = new WeakMap()
-  var $appliedMethods = new WeakMap()
+  var $basicStyleElement = new WeakMap();
+  var $locations = new WeakMap();
+  var $adoptersByLocation = new WeakMap();
+  var $appliedMethods = new WeakMap();
   function addAdopterLocation(sheet, location) {
-    var adopter = document.createElement("style")
-    $adoptersByLocation.get(sheet).set(location, adopter)
-    $locations.get(sheet).push(location)
-    return adopter
+    var adopter = document.createElement("style");
+    $adoptersByLocation.get(sheet).set(location, adopter);
+    $locations.get(sheet).push(location);
+    return adopter;
   }
   function getAdopterByLocation(sheet, location) {
-    return $adoptersByLocation.get(sheet).get(location)
+    return $adoptersByLocation.get(sheet).get(location);
   }
   function removeAdopterLocation(sheet, location) {
-    $adoptersByLocation.get(sheet).delete(location)
+    $adoptersByLocation.get(sheet).delete(location);
     $locations.set(
       sheet,
       $locations.get(sheet).filter(function (_location) {
-        return _location !== location
+        return _location !== location;
       }),
-    )
+    );
   }
   function restyleAdopter(sheet, adopter) {
     requestAnimationFrame(function () {
-      adopter.textContent = $basicStyleElement.get(sheet).textContent
+      adopter.textContent = $basicStyleElement.get(sheet).textContent;
       $appliedMethods.get(sheet).forEach(function (command) {
-        return adopter.sheet[command.method].apply(adopter.sheet, command.args)
-      })
-    })
+        return adopter.sheet[command.method].apply(adopter.sheet, command.args);
+      });
+    });
   }
   function checkInvocationCorrectness(self) {
     if (!$basicStyleElement.has(self)) {
-      throw new TypeError("Illegal invocation")
+      throw new TypeError("Illegal invocation");
     }
   }
   function ConstructedStyleSheet() {
-    var self = this
-    var style = document.createElement("style")
-    bootstrapper.body.appendChild(style)
-    $basicStyleElement.set(self, style)
-    $locations.set(self, [])
-    $adoptersByLocation.set(self, new WeakMap())
-    $appliedMethods.set(self, [])
+    var self = this;
+    var style = document.createElement("style");
+    bootstrapper.body.appendChild(style);
+    $basicStyleElement.set(self, style);
+    $locations.set(self, []);
+    $adoptersByLocation.set(self, new WeakMap());
+    $appliedMethods.set(self, []);
   }
-  var proto$1 = ConstructedStyleSheet.prototype
+  var proto$1 = ConstructedStyleSheet.prototype;
   proto$1.replace = function replace(contents) {
     try {
-      this.replaceSync(contents)
-      return Promise.resolve(this)
+      this.replaceSync(contents);
+      return Promise.resolve(this);
     } catch (e) {
-      return Promise.reject(e)
+      return Promise.reject(e);
     }
-  }
+  };
   proto$1.replaceSync = function replaceSync(contents) {
-    checkInvocationCorrectness(this)
+    checkInvocationCorrectness(this);
     if (typeof contents === "string") {
-      var self_1 = this
-      $basicStyleElement.get(self_1).textContent = rejectImports(contents)
-      $appliedMethods.set(self_1, [])
+      var self_1 = this;
+      $basicStyleElement.get(self_1).textContent = rejectImports(contents);
+      $appliedMethods.set(self_1, []);
       $locations.get(self_1).forEach(function (location) {
         if (location.isConnected()) {
-          restyleAdopter(self_1, getAdopterByLocation(self_1, location))
+          restyleAdopter(self_1, getAdopterByLocation(self_1, location));
         }
-      })
+      });
     }
-  }
+  };
   defineProperty(proto$1, "cssRules", {
     configurable: true,
     enumerable: true,
     get: function cssRules() {
-      checkInvocationCorrectness(this)
-      return $basicStyleElement.get(this).sheet.cssRules
+      checkInvocationCorrectness(this);
+      return $basicStyleElement.get(this).sheet.cssRules;
     },
-  })
+  });
   defineProperty(proto$1, "media", {
     configurable: true,
     enumerable: true,
     get: function media() {
-      checkInvocationCorrectness(this)
-      return $basicStyleElement.get(this).sheet.media
+      checkInvocationCorrectness(this);
+      return $basicStyleElement.get(this).sheet.media;
     },
-  })
+  });
   cssStyleSheetMethods.forEach(function (method) {
     proto$1[method] = function () {
-      var self = this
-      checkInvocationCorrectness(self)
-      var args = arguments
-      $appliedMethods.get(self).push({ method: method, args: args })
+      var self = this;
+      checkInvocationCorrectness(self);
+      var args = arguments;
+      $appliedMethods.get(self).push({ method: method, args: args });
       $locations.get(self).forEach(function (location) {
         if (location.isConnected()) {
-          var sheet = getAdopterByLocation(self, location).sheet
-          sheet[method].apply(sheet, args)
+          var sheet = getAdopterByLocation(self, location).sheet;
+          sheet[method].apply(sheet, args);
         }
-      })
-      var basicSheet = $basicStyleElement.get(self).sheet
-      return basicSheet[method].apply(basicSheet, args)
-    }
-  })
+      });
+      var basicSheet = $basicStyleElement.get(self).sheet;
+      return basicSheet[method].apply(basicSheet, args);
+    };
+  });
   defineProperty(ConstructedStyleSheet, Symbol.hasInstance, {
     configurable: true,
     value: isCSSStyleSheetInstance,
-  })
+  });
 
   var defaultObserverOptions = {
     childList: true,
     subtree: true,
-  }
-  var locations = new WeakMap()
+  };
+  var locations = new WeakMap();
   function getAssociatedLocation(element) {
-    var location = locations.get(element)
+    var location = locations.get(element);
     if (!location) {
-      location = new Location(element)
-      locations.set(element, location)
+      location = new Location(element);
+      locations.set(element, location);
     }
-    return location
+    return location;
   }
   function attachAdoptedStyleSheetProperty(constructor) {
     defineProperty(constructor.prototype, "adoptedStyleSheets", {
       configurable: true,
       enumerable: true,
       get: function () {
-        return getAssociatedLocation(this).sheets
+        return getAssociatedLocation(this).sheets;
       },
       set: function (sheets) {
-        getAssociatedLocation(this).update(sheets)
+        getAssociatedLocation(this).update(sheets);
       },
-    })
+    });
   }
   function traverseWebComponents(node, callback) {
     var iter = document.createNodeIterator(
@@ -214,168 +214,168 @@
       function (foundNode) {
         return getShadowRoot(foundNode)
           ? NodeFilter.FILTER_ACCEPT
-          : NodeFilter.FILTER_REJECT
+          : NodeFilter.FILTER_REJECT;
       },
       null,
       false,
-    )
+    );
     for (var next = void 0; (next = iter.nextNode()); ) {
-      callback(getShadowRoot(next))
+      callback(getShadowRoot(next));
     }
   }
-  var $element = new WeakMap()
-  var $uniqueSheets = new WeakMap()
-  var $observer = new WeakMap()
+  var $element = new WeakMap();
+  var $uniqueSheets = new WeakMap();
+  var $observer = new WeakMap();
   function isExistingAdopter(self, element) {
     return (
       element instanceof HTMLStyleElement &&
       $uniqueSheets.get(self).some(function (sheet) {
-        return getAdopterByLocation(sheet, self)
+        return getAdopterByLocation(sheet, self);
       })
-    )
+    );
   }
   function getAdopterContainer(self) {
-    var element = $element.get(self)
-    return element instanceof Document ? element.body : element
+    var element = $element.get(self);
+    return element instanceof Document ? element.body : element;
   }
   function adopt(self) {
-    var styleList = document.createDocumentFragment()
-    var sheets = $uniqueSheets.get(self)
-    var observer = $observer.get(self)
-    var container = getAdopterContainer(self)
-    observer.disconnect()
+    var styleList = document.createDocumentFragment();
+    var sheets = $uniqueSheets.get(self);
+    var observer = $observer.get(self);
+    var container = getAdopterContainer(self);
+    observer.disconnect();
     sheets.forEach(function (sheet) {
       styleList.appendChild(
         getAdopterByLocation(sheet, self) || addAdopterLocation(sheet, self),
-      )
-    })
-    container.insertBefore(styleList, null)
-    observer.observe(container, defaultObserverOptions)
+      );
+    });
+    container.insertBefore(styleList, null);
+    observer.observe(container, defaultObserverOptions);
     sheets.forEach(function (sheet) {
-      restyleAdopter(sheet, getAdopterByLocation(sheet, self))
-    })
+      restyleAdopter(sheet, getAdopterByLocation(sheet, self));
+    });
   }
   function Location(element) {
-    var self = this
-    self.sheets = []
-    $element.set(self, element)
-    $uniqueSheets.set(self, [])
+    var self = this;
+    self.sheets = [];
+    $element.set(self, element);
+    $uniqueSheets.set(self, []);
     $observer.set(
       self,
       new MutationObserver(function (mutations, observer) {
         if (!document) {
-          observer.disconnect()
-          return
+          observer.disconnect();
+          return;
         }
         mutations.forEach(function (mutation) {
           if (!hasShadyCss) {
             forEach.call(mutation.addedNodes, function (node) {
               if (!(node instanceof Element)) {
-                return
+                return;
               }
               traverseWebComponents(node, function (root) {
-                getAssociatedLocation(root).connect()
-              })
-            })
+                getAssociatedLocation(root).connect();
+              });
+            });
           }
           forEach.call(mutation.removedNodes, function (node) {
             if (!(node instanceof Element)) {
-              return
+              return;
             }
             if (isExistingAdopter(self, node)) {
-              adopt(self)
+              adopt(self);
             }
             if (!hasShadyCss) {
               traverseWebComponents(node, function (root) {
-                getAssociatedLocation(root).disconnect()
-              })
+                getAssociatedLocation(root).disconnect();
+              });
             }
-          })
-        })
+          });
+        });
       }),
-    )
+    );
   }
   Location.prototype = {
     isConnected: function () {
-      var element = $element.get(this)
+      var element = $element.get(this);
       return element instanceof Document
         ? element.readyState !== "loading"
-        : isElementConnected(element.host)
+        : isElementConnected(element.host);
     },
     connect: function () {
-      var container = getAdopterContainer(this)
-      $observer.get(this).observe(container, defaultObserverOptions)
+      var container = getAdopterContainer(this);
+      $observer.get(this).observe(container, defaultObserverOptions);
       if ($uniqueSheets.get(this).length > 0) {
-        adopt(this)
+        adopt(this);
       }
       traverseWebComponents(container, function (root) {
-        getAssociatedLocation(root).connect()
-      })
+        getAssociatedLocation(root).connect();
+      });
     },
     disconnect: function () {
-      $observer.get(this).disconnect()
+      $observer.get(this).disconnect();
     },
     update: function (sheets) {
-      var self = this
+      var self = this;
       var locationType =
-        $element.get(self) === document ? "Document" : "ShadowRoot"
+        $element.get(self) === document ? "Document" : "ShadowRoot";
       if (!Array.isArray(sheets)) {
         throw new TypeError(
           "Failed to set the 'adoptedStyleSheets' property on " +
             locationType +
             ": Iterator getter is not callable.",
-        )
+        );
       }
       if (!sheets.every(isCSSStyleSheetInstance)) {
         throw new TypeError(
           "Failed to set the 'adoptedStyleSheets' property on " +
             locationType +
             ": Failed to convert value to 'CSSStyleSheet'",
-        )
+        );
       }
       if (sheets.some(isNonConstructedStyleSheetInstance)) {
         throw new TypeError(
           "Failed to set the 'adoptedStyleSheets' property on " +
             locationType +
             ": Can't adopt non-constructed stylesheets",
-        )
+        );
       }
-      self.sheets = sheets
-      var oldUniqueSheets = $uniqueSheets.get(self)
-      var uniqueSheets = unique(sheets)
-      var removedSheets = diff(oldUniqueSheets, uniqueSheets)
+      self.sheets = sheets;
+      var oldUniqueSheets = $uniqueSheets.get(self);
+      var uniqueSheets = unique(sheets);
+      var removedSheets = diff(oldUniqueSheets, uniqueSheets);
       removedSheets.forEach(function (sheet) {
-        removeNode(getAdopterByLocation(sheet, self))
-        removeAdopterLocation(sheet, self)
-      })
-      $uniqueSheets.set(self, uniqueSheets)
+        removeNode(getAdopterByLocation(sheet, self));
+        removeAdopterLocation(sheet, self);
+      });
+      $uniqueSheets.set(self, uniqueSheets);
       if (self.isConnected() && uniqueSheets.length > 0) {
-        adopt(self)
+        adopt(self);
       }
     },
-  }
+  };
 
-  window.CSSStyleSheet = ConstructedStyleSheet
-  attachAdoptedStyleSheetProperty(Document)
+  window.CSSStyleSheet = ConstructedStyleSheet;
+  attachAdoptedStyleSheetProperty(Document);
   if ("ShadowRoot" in window) {
-    attachAdoptedStyleSheetProperty(ShadowRoot)
-    var proto = Element.prototype
-    var attach_1 = proto.attachShadow
+    attachAdoptedStyleSheetProperty(ShadowRoot);
+    var proto = Element.prototype;
+    var attach_1 = proto.attachShadow;
     proto.attachShadow = function attachShadow(init) {
-      var root = attach_1.call(this, init)
+      var root = attach_1.call(this, init);
       if (init.mode === "closed") {
-        closedShadowRootRegistry.set(this, root)
+        closedShadowRootRegistry.set(this, root);
       }
-      return root
-    }
+      return root;
+    };
   }
-  var documentLocation = getAssociatedLocation(document)
+  var documentLocation = getAssociatedLocation(document);
   if (documentLocation.isConnected()) {
-    documentLocation.connect()
+    documentLocation.connect();
   } else {
     document.addEventListener(
       "DOMContentLoaded",
       documentLocation.connect.bind(documentLocation),
-    )
+    );
   }
-})()
+})();

package/src/plugins/transpilation/babel/regenerator_runtime/babel_plugin_regenerator_runtime_as_jsenv_import.js

@@ -1,10 +1,10 @@
-import { pathToFileURL } from "node:url"
-import { injectJsImport } from "@jsenv/ast"
+import { pathToFileURL } from "node:url";
+import { injectJsImport } from "@jsenv/ast";
 
 export const regeneratorRuntimeClientFileUrl = new URL(
   "./client/regenerator_runtime.js",
   import.meta.url,
-).href
+).href;
 
 export const babelPluginRegeneratorRuntimeAsJsenvImport = (
   babel,
@@ -14,20 +14,20 @@ export const babelPluginRegeneratorRuntimeAsJsenvImport = (
     name: "regenerator-runtime-as-jsenv-import",
     visitor: {
       Identifier(path, opts) {
-        const { filename } = opts
-        const fileUrl = pathToFileURL(filename).href
+        const { filename } = opts;
+        const fileUrl = pathToFileURL(filename).href;
         if (fileUrl === regeneratorRuntimeClientFileUrl) {
-          return
+          return;
         }
-        const { node } = path
+        const { node } = path;
         if (node.name === "regeneratorRuntime") {
           injectJsImport({
             programPath: path.scope.getProgramParent().path,
             from: getImportSpecifier(regeneratorRuntimeClientFileUrl),
             sideEffect: true,
-          })
+          });
         }
       },
     },
-  }
-}
+  };
+};

package/src/plugins/transpilation/babel/require_babel_plugin.js

@@ -1,8 +1,8 @@
-import { createRequire } from "node:module"
-import { pathToFileURL } from "node:url"
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
-const babelPluginPackagePath = requireFromJsenv.resolve("@jsenv/babel-plugins")
-const babelPluginPackageUrl = pathToFileURL(babelPluginPackagePath)
+const babelPluginPackagePath = requireFromJsenv.resolve("@jsenv/babel-plugins");
+const babelPluginPackageUrl = pathToFileURL(babelPluginPackagePath);
 
-export const requireBabelPlugin = createRequire(babelPluginPackageUrl)
+export const requireBabelPlugin = createRequire(babelPluginPackageUrl);

package/src/plugins/transpilation/css/jsenv_plugin_css_transpilation.js

@@ -1,4 +1,4 @@
-import { fileURLToPath } from "node:url"
+import { fileURLToPath } from "node:url";
 
 export const jsenvPluginCssTranspilation = () => {
   return {
@@ -6,21 +6,21 @@ export const jsenvPluginCssTranspilation = () => {
     appliesDuring: "*",
     transformUrlContent: {
       css: async (urlInfo, context) => {
-        const { code, map } = await transpileCss(urlInfo, context)
+        const { code, map } = await transpileCss(urlInfo, context);
         return {
           content: String(code),
           sourcemap: map,
-        }
+        };
       },
     },
-  }
-}
+  };
+};
 
 const transpileCss = async (urlInfo, context) => {
   // https://lightningcss.dev/docs.html
-  const { transform } = await import("lightningcss")
+  const { transform } = await import("lightningcss");
 
-  const targets = runtimeCompatToTargets(context.runtimeCompat)
+  const targets = runtimeCompatToTargets(context.runtimeCompat);
   const { code, map } = transform({
     filename: fileURLToPath(urlInfo.originalUrl),
     code: Buffer.from(urlInfo.content),
@@ -30,25 +30,25 @@ const transpileCss = async (urlInfo, context) => {
       nesting: true,
       customMedia: true,
     },
-  })
-  return { code, map }
-}
+  });
+  return { code, map };
+};
 
 const runtimeCompatToTargets = (runtimeCompat) => {
-  const targets = {}
-  ;["chrome", "firefox", "ie", "opera", "safari"].forEach((runtimeName) => {
-    const version = runtimeCompat[runtimeName]
+  const targets = {};
+  ["chrome", "firefox", "ie", "opera", "safari"].forEach((runtimeName) => {
+    const version = runtimeCompat[runtimeName];
     if (version) {
-      targets[runtimeName] = versionToBits(version)
+      targets[runtimeName] = versionToBits(version);
     }
-  })
-  return targets
-}
+  });
+  return targets;
+};
 
 const versionToBits = (version) => {
   const [major, minor = 0, patch = 0] = version
     .split("-")[0]
     .split(".")
-    .map((v) => parseInt(v, 10))
-  return (major << 16) | (minor << 8) | patch
-}
+    .map((v) => parseInt(v, 10));
+  return (major << 16) | (minor << 8) | patch;
+};