@endo/compartment-mapper 1.2.1 → 1.3.0

package/src/link.js

@@ -9,27 +9,34 @@
 // @ts-check
 
 /** @import {ModuleMapHook} from 'ses' */
-/** @import {ParseFn, ParserForLanguage} from './types.js' */
-/** @import {ParserImplementation} from './types.js' */
-/** @import {ShouldDeferError} from './types.js' */
-/** @import {ModuleTransforms} from './types.js' */
-/** @import {LanguageForExtension} from './types.js' */
-/** @import {ModuleDescriptor} from './types.js' */
-/** @import {CompartmentDescriptor} from './types.js' */
-/** @import {CompartmentMapDescriptor} from './types.js' */
-/** @import {LinkOptions} from './types.js' */
+/**
+ * @import {
+ *   CompartmentDescriptor,
+ *   CompartmentMapDescriptor,
+ *   ImportNowHookMaker,
+ *   LanguageForExtension,
+ *   LinkOptions,
+ *   LinkResult,
+ *   ModuleDescriptor,
+ *   ParseFn,
+ *   ParseFnAsync,
+ *   ParserForLanguage,
+ *   ParserImplementation,
+ *   ShouldDeferError,
+ * } from './types.js'
+ */
 /** @import {ERef} from '@endo/eventual-send' */
 
+import { makeMapParsers } from './map-parser.js';
 import { resolve as resolveFallback } from './node-module-specifier.js';
-import { parseExtension } from './extension.js';
 import {
-  enforceModulePolicy,
   ATTENUATORS_COMPARTMENT,
   attenuateGlobals,
+  enforceModulePolicy,
   makeDeferredAttenuatorsProvider,
 } from './policy.js';
 
-const { assign, create, entries, freeze, fromEntries } = Object;
+const { assign, create, entries, freeze } = Object;
 const { hasOwnProperty } = Object.prototype;
 const { apply } = Reflect;
 const { allSettled } = Promise;
@@ -52,130 +59,6 @@ const q = JSON.stringify;
  */
 const has = (object, key) => apply(hasOwnProperty, object, [key]);
 
