@jsenv/core 29.1.19 → 29.2.1

package/dist/js/execute_using_dynamic_import.js

@@ -3,29 +3,26 @@ import { Session } from "node:inspector";
 import { PerformanceObserver, performance } from "node:perf_hooks";
 
 // https://developer.mozilla.org/en-US/docs/Glossary/Primitive
+
 const isComposite = value => {
   if (value === null) {
     return false;
   }
-
   const type = typeof value;
-
   if (type === "object") {
     return true;
   }
-
   if (type === "function") {
     return true;
   }
-
   return false;
 };
 
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
 const compositeWellKnownMap = new WeakMap();
 const primitiveWellKnownMap = new Map();
 const getCompositeGlobalPath = value => compositeWellKnownMap.get(value);
 const getPrimitiveGlobalPath = value => primitiveWellKnownMap.get(value);
-
 const visitGlobalObject = value => {
   const visitValue = (value, path) => {
     if (isComposite(value)) {
@@ -33,47 +30,38 @@ const visitGlobalObject = value => {
       if (compositeWellKnownMap.has(value)) {
         return;
       }
-
       compositeWellKnownMap.set(value, path);
-
       const visitProperty = property => {
         let descriptor;
-
         try {
           descriptor = Object.getOwnPropertyDescriptor(value, property);
         } catch (e) {
           if (e.name === "SecurityError") {
             return;
           }
-
           throw e;
         }
-
         if (!descriptor) {
           // it's apparently possible to have getOwnPropertyNames returning
           // a property that later returns a null descriptor
           // for instance window.showModalDialog in webkit 13.0
           return;
-        } // do not trigger getter/setter
-
+        }
 
+        // do not trigger getter/setter
         if ("value" in descriptor) {
           const propertyValue = descriptor.value;
           visitValue(propertyValue, [...path, property]);
         }
       };
-
       Object.getOwnPropertyNames(value).forEach(name => visitProperty(name));
       Object.getOwnPropertySymbols(value).forEach(symbol => visitProperty(symbol));
     }
-
     primitiveWellKnownMap.set(value, path);
     return;
   };
-
   visitValue(value, []);
 };
-
 if (typeof window === "object") visitGlobalObject(window);
 if (typeof global === "object") visitGlobalObject(global);
 
