@agoric/internal 0.4.0 → 0.4.1-upgrade-23-dev-bd79330.0.bd79330

package/src/types.js

@@ -0,0 +1,173 @@
+/* eslint-disable max-classes-per-file */
+                                                                
+                                                                   
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- used in JSDoc
+                                                                          
+                                               
+
+/**
+ * A mapping of a tuple type (as from `Parameters<...>`) into a corresponding
+ * object type with named fields.
+ *
+ * @example
+ * ```
+ * RecordFromTuple<[string, bigint], ['denom', 'amount']>
+ * //=> { denom: string, amount: bigint }
+ * ```
+ */
+                            
+                                   
+                                                                      
+                                                                       
+
+/**
+ * A map corresponding with a total function such that `get(key)` is assumed to
+ * always succeed.
+ */
+                                                       
+                                                                               
+                     
+  
+                                                   
+                                                           
+
+/**
+ * A permit is either `true` or a string (both meaning no attenuation, with a
+ * string serving as a grouping label for convenience and/or diagram
+ * generation), or an object whose keys identify child properties and whose
+ * corresponding values are theirselves (recursive) Permits.
+ */
+                       
+        
+          
+                                                                         
+
+                                                                 
+     
+                                       
+                                   
+                                  
+                 
+                
+     
+      
+
+                                                                  
+                   
+
+                     
+
+                                  
+
+                          
+
+                         
+ 
+
+                                  
+                                        
+                       
+                       
+
+                      
+ 
+
+/**
+ * Returns a boolean for whether the given type is a primitive value or
+ * primitive type.
+ *
+ * @example
+ * ```
+ * IsPrimitive<'string'>
+ * //=> true
+ *
+ * IsPrimitive<string>
+ * //=> true
+ *
+ * IsPrimitive<Object>
+ * //=> false
+ */
+                                                                    
+
+// XXX https://github.com/endojs/endo/issues/2979
+                                                      
+        
+                                      
+          
+            
+
+/** Recursively extract the non-callable properties of T */
+                         
+                             
+       
+                        
+             
+                                                                                
+
+/**
+ * A type that doesn't assume its parameter is local, but is satisfied with both
+ * local and remote references. It accepts both near and marshalled references
+ * that were returned from `Remotable` or `Far`.
+ */
+                                                        
+           
+                                   
+
+// TODO: Add type tests for Remote and ERemote.
+/**
+ * A type that accepts either resolved or promised references that may be either
+ * near or marshalled. @see {ERef} and @see {Remote}.
+ */
+                                                               
+                        
+  
+
+/*
+ * Stop-gap until https://github.com/Agoric/agoric-sdk/issues/6160
+ * explictly specify the type that the Pattern will verify through a match.
+ *
+ * TODO move all this pattern typing stuff to @endo/patterns
+ *
+ * CAVEAT: We use a constant string here to avoid exposing a `unique symbol`
+ * type publicly, such as with:
+ *
+ * @example
+ *   declare const mySymbol: unique symbol;
+ *
+ * Without this workaround, we've observed errors when using at least
+ * `typescript@5.9.3`'s `tsc` to generate declaration files (.d.ts) for
+ * consumers of modules that in turn import the declaration:
+ *
+ * @example
+ *   error TS9006: Declaration emit for this file requires using private name
+ *   'tag' from module '.../internal/src/tagged"'. An explicit
+ *   type annotation may unblock declaration emit.
+ */
+// declare const validatedType: unique symbol;
+                                                     
+
+/**
+ * Tag a pattern with the static type it represents.
+ */
+                                                                
+
+                                                               
+                                               
+
+// TODO make Endo's mustMatch do this
+/**
+ * Returning normally indicates success. Match failure is indicated by
+ * throwing.
+ *
+ * Note: remotables can only be matched as "remotable", not the specific kind.
+ *
+ * @see {endoMustMatch} for the implementation. This one has a type annotation to narrow if the pattern is a TypedPattern.
+ */
+                                                    
+                    
+             
+                          
+                                                                                
+
+                                              

package/src/upgrade-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upgrade-api.d.ts","sourceRoot":"","sources":["upgrade-api.js"],"names":[],"mappings":";;;;;AAgCO,yDAJI,MAAM,uBACN,MAAM,GACJ,oBAAoB,CAO7B;AASG,+CALI,GAAG,GAGD,MAAM,IAAI,oBAAoB,CAKC;AAgBrC,yCAHI,GAAG,GACD,MAAM,IAAI,KAAK,CAQS;;;;;mCA5DxB;IACR,IAAI,EAAE,aAAa,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B"}
+{"version":3,"file":"upgrade-api.d.ts","sourceRoot":"","sources":["upgrade-api.js"],"names":[],"mappings":";;;;;AA+BO,yDAJI,MAAM,uBACN,MAAM,GACJ,oBAAoB,CAO7B;AASG,+CALI,GAAG,GAGD,MAAM,IAAI,oBAAoB,CAMC;AAgBrC,yCAHI,GAAG,GACD,MAAM,IAAI,KAAK,CASS;;;;;mCA9DxB;IACR,IAAI,EAAE,aAAa,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B"}

