@agoric/internal 0.4.0-upgrade-14-dev-c8f9e7b.0 → 0.4.0-upgrade-16-dev-07b0130.0

package/src/tagged.d.ts

@@ -0,0 +1,155 @@
+/** @file adapted from https://raw.githubusercontent.com/sindresorhus/type-fest/main/source/opaque.d.ts */
+
+declare const tag: unique symbol;
+
+export type TagContainer<Token> = {
+  readonly [tag]: Token;
+};
+
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{
+  [K in Token]: TagMetadata;
+}>;
+
+/**
+Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
+ 
+A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
+ 
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+ 
+A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
+ 
+A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
+  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
+	- `A` contains at least all the tags `B` has;
+	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
+ 
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
+	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
+ 
+@example
+```
+import type {Tagged} from 'type-fest';
+ 
+type AccountNumber = Tagged<number, 'AccountNumber'>;
+type AccountBalance = Tagged<number, 'AccountBalance'>;
+ 
+function createAccountNumber(): AccountNumber {
+	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
+	return 2 as AccountNumber;
+}
+ 
+function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
+	return 4 as AccountBalance;
+}
+ 
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+ 
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
+// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
+getMoneyForAccount(2);
+ 
+// You can also use tagged values like their underlying, untagged type.
+// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
+// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
+const accountNumber = createAccountNumber() + 2;
+```
+ 
+@example
+```
+import type {Tagged} from 'type-fest';
+ 
+// You can apply multiple tags to a type by using `Tagged` repeatedly.
+type Url = Tagged<string, 'URL'>;
+type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
+ 
+// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
+type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
+```
+ 
+@category Type
+ */
+export type Tagged<
+  Type,
+  TagName extends PropertyKey,
+  TagMetadata = never,
+> = Type & Tag<TagName, TagMetadata>;
+
+/**
+Given a type and a tag name, returns the metadata associated with that tag on that type.
+ 
+In the example below, one could use `Tagged<string, 'JSON'>` to represent "a string that is valid JSON". That type might be useful -- for instance, it communicates that the value can be safely passed to `JSON.parse` without it throwing an exception. However, it doesn't indicate what type of value will be produced on parse (which is sometimes known). `JsonOf<T>` solves this; it represents "a string that is valid JSON and that, if parsed, would produce a value of type T". The type T is held in the metadata associated with the `'JSON'` tag.
+ 
+This article explains more about [how tag metadata works and when it can be useful](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
+ 
+@example
+```
+import type {Tagged} from 'type-fest';
+ 
+type JsonOf<T> = Tagged<string, 'JSON', T>;
+ 
+function stringify<T>(it: T) {
+  return JSON.stringify(it) as JsonOf<T>;
+}
+ 
+function parse<T extends JsonOf<unknown>>(it: T) {
+  return JSON.parse(it) as GetTagMetadata<T, 'JSON'>;
+}
+ 
+const x = stringify({ hello: 'world' });
+const parsed = parse(x); // The type of `parsed` is { hello: string }
+```
+ 
+@category Type
+ */
+export type GetTagMetadata<
+  Type extends Tag<TagName, unknown>,
+  TagName extends PropertyKey,
+> = Type[typeof tag][TagName];
+
+/**
+Revert a tagged type back to its original type by removing all tags.
+ 
+Why is this necessary?
+ 
+1. Use a `Tagged` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+ 
+@example
+```
+import type {Tagged, UnwrapTagged} from 'type-fest';
+ 
+type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
+ 
+const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1
+};
+ 
+// Without UnwrapTagged, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+ 
+// Attempting to pass an non-Tagged type to UnwrapTagged will raise a type error.
+type WontWork = UnwrapTagged<string>;
+```
+ 
+@category Type
+ */
+export type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> =
+  RemoveAllTags<TaggedType>;
+
+type RemoveAllTags<T> =
+  T extends Tag<PropertyKey, any>
+    ? {
+        [ThisTag in keyof T[typeof tag]]: T extends Tagged<
+          infer Type,
+          ThisTag,
+          T[typeof tag][ThisTag]
+        >
+          ? RemoveAllTags<Type>
+          : never;
+      }[keyof T[typeof tag]]
+    : T;