@@ -88,58 +76,46 @@ const decompose = (mainValue, {
 }) => {
   const valueMap = {};
   const recipeArray = [];
-
   const valueToIdentifier = (value, path = []) => {
     if (!isComposite(value)) {
       const existingIdentifier = identifierForPrimitive(value);
-
       if (existingIdentifier !== undefined) {
         return existingIdentifier;
       }
-
       const identifier = identifierForNewValue(value);
       recipeArray[identifier] = primitiveToRecipe(value);
       return identifier;
     }
-
     if (typeof Promise === "function" && value instanceof Promise) {
       throw new Error(createPromiseAreNotSupportedMessage({
         path
       }));
     }
-
     if (typeof WeakSet === "function" && value instanceof WeakSet) {
       throw new Error(createWeakSetAreNotSupportedMessage({
         path
       }));
     }
-
     if (typeof WeakMap === "function" && value instanceof WeakMap) {
       throw new Error(createWeakMapAreNotSupportedMessage({
         path
       }));
     }
-
     if (typeof value === "function" && !functionAllowed) {
       throw new Error(createForbiddenFunctionMessage({
         path
       }));
     }
-
     const existingIdentifier = identifierForComposite(value);
-
     if (existingIdentifier !== undefined) {
       return existingIdentifier;
     }
-
     const identifier = identifierForNewValue(value);
     const compositeGlobalPath = getCompositeGlobalPath(value);
-
     if (compositeGlobalPath) {
       recipeArray[identifier] = createGlobalReferenceRecipe(compositeGlobalPath);
       return identifier;
     }
-
     const propertyDescriptionArray = [];
     Object.getOwnPropertyNames(value).forEach(propertyName => {
       const propertyDescriptor = Object.getOwnPropertyDescriptor(value, propertyName);
@@ -151,7 +127,6 @@ const decompose = (mainValue, {
       });
     });
     const symbolDescriptionArray = [];
-
     if (!ignoreSymbols) {
       Object.getOwnPropertySymbols(value).forEach(symbol => {
         const propertyDescriptor = Object.getOwnPropertyDescriptor(value, symbol);
@@ -163,7 +138,6 @@ const decompose = (mainValue, {
         });
       });
     }
-
     const methodDescriptionArray = computeMethodDescriptionArray(value, path);
     const extensible = Object.isExtensible(value);
     recipeArray[identifier] = createCompositeRecipe({
@@ -174,7 +148,6 @@ const decompose = (mainValue, {
     });
     return identifier;
   };
-
   const computePropertyDescription = (propertyDescriptor, propertyNameOrSymbol, path) => {
     if (propertyDescriptor.set && !functionAllowed) {
       throw new Error(createForbiddenPropertySetterMessage({
@@ -182,14 +155,12 @@ const decompose = (mainValue, {
         propertyNameOrSymbol
       }));
     }
-
     if (propertyDescriptor.get && !functionAllowed) {
       throw new Error(createForbiddenPropertyGetterMessage({
         path,
         propertyNameOrSymbol
       }));
     }
-
     return {
       configurable: propertyDescriptor.configurable,
       writable: propertyDescriptor.writable,
@@ -199,10 +170,8 @@ const decompose = (mainValue, {
       valueIdentifier: "value" in propertyDescriptor ? valueToIdentifier(propertyDescriptor.value, [...path, String(propertyNameOrSymbol), "[[descriptor:value]]"]) : undefined
     };
   };
-
   const computeMethodDescriptionArray = (value, path) => {
     const methodDescriptionArray = [];
-
     if (typeof Set === "function" && value instanceof Set) {
       const callArray = [];
       value.forEach((entryValue, index) => {
@@ -214,7 +183,6 @@ const decompose = (mainValue, {
         callArray
       });
     }
-
     if (typeof Map === "function" && value instanceof Map) {
       const callArray = [];
       value.forEach((entryValue, entryKey) => {
@@ -227,10 +195,8 @@ const decompose = (mainValue, {
         callArray
       });
     }
-
     return methodDescriptionArray;
   };
-
   const identifierForPrimitive = value => {
     return Object.keys(valueMap).find(existingIdentifier => {
       const existingValue = valueMap[existingIdentifier];
@@ -238,94 +204,79 @@ const decompose = (mainValue, {
       return value === existingValue;
     });
   };
-
   const identifierForComposite = value => {
     return Object.keys(valueMap).find(existingIdentifier => {
       const existingValue = valueMap[existingIdentifier];
       return value === existingValue;
     });
   };
-
   const identifierForNewValue = value => {
     const identifier = nextIdentifier();
     valueMap[identifier] = value;
     return identifier;
   };
-
   let currentIdentifier = -1;
-
   const nextIdentifier = () => {
     const identifier = String(parseInt(currentIdentifier) + 1);
     currentIdentifier = identifier;
     return identifier;
   };
+  const mainIdentifier = valueToIdentifier(mainValue);
 
-  const mainIdentifier = valueToIdentifier(mainValue); // prototype, important to keep after the whole structure was visited
+  // prototype, important to keep after the whole structure was visited
   // so that we discover if any prototype is part of the value
-
   const prototypeValueToIdentifier = prototypeValue => {
     // prototype is null
     if (prototypeValue === null) {
       return valueToIdentifier(prototypeValue);
-    } // prototype found somewhere already
-
+    }
 
+    // prototype found somewhere already
     const prototypeExistingIdentifier = identifierForComposite(prototypeValue);
-
     if (prototypeExistingIdentifier !== undefined) {
       return prototypeExistingIdentifier;
-    } // mark prototype as visited
-
+    }
 
-    const prototypeIdentifier = identifierForNewValue(prototypeValue); // prototype is a global reference ?
+    // mark prototype as visited
+    const prototypeIdentifier = identifierForNewValue(prototypeValue);
 
+    // prototype is a global reference ?
     const prototypeGlobalPath = getCompositeGlobalPath(prototypeValue);
-
     if (prototypeGlobalPath) {
       recipeArray[prototypeIdentifier] = createGlobalReferenceRecipe(prototypeGlobalPath);
       return prototypeIdentifier;
-    } // otherwise prototype is unknown
-
+    }
 
+    // otherwise prototype is unknown
     if (prototypeStrict) {
       throw new Error(createUnknownPrototypeMessage({
         prototypeValue
       }));
     }
-
     return prototypeValueToIdentifier(Object.getPrototypeOf(prototypeValue));
   };
-
   const identifierForValueOf = (value, path = []) => {
     if (value instanceof Array) {
       return valueToIdentifier(value.length, [...path, "length"]);
     }
-
     if ("valueOf" in value === false) {
       return undefined;
     }
-
     if (typeof value.valueOf !== "function") {
       return undefined;
     }
-
     const valueOfReturnValue = value.valueOf();
-
     if (!isComposite(valueOfReturnValue)) {
       return valueToIdentifier(valueOfReturnValue, [...path, "valueOf()"]);
     }
-
     if (valueOfReturnValue === value) {
       return undefined;
     }
-
     throw new Error(createUnexpectedValueOfReturnValueMessage());
   };
-
   recipeArray.slice().forEach((recipe, index) => {
     if (recipe.type === "composite") {
       const value = valueMap[index];
-
       if (typeof value === "function") {
         const valueOfIdentifier = nextIdentifier();
         recipeArray[valueOfIdentifier] = {
@@ -335,7 +286,6 @@ const decompose = (mainValue, {
         recipe.valueOfIdentifier = valueOfIdentifier;
         return;
       }
-
       if (value instanceof RegExp) {
         const valueOfIdentifier = nextIdentifier();
         recipeArray[valueOfIdentifier] = {
@@ -344,9 +294,9 @@ const decompose = (mainValue, {
         };
         recipe.valueOfIdentifier = valueOfIdentifier;
         return;
-      } // valueOf, mandatory to uneval new Date(10) for instance.
-
+      }
 
+      // valueOf, mandatory to uneval new Date(10) for instance.
       recipe.valueOfIdentifier = identifierForValueOf(value);
       const prototypeValue = Object.getPrototypeOf(value);
       recipe.prototypeIdentifier = prototypeValueToIdentifier(prototypeValue);
@@ -358,40 +308,31 @@ const decompose = (mainValue, {
     valueMap
   };
 };
-
 const primitiveToRecipe = value => {
   if (typeof value === "symbol") {
     return symbolToRecipe(value);
   }
-
   return createPimitiveRecipe(value);
 };
-
 const symbolToRecipe = symbol => {
   const globalSymbolKey = Symbol.keyFor(symbol);
-
   if (globalSymbolKey !== undefined) {
     return createGlobalSymbolRecipe(globalSymbolKey);
   }
-
   const symbolGlobalPath = getPrimitiveGlobalPath(symbol);
-
   if (!symbolGlobalPath) {
     throw new Error(createUnknownSymbolMessage({
       symbol
     }));
   }
-
   return createGlobalReferenceRecipe(symbolGlobalPath);
 };
-
 const createPimitiveRecipe = value => {
   return {
     type: "primitive",
     value
   };
 };
-
 const createGlobalReferenceRecipe = path => {
   const recipe = {
     type: "global-reference",
@@ -399,14 +340,12 @@ const createGlobalReferenceRecipe = path => {
   };
   return recipe;
 };
-
 const createGlobalSymbolRecipe = key => {
   return {
     type: "global-symbol",
     key
   };
 };
-
 const createCompositeRecipe = ({
   prototypeIdentifier,
   valueOfIdentifier,
@@ -425,72 +364,59 @@ const createCompositeRecipe = ({
     extensible
   };
 };
-
 const createPromiseAreNotSupportedMessage = ({
   path
 }) => {
   if (path.length === 0) {
     return `promise are not supported.`;
   }
-
   return `promise are not supported.
 promise found at: ${path.join("")}`;
 };
-
 const createWeakSetAreNotSupportedMessage = ({
   path
 }) => {
   if (path.length === 0) {
     return `weakSet are not supported.`;
   }
-
   return `weakSet are not supported.
 weakSet found at: ${path.join("")}`;
 };
-
 const createWeakMapAreNotSupportedMessage = ({
   path
 }) => {
   if (path.length === 0) {
     return `weakMap are not supported.`;
   }
-
   return `weakMap are not supported.
 weakMap found at: ${path.join("")}`;
 };
-
 const createForbiddenFunctionMessage = ({
   path
 }) => {
   if (path.length === 0) {
     return `function are not allowed.`;
   }
-
   return `function are not allowed.
 function found at: ${path.join("")}`;
 };
-
 const createForbiddenPropertyGetterMessage = ({
   path,
   propertyNameOrSymbol
 }) => `property getter are not allowed.
 getter found on property: ${String(propertyNameOrSymbol)}
 at: ${path.join("")}`;
-
 const createForbiddenPropertySetterMessage = ({
   path,
   propertyNameOrSymbol
 }) => `property setter are not allowed.
 setter found on property: ${String(propertyNameOrSymbol)}
 at: ${path.join("")}`;
-
 const createUnexpectedValueOfReturnValueMessage = () => `valueOf() must return a primitive of the object itself.`;
-
 const createUnknownSymbolMessage = ({
   symbol
 }) => `symbol must be global, like Symbol.iterator, or created using Symbol.for().
 symbol: ${symbol.toString()}`;
-
 const createUnknownPrototypeMessage = ({
   prototypeValue
 }) => `prototype must be global, like Object.prototype, or somewhere in the value.
@@ -501,68 +427,58 @@ prototype constructor name: ${prototypeValue.constructor.name}`;
 // when used internally by uneval
 const sortRecipe = recipeArray => {
   const findInRecipePrototypeChain = (recipe, callback) => {
-    let currentRecipe = recipe; // eslint-disable-next-line no-constant-condition
-
+    let currentRecipe = recipe;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       if (currentRecipe.type !== "composite") {
         break;
       }
-
       const prototypeIdentifier = currentRecipe.prototypeIdentifier;
-
       if (prototypeIdentifier === undefined) {
         break;
       }
-
       currentRecipe = recipeArray[prototypeIdentifier];
-
       if (callback(currentRecipe, prototypeIdentifier)) {
         return prototypeIdentifier;
       }
     }
-
     return undefined;
   };
-
   const recipeArrayOrdered = recipeArray.slice();
   recipeArrayOrdered.sort((leftRecipe, rightRecipe) => {
     const leftType = leftRecipe.type;
     const rightType = rightRecipe.type;
-
     if (leftType === "composite" && rightType === "composite") {
-      const rightRecipeIsInLeftRecipePrototypeChain = findInRecipePrototypeChain(leftRecipe, recipeCandidate => recipeCandidate === rightRecipe); // if left recipe requires right recipe, left must be after right
-
+      const rightRecipeIsInLeftRecipePrototypeChain = findInRecipePrototypeChain(leftRecipe, recipeCandidate => recipeCandidate === rightRecipe);
+      // if left recipe requires right recipe, left must be after right
       if (rightRecipeIsInLeftRecipePrototypeChain) {
         return 1;
       }
-
-      const leftRecipeIsInRightRecipePrototypeChain = findInRecipePrototypeChain(rightRecipe, recipeCandidate => recipeCandidate === leftRecipe); // if right recipe requires left recipe, right must be after left
-
+      const leftRecipeIsInRightRecipePrototypeChain = findInRecipePrototypeChain(rightRecipe, recipeCandidate => recipeCandidate === leftRecipe);
+      // if right recipe requires left recipe, right must be after left
       if (leftRecipeIsInRightRecipePrototypeChain) {
         return -1;
       }
     }
-
     if (leftType !== rightType) {
       // if left is a composite, left must be after right
       if (leftType === "composite") {
         return 1;
-      } // if right is a composite, right must be after left
-
+      }
 
+      // if right is a composite, right must be after left
       if (rightType === "composite") {
         return -1;
       }
     }
-
     const leftIndex = recipeArray.indexOf(leftRecipe);
-    const rightIndex = recipeArray.indexOf(rightRecipe); // left was before right, don't change that
-
+    const rightIndex = recipeArray.indexOf(rightRecipe);
+    // left was before right, don't change that
     if (leftIndex < rightIndex) {
       return -1;
-    } // right was after left, don't change that
-
+    }
 
+    // right was after left, don't change that
     return 1;
   });
   return recipeArrayOrdered;
@@ -575,11 +491,9 @@ const escapeString = value => {
   let i = 0;
   const j = string.length;
   var escapedString = "";
-
   while (i < j) {
     const char = string[i];
     let escapedChar;
-
     if (char === '"' || char === "'" || char === "\\") {
       escapedChar = `\\${char}`;
     } else if (char === "\n") {
@@ -593,11 +507,9 @@ const escapeString = value => {
     } else {
       escapedChar = char;
     }
-
     escapedString += escapedChar;
     i++;
   }
-
   return escapedString;
 };
 
@@ -635,45 +547,35 @@ function safeDefineProperty(object, propertyNameOrSymbol, descriptor) {
     const indexSorted = recipeArraySorted.indexOf(recipe);
     variableNameMap[index] = `_${indexSorted}`;
   });
-
   const identifierToVariableName = identifier => variableNameMap[identifier];
-
   const recipeToSetupSource = recipe => {
     if (recipe.type === "primitive") return primitiveRecipeToSetupSource(recipe);
     if (recipe.type === "global-symbol") return globalSymbolRecipeToSetupSource(recipe);
     if (recipe.type === "global-reference") return globalReferenceRecipeToSetupSource(recipe);
     return compositeRecipeToSetupSource(recipe);
   };
-
   const primitiveRecipeToSetupSource = ({
     value
   }) => {
     const type = typeof value;
-
     if (type === "string") {
       return `"${escapeString(value)}";`;
     }
-
     if (type === "bigint") {
       return `${value.toString()}n`;
     }
-
     if (Object.is(value, -0)) {
       return "-0;";
     }
-
     return `${String(value)};`;
   };
-
   const globalSymbolRecipeToSetupSource = recipe => {
     return `Symbol.for("${escapeString(recipe.key)}");`;
   };
-
   const globalReferenceRecipeToSetupSource = recipe => {
     const pathSource = recipe.path.map(part => `["${escapeString(part)}"]`).join("");
     return `globalObject${pathSource};`;
   };
-
   const compositeRecipeToSetupSource = ({
     prototypeIdentifier,
     valueOfIdentifier
@@ -681,44 +583,33 @@ function safeDefineProperty(object, propertyNameOrSymbol, descriptor) {
     if (prototypeIdentifier === undefined) {
       return identifierToVariableName(valueOfIdentifier);
     }
-
     const prototypeValue = valueMap[prototypeIdentifier];
-
     if (prototypeValue === null) {
       return `Object.create(null);`;
     }
-
     const prototypeConstructor = prototypeValue.constructor;
-
     if (prototypeConstructor === Object) {
       return `Object.create(${identifierToVariableName(prototypeIdentifier)});`;
     }
-
     if (valueOfIdentifier === undefined) {
       return `new ${prototypeConstructor.name}();`;
     }
-
     if (prototypeConstructor.name === "BigInt") {
       return `Object(${identifierToVariableName(valueOfIdentifier)})`;
     }
-
     return `new ${prototypeConstructor.name}(${identifierToVariableName(valueOfIdentifier)});`;
   };
-
   recipeArraySorted.forEach(recipe => {
     const recipeVariableName = identifierToVariableName(recipeArray.indexOf(recipe));
     source += `var ${recipeVariableName} = ${recipeToSetupSource(recipe)}
 `;
   });
-
   const recipeToMutateSource = (recipe, recipeVariableName) => {
     if (recipe.type === "composite") {
       return compositeRecipeToMutateSource(recipe, recipeVariableName);
     }
-
     return ``;
   };
-
   const compositeRecipeToMutateSource = ({
     propertyDescriptionArray,
     symbolDescriptionArray,
@@ -744,20 +635,16 @@ function safeDefineProperty(object, propertyNameOrSymbol, descriptor) {
     }) => {
       mutateSource += generateMethodCallSource(recipeVariableName, methodNameIdentifier, callArray);
     });
-
     if (!extensible) {
       mutateSource += generatePreventExtensionSource(recipeVariableName);
     }
-
     return mutateSource;
   };
-
   const generateDefinePropertySource = (recipeVariableName, propertyNameOrSymbolIdentifier, propertyDescription) => {
     const propertyOrSymbolVariableName = identifierToVariableName(propertyNameOrSymbolIdentifier);
     const propertyDescriptorSource = generatePropertyDescriptorSource(propertyDescription);
     return `safeDefineProperty(${recipeVariableName}, ${propertyOrSymbolVariableName}, ${propertyDescriptorSource});`;
   };
-
   const generatePropertyDescriptorSource = ({
     configurable,
     writable,
@@ -774,7 +661,6 @@ function safeDefineProperty(object, propertyNameOrSymbol, descriptor) {
   set: ${setIdentifier === undefined ? undefined : identifierToVariableName(setIdentifier)},
 }`;
     }
-
     return `{
   configurable: ${configurable},
   writable: ${writable},
@@ -782,7 +668,6 @@ function safeDefineProperty(object, propertyNameOrSymbol, descriptor) {
   value: ${valueIdentifier === undefined ? undefined : identifierToVariableName(valueIdentifier)}
 }`;
   };
-
   const generateMethodCallSource = (recipeVariableName, methodNameIdentifier, callArray) => {
     let methodCallSource = ``;
     const methodVariableName = identifierToVariableName(methodNameIdentifier);
@@ -792,11 +677,9 @@ function safeDefineProperty(object, propertyNameOrSymbol, descriptor) {
     });
     return methodCallSource;
   };
-
   const generatePreventExtensionSource = recipeVariableName => {
     return `Object.preventExtensions(${recipeVariableName});`;
   };
-
   recipeArraySorted.forEach(recipe => {
     const recipeVariableName = identifierToVariableName(recipeArray.indexOf(recipe));
     source += `${recipeToMutateSource(recipe, recipeVariableName)}`;
@@ -825,7 +708,6 @@ const startJsCoverage = async ({
 } = {}) => {
   const session = new Session();
   session.connect();
-
   const postSession = (action, options) => {
     const promise = new Promise((resolve, reject) => {
       session.post(action, options, (error, data) => {
@@ -838,25 +720,21 @@ const startJsCoverage = async ({
     });
     return promise;
   };
-
   await postSession("Profiler.enable");
   await postSession("Profiler.startPreciseCoverage", {
     callCount,
     detailed
   });
-
   const takeJsCoverage = async () => {
     const coverage = await postSession("Profiler.takePreciseCoverage");
     return coverage;
   };
-
   const stopJsCoverage = async () => {
     const coverage = await takeJsCoverage();
     await postSession("Profiler.stopPreciseCoverage");
     await postSession("Profiler.disable");
     return coverage;
   };
-
   return {
     takeJsCoverage,
     stopJsCoverage
@@ -864,9 +742,10 @@ const startJsCoverage = async ({
 };
 
 const startObservingPerformances = () => {
-  const measureEntries = []; // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html
-
-  const perfObserver = new PerformanceObserver(( // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceobserverentrylist
+  const measureEntries = [];
+  // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html
+  const perfObserver = new PerformanceObserver((
+  // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceobserverentrylist
   list) => {
     const perfMeasureEntries = list.getEntriesByType("measure");
     measureEntries.push(...perfMeasureEntries);
@@ -881,12 +760,12 @@ const startObservingPerformances = () => {
     });
     performance.clearMarks();
     perfObserver.disconnect();
-    return { ...readNodePerformance(),
+    return {
+      ...readNodePerformance(),
       measures: measuresFromMeasureEntries(measureEntries)
     };
   };
 };
-
 const readNodePerformance = () => {
   const nodePerformance = {
     nodeTiming: asPlainObject(performance.nodeTiming),
@@ -894,9 +773,9 @@ const readNodePerformance = () => {
     eventLoopUtilization: performance.eventLoopUtilization()
   };
   return nodePerformance;
-}; // remove getters that cannot be stringified
-
+};
 
+// remove getters that cannot be stringified
 const asPlainObject = objectWithGetters => {
   const objectWithoutGetters = {};
   Object.keys(objectWithGetters).forEach(key => {
@@ -904,16 +783,16 @@ const asPlainObject = objectWithGetters => {
   });
   return objectWithoutGetters;
 };
-
 const measuresFromMeasureEntries = measureEntries => {
-  const measures = {}; // Sort to ensure measures order is predictable
+  const measures = {};
+  // Sort to ensure measures order is predictable
   // It seems to be already predictable on Node 16+ but
   // it's not the case on Node 14.
-
   measureEntries.sort((a, b) => {
     return a.startTime - b.startTime;
   });
-  measureEntries.forEach(( // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceentry
+  measureEntries.forEach((
+  // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceentry
   perfMeasureEntry) => {
     measures[perfMeasureEntry.name] = perfMeasureEntry.duration;
   });
@@ -931,7 +810,6 @@ const executeUsingDynamicImport = async ({
 }) => {
   const result = {};
   const afterImportCallbacks = [];
-
   if (coverageEnabled && coverageMethodForNodeJs === "Profiler") {
     const {
       filterV8Coverage
@@ -948,7 +826,6 @@ const executeUsingDynamicImport = async ({
       writeFileSync(new URL(coverageFileUrl), JSON.stringify(coverageLight, null, "  "));
     });
   }
-
   if (collectPerformance) {
     const getPerformance = startObservingPerformances();
     afterImportCallbacks.push(async () => {
@@ -956,7 +833,6 @@ const executeUsingDynamicImport = async ({
       result.performance = performance;
     });
   }
-
   const namespace = await import(fileUrl);
   const namespaceResolved = {};
   await Promise.all(Object.keys(namespace).map(async key => {