package/src/upgrade-api.js

@@ -1,5 +1,4 @@
 // @ts-check
-// @jessie-check
 
 import { M, matches } from '@endo/patterns';
 
@@ -45,7 +44,8 @@ harden(makeUpgradeDisconnection);
  * @returns {reason is UpgradeDisconnection}
  */
 export const isUpgradeDisconnection = reason =>
-  reason != null && // eslint-disable-line eqeqeq
+  reason !== null &&
+  reason !== undefined &&
   isFrozen(reason) &&
   matches(reason, UpgradeDisconnectionShape);
 harden(isUpgradeDisconnection);
@@ -64,7 +64,8 @@ harden(isUpgradeDisconnection);
  * @returns {reason is Error}
  */
 export const isAbandonedError = reason =>
-  reason != null && // eslint-disable-line eqeqeq
+  reason !== null &&
+  reason !== undefined &&
   isFrozen(reason) &&
   matches(reason, M.error()) &&
   // We're not using a constant here since this special value is already

package/src/work-pool.d.ts

@@ -0,0 +1,13 @@
+export function makeWorkPool<T, U = T, M extends "all" | "allSettled" = "all">(source: AsyncIterable<T> | Iterable<T>, config: undefined | [capacity: number][0] | {
+    capacity?: number;
+    mode?: M;
+}, processInput?: (input: Awaited<T>, index?: number) => Promise<Awaited<U>> | Awaited<U>): AsyncGenerator<[M extends "allSettled" ? PromiseSettledResult<Awaited<U>> : Awaited<U>, number]> & {
+    done: Promise<boolean>;
+    then: () => never;
+};
+export type PromiseKit<T> = {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason: any) => void;
+    promise: Promise<T>;
+};
+//# sourceMappingURL=work-pool.d.ts.map

package/src/work-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-pool.d.ts","sourceRoot":"","sources":["work-pool.js"],"names":[],"mappings":"AAgFO,6BAlBM,CAAC,EACA,CAAC,MACsB,CAAC,SAAxB,KAAK,GAAG,YAAa,kBACxB,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,UAC9B,SAAS,GACb,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GACrB;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAA;CAAE,iBAC3B,CACN,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EACjB,KAAK,CAAC,EAAE,MAAM,KACX,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC3B,cAAc,CAC1B,CACM,CAAC,SAAS,YAAY,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC5E,MAAY,CACP,CACF,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,KAAK,CAAA;CAAE,CA0JnD;uBAtNY,CAAC;aAEA,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;YACnC,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI;aACrB,OAAO,CAAC,CAAC,CAAC"}

package/src/work-pool.js