package/src/testing-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["testing-utils.js"],"names":[],"mappings":"AAWO,mDACwC"}
+{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["testing-utils.js"],"names":[],"mappings":"AAaO,mDACwC"}

package/src/testing-utils.js

@@ -1,13 +1,15 @@
-/** @file note this cannot be called test-utils.js due to https://github.com/Agoric/agoric-sdk/issues/7503 */
+/**
+ * @file note this cannot be called test-utils.js due to
+ *   https://github.com/Agoric/agoric-sdk/issues/7503
+ */
 /* global setImmediate */
 
 /**
  * A workaround for some issues with fake time in tests.
  *
- * Lines of test code can depend on async promises outside the test
- * resolving before they run. Awaiting this function result ensures
- * that all promises that can do resolve.
- * Note that this doesn't mean all outstanding promises.
+ * Lines of test code can depend on async promises outside the test resolving
+ * before they run. Awaiting this function result ensures that all promises that
+ * can do resolve. Note that this doesn't mean all outstanding promises.
  */
 export const eventLoopIteration = async () =>
   new Promise(resolve => setImmediate(resolve));

package/src/tokens.d.ts

@@ -0,0 +1,34 @@
+export namespace Stable {
+    export let symbol: "IST";
+    export let denom: "uist";
+    export let proposedName: "Agoric stable token";
+    export { NAT as assetKind };
+    export namespace displayInfo {
+        export let decimalPlaces: 6;
+        export { NAT as assetKind };
+    }
+}
+export namespace Stake {
+    let symbol_1: "BLD";
+    export { symbol_1 as symbol };
+    let denom_1: "ubld";
+    export { denom_1 as denom };
+    let proposedName_1: "Agoric staking token";
+    export { proposedName_1 as proposedName };
+    export { NAT as assetKind };
+    export namespace displayInfo_1 {
+        let decimalPlaces_1: 6;
+        export { decimalPlaces_1 as decimalPlaces };
+        export { NAT as assetKind };
+    }
+    export { displayInfo_1 as displayInfo };
+}
+export type TokenKeyword = "IST" | "BLD";
+/** @typedef {'IST' | 'BLD'} TokenKeyword */
+/**
+ * This is defined by ERTP. For dependency pragmatism it's repeated here. We
+ * rely on the static type check and unit tests to detect any incompatibility.
+ */
+declare const NAT: "nat";
+export {};
+//# sourceMappingURL=tokens.d.ts.map

package/src/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["tokens.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;2BAEc,KAAK,GAAG,KAAK;AAA3B,4CAA4C;AAE5C;;;GAGG;AACH,yBAAkB"}

package/src/tokens.js

@@ -0,0 +1,35 @@
+// @ts-check
+
+/** @typedef {'IST' | 'BLD'} TokenKeyword */
+
+/**
+ * This is defined by ERTP. For dependency pragmatism it's repeated here. We
+ * rely on the static type check and unit tests to detect any incompatibility.
+ */
+const NAT = 'nat';
+
+export const Stable = harden(
+  /** @type {const} */ ({
+    symbol: 'IST',
+    denom: 'uist',
+    proposedName: 'Agoric stable token',
+    assetKind: NAT,
+    displayInfo: {
+      decimalPlaces: 6,
+      assetKind: NAT,
+    },
+  }),
+);
+
+export const Stake = harden(
+  /** @type {const} */ ({
+    symbol: 'BLD',
+    denom: 'ubld',
+    proposedName: 'Agoric staking token',
+    assetKind: NAT,
+    displayInfo: {
+      decimalPlaces: 6,
+      assetKind: NAT,
+    },
+  }),
+);

package/src/typeGuards.d.ts

@@ -1,2 +1,4 @@
 export const StorageNodeShape: import("@endo/patterns").Matcher;