-/**
- * Decide if extension is clearly indicating a parser/language for a file
- *
- * @param {string} extension
- * @returns {boolean}
- */
-const extensionImpliesLanguage = extension => extension !== 'js';
-
-/**
- * `makeExtensionParser` produces a `parser` that parses the content of a
- * module according to the corresponding module language, given the extension
- * of the module specifier and the configuration of the containing compartment.
- * We do not yet support import assertions and we do not have a mechanism
- * for validating the MIME type of the module content against the
- * language implied by the extension or file name.
- *
- * @param {Record<string, string>} languageForExtension - maps a file extension
- * to the corresponding language.
- * @param {Record<string, string>} languageForModuleSpecifier - In a rare case,
- * the type of a module is implied by package.json and should not be inferred
- * from its extension.
- * @param {ParserForLanguage} parserForLanguage
- * @param {ModuleTransforms} moduleTransforms
- * @returns {ParseFn}
- */
-const makeExtensionParser = (
-  languageForExtension,
-  languageForModuleSpecifier,
-  parserForLanguage,
-  moduleTransforms,
-) => {
-  return async (bytes, specifier, location, packageLocation, options) => {
-    await null;
-    let language;
-    const extension = parseExtension(location);
-
-    if (
-      !extensionImpliesLanguage(extension) &&
-      has(languageForModuleSpecifier, specifier)
-    ) {
-      language = languageForModuleSpecifier[specifier];
-    } else {
-      language = languageForExtension[extension] || extension;
-    }
-
-    let sourceMap;
-
-    if (has(moduleTransforms, language)) {
-      try {
-        ({
-          bytes,
-          parser: language,
-          sourceMap,
-        } = await moduleTransforms[language](
-          bytes,
-          specifier,
-          location,
-          packageLocation,
-          {
-            // At time of writing, sourceMap is always undefined, but keeping
-            // it here is more resilient if the surrounding if block becomes a
-            // loop for multi-step transforms.
-            sourceMap,
-          },
-        ));
-      } catch (err) {
-        throw Error(
-          `Error transforming ${q(language)} source in ${q(location)}: ${
-            err.message
-          }`,
-          { cause: err },
-        );
-      }
-    }
-
-    if (!has(parserForLanguage, language)) {
-      throw Error(
-        `Cannot parse module ${specifier} at ${location}, no parser configured for the language ${language}`,
-      );
-    }
-    const { parse } = /** @type {ParserImplementation} */ (
-      parserForLanguage[language]
-    );
-    return parse(bytes, specifier, location, packageLocation, {
-      sourceMap,
-      ...options,
-    });
-  };
-};
-
-/**
- * @param {LanguageForExtension} languageForExtension
- * @param {Record<string, string>} languageForModuleSpecifier - In a rare case, the type of a module
- * is implied by package.json and should not be inferred from its extension.
- * @param {ParserForLanguage} parserForLanguage
- * @param {ModuleTransforms} moduleTransforms
- * @returns {ParseFn}
- */
-export const mapParsers = (
-  languageForExtension,
-  languageForModuleSpecifier,
-  parserForLanguage,
-  moduleTransforms = {},
-) => {
-  const languageForExtensionEntries = [];
-  const problems = [];
-  for (const [extension, language] of entries(languageForExtension)) {
-    if (has(parserForLanguage, language)) {
-      languageForExtensionEntries.push([extension, language]);
-    } else {
-      problems.push(`${q(language)} for extension ${q(extension)}`);
-    }
-  }
-  if (problems.length > 0) {
-    throw Error(`No parser available for language: ${problems.join(', ')}`);
-  }
-  return makeExtensionParser(
-    fromEntries(languageForExtensionEntries),
-    languageForModuleSpecifier,
-    parserForLanguage,
-    moduleTransforms,
-  );
-};
-
 /**
  * For a full, absolute module specifier like "dependency",
  * produce the module specifier in the dependency, like ".".
@@ -328,36 +211,57 @@ const makeModuleMapHook = (
   return moduleMapHook;
 };
 
+/**
+ * @type {ImportNowHookMaker}
+ */
+const impossibleImportNowHookMaker = () => {
+  return function impossibleImportNowHook() {
+    throw new Error('Provided read powers do not support dynamic requires');
+  };
+};
+
 /**
  * Assemble a DAG of compartments as declared in a compartment map starting at
  * the named compartment and building all compartments that it depends upon,
  * recursively threading the modules exported by one compartment into the
  * compartment that imports them.
- * Returns the root of the compartment DAG.
- * Does not load or execute any modules.
- * Uses makeImportHook with the given "location" string of each compartment in
- * the DAG.
- * Passes the given globals and external modules into the root compartment
- * only.
  *
+ * - Returns the root of the compartment DAG.
+ * - Does not load or execute any modules.
+ * - Uses `makeImportHook` with the given "location" string of each compartment
+ *   in the DAG.
+ * - Passes the given globals and external modules into the root compartment
+ *   only.
+ *
+ * @param {CompartmentMapDescriptor} compartmentMap
+ * @param {LinkOptions} options
+ * @returns {LinkResult} the root compartment of the compartment DAG
+ */
+
+/**
  * @param {CompartmentMapDescriptor} compartmentMap
  * @param {LinkOptions} options
+ * @returns {LinkResult}
  */
 export const link = (
   { entry, compartments: compartmentDescriptors },
-  {
+  options,
+) => {
+  const {
     resolve = resolveFallback,
     makeImportHook,
+    makeImportNowHook = impossibleImportNowHookMaker,
     parserForLanguage: parserForLanguageOption = {},
     languageForExtension: languageForExtensionOption = {},
     globals = {},
     transforms = [],
-    moduleTransforms = {},
+    moduleTransforms,
+    syncModuleTransforms,
     __shimTransforms__ = [],
     archiveOnly = false,
     Compartment = defaultCompartment,
-  },
-) => {
+  } = options;
+
   const { compartment: entryCompartmentName } = entry;
 
   /** @type {Record<string, Compartment>} */
@@ -382,19 +286,28 @@ export const link = (
     assign(create(null), parserForLanguageOption),
   );
 
+  const mapParsers = makeMapParsers({
+    parserForLanguage,
+    moduleTransforms,
+    syncModuleTransforms,
+  });
+
   for (const [compartmentName, compartmentDescriptor] of entries(
     compartmentDescriptors,
   )) {
-    // TODO: The default assignments seem to break type inference
     const {
       location,
       name,
-      modules = create(null),
       parsers: languageForExtensionOverrides = {},
       types: languageForModuleSpecifierOverrides = {},
-      scopes = create(null),
     } = compartmentDescriptor;
 
+    // this is for retaining the correct type inference about these values
+    // without use of `let`
+    const { scopes: _scopes, modules: _modules } = compartmentDescriptor;
+    const modules = _modules || create(null);
+    const scopes = _scopes || create(null);
+
     // Capture the default.
     // The `moduleMapHook` writes back to the compartment map.
     compartmentDescriptor.modules = modules;
@@ -412,12 +325,12 @@ export const link = (
       ),
     );
 
-    const parse = mapParsers(
-      languageForExtension,
-      languageForModuleSpecifier,
-      parserForLanguage,
-      moduleTransforms,
+    // TS is kind of dumb about this, so we can use a type assertion to avoid a
+    // pointless ternary.
+    const parse = /** @type {ParseFn|ParseFnAsync} */ (
+      mapParsers(languageForExtension, languageForModuleSpecifier)
     );
+
     /** @type {ShouldDeferError} */
     const shouldDeferError = language => {
       if (language && has(parserForLanguage, language)) {
@@ -441,6 +354,14 @@ export const link = (
       shouldDeferError,
       compartments,
     });
+
+    const importNowHook = makeImportNowHook({
+      packageLocation: location,
+      packageName: name,
+      parse,
+      compartments,
+    });
+
     const moduleMapHook = makeModuleMapHook(
       compartmentDescriptor,
       compartments,
@@ -453,6 +374,7 @@ export const link = (
       name: location,
       resolveHook,
       importHook,
+      importNowHook,
       moduleMapHook,
       transforms,
       __shimTransforms__,

package/src/map-parser.d.ts

@@ -0,0 +1,4 @@
+export function makeMapParsers({ parserForLanguage, moduleTransforms, syncModuleTransforms, }: MakeMapParsersOptions): MapParsersFn;
+import type { MakeMapParsersOptions } from './types.js';
+import type { MapParsersFn } from './types.js';
+//# sourceMappingURL=map-parser.d.ts.map

package/src/map-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-parser.d.ts","sourceRoot":"","sources":["map-parser.js"],"names":[],"mappings":"AAqSO,+FAHI,qBAAqB,GACnB,YAAY,CA+CxB;2CAxTS,YAAY;kCAAZ,YAAY"}

package/src/map-parser.js

@@ -0,0 +1,339 @@
+/**
+ * Exports {@link makeMapParsers}, which creates a function which matches a
+ * module to a parser based on reasons.
+ *
+ * @module
+ */
+
+// @ts-check
+
+import { syncTrampoline, asyncTrampoline } from '@endo/trampoline';
+import { parseExtension } from './extension.js';
+
+/**
+ * @import {
+ *   LanguageForExtension,
+ *   LanguageForModuleSpecifier,
+ *   MakeMapParsersOptions,
+ *   MapParsersFn,
+ *   ModuleTransform,
+ *   ModuleTransforms,
+ *   ParseFn,
+ *   ParseFnAsync,
+ *   ParseResult,
+ *   ParserForLanguage,
+ *   SyncModuleTransform,
+ *   SyncModuleTransforms
+ * } from './types.js';
+ */
+
+const { entries, fromEntries, keys, hasOwnProperty, values } = Object;
+const { apply } = Reflect;
+// q, as in quote, for strings in error messages.
+const q = JSON.stringify;
+
+/**
+ * @param {Record<string, unknown>} object
+ * @param {string} key
+ * @returns {boolean}
+ */
+const has = (object, key) => apply(hasOwnProperty, object, [key]);
+
+/**
+ * Decide if extension is clearly indicating a parser/language for a file
+ *
+ * @param {string} extension
+ * @returns {boolean}
+ */
+const extensionImpliesLanguage = extension => extension !== 'js';
+
+/**
+ * Produces a `parser` that parses the content of a module according to the
+ * corresponding module language, given the extension of the module specifier
+ * and the configuration of the containing compartment. We do not yet support
+ * import assertions and we do not have a mechanism for validating the MIME type
+ * of the module content against the language implied by the extension or file
+ * name.
+ *
+ * @param {boolean} preferSynchronous
+ * @param {Record<string, string>} languageForExtension - maps a file extension
+ * to the corresponding language.
+ * @param {Record<string, string>} languageForModuleSpecifier - In a rare case,
+ * the type of a module is implied by package.json and should not be inferred
+ * from its extension.
+ * @param {ParserForLanguage} parserForLanguage
+ * @param {ModuleTransforms} moduleTransforms
+ * @param {SyncModuleTransforms} syncModuleTransforms
+ * @returns {ParseFnAsync|ParseFn}
+ */
+const makeExtensionParser = (
+  preferSynchronous,
+  languageForExtension,
+  languageForModuleSpecifier,
+  parserForLanguage,
+  moduleTransforms,
+  syncModuleTransforms,
+) => {
+  /** @type {Record<string, ModuleTransform | SyncModuleTransform>} */
+  let transforms;
+
+  /**
+   * Function returning a generator which executes a parser for a module in either sync or async context.
+   *
+   * @param {Uint8Array} bytes
+   * @param {string} specifier
+   * @param {string} location
+   * @param {string} packageLocation
+   * @param {*} options
+   * @returns {Generator<ReturnType<ModuleTransform>|ReturnType<SyncModuleTransform>, ParseResult, Awaited<ReturnType<ModuleTransform>|ReturnType<SyncModuleTransform>>>}
+   */
+  function* getParserGenerator(
+    bytes,
+    specifier,
+    location,
+    packageLocation,
+    options,
+  ) {
+    /** @type {string} */
+    let language;
+    const extension = parseExtension(location);
+
+    if (
+      !extensionImpliesLanguage(extension) &&
+      has(languageForModuleSpecifier, specifier)
+    ) {
+      language = languageForModuleSpecifier[specifier];
+    } else {
+      language = languageForExtension[extension] || extension;
+    }
+
+    /** @type {string|undefined} */
+    let sourceMap;
+
+    if (has(transforms, language)) {
+      try {
+        ({
+          bytes,
+          parser: language,
+          sourceMap,
+        } = yield transforms[language](
+          bytes,
+          specifier,
+          location,
+          packageLocation,
+          {
+            // At time of writing, sourceMap is always undefined, but keeping
+            // it here is more resilient if the surrounding if block becomes a
+            // loop for multi-step transforms.
+            sourceMap,
+          },
+        ));
+      } catch (err) {
+        throw Error(
+          `Error transforming ${q(language)} source in ${q(location)}: ${err.message}`,
+          { cause: err },
+        );
+      }
+    }
+    if (!has(parserForLanguage, language)) {
+      throw Error(
+        `Cannot parse module ${specifier} at ${location}, no parser configured for the language ${language}`,
+      );
+    }
+    const { parse } = parserForLanguage[language];
+    return parse(bytes, specifier, location, packageLocation, {
+      sourceMap,
+      ...options,
+    });
+  }
+
+  /**
+   * @type {ParseFn}
+   */
+  const syncParser = (bytes, specifier, location, packageLocation, options) => {
+    const result = syncTrampoline(
+      getParserGenerator,
+      bytes,
+      specifier,
+      location,
+      packageLocation,
+      options,
+    );
+    if ('then' in result && typeof result.then === 'function') {
+      throw new TypeError(
+        'Sync parser cannot return a Thenable; ensure parser is actually synchronous',
+      );
+    }
+    return result;
+  };
+  syncParser.isSyncParser = true;
+
+  /**
+   * @type {ParseFnAsync}
+   */
+  const asyncParser = async (
+    bytes,
+    specifier,
+    location,
+    packageLocation,
+    options,
+  ) => {
+    return asyncTrampoline(
+      getParserGenerator,
+      bytes,
+      specifier,
+      location,
+      packageLocation,
+      options,
+    );
+  };
+
+  // Unfortunately, typescript was not smart enough to figure out the return
+  // type depending on a boolean in arguments, so it has to be
+  // ParseFnAsync|ParseFn
+  if (preferSynchronous) {
+    transforms = syncModuleTransforms;
+    return syncParser;
+  } else {
+    // we can fold syncModuleTransforms into moduleTransforms because
+    // async supports sync, but not vice-versa
+    transforms = {
+      ...syncModuleTransforms,
+      ...moduleTransforms,
+    };
+
+    return asyncParser;
+  }
+};
+
+/**
+ * Creates a synchronous parser
+ *
+ * @overload
+ * @param {LanguageForExtension} languageForExtension
+ * @param {LanguageForModuleSpecifier} languageForModuleSpecifier - In a rare case,
+ * the type of a module is implied by package.json and should not be inferred
+ * from its extension.
+ * @param {ParserForLanguage} parserForLanguage
+ * @param {ModuleTransforms} [moduleTransforms]
+ * @param {SyncModuleTransforms} [syncModuleTransforms]
+ * @param {true} preferSynchronous If `true`, will create a `ParseFn`
+ * @returns {ParseFn}
+ */
+
+/**
+ * Creates an asynchronous parser
+ *
+ * @overload
+ * @param {LanguageForExtension} languageForExtension
+ * @param {LanguageForModuleSpecifier} languageForModuleSpecifier - In a rare case,
+ * the type of a module is implied by package.json and should not be inferred
+ * from its extension.
+ * @param {ParserForLanguage} parserForLanguage
+ * @param {ModuleTransforms} [moduleTransforms]
+ * @param {SyncModuleTransforms} [syncModuleTransforms]
+ * @param {false} [preferSynchronous]
+ * @returns {ParseFnAsync}
+ */
+
+/**
+ * @param {LanguageForExtension} languageForExtension
+ * @param {LanguageForModuleSpecifier} languageForModuleSpecifier - In a rare case,
+ * the type of a module is implied by package.json and should not be inferred
+ * from its extension.
+ * @param {ParserForLanguage} parserForLanguage
+ * @param {ModuleTransforms} [moduleTransforms]
+ * @param {SyncModuleTransforms} [syncModuleTransforms]
+ * @param {boolean} [preferSynchronous] If `true`, will create a `ParseFn`
+ * @returns {ParseFnAsync|ParseFn}
+ */
+function mapParsers(
+  languageForExtension,
+  languageForModuleSpecifier,
+  parserForLanguage,
+  moduleTransforms = {},
+  syncModuleTransforms = {},
+  preferSynchronous = false,
+) {
+  const languageForExtensionEntries = [];
+  const problems = [];
+  for (const [extension, language] of entries(languageForExtension)) {
+    if (has(parserForLanguage, language)) {
+      languageForExtensionEntries.push([extension, language]);
+    } else {
+      problems.push(`${q(language)} for extension ${q(extension)}`);
+    }
+  }
+  if (problems.length > 0) {
+    throw Error(`No parser available for language: ${problems.join(', ')}`);
+  }
+  return makeExtensionParser(
+    preferSynchronous,
+    fromEntries(languageForExtensionEntries),
+    languageForModuleSpecifier,
+    parserForLanguage,
+    moduleTransforms,
+    syncModuleTransforms,
+  );
+}
+
+/**
+ * Prepares a function to map parsers after verifying whether synchronous
+ * behavior is preferred. Synchronous behavior is selected if all parsers are
+ * synchronous and no async transforms are provided.
+ *
+ * _Note:_ The type argument for {@link MapParsersFn} _could_ be inferred from
+ * the function arguments _if_ {@link ParserForLanguage} contained only values
+ * of type `ParserImplementation & {synchronous: true}` (and also considering
+ * the emptiness of `moduleTransforms`); may only be worth the effort if it was
+ * causing issues in practice.
+ *
+ * @param {MakeMapParsersOptions} options
+ * @returns {MapParsersFn}
+ */
+export const makeMapParsers = ({
+  parserForLanguage,
+  moduleTransforms,
+  syncModuleTransforms,
+}) => {
+  /**
+   * Async `mapParsers()` function; returned when a non-synchronous parser is
+   * present _or_ when `moduleTransforms` is non-empty.
+   *
+   * @type {MapParsersFn<ParseFnAsync>}
+   */
+  const asyncParseFn = (languageForExtension, languageForModuleSpecifier) =>
+    mapParsers(
+      languageForExtension,
+      languageForModuleSpecifier,
+      parserForLanguage,
+      moduleTransforms,
+      syncModuleTransforms,
+    );
+
+  if (moduleTransforms && keys(moduleTransforms).length > 0) {
+    return asyncParseFn;
+  }
+
+  // all parsers must explicitly be flagged `synchronous` to return a
+  // `MapParsersFn<ParseFn>`
+  if (values(parserForLanguage).some(({ synchronous }) => !synchronous)) {
+    return asyncParseFn;
+  }
+
+  /**
+   * Synchronous `mapParsers()` function; returned when all parsers are
+   * synchronous and `moduleTransforms` is empty.
+   *
+   * @type {MapParsersFn<ParseFn>}
+   */
+  return (languageForExtension, languageForModuleSpecifier) =>
+    mapParsers(
+      languageForExtension,
+      languageForModuleSpecifier,
+      parserForLanguage,
+      moduleTransforms,
+      syncModuleTransforms,
+      true,
+    );
+};

package/src/node-modules.d.ts

@@ -1,8 +1,4 @@
-export function compartmentMapForNodeModules(readPowers: ReadFn | ReadPowers | MaybeReadPowers, packageLocation: string, conditions: Set<string>, packageDescriptor: object, moduleSpecifier: string, options?: {
-    dev?: boolean | undefined;
-    commonDependencies?: object;
-    policy?: object;
-} | undefined): Promise<CompartmentMapDescriptor>;
+export function compartmentMapForNodeModules(readPowers: ReadFn | ReadPowers | MaybeReadPowers, packageLocation: string, conditions: Set<string>, packageDescriptor: object, moduleSpecifier: string, options?: CompartmentMapForNodeModulesOptions | undefined): Promise<CompartmentMapDescriptor>;
 export function mapNodeModules(readPowers: ReadFn | ReadPowers | MaybeReadPowers, moduleLocation: string, options?: {
     tags?: Set<string> | undefined;
     conditions?: Set<string> | undefined;
@@ -49,6 +45,7 @@ export type ReadDescriptorFn = (packageLocation: string) => Promise<object>;
 import type { ReadFn } from './types.js';
 import type { ReadPowers } from './types.js';
 import type { MaybeReadPowers } from './types.js';
+import type { CompartmentMapForNodeModulesOptions } from './types.js';
 import type { CompartmentMapDescriptor } from './types.js';
 import type { LanguageForExtension } from './types.js';
 import type { Language } from './types.js';

package/src/node-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-modules.d.ts","sourceRoot":"","sources":["node-modules.js"],"names":[],"mappings":"AAivBO,yDAXI,MAAM,GAAG,UAAU,GAAG,eAAe,mBACrC,MAAM,cACN,GAAG,CAAC,MAAM,CAAC,qBACX,MAAM,mBACN,MAAM;;yBAGN,MAAM;aACN,MAAM;gBACJ,OAAO,CAAC,wBAAwB,CAAC,CA+C7C;AAaM,2CAVI,MAAM,GAAG,UAAU,GAAG,eAAe,kBACrC,MAAM;;;;yBAKN,MAAM;aACN,MAAM;gBACJ,OAAO,CAAC,wBAAwB,CAAC,CAmC7C;;;;;;;oBA5yBY,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC;;WAKnB,MAAM;UACN,MAAM;UACN,KAAK,CAAC,MAAM,CAAC;iBACb,KAAK,CAAC,MAAM,CAAC;qBACb,OAAO;qBACP,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;qBACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;yBACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;aAEtB,oBAAoB;;;;;WAEpB,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;;0CAKzB,MAAM,CAAC,MAAM,EAAE;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC;iDA+E/C,MAAM,KACJ,OAAO,CAAC,MAAM,CAAC;4BAhHF,YAAY;gCACR,YAAY;qCAHP,YAAY;8CAJH,YAAY;0CAEhB,YAAY;8BADxB,YAAY"}
+{"version":3,"file":"node-modules.d.ts","sourceRoot":"","sources":["node-modules.js"],"names":[],"mappings":"AAwvBO,yDARI,MAAM,GAAG,UAAU,GAAG,eAAe,mBACrC,MAAM,cACN,GAAG,CAAC,MAAM,CAAC,qBACX,MAAM,mBACN,MAAM,8DAEJ,OAAO,CAAC,wBAAwB,CAAC,CA+C7C;AAaM,2CAVI,MAAM,GAAG,UAAU,GAAG,eAAe,kBACrC,MAAM;;;;yBAKN,MAAM;aACN,MAAM;gBACJ,OAAO,CAAC,wBAAwB,CAAC,CAmC7C;;;;;;;oBAjzBY,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC;;WAKnB,MAAM;UACN,MAAM;UACN,KAAK,CAAC,MAAM,CAAC;iBACb,KAAK,CAAC,MAAM,CAAC;qBACb,OAAO;qBACP,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;qBACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;yBACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;aAEtB,oBAAoB;;;;;WAEpB,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;;0CAKzB,MAAM,CAAC,MAAM,EAAE;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC;iDA+E/C,MAAM,KACJ,OAAO,CAAC,MAAM,CAAC;4BAhHF,YAAY;gCACR,YAAY;qCAHP,YAAY;yDAPQ,YAAY;8CAGvB,YAAY;0CAEhB,YAAY;8BADxB,YAAY"}