@@ -0,0 +1,233 @@
+// @ts-check
+/**
+ * @file A pure JavaScript async work pool utility that is compatible with but
+ *   not dependent upon a hardened environment.
+ */
+
+const { isInteger } = Number;
+
+const sink = () => {};
+
+/**
+ * @param {unknown} val
+ * @returns {val is bigint | boolean | null | number | string | symbol | undefined}
+ */
+const isPrimitive = val =>
+  !val || (typeof val !== 'object' && typeof val !== 'function');
+
+/**
+ * @template T
+ * @typedef {object} PromiseKit
+ * @property {(value: T | PromiseLike<T>) => void} resolve
+ * @property {(reason: any) => void} reject
+ * @property {Promise<T>} promise
+ */
+
+/**
+ * @template T
+ * @returns {PromiseKit<T>}
+ */
+const makePromiseKit = () => {
+  /** @type {PromiseKit<T>['resolve']} */
+  let resolve;
+  /** @type {PromiseKit<T>['reject']} */
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  // @ts-expect-error TS2454 use before assign
+  return { promise, resolve, reject };
+};
+
+/**
+ * Consume an async iterable with at most `capacity` unsettled results at any
+ * given time, passing each input through `processInput` and providing [result,
+ * index] pairs in settlement order. Source order can be recovered with consumer
+ * code like:
+ *
+ *     const results = [];
+ *     for (const [result, i] of makeWorkPool(...)) results[i] = result;
+ *
+ * or something more sophisticated to eagerly detect complete subsequences
+ * immediately following a previous high-water mark for contiguous results.
+ *
+ * To support cases in which `processInput` is used only for side effects rather
+ * than its return value, the returned AsyncGenerator has a promise-valued
+ * `done` property that fulfills when all input has been processed (to `true` if
+ * the source was exhausted or to `false` if iteration was aborted early),
+ * regardless of how many final iteration results have been consumed:
+ *
+ *     await makeWorkPool(...).done;
+ *
+ * @template T
+ * @template [U=T]
+ * @template {'all' | 'allSettled'} [M='all']
+ * @param {AsyncIterable<T> | Iterable<T>} source
+ * @param {undefined
+ *   | [capacity: number][0]
+ *   | { capacity?: number; mode?: M }} config
+ * @param {(
+ *   input: Awaited<T>,
+ *   index?: number,
+ * ) => Promise<Awaited<U>> | Awaited<U>} [processInput]
+ * @returns {AsyncGenerator<
+ *   [
+ *     M extends 'allSettled' ? PromiseSettledResult<Awaited<U>> : Awaited<U>,
+ *     number,
+ *   ]
+ * > & { done: Promise<boolean>; then: () => never }}
+ */
+export const makeWorkPool = (
+  source,
+  config,
+  processInput = x => /** @type {any} */ (x),
+) => {
+  // Validate arguments.
+  if (isPrimitive(config)) config = { capacity: config, mode: undefined };
+  const { capacity = 10, mode = 'all' } = config;
+  if (!(capacity === Infinity || (isInteger(capacity) && capacity > 0))) {
+    throw RangeError('capacity must be a positive integer');
+  }
+  if (mode !== 'all' && mode !== 'allSettled') {
+    throw RangeError('mode must be "all" or "allSettled"');
+  }
+
+  // Normalize source into an `inputs` iterator.
+  const makeInputs = source[Symbol.asyncIterator] || source[Symbol.iterator];
+  const inputs =
+    /** @type {AsyncIterator<Awaited<T>> | Iterator<Awaited<T>>} */ (
+      Reflect.apply(makeInputs, source, [])
+    );
+  let inputsExhausted = false;
+  let terminated = false;
+  const doneKit = /** @type {PromiseKit<boolean>} */ (makePromiseKit());
+
+  // Concurrently consume up to `capacity` inputs, pushing the result of
+  // processing each into a linked chain of promises before consuming more.
+  let nextIndex = 0;
+  /**
+   * @typedef {object} ResultNode
+   * @property {Promise<ResultNode>} nextP
+   * @property {number} index
+   * @property {M extends 'allSettled'
+   *   ? PromiseSettledResult<Awaited<U>>
+   *   : Awaited<U>} result
+   */
+  const { promise: headP, ...headResolvers } =
+    /** @type {PromiseKit<ResultNode>} */ (makePromiseKit());
+  let { resolve: resolveCurrent, reject } = headResolvers;
+  let inFlight = 0;
+  const takeMoreInput = async () => {
+    await null;
+    while (inFlight < capacity && !inputsExhausted && !terminated) {
+      inFlight += 1;
+      const index = nextIndex;
+      nextIndex += 1;
+      /** @type {Promise<IteratorResult<Awaited<T>>>} */
+      let iterResultP;
+      try {
+        iterResultP = Promise.resolve(inputs.next());
+      } catch (err) {
+        iterResultP = Promise.reject(err);
+      }
+      void iterResultP
+        .then(async iterResult => {
+          if (terminated) return;
+
+          if (iterResult.done) {
+            inFlight -= 1;
+            inputsExhausted = true;
+            void takeMoreInput();
+            return;
+          }
+
+          // Process the input, propagating errors if mode is not "allSettled".
+          await null;
+          /** @type {PromiseSettledResult<Awaited<U>>} */
+          let settlementDesc = { status: 'rejected', reason: undefined };
+          try {
+            const fulfillment = await processInput(iterResult.value, index);
+            if (terminated) return;
+            settlementDesc = { status: 'fulfilled', value: fulfillment };
+          } catch (err) {
+            if (terminated) return;
+            if (mode !== 'allSettled') throw err;
+            /** @type {PromiseRejectedResult} */ (settlementDesc).reason = err;
+          }
+
+          // Fulfill the current tail promise with a record that includes the
+          // source index to which it corresponds and a reference to a new
+          // [unsettled] successor (thereby extending the chain), then try to
+          // consume more input.
+          const { promise: nextP, ...nextResolvers } =
+            /** @type {PromiseKit<ResultNode>} */ (makePromiseKit());
+          // Analogous to `Promise.allSettled`, mode "allSettled" produces
+          // { status, value, reason } PromiseSettledResult records.
+          const result =
+            mode === 'allSettled'
+              ? settlementDesc
+              : /** @type {PromiseFulfilledResult<Awaited<U>>} */ (
+                  settlementDesc
+                ).value;
+          inFlight -= 1;
+          void takeMoreInput();
+          const untypedResult = /** @type {any} */ (result);
+          resolveCurrent({ nextP, index, result: untypedResult });
+          ({ resolve: resolveCurrent, reject } = nextResolvers);
+        })
+        .catch(err => {
+          // End the chain with this rejection.
+          terminated = true;
+          reject(err);
+          doneKit.reject(err);
+          void (async () => inputs.throw?.(err))().catch(sink);
+        });
+    }
+    if (inFlight <= 0 && inputsExhausted) {
+      // @ts-expect-error This dummy signaling record conveys no result.
+      resolveCurrent({ nextP: undefined, index: -1, result: undefined });
+      doneKit.resolve(true);
+    }
+  };
+
+  const results = (async function* generateResults(nextP) {
+    await null;
+    let exhausted = false;
+    try {
+      for (;;) {
+        const { nextP: successor, index, result } = await nextP;
+        nextP = successor;
+        if (!successor) break;
+        yield /** @type {[typeof result, number]} */ (
+          Object.freeze([result, index])
+        );
+      }
+      exhausted = true;
+    } catch (err) {
+      terminated = true;
+      doneKit.reject(err);
+      void (async () => inputs.throw?.(err))().catch(sink);
+      throw err;
+    } finally {
+      const interrupted = !exhausted && !terminated;
+      terminated = true;
+      doneKit.resolve(false);
+      if (interrupted) void (async () => inputs.return?.())().catch(sink);
+    }
+  })(headP);
+  Object.defineProperty(results, 'done', {
+    value: doneKit.promise,
+    enumerable: true,
+  });
+  Object.defineProperty(results, 'then', {
+    value: () => {
+      throw Error('A work pool is not thenable; did you forget `.done`?');
+    },
+  });
+
+  void takeMoreInput();
+
+  // @ts-expect-error
+  return Object.freeze(results);
+};