+/** To be used only for 'helper' facets where the calls are from trusted code. */
+export const UnguardedHelperI: import("@endo/patterns").InterfaceGuard<any>;
 //# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA,gEAA2D"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA,gEAA2D;AAE3D,iFAAiF;AACjF,4EAKE"}

package/src/typeGuards.js

@@ -3,3 +3,11 @@
 import { M } from '@endo/patterns';
 
 export const StorageNodeShape = M.remotable('StorageNode');
+
+/** To be used only for 'helper' facets where the calls are from trusted code. */
+export const UnguardedHelperI = M.interface(
+  'helper',
+  {},
+  // not exposed so sloppy okay
+  { sloppy: true },
+);

package/src/types.d.ts

@@ -1,4 +1,8 @@
 /* eslint-disable max-classes-per-file */
+import type { ERef, RemotableBrand } from '@endo/eventual-send';
+import type { Primitive } from '@endo/pass-style';
+import type { Callable } from './utils.js';
+
 export declare class Callback<I extends (...args: unknown[]) => any> {
   private iface: I;
 
@@ -18,3 +22,45 @@ export declare class SyncCallback<
 
   public isSync: true;
 }
+
+/**
+Returns a boolean for whether the given type is primitive value or primitive type.
+ 
+@example
+```
+IsPrimitive<'string'>
+//=> true
+ 
+IsPrimitive<string>
+//=> true
+ 
+IsPrimitive<Object>
+//=> false
+```
+ */
+export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
+
+/** Recursively extract the non-callable properties of T */
+export type DataOnly<T> =
+  IsPrimitive<T> extends true
+    ? T
+    : T extends Callable
+      ? never
+      : { [P in keyof T as T[P] extends Callable ? never : P]: DataOnly<T[P]> };
+
+/**
+ * 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`.
+ */
+export type Remote<Primary, Local = DataOnly<Primary>> =
+  | Primary
+  | RemotableBrand<Local, Primary>;
+
+// TODO: Add type tests for FarRef and Remote.
+/**
+ * Potentially remote promises or settled references.
+ */
+export type FarRef<Primary, Local = DataOnly<Primary>> = ERef<
+  Remote<Primary, Local>
+>;

package/src/types.js

@@ -0,0 +1,2 @@
+// Empty JS file to correspond with its .d.ts twin
+export {};

package/src/upgrade-api.d.ts