package/vendor/anylogger.d.ts

@@ -0,0 +1,98 @@
+/**
+ * VENDORED SOURCE - DO NOT EDIT DIRECTLY
+ *
+ * Source of truth for the anylogger vendored module.
+ *
+ * This vendoring flow intentionally keeps three files:
+ * - `vendor/anylogger.ts`: upstream TypeScript source (kept close to upstream).
+ * - `vendor/anylogger.js`: generated runtime for consumers that import JS directly.
+ * - `vendor/anylogger.d.ts`: generated declarations for type imports from that same JS path.
+ *
+ * To regenerate generated artifacts after editing the TypeScript source file (vendor/anylogger.ts):
+ * `cd packages/internal && yarn run -T tsc --project vendor/tsconfig.anylogger.json`
+ */
+/**
+ * A log function is a function that takes a variable amount of
+ * arguments and returns void.
+ */
+export type LogFunction = (...args: any) => void;
+/**
+ * The default base log levels for anylogger.
+ */
+export type LogLevels = {
+    error: 1;
+    warn: 2;
+    info: 3;
+    log: 4;
+    debug: 5;
+    trace: 6;
+};
+/**
+ * A log level is a string that is a key of `LogLevels`.
+ */
+export type LogLevel = keyof LogLevels;
+/**
+ * All loggers, keyed by name.
+ */
+export type AllLoggers = {
+    [name: string]: Logger;
+};
+/**
+ * An alias for the much used concept of a LoggerName.
+ */
+export type LoggerName = string;
+/**
+ * An adapter accepts a LogFunction and returns a Logger.
+ */
+export type Adapter = (logfn: LogFunction) => Logger;
+/**
+ * A logger is a log function that has a `name` that corresponds to the logger
+ * name, a method `enabledFor(level: LogLevel)` to check whether the logger is
+ * enabled for a certain log level, and log methods for each of the log levels
+ * supported by AnyLogger: `error`, `warn`, `info`, `log`, `debug` and `trace`.
+ */
+export type Logger = LogFunction & {
+    readonly name: LoggerName;
+    enabledFor: (level?: LogLevel) => boolean | void;
+} & {
+    [P in keyof LogLevels as `${P}`]: LogFunction;
+};
+/**
+ * Gets or creates a logger by name.
+ */
+export type AnyLogger = ((name: LoggerName) => Logger) & {
+    /**
+     * Stores all loggers created so far.
+     */
+    all: AllLoggers;
+    /**
+     * An object containing a mapping of level names to level values.
+     */
+    levels: {
+        [level: string]: number;
+    };
+    /**
+     * Called when a new logger needs to be created.
+     */
+    new: (name: LoggerName) => LogFunction;
+    /**
+     * Called by the log function that the default implementation of
+     * `anylogger.new` creates.
+     */
+    log: (name: LoggerName, ...args: any) => void;
+    /**
+     * Called when a log function needs to be extended.
+     */
+    ext: Adapter;
+};
+/**
+ * Back-compat alias used by callers in this repository.
+ */
+export type BaseLevels = LogLevels;
+/**
+ *  A  N  Y  L  O  G  G  E  R
+ *  Get a logger. Any logger.
+ */
+declare const anylogger: AnyLogger;
+export default anylogger;
+//# sourceMappingURL=anylogger.d.ts.map