@@ -1,7 +1,16 @@
-export function makeUpgradeDisconnection(upgradeMessage: string, toIncarnationNumber: number): DisconnectionObject;
-export function isUpgradeDisconnection(err: any): err is DisconnectionObject;
-export type DisconnectionObject = {
-    name: string;
+export namespace UpgradeDisconnectionShape {
+    let name: string;
+    let upgradeMessage: import("@endo/patterns").Matcher;
+    let incarnationNumber: import("@endo/patterns").Matcher;
+}
+export function makeUpgradeDisconnection(upgradeMessage: string, toIncarnationNumber: number): UpgradeDisconnection;
+export function isUpgradeDisconnection(reason: any): reason is UpgradeDisconnection;
+/**
+ * An Error-like object for use as the rejection reason of promises abandoned by
+ * upgrade.
+ */
+export type UpgradeDisconnection = {
+    name: "vatUpgraded";
     upgradeMessage: string;
     incarnationNumber: number;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"upgrade-api.d.ts","sourceRoot":"","sources":["upgrade-api.js"],"names":[],"mappings":"AAgBO,yDAJI,MAAM,uBACN,MAAM,GACJ,mBAAmB,CAO5B;AAcG,4CAHI,GAAG,8BAO6B;kCAlC9B;IAAE,MAAM,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE"}
+{"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,CAGqB;;;;;mCApCnD;IACZ,IAAQ,EAAE,aAAa,CAAC;IACxB,cAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAqB,EAAE,MAAM,CAAC;CAC3B"}

package/src/upgrade-api.js

@@ -1,18 +1,34 @@
 // @ts-check
 // @jessie-check
-import { isObject } from '@endo/marshal';
+
+import { M, matches } from '@endo/patterns';
+
+const { isFrozen } = Object;
 
 /**
- * @typedef {{ name: string, upgradeMessage: string, incarnationNumber: number }} DisconnectionObject
+ * An Error-like object for use as the rejection reason of promises abandoned by
+ * upgrade.
+ *
+ * @typedef {{
+ *   name: 'vatUpgraded';
+ *   upgradeMessage: string;
+ *   incarnationNumber: number;
+ * }} UpgradeDisconnection
  */
 
+export const UpgradeDisconnectionShape = harden({
+  name: 'vatUpgraded',
+  upgradeMessage: M.string(),
+  incarnationNumber: M.number(),
+});
+
 /**
- * Makes an Error-like object for use as the rejection value of promises
+ * Makes an Error-like object for use as the rejection reason of promises
  * abandoned by upgrade.
  *
  * @param {string} upgradeMessage
  * @param {number} toIncarnationNumber
- * @returns {DisconnectionObject}
+ * @returns {UpgradeDisconnection}
  */
 export const makeUpgradeDisconnection = (upgradeMessage, toIncarnationNumber) =>
   harden({
@@ -22,20 +38,12 @@ export const makeUpgradeDisconnection = (upgradeMessage, toIncarnationNumber) =>
   });
 harden(makeUpgradeDisconnection);
 
-// TODO: Simplify once we have @endo/patterns (or just export the shape).
-// const upgradeDisconnectionShape = harden({
-//   name: 'vatUpgraded',
-//   upgradeMessage: M.string(),
-//   incarnationNumber: M.number(),
-// });
-// const isUpgradeDisconnection = err => matches(err, upgradeDisconnectionShape);
 /**
- * @param {any} err
- * @returns {err is DisconnectionObject}
+ * @param {any} reason If `reason` is not frozen, it cannot be an
+ *   UpgradeDisconnection, so returns false without even checking against the
+ *   shape.
+ * @returns {reason is UpgradeDisconnection}
  */
-export const isUpgradeDisconnection = err =>
-  isObject(err) &&
-  err.name === 'vatUpgraded' &&
-  typeof err.upgradeMessage === 'string' &&
-  typeof err.incarnationNumber === 'number';
+export const isUpgradeDisconnection = reason =>
+  isFrozen(reason) && matches(reason, UpgradeDisconnectionShape);
 harden(isUpgradeDisconnection);

package/src/utils.d.ts

@@ -1,67 +1,62 @@
 export const BASIS_POINTS: 10000n;
-export function fromUniqueEntries<K, V>(allEntries: Iterable<[K, V]>): {};
-export function objectMap<O extends Record<string, any>, R>(original: O, mapFn: (value: O[keyof O], key: keyof O) => R): { [P in keyof O]: R; };
-export function listDifference(leftNames: Array<string | symbol>, rightNames: Array<string | symbol>): (string | symbol)[];
-export function throwLabeled(innerErr: Error, label: string | number, ErrorConstructor?: ErrorConstructor | undefined): never;
-export function applyLabelingError<A, R>(func: (...args: A[]) => R, args: A[], label?: string | number | undefined): R;
+/** @import {ERef} from '@endo/far' */
 /**
  * @template T
- * @typedef {{[KeyType in keyof T]: T[KeyType]} & {}} Simplify
- * flatten the type output to improve type hints shown in editors
- * https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
+ * @typedef {{ [KeyType in keyof T]: T[KeyType] } & {}} Simplify flatten the
+ *   type output to improve type hints shown in editors
+ *   https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
  */
 /**
  * @typedef {(...args: any[]) => any} Callable
  */
 /**
  * @template {{}} T
- * @typedef {{ [K in keyof T]: T[K] extends Callable ? T[K] : DeeplyAwaited<T[K]> }} DeeplyAwaitedObject
+ * @typedef {{
+ *   [K in keyof T]: T[K] extends Callable ? T[K] : DeeplyAwaited<T[K]>;
+ * }} DeeplyAwaitedObject
  */
 /**
  * @template T
- * @typedef {T extends PromiseLike<any> ? Awaited<T> : T extends {} ? Simplify<DeeplyAwaitedObject<T>> : Awaited<T>} DeeplyAwaited
+ * @typedef {T extends PromiseLike<any>
+ *     ? Awaited<T>
+ *     : T extends {}
+ *       ? Simplify<DeeplyAwaitedObject<T>>
+ *       : Awaited<T>} DeeplyAwaited
  */
 /**
  * A more constrained version of {deeplyFulfilled} for type safety until
- * https://github.com/endojs/endo/issues/1257
- * Useful in starting contracts that need all terms to be fulfilled
- * in order to be durable.
+ * https://github.com/endojs/endo/issues/1257 Useful in starting contracts that
+ * need all terms to be fulfilled in order to be durable.
  *
  * @type {<T extends {}>(unfulfilledTerms: T) => Promise<DeeplyAwaited<T>>}
  */
 export const deeplyFulfilledObject: <T extends {}>(unfulfilledTerms: T) => Promise<DeeplyAwaited<T>>;
-export function makeMeasureSeconds(currentTimeMillisec: typeof import('perf_hooks').performance.now): <T>(fn: () => Promise<T>) => Promise<{
+export function makeMeasureSeconds(currentTimeMillisec: typeof import("perf_hooks").performance.now): <T>(fn: () => Promise<T>) => Promise<{
     result: T;
     duration: number;
 }>;
-export function makeAggregateError(errors: Error[], message?: string | undefined): Error;
-export function PromiseAllOrErrors<T>(items: readonly (T | PromiseLike<T>)[]): Promise<T[]>;
-/**
- * @type {<T>(
- *   trier: () => Promise<T>,
- *  finalizer: (error?: unknown) => Promise<void>,
- * ) => Promise<T>}
- */ export const aggregateTryFinally: <T>(trier: () => Promise<T>, finalizer: (error?: unknown) => Promise<void>) => Promise<T>;
 export function assertAllDefined<T extends Record<string, unknown>>(obj: T): asserts obj is AllDefined<T>;
 export const forever: AsyncIterable<undefined>;
 export function whileTrue<T>(produce: () => T): AsyncIterable<Awaited<T>>;
 export function untilTrue<T>(produce: () => T): AsyncIterable<Awaited<T>>;
-/** @type { <X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
+/** @type {<X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
 export const zip: <X, Y>(xs: X[], ys: Y[]) => [X, Y][];
-/** @type { <T extends Record<string, ERef<any>>>(obj: T) => Promise<{ [K in keyof T]: Awaited<T[K]>}> } */
-export const allValues: <T extends Record<string, any>>(obj: T) => Promise<{ [K in keyof T]: Awaited<T[K]>; }>;
-export function synchronizedTee<T = unknown>(sourceStream: AsyncIterator<T, void, void>, readerCount: number): AsyncGenerator<T, void, void>[];
 /**
- * <T>
+ * @type {<T extends Record<string, ERef<any>>>(
+ *   obj: T,
+ * ) => Promise<{ [K in keyof T]: Awaited<T[K]> }>}
  */
-export type ERef<T> = import('@endo/eventual-send').ERef<T>;
+export const allValues: <T extends Record<string, ERef<any>>>(obj: T) => Promise<{ [K in keyof T]: Awaited<T[K]>; }>;
+export function synchronizedTee<T = unknown>(sourceStream: AsyncIterator<T, void, void>, readerCount: number): AsyncGenerator<T, void, void>[];
 /**
- * flatten the type output to improve type hints shown in editors
- * https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
+ * flatten the
+ *   type output to improve type hints shown in editors
+ *   https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
  */
-export type Simplify<T> = { [KeyType_1 in keyof T]: T[KeyType_1]; };
+export type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
 export type Callable = (...args: any[]) => any;
 export type DeeplyAwaitedObject<T extends {}> = { [K in keyof T]: T[K] extends Callable ? T[K] : DeeplyAwaited<T[K]>; };
 export type DeeplyAwaited<T> = T extends PromiseLike<any> ? Awaited<T> : T extends {} ? Simplify<DeeplyAwaitedObject<T>> : Awaited<T>;
 export type AllDefined<T extends Record<string, unknown>> = { [P in keyof T]: Exclude<T[P], undefined>; };
+import type { ERef } from '@endo/far';
 //# sourceMappingURL=utils.d.ts.map

package/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAcA,kCAAoC;AAa7B,0EAcN;AA0CM,gJAIN;AAOM,0CAHI,MAAM,MAAM,GAAG,MAAM,CAAC,cACtB,MAAM,MAAM,GAAG,MAAM,CAAC,uBAKhC;AASM,uCALI,KAAK,SACL,MAAM,GAAC,MAAM,oDAEX,KAAK,CAYjB;AAUM,uHAyBN;AAGD;;;;;GAKG;AAEH;;GAEG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;GAOG;AACH,qGAGE;AAUK,wDAHI,cAAc,YAAY,EAAE,WAAW,CAAC,GAAG;;cACmB,MAAM;GAW9E;AAMM,2CAHI,KAAK,EAAE,uCAcjB;AAOM,4FAeN;AAED;;;;;GAKG,CAAC,mFAFoB,OAAO,KAAK,QAAQ,IAAI,CAAC,gBAY7C;AAiBG,0GAUN;AAQD,+CAAoD;AAU7C,0EAUH;AAUG,0EAaH;AAEJ,oDAAoD;AACpD,uDAAqE;AAErE,2GAA2G;AAC3G,+GAIE;AAWK,sGAFI,MAAM,mCA4FhB;;;;sBAlbyB,OAAO,qBAAqB,EAAE,IAAI,CAAC,CAAC,CAAC;;;;;;iCAkJxC,GAAG,EAAE,KAAK,GAAG;;+BAUvB,CAAC,SAAS,YAAY,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,SAAS,oBAAoB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAYA,kCAAoC;AAEpC,sCAAsC;AAEtC;;;;;GAKG;AAEH;;GAEG;AAEH;;;;;GAKG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,oCAFU,CAAC,CAAY,SAAF,EAAE,EAAE,gBAAgB,EAAE,CAAC,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAKxE;AAYK,wDALI,cAAc,YAAY,EAAE,WAAW,CAAC,GAAG,GACzC,CAAC,CAAC,EACd,EAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KACjB,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAW/C;AAgBM,iCALgC,CAAC,SAA1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,OAC3B,CAAC,GACC,QAAQ,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAaxC;AAQD,+CAAoD;AAS7C,0BANM,CAAC,WACH,MAAM,CAAC,GAGL,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAYlC;AASG,0BANM,CAAC,WACH,MAAM,CAAC,GAGL,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAelC;AAEJ,mDAAmD;AACnD,kBADW,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CACsB;AAErE;;;;GAIG;AACH,wBAJU,CAAC,CAAmC,SAAzB,MAAM,CAAC,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,EAC7C,GAAO,EAAE,CAAC,KACH,OAAO,CAAC,GAAG,CAAY,IAAP,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAE,CAAC,CAMhD;AAWK,gCAJO,CAAC,0BACJ,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,eAC5B,MAAM,mCAwGhB;;;;;;qBAnQY,CAAC,IACD,GAAG,OAAkB,IAAP,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAE,GAAG,EAAE;uBAMzC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG;gCAIlB,CAAC,SAAN,EAAI,IACJ,GACP,CAAY,IAAP,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACnE;0BAIS,CAAC,IACD,CAAC,SAAS,WAAW,CAAC,GAAG,CAAC,GAC9B,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,EAAE,GACV,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,GAChC,OAAO,CAAC,CAAC,CAAC;uBAqCkB,CAAC,SAA1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,IACzB,GAAG,CAAY,IAAP,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GAAE;0BAhEjC,WAAW"}