package/vendor/anylogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anylogger.d.ts","sourceRoot":"","sources":["anylogger.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAGH;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,CAAC,CAAC;IACR,IAAI,EAAE,CAAC,CAAC;IACR,GAAG,EAAE,CAAC,CAAC;IACP,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC;AAEvC;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;AAErD;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,WAAW,GAAG;IACjC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,KAAK,OAAO,GAAG,IAAI,CAAC;CAClD,GAAG;KACD,CAAC,IAAI,MAAM,SAAS,IAAI,GAAG,CAAC,EAAE,GAAG,WAAW;CAC9C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CAAC,GAAG;IACvD;;OAEG;IACH,GAAG,EAAE,UAAU,CAAC;IAEhB;;OAEG;IACH,MAAM,EAAE;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAEpC;;OAEG;IACH,GAAG,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,WAAW,CAAC;IAEvC;;;OAGG;IACH,GAAG,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;IAE9C;;OAEG;IACH,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC;AAEnC;;;GAGG;AAGH,QAAA,MAAM,SAAS,EAIkD,SAAS,CAAC;AAyC3E,eAAe,SAAS,CAAC"}

package/vendor/anylogger.js

@@ -0,0 +1,60 @@
+// @ts-nocheck
+/**
+ * VENDORED SOURCE - DO NOT EDIT DIRECTLY
+ *
+ * Source of truth for the anylogger vendored module.
+ *
+ * This vendoring flow intentionally keeps three files:
+ * - `vendor/anylogger.ts`: upstream TypeScript source (kept close to upstream).
+ * - `vendor/anylogger.js`: generated runtime for consumers that import JS directly.
+ * - `vendor/anylogger.d.ts`: generated declarations for type imports from that same JS path.
+ *
+ * To regenerate generated artifacts after editing the TypeScript source file (vendor/anylogger.ts):
+ * `cd packages/internal && yarn run -T tsc --project vendor/tsconfig.anylogger.json`
+ */
+// prettier-ignore-start
+/**
+ *  A  N  Y  L  O  G  G  E  R
+ *  Get a logger. Any logger.
+ */
+// the main `anylogger` function
+const anylogger = ((name) => 
+// return the existing logger, or
+anylogger.all[name] ||
+    // create and store a new logger with that name
+    (anylogger.all[name] = anylogger.ext(anylogger.new(name))));
+// all loggers created so far
+anylogger.all = Object.create(null);
+// the supported levels
+anylogger.levels = { error: 1, warn: 2, info: 3, log: 4, debug: 5, trace: 6 };
+// creates a new named log function
+anylogger.new = name => ({
+    // to assign the function `name`, set it to a named key in an object.
+    // the default implementation calls `anylogger.log`, which should be a
+    // good choice in many cases.
+    [name]: (...args) => anylogger.log(name, ...args),
+})[name]; // return only the function, not the encapsulating object
+// logs with the logger with the given `name`
+anylogger.log = (name, ...args) => {
+    // select the logger to use
+    anylogger.all[name][
+    // select the level to use
+    // if multiple args and first matches a level name
+    args.length > 1 && anylogger.levels[args[0]]
+        ? args.shift() // use the level from the args
+        : 'log' // else use default level `'log'`
+    ](...args); // call method matching level with remaining args
+};
+// extends the given `logger` function
+// the implementation here only adds no-ops
+// adapters should change this behavior
+anylogger.ext = (logger) => {
+    logger.enabledFor = () => { };
+    for (const method in anylogger.levels) {
+        logger[method] = () => { };
+    }
+    return logger;
+};
+// this is a real ESM module
+export default anylogger;
+// prettier-ignore-end