@metamask/utils 8.4.0 → 8.5.0

package/dist/chunk-6C35XQOF.mjs

@@ -1,257 +0,0 @@
-import {
-  assertStruct
-} from "./chunk-74DGVJVE.mjs";
-import {
-  hasProperty
-} from "./chunk-H4YFDLB7.mjs";
-
-// src/json.ts
-import {
-  any,
-  array,
-  boolean,
-  coerce,
-  create,
-  define,
-  integer,
-  is,
-  lazy,
-  literal,
-  nullable,
-  number,
-  object as superstructObject,
-  optional,
-  record,
-  string,
-  union,
-  unknown,
-  Struct
-} from "superstruct";
-var object = (schema) => (
-  // The type is slightly different from a regular object struct, because we
-  // want to make properties with `undefined` in their type optional, but not
-  // `undefined` itself. This means that we need a type cast.
-  superstructObject(schema)
-);
-function hasOptional({ path, branch }) {
-  const field = path[path.length - 1];
-  return hasProperty(branch[branch.length - 2], field);
-}
-function exactOptional(struct) {
-  return new Struct({
-    ...struct,
-    type: `optional ${struct.type}`,
-    validator: (value, context) => !hasOptional(context) || struct.validator(value, context),
-    refiner: (value, context) => !hasOptional(context) || struct.refiner(value, context)
-  });
-}
-var finiteNumber = () => define("finite number", (value) => {
-  return is(value, number()) && Number.isFinite(value);
-});
-var UnsafeJsonStruct = union([
-  literal(null),
-  boolean(),
-  finiteNumber(),
-  string(),
-  array(lazy(() => UnsafeJsonStruct)),
-  record(
-    string(),
-    lazy(() => UnsafeJsonStruct)
-  )
-]);
-var JsonStruct = coerce(UnsafeJsonStruct, any(), (value) => {
-  assertStruct(value, UnsafeJsonStruct);
-  return JSON.parse(
-    JSON.stringify(value, (propKey, propValue) => {
-      if (propKey === "__proto__" || propKey === "constructor") {
-        return void 0;
-      }
-      return propValue;
-    })
-  );
-});
-function isValidJson(value) {
-  try {
-    getSafeJson(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getSafeJson(value) {
-  return create(value, JsonStruct);
-}
-function getJsonSize(value) {
-  assertStruct(value, JsonStruct, "Invalid JSON value");
-  const json = JSON.stringify(value);
-  return new TextEncoder().encode(json).byteLength;
-}
-var jsonrpc2 = "2.0";
-var JsonRpcVersionStruct = literal(jsonrpc2);
-var JsonRpcIdStruct = nullable(union([number(), string()]));
-var JsonRpcErrorStruct = object({
-  code: integer(),
-  message: string(),
-  data: exactOptional(JsonStruct),
-  stack: exactOptional(string())
-});
-var JsonRpcParamsStruct = union([record(string(), JsonStruct), array(JsonStruct)]);
-var JsonRpcRequestStruct = object({
-  id: JsonRpcIdStruct,
-  jsonrpc: JsonRpcVersionStruct,
-  method: string(),
-  params: exactOptional(JsonRpcParamsStruct)
-});
-var JsonRpcNotificationStruct = object({
-  jsonrpc: JsonRpcVersionStruct,
-  method: string(),
-  params: exactOptional(JsonRpcParamsStruct)
-});
-function isJsonRpcNotification(value) {
-  return is(value, JsonRpcNotificationStruct);
-}
-function assertIsJsonRpcNotification(value, ErrorWrapper) {
-  assertStruct(
-    value,
-    JsonRpcNotificationStruct,
-    "Invalid JSON-RPC notification",
-    ErrorWrapper
-  );
-}
-function isJsonRpcRequest(value) {
-  return is(value, JsonRpcRequestStruct);
-}
-function assertIsJsonRpcRequest(value, ErrorWrapper) {
-  assertStruct(
-    value,
-    JsonRpcRequestStruct,
-    "Invalid JSON-RPC request",
-    ErrorWrapper
-  );
-}
-var PendingJsonRpcResponseStruct = superstructObject({
-  id: JsonRpcIdStruct,
-  jsonrpc: JsonRpcVersionStruct,
-  result: optional(unknown()),
-  error: optional(JsonRpcErrorStruct)
-});
-var JsonRpcSuccessStruct = object({
-  id: JsonRpcIdStruct,
-  jsonrpc: JsonRpcVersionStruct,
-  result: JsonStruct
-});
-var JsonRpcFailureStruct = object({
-  id: JsonRpcIdStruct,
-  jsonrpc: JsonRpcVersionStruct,
-  error: JsonRpcErrorStruct
-});
-var JsonRpcResponseStruct = union([
-  JsonRpcSuccessStruct,
-  JsonRpcFailureStruct
-]);
-function isPendingJsonRpcResponse(response) {
-  return is(response, PendingJsonRpcResponseStruct);
-}
-function assertIsPendingJsonRpcResponse(response, ErrorWrapper) {
-  assertStruct(
-    response,
-    PendingJsonRpcResponseStruct,
-    "Invalid pending JSON-RPC response",
-    ErrorWrapper
-  );
-}
-function isJsonRpcResponse(response) {
-  return is(response, JsonRpcResponseStruct);
-}
-function assertIsJsonRpcResponse(value, ErrorWrapper) {
-  assertStruct(
-    value,
-    JsonRpcResponseStruct,
-    "Invalid JSON-RPC response",
-    ErrorWrapper
-  );
-}
-function isJsonRpcSuccess(value) {
-  return is(value, JsonRpcSuccessStruct);
-}
-function assertIsJsonRpcSuccess(value, ErrorWrapper) {
-  assertStruct(
-    value,
-    JsonRpcSuccessStruct,
-    "Invalid JSON-RPC success response",
-    ErrorWrapper
-  );
-}
-function isJsonRpcFailure(value) {
-  return is(value, JsonRpcFailureStruct);
-}
-function assertIsJsonRpcFailure(value, ErrorWrapper) {
-  assertStruct(
-    value,
-    JsonRpcFailureStruct,
-    "Invalid JSON-RPC failure response",
-    ErrorWrapper
-  );
-}
-function isJsonRpcError(value) {
-  return is(value, JsonRpcErrorStruct);
-}
-function assertIsJsonRpcError(value, ErrorWrapper) {
-  assertStruct(
-    value,
-    JsonRpcErrorStruct,
-    "Invalid JSON-RPC error",
-    ErrorWrapper
-  );
-}
-function getJsonRpcIdValidator(options) {
-  const { permitEmptyString, permitFractions, permitNull } = {
-    permitEmptyString: true,
-    permitFractions: false,
-    permitNull: true,
-    ...options
-  };
-  const isValidJsonRpcId = (id) => {
-    return Boolean(
-      typeof id === "number" && (permitFractions || Number.isInteger(id)) || typeof id === "string" && (permitEmptyString || id.length > 0) || permitNull && id === null
-    );
-  };
-  return isValidJsonRpcId;
-}
-
-export {
-  object,
-  exactOptional,
-  UnsafeJsonStruct,
-  JsonStruct,
-  isValidJson,
-  getSafeJson,
-  getJsonSize,
-  jsonrpc2,
-  JsonRpcVersionStruct,
-  JsonRpcIdStruct,
-  JsonRpcErrorStruct,
-  JsonRpcParamsStruct,
-  JsonRpcRequestStruct,
-  JsonRpcNotificationStruct,
-  isJsonRpcNotification,
-  assertIsJsonRpcNotification,
-  isJsonRpcRequest,
-  assertIsJsonRpcRequest,
-  PendingJsonRpcResponseStruct,
-  JsonRpcSuccessStruct,
-  JsonRpcFailureStruct,
-  JsonRpcResponseStruct,
-  isPendingJsonRpcResponse,
-  assertIsPendingJsonRpcResponse,
-  isJsonRpcResponse,
-  assertIsJsonRpcResponse,
-  isJsonRpcSuccess,
-  assertIsJsonRpcSuccess,
-  isJsonRpcFailure,
-  assertIsJsonRpcFailure,
-  isJsonRpcError,
-  assertIsJsonRpcError,
-  getJsonRpcIdValidator
-};
-//# sourceMappingURL=chunk-6C35XQOF.mjs.map

package/dist/chunk-6C35XQOF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/json.ts"],"sourcesContent":["import type { Context, Infer } from 'superstruct';\nimport {\n  any,\n  array,\n  boolean,\n  coerce,\n  create,\n  define,\n  integer,\n  is,\n  lazy,\n  literal,\n  nullable,\n  number,\n  object as superstructObject,\n  optional,\n  record,\n  string,\n  union,\n  unknown,\n  Struct,\n} from 'superstruct';\nimport type {\n  ObjectSchema,\n  Optionalize,\n  Simplify,\n} from 'superstruct/dist/utils';\n\nimport type { AssertionErrorConstructor } from './assert';\nimport { assertStruct } from './assert';\nimport { hasProperty } from './misc';\n\n/**\n * Any JSON-compatible value.\n */\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [prop: string]: Json };\n\n/**\n * A helper type to make properties with `undefined` in their type optional, but\n * not `undefined` itself.\n *\n * @example\n * ```ts\n * type Foo = ObjectOptional<{ foo: string | undefined }>;\n * // Foo is equivalent to { foo?: string }\n * ```\n */\nexport type ObjectOptional<Schema extends Record<string, unknown>> = {\n  [Key in keyof Schema as Schema[Key] extends ExactOptionalGuard\n    ? Key\n    : never]?: Schema[Key] extends ExactOptionalGuard & infer Original\n    ? Original\n    : never;\n} & {\n  [Key in keyof Schema as Schema[Key] extends ExactOptionalGuard\n    ? never\n    : Key]: Schema[Key];\n};\n\n/**\n * An object type with support for exact optionals. This is used by the `object`\n * struct. This uses the {@link ObjectOptional} helper to make properties with\n * `undefined` in their type optional, but not `undefined` itself.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ObjectOptional<\n    Optionalize<{\n      [Key in keyof Schema]: Infer<Schema[Key]>;\n    }>\n  >\n>;\n\n/**\n * A struct to check if the given value is a valid object, with support for\n * {@link exactOptional} types.\n *\n * @param schema - The schema of the object.\n * @returns A struct to check if the given value is an object.\n */\nexport const object = <Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>> =>\n  // The type is slightly different from a regular object struct, because we\n  // want to make properties with `undefined` in their type optional, but not\n  // `undefined` itself. This means that we need a type cast.\n  superstructObject(schema) as unknown as Struct<ObjectType<Schema>>;\n\ndeclare const exactOptionalSymbol: unique symbol;\ntype ExactOptionalGuard = {\n  _exactOptionalGuard?: typeof exactOptionalSymbol;\n};\n\n/**\n * Check the last field of a path is present.\n *\n * @param context - The context to check.\n * @param context.path - The path to check.\n * @param context.branch - The branch to check.\n * @returns Whether the last field of a path is present.\n */\nfunction hasOptional({ path, branch }: Context): boolean {\n  const field = path[path.length - 1];\n  return hasProperty(branch[branch.length - 2], field);\n}\n\n/**\n * A struct which allows the property of an object to be absent, or to be present\n * as long as it's valid and not set to `undefined`.\n *\n * This struct should be used in conjunction with the {@link object} from this\n * library, to get proper type inference.\n *\n * @param struct - The struct to check the value against, if present.\n * @returns A struct to check if the given value is valid, or not present.\n * @example\n * ```ts\n * const struct = object({\n *   foo: exactOptional(string()),\n *   bar: exactOptional(number()),\n *   baz: optional(boolean()),\n *   qux: unknown(),\n * });\n *\n * type Type = Infer<typeof struct>;\n * // Type is equivalent to:\n * // {\n * //   foo?: string;\n * //   bar?: number;\n * //   baz?: boolean | undefined;\n * //   qux: unknown;\n * // }\n * ```\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type & ExactOptionalGuard, Schema> {\n  return new Struct<Type & ExactOptionalGuard, Schema>({\n    ...struct,\n\n    type: `optional ${struct.type}`,\n    validator: (value, context) =>\n      !hasOptional(context) || struct.validator(value, context),\n\n    refiner: (value, context) =>\n      !hasOptional(context) || struct.refiner(value as Type, context),\n  });\n}\n\n/**\n * A struct to check if the given value is finite number. Superstruct's\n * `number()` struct does not check if the value is finite.\n *\n * @returns A struct to check if the given value is finite number.\n */\nconst finiteNumber = () =>\n  define<number>('finite number', (value) => {\n    return is(value, number()) && Number.isFinite(value);\n  });\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * Note that this struct is unsafe. For safe validation, use {@link JsonStruct}.\n */\n// We cannot infer the type of the struct, because it is recursive.\nexport const UnsafeJsonStruct: Struct<Json> = union([\n  literal(null),\n  boolean(),\n  finiteNumber(),\n  string(),\n  array(lazy(() => UnsafeJsonStruct)),\n  record(\n    string(),\n    lazy(() => UnsafeJsonStruct),\n  ),\n]);\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * This struct sanitizes the value before validating it, so that it is safe to\n * use with untrusted input.\n */\nexport const JsonStruct = coerce(UnsafeJsonStruct, any(), (value) => {\n  assertStruct(value, UnsafeJsonStruct);\n  return JSON.parse(\n    JSON.stringify(value, (propKey, propValue) => {\n      // Strip __proto__ and constructor properties to prevent prototype pollution.\n      if (propKey === '__proto__' || propKey === 'constructor') {\n        return undefined;\n      }\n      return propValue;\n    }),\n  );\n});\n\n/**\n * Check if the given value is a valid {@link Json} value, i.e., a value that is\n * serializable to JSON.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link Json} value.\n */\nexport function isValidJson(value: unknown): value is Json {\n  try {\n    getSafeJson(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate and return sanitized JSON.\n *\n * Note:\n * This function uses sanitized JsonStruct for validation\n * that applies stringify and then parse of a value provided\n * to ensure that there are no getters which can have side effects\n * that can cause security issues.\n *\n * @param value - JSON structure to be processed.\n * @returns Sanitized JSON structure.\n */\nexport function getSafeJson<Type extends Json = Json>(value: unknown): Type {\n  return create(value, JsonStruct) as Type;\n}\n\n/**\n * Get the size of a JSON value in bytes. This also validates the value.\n *\n * @param value - The JSON value to get the size of.\n * @returns The size of the JSON value in bytes.\n */\nexport function getJsonSize(value: unknown): number {\n  assertStruct(value, JsonStruct, 'Invalid JSON value');\n\n  const json = JSON.stringify(value);\n  return new TextEncoder().encode(json).byteLength;\n}\n\n/**\n * The string '2.0'.\n */\nexport const jsonrpc2 = '2.0' as const;\nexport const JsonRpcVersionStruct = literal(jsonrpc2);\n\n/**\n * A String specifying the version of the JSON-RPC protocol.\n * MUST be exactly \"2.0\".\n */\nexport type JsonRpcVersion2 = typeof jsonrpc2;\n\nexport const JsonRpcIdStruct = nullable(union([number(), string()]));\n\n/**\n * An identifier established by the Client that MUST contain a String, Number,\n * or NULL value if included. If it is not included it is assumed to be a\n * notification. The value SHOULD normally not be Null and Numbers SHOULD\n * NOT contain fractional parts.\n */\nexport type JsonRpcId = Infer<typeof JsonRpcIdStruct>;\n\nexport const JsonRpcErrorStruct = object({\n  code: integer(),\n  message: string(),\n  data: exactOptional(JsonStruct),\n  stack: exactOptional(string()),\n});\n\n/**\n * Mark a certain key of a type as optional.\n */\nexport type OptionalField<\n  Type extends Record<string, unknown>,\n  Key extends keyof Type,\n> = Omit<Type, Key> & Partial<Pick<Type, Key>>;\n\n/**\n * A JSON-RPC error object.\n *\n * Note that TypeScript infers `unknown | undefined` as `unknown`, meaning that\n * the `data` field is not optional. To make it optional, we use the\n * `OptionalField` helper, to explicitly make it optional.\n */\nexport type JsonRpcError = OptionalField<\n  Infer<typeof JsonRpcErrorStruct>,\n  'data'\n>;\n\nexport const JsonRpcParamsStruct: Struct<Json[] | Record<string, Json>, null> =\n  union([record(string(), JsonStruct), array(JsonStruct)]);\n\nexport type JsonRpcParams = Json[] | Record<string, Json>;\n\nexport const JsonRpcRequestStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  method: string(),\n  params: exactOptional(JsonRpcParamsStruct),\n});\n\nexport type InferWithParams<\n  Type extends Struct<any>,\n  Params extends JsonRpcParams,\n> = Infer<Type> & {\n  params?: Params;\n};\n\n/**\n * A JSON-RPC request object.\n */\nexport type JsonRpcRequest<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcRequestStruct, Params>;\n\nexport const JsonRpcNotificationStruct = object({\n  jsonrpc: JsonRpcVersionStruct,\n  method: string(),\n  params: exactOptional(JsonRpcParamsStruct),\n});\n\n/**\n * A JSON-RPC notification object.\n */\nexport type JsonRpcNotification<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcNotificationStruct, Params>;\n\n/**\n * Check if the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcNotification}\n * object.\n */\nexport function isJsonRpcNotification(\n  value: unknown,\n): value is JsonRpcNotification {\n  return is(value, JsonRpcNotificationStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcNotification} object.\n */\nexport function assertIsJsonRpcNotification(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcNotification {\n  assertStruct(\n    value,\n    JsonRpcNotificationStruct,\n    'Invalid JSON-RPC notification',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcRequest} object.\n */\nexport function isJsonRpcRequest(value: unknown): value is JsonRpcRequest {\n  return is(value, JsonRpcRequestStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The JSON-RPC request or notification to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcRequest} object.\n */\nexport function assertIsJsonRpcRequest(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcRequest {\n  assertStruct(\n    value,\n    JsonRpcRequestStruct,\n    'Invalid JSON-RPC request',\n    ErrorWrapper,\n  );\n}\n\nexport const PendingJsonRpcResponseStruct = superstructObject({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: optional(unknown()),\n  error: optional(JsonRpcErrorStruct),\n});\n\n/**\n * A JSON-RPC response object that has not yet been resolved.\n */\nexport type PendingJsonRpcResponse<Result extends Json> = Omit<\n  Infer<typeof PendingJsonRpcResponseStruct>,\n  'result'\n> & {\n  result?: Result;\n};\n\nexport const JsonRpcSuccessStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: JsonStruct,\n});\n\n/**\n * A successful JSON-RPC response object.\n */\nexport type JsonRpcSuccess<Result extends Json> = Omit<\n  Infer<typeof JsonRpcSuccessStruct>,\n  'result'\n> & {\n  result: Result;\n};\n\nexport const JsonRpcFailureStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  error: JsonRpcErrorStruct as Struct<JsonRpcError>,\n});\n\n/**\n * A failed JSON-RPC response object.\n */\nexport type JsonRpcFailure = Infer<typeof JsonRpcFailureStruct>;\n\nexport const JsonRpcResponseStruct = union([\n  JsonRpcSuccessStruct,\n  JsonRpcFailureStruct,\n]);\n\n/**\n * A JSON-RPC response object. Must be checked to determine whether it's a\n * success or failure.\n *\n * @template Result - The type of the result.\n */\nexport type JsonRpcResponse<Result extends Json> =\n  | JsonRpcSuccess<Result>\n  | JsonRpcFailure;\n\n/**\n * Type guard to check whether specified JSON-RPC response is a\n * {@link PendingJsonRpcResponse}.\n *\n * @param response - The JSON-RPC response to check.\n * @returns Whether the specified JSON-RPC response is pending.\n */\nexport function isPendingJsonRpcResponse(\n  response: unknown,\n): response is PendingJsonRpcResponse<Json> {\n  return is(response, PendingJsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link PendingJsonRpcResponse} object.\n *\n * @param response - The JSON-RPC response to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link PendingJsonRpcResponse}\n * object.\n */\nexport function assertIsPendingJsonRpcResponse(\n  response: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts response is PendingJsonRpcResponse<Json> {\n  assertStruct(\n    response,\n    PendingJsonRpcResponseStruct,\n    'Invalid pending JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Type guard to check if a value is a {@link JsonRpcResponse}.\n *\n * @param response - The object to check.\n * @returns Whether the object is a JsonRpcResponse.\n */\nexport function isJsonRpcResponse(\n  response: unknown,\n): response is JsonRpcResponse<Json> {\n  return is(response, JsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcResponse} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcResponse} object.\n */\nexport function assertIsJsonRpcResponse(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcResponse<Json> {\n  assertStruct(\n    value,\n    JsonRpcResponseStruct,\n    'Invalid JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcSuccess} object.\n */\nexport function isJsonRpcSuccess(\n  value: unknown,\n): value is JsonRpcSuccess<Json> {\n  return is(value, JsonRpcSuccessStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcSuccess} object.\n */\nexport function assertIsJsonRpcSuccess(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcSuccess<Json> {\n  assertStruct(\n    value,\n    JsonRpcSuccessStruct,\n    'Invalid JSON-RPC success response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcFailure} object.\n */\nexport function isJsonRpcFailure(value: unknown): value is JsonRpcFailure {\n  return is(value, JsonRpcFailureStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcFailure} object.\n */\nexport function assertIsJsonRpcFailure(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcFailure {\n  assertStruct(\n    value,\n    JsonRpcFailureStruct,\n    'Invalid JSON-RPC failure response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcError} object.\n */\nexport function isJsonRpcError(value: unknown): value is JsonRpcError {\n  return is(value, JsonRpcErrorStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcError} object.\n */\nexport function assertIsJsonRpcError(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcError {\n  assertStruct(\n    value,\n    JsonRpcErrorStruct,\n    'Invalid JSON-RPC error',\n    ErrorWrapper,\n  );\n}\n\ntype JsonRpcValidatorOptions = {\n  permitEmptyString?: boolean;\n  permitFractions?: boolean;\n  permitNull?: boolean;\n};\n\n/**\n * Gets a function for validating JSON-RPC request / response `id` values.\n *\n * By manipulating the options of this factory, you can control the behavior\n * of the resulting validator for some edge cases. This is useful because e.g.\n * `null` should sometimes but not always be permitted.\n *\n * Note that the empty string (`''`) is always permitted by the JSON-RPC\n * specification, but that kind of sucks and you may want to forbid it in some\n * instances anyway.\n *\n * For more details, see the\n * [JSON-RPC Specification](https://www.jsonrpc.org/specification).\n *\n * @param options - An options object.\n * @param options.permitEmptyString - Whether the empty string (i.e. `''`)\n * should be treated as a valid ID. Default: `true`\n * @param options.permitFractions - Whether fractional numbers (e.g. `1.2`)\n * should be treated as valid IDs. Default: `false`\n * @param options.permitNull - Whether `null` should be treated as a valid ID.\n * Default: `true`\n * @returns The JSON-RPC ID validator function.\n */\nexport function getJsonRpcIdValidator(options?: JsonRpcValidatorOptions) {\n  const { permitEmptyString, permitFractions, permitNull } = {\n    permitEmptyString: true,\n    permitFractions: false,\n    permitNull: true,\n    ...options,\n  };\n\n  /**\n   * Type guard for {@link JsonRpcId}.\n   *\n   * @param id - The JSON-RPC ID value to check.\n   * @returns Whether the given ID is valid per the options given to the\n   * factory.\n   */\n  const isValidJsonRpcId = (id: unknown): id is JsonRpcId => {\n    return Boolean(\n      (typeof id === 'number' && (permitFractions || Number.isInteger(id))) ||\n        (typeof id === 'string' && (permitEmptyString || id.length > 0)) ||\n        (permitNull && id === null),\n    );\n  };\n\n  return isValidJsonRpcId;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-6NZW4WK4.js

@@ -1,35 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunk6ZDHSOUVjs = require('./chunk-6ZDHSOUV.js');
-
-// src/base64.ts
-var _superstruct = require('superstruct');
-var base64 = (struct, options = {}) => {
-  const paddingRequired = _nullishCoalesce(options.paddingRequired, () => ( false));
-  const characterSet = _nullishCoalesce(options.characterSet, () => ( "base64"));
-  let letters;
-  if (characterSet === "base64") {
-    letters = String.raw`[A-Za-z0-9+\/]`;
-  } else {
-    _chunk6ZDHSOUVjs.assert.call(void 0, characterSet === "base64url");
-    letters = String.raw`[-_A-Za-z0-9]`;
-  }
-  let re;
-  if (paddingRequired) {
-    re = new RegExp(
-      `^(?:${letters}{4})*(?:${letters}{3}=|${letters}{2}==)?$`,
-      "u"
-    );
-  } else {
-    re = new RegExp(
-      `^(?:${letters}{4})*(?:${letters}{2,3}|${letters}{3}=|${letters}{2}==)?$`,
-      "u"
-    );
-  }
-  return _superstruct.pattern.call(void 0, struct, re);
-};
-
-
-
-exports.base64 = base64;
-//# sourceMappingURL=chunk-6NZW4WK4.js.map

package/dist/chunk-6NZW4WK4.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/base64.ts"],"names":[],"mappings":";;;;;AACA,SAAS,eAAe;AA4BjB,IAAM,SAAS,CACpB,QACA,UAAyB,CAAC,MACvB;AACH,QAAM,kBAAkB,QAAQ,mBAAmB;AACnD,QAAM,eAAe,QAAQ,gBAAgB;AAE7C,MAAI;AACJ,MAAI,iBAAiB,UAAU;AAC7B,cAAU,OAAO;AAAA,EACnB,OAAO;AACL,WAAO,iBAAiB,WAAW;AACnC,cAAU,OAAO;AAAA,EACnB;AAEA,MAAI;AACJ,MAAI,iBAAiB;AACnB,SAAK,IAAI;AAAA,MACP,OAAO,OAAO,WAAW,OAAO,QAAQ,OAAO;AAAA,MAC/C;AAAA,IACF;AAAA,EACF,OAAO;AACL,SAAK,IAAI;AAAA,MACP,OAAO,OAAO,WAAW,OAAO,SAAS,OAAO,QAAQ,OAAO;AAAA,MAC/D;AAAA,IACF;AAAA,EACF;AAEA,SAAO,QAAQ,QAAQ,EAAE;AAC3B","sourcesContent":["import type { Struct } from 'superstruct';\nimport { pattern } from 'superstruct';\n\nimport { assert } from './assert';\n\nexport type Base64Options = {\n  /**\n   * Is the `=` padding at the end required or not.\n   *\n   * @default false\n   */\n  // Padding is optional in RFC 4648, that's why the default value is false\n  paddingRequired?: boolean;\n  /**\n   * Which character set should be used.\n   * The sets are based on {@link https://datatracker.ietf.org/doc/html/rfc4648 RFC 4648}.\n   *\n   * @default 'base64'\n   */\n  characterSet?: 'base64' | 'base64url';\n};\n\n/**\n * Ensure that a provided string-based struct is valid base64.\n *\n * @param struct - The string based struct.\n * @param options - Optional options to specialize base64 validation. See {@link Base64Options} documentation.\n * @returns A superstruct validating base64.\n */\nexport const base64 = <Type extends string, Schema>(\n  struct: Struct<Type, Schema>,\n  options: Base64Options = {},\n) => {\n  const paddingRequired = options.paddingRequired ?? false;\n  const characterSet = options.characterSet ?? 'base64';\n\n  let letters: string;\n  if (characterSet === 'base64') {\n    letters = String.raw`[A-Za-z0-9+\\/]`;\n  } else {\n    assert(characterSet === 'base64url');\n    letters = String.raw`[-_A-Za-z0-9]`;\n  }\n\n  let re: RegExp;\n  if (paddingRequired) {\n    re = new RegExp(\n      `^(?:${letters}{4})*(?:${letters}{3}=|${letters}{2}==)?$`,\n      'u',\n    );\n  } else {\n    re = new RegExp(\n      `^(?:${letters}{4})*(?:${letters}{2,3}|${letters}{3}=|${letters}{2}==)?$`,\n      'u',\n    );\n  }\n\n  return pattern(struct, re);\n};\n"]}

package/dist/chunk-6ZDHSOUV.js

@@ -1,59 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-var _chunkIZC266HSjs = require('./chunk-IZC266HS.js');
-
-// src/assert.ts
-var _superstruct = require('superstruct');
-function isConstructable(fn) {
-  return Boolean(typeof _optionalChain([fn, 'optionalAccess', _ => _.prototype, 'optionalAccess', _2 => _2.constructor, 'optionalAccess', _3 => _3.name]) === "string");
-}
-function getErrorMessageWithoutTrailingPeriod(error) {
-  return _chunkIZC266HSjs.getErrorMessage.call(void 0, error).replace(/\.$/u, "");
-}
-function getError(ErrorWrapper, message) {
-  if (isConstructable(ErrorWrapper)) {
-    return new ErrorWrapper({
-      message
-    });
-  }
-  return ErrorWrapper({
-    message
-  });
-}
-var AssertionError = class extends Error {
-  constructor(options) {
-    super(options.message);
-    this.code = "ERR_ASSERTION";
-  }
-};
-function assert(value, message = "Assertion failed.", ErrorWrapper = AssertionError) {
-  if (!value) {
-    if (message instanceof Error) {
-      throw message;
-    }
-    throw getError(ErrorWrapper, message);
-  }
-}
-function assertStruct(value, struct, errorPrefix = "Assertion failed", ErrorWrapper = AssertionError) {
-  try {
-    _superstruct.assert.call(void 0, value, struct);
-  } catch (error) {
-    throw getError(
-      ErrorWrapper,
-      `${errorPrefix}: ${getErrorMessageWithoutTrailingPeriod(error)}.`
-    );
-  }
-}
-function assertExhaustive(_object) {
-  throw new Error(
-    "Invalid branch reached. Should be detected during compilation."
-  );
-}
-
-
-
-
-
-
-exports.AssertionError = AssertionError; exports.assert = assert; exports.assertStruct = assertStruct; exports.assertExhaustive = assertExhaustive;
-//# sourceMappingURL=chunk-6ZDHSOUV.js.map

package/dist/chunk-6ZDHSOUV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/assert.ts"],"names":[],"mappings":";;;;;AACA,SAAS,UAAU,yBAAyB;AAe5C,SAAS,gBACP,IACgD;AAEhD,SAAO,QAAQ,OAAO,IAAI,WAAW,aAAa,SAAS,QAAQ;AACrE;AAYA,SAAS,qCAAqC,OAAwB;AAEpE,SAAO,gBAAgB,KAAK,EAAE,QAAQ,QAAQ,EAAE;AAClD;AAUA,SAAS,SAAS,cAAyC,SAAiB;AAC1E,MAAI,gBAAgB,YAAY,GAAG;AACjC,WAAO,IAAI,aAAa;AAAA,MACtB;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO,aAAa;AAAA,IAClB;AAAA,EACF,CAAC;AACH;AAKO,IAAM,iBAAN,cAA6B,MAAM;AAAA,EAGxC,YAAY,SAA8B;AACxC,UAAM,QAAQ,OAAO;AAHvB,SAAS,OAAO;AAAA,EAIhB;AACF;AAcO,SAAS,OACd,OACA,UAA0B,qBAE1B,eAA0C,gBAC3B;AACf,MAAI,CAAC,OAAO;AACV,QAAI,mBAAmB,OAAO;AAC5B,YAAM;AAAA,IACR;AAEA,UAAM,SAAS,cAAc,OAAO;AAAA,EACtC;AACF;AAaO,SAAS,aACd,OACA,QACA,cAAc,oBAEd,eAA0C,gBACnB;AACvB,MAAI;AACF,sBAAkB,OAAO,MAAM;AAAA,EACjC,SAAS,OAAO;AACd,UAAM;AAAA,MACJ;AAAA,MACA,GAAG,WAAW,KAAK,qCAAqC,KAAK,CAAC;AAAA,IAChE;AAAA,EACF;AACF;AAqBO,SAAS,iBAAiB,SAAuB;AACtD,QAAM,IAAI;AAAA,IACR;AAAA,EACF;AACF","sourcesContent":["import type { Struct } from 'superstruct';\nimport { assert as assertSuperstruct } from 'superstruct';\n\nimport { getErrorMessage } from './errors';\n\nexport type AssertionErrorConstructor =\n  | (new (args: { message: string }) => Error)\n  | ((args: { message: string }) => Error);\n\n/**\n * Check if a value is a constructor, i.e., a function that can be called with\n * the `new` keyword.\n *\n * @param fn - The value to check.\n * @returns `true` if the value is a constructor, or `false` otherwise.\n */\nfunction isConstructable(\n  fn: AssertionErrorConstructor,\n): fn is new (args: { message: string }) => Error {\n  /* istanbul ignore next */\n  return Boolean(typeof fn?.prototype?.constructor?.name === 'string');\n}\n\n/**\n * Attempts to obtain the message from a possible error object. If it is\n * possible to do so, any trailing period will be removed from the message;\n * otherwise an empty string is returned.\n *\n * @param error - The error object to get the message from.\n * @returns The message without any trailing period if `error` is an object\n * with a `message` property; the string version of `error` without any trailing\n * period if it is not `undefined` or `null`; otherwise an empty string.\n */\nfunction getErrorMessageWithoutTrailingPeriod(error: unknown): string {\n  // We'll add our own period.\n  return getErrorMessage(error).replace(/\\.$/u, '');\n}\n\n/**\n * Initialise an {@link AssertionErrorConstructor} error.\n *\n * @param ErrorWrapper - The error class to use.\n * @param message - The error message.\n * @returns The error object.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction getError(ErrorWrapper: AssertionErrorConstructor, message: string) {\n  if (isConstructable(ErrorWrapper)) {\n    return new ErrorWrapper({\n      message,\n    });\n  }\n  return ErrorWrapper({\n    message,\n  });\n}\n\n/**\n * The default error class that is thrown if an assertion fails.\n */\nexport class AssertionError extends Error {\n  readonly code = 'ERR_ASSERTION';\n\n  constructor(options: { message: string }) {\n    super(options.message);\n  }\n}\n\n/**\n * Same as Node.js assert.\n * If the value is falsy, throws an error, does nothing otherwise.\n *\n * @throws {@link AssertionError} If value is falsy.\n * @param value - The test that should be truthy to pass.\n * @param message - Message to be passed to {@link AssertionError} or an\n * {@link Error} instance to throw.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}. If a custom error class is provided for\n * the `message` argument, this argument is ignored.\n */\nexport function assert(\n  value: any,\n  message: string | Error = 'Assertion failed.',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value {\n  if (!value) {\n    if (message instanceof Error) {\n      throw message;\n    }\n\n    throw getError(ErrorWrapper, message);\n  }\n}\n\n/**\n * Assert a value against a Superstruct struct.\n *\n * @param value - The value to validate.\n * @param struct - The struct to validate against.\n * @param errorPrefix - A prefix to add to the error message. Defaults to\n * \"Assertion failed\".\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the value is not valid.\n */\nexport function assertStruct<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  errorPrefix = 'Assertion failed',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value is Type {\n  try {\n    assertSuperstruct(value, struct);\n  } catch (error) {\n    throw getError(\n      ErrorWrapper,\n      `${errorPrefix}: ${getErrorMessageWithoutTrailingPeriod(error)}.`,\n    );\n  }\n}\n\n/**\n * Use in the default case of a switch that you want to be fully exhaustive.\n * Using this function forces the compiler to enforce exhaustivity during\n * compile-time.\n *\n * @example\n * ```\n * const number = 1;\n * switch (number) {\n *   case 0:\n *     ...\n *   case 1:\n *     ...\n *   default:\n *     assertExhaustive(snapPrefix);\n * }\n * ```\n * @param _object - The object on which the switch is being operated.\n */\nexport function assertExhaustive(_object: never): never {\n  throw new Error(\n    'Invalid branch reached. Should be detected during compilation.',\n  );\n}\n"]}

package/dist/chunk-74DGVJVE.mjs

@@ -1,59 +0,0 @@
-import {
-  getErrorMessage
-} from "./chunk-XYGUOY6N.mjs";
-
-// src/assert.ts
-import { assert as assertSuperstruct } from "superstruct";
-function isConstructable(fn) {
-  return Boolean(typeof fn?.prototype?.constructor?.name === "string");
-}
-function getErrorMessageWithoutTrailingPeriod(error) {
-  return getErrorMessage(error).replace(/\.$/u, "");
-}
-function getError(ErrorWrapper, message) {
-  if (isConstructable(ErrorWrapper)) {
-    return new ErrorWrapper({
-      message
-    });
-  }
-  return ErrorWrapper({
-    message
-  });
-}
-var AssertionError = class extends Error {
-  constructor(options) {
-    super(options.message);
-    this.code = "ERR_ASSERTION";
-  }
-};
-function assert(value, message = "Assertion failed.", ErrorWrapper = AssertionError) {
-  if (!value) {
-    if (message instanceof Error) {
-      throw message;
-    }
-    throw getError(ErrorWrapper, message);
-  }
-}
-function assertStruct(value, struct, errorPrefix = "Assertion failed", ErrorWrapper = AssertionError) {
-  try {
-    assertSuperstruct(value, struct);
-  } catch (error) {
-    throw getError(
-      ErrorWrapper,
-      `${errorPrefix}: ${getErrorMessageWithoutTrailingPeriod(error)}.`
-    );
-  }
-}
-function assertExhaustive(_object) {
-  throw new Error(
-    "Invalid branch reached. Should be detected during compilation."
-  );
-}
-
-export {
-  AssertionError,
-  assert,
-  assertStruct,
-  assertExhaustive
-};
-//# sourceMappingURL=chunk-74DGVJVE.mjs.map

package/dist/chunk-74DGVJVE.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/assert.ts"],"sourcesContent":["import type { Struct } from 'superstruct';\nimport { assert as assertSuperstruct } from 'superstruct';\n\nimport { getErrorMessage } from './errors';\n\nexport type AssertionErrorConstructor =\n  | (new (args: { message: string }) => Error)\n  | ((args: { message: string }) => Error);\n\n/**\n * Check if a value is a constructor, i.e., a function that can be called with\n * the `new` keyword.\n *\n * @param fn - The value to check.\n * @returns `true` if the value is a constructor, or `false` otherwise.\n */\nfunction isConstructable(\n  fn: AssertionErrorConstructor,\n): fn is new (args: { message: string }) => Error {\n  /* istanbul ignore next */\n  return Boolean(typeof fn?.prototype?.constructor?.name === 'string');\n}\n\n/**\n * Attempts to obtain the message from a possible error object. If it is\n * possible to do so, any trailing period will be removed from the message;\n * otherwise an empty string is returned.\n *\n * @param error - The error object to get the message from.\n * @returns The message without any trailing period if `error` is an object\n * with a `message` property; the string version of `error` without any trailing\n * period if it is not `undefined` or `null`; otherwise an empty string.\n */\nfunction getErrorMessageWithoutTrailingPeriod(error: unknown): string {\n  // We'll add our own period.\n  return getErrorMessage(error).replace(/\\.$/u, '');\n}\n\n/**\n * Initialise an {@link AssertionErrorConstructor} error.\n *\n * @param ErrorWrapper - The error class to use.\n * @param message - The error message.\n * @returns The error object.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction getError(ErrorWrapper: AssertionErrorConstructor, message: string) {\n  if (isConstructable(ErrorWrapper)) {\n    return new ErrorWrapper({\n      message,\n    });\n  }\n  return ErrorWrapper({\n    message,\n  });\n}\n\n/**\n * The default error class that is thrown if an assertion fails.\n */\nexport class AssertionError extends Error {\n  readonly code = 'ERR_ASSERTION';\n\n  constructor(options: { message: string }) {\n    super(options.message);\n  }\n}\n\n/**\n * Same as Node.js assert.\n * If the value is falsy, throws an error, does nothing otherwise.\n *\n * @throws {@link AssertionError} If value is falsy.\n * @param value - The test that should be truthy to pass.\n * @param message - Message to be passed to {@link AssertionError} or an\n * {@link Error} instance to throw.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}. If a custom error class is provided for\n * the `message` argument, this argument is ignored.\n */\nexport function assert(\n  value: any,\n  message: string | Error = 'Assertion failed.',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value {\n  if (!value) {\n    if (message instanceof Error) {\n      throw message;\n    }\n\n    throw getError(ErrorWrapper, message);\n  }\n}\n\n/**\n * Assert a value against a Superstruct struct.\n *\n * @param value - The value to validate.\n * @param struct - The struct to validate against.\n * @param errorPrefix - A prefix to add to the error message. Defaults to\n * \"Assertion failed\".\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the value is not valid.\n */\nexport function assertStruct<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  errorPrefix = 'Assertion failed',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value is Type {\n  try {\n    assertSuperstruct(value, struct);\n  } catch (error) {\n    throw getError(\n      ErrorWrapper,\n      `${errorPrefix}: ${getErrorMessageWithoutTrailingPeriod(error)}.`,\n    );\n  }\n}\n\n/**\n * Use in the default case of a switch that you want to be fully exhaustive.\n * Using this function forces the compiler to enforce exhaustivity during\n * compile-time.\n *\n * @example\n * ```\n * const number = 1;\n * switch (number) {\n *   case 0:\n *     ...\n *   case 1:\n *     ...\n *   default:\n *     assertExhaustive(snapPrefix);\n * }\n * ```\n * @param _object - The object on which the switch is being operated.\n */\nexport function assertExhaustive(_object: never): never {\n  throw new Error(\n    'Invalid branch reached. Should be detected during compilation.',\n  );\n}\n"],"mappings":";;;;;AACA,SAAS,UAAU,yBAAyB;AAe5C,SAAS,gBACP,IACgD;AAEhD,SAAO,QAAQ,OAAO,IAAI,WAAW,aAAa,SAAS,QAAQ;AACrE;AAYA,SAAS,qCAAqC,OAAwB;AAEpE,SAAO,gBAAgB,KAAK,EAAE,QAAQ,QAAQ,EAAE;AAClD;AAUA,SAAS,SAAS,cAAyC,SAAiB;AAC1E,MAAI,gBAAgB,YAAY,GAAG;AACjC,WAAO,IAAI,aAAa;AAAA,MACtB;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO,aAAa;AAAA,IAClB;AAAA,EACF,CAAC;AACH;AAKO,IAAM,iBAAN,cAA6B,MAAM;AAAA,EAGxC,YAAY,SAA8B;AACxC,UAAM,QAAQ,OAAO;AAHvB,SAAS,OAAO;AAAA,EAIhB;AACF;AAcO,SAAS,OACd,OACA,UAA0B,qBAE1B,eAA0C,gBAC3B;AACf,MAAI,CAAC,OAAO;AACV,QAAI,mBAAmB,OAAO;AAC5B,YAAM;AAAA,IACR;AAEA,UAAM,SAAS,cAAc,OAAO;AAAA,EACtC;AACF;AAaO,SAAS,aACd,OACA,QACA,cAAc,oBAEd,eAA0C,gBACnB;AACvB,MAAI;AACF,sBAAkB,OAAO,MAAM;AAAA,EACjC,SAAS,OAAO;AACd,UAAM;AAAA,MACJ;AAAA,MACA,GAAG,WAAW,KAAK,qCAAqC,KAAK,CAAC;AAAA,IAChE;AAAA,EACF;AACF;AAqBO,SAAS,iBAAiB,SAAuB;AACtD,QAAM,IAAI;AAAA,IACR;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-AY6FDCBT.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-AY6FDCBT.mjs.map

package/dist/chunk-AY6FDCBT.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-C6HGFEYL.js

@@ -1,23 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/promise.ts
-function createDeferredPromise({
-  suppressUnhandledRejection = false
-} = {}) {
-  let resolve;
-  let reject;
-  const promise = new Promise(
-    (innerResolve, innerReject) => {
-      resolve = innerResolve;
-      reject = innerReject;
-    }
-  );
-  if (suppressUnhandledRejection) {
-    promise.catch((_error) => {
-    });
-  }
-  return { promise, resolve, reject };
-}
-
-
-
-exports.createDeferredPromise = createDeferredPromise;
-//# sourceMappingURL=chunk-C6HGFEYL.js.map

package/dist/chunk-C6HGFEYL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/promise.ts"],"names":[],"mappings":";AA0CO,SAAS,sBAAqC;AAAA,EACnD,6BAA6B;AAC/B,IAEI,CAAC,GAA4B;AAC/B,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI;AAAA,IAClB,CACE,cACA,gBACG;AACH,gBAAU;AACV,eAAS;AAAA,IACX;AAAA,EACF;AAEA,MAAI,4BAA4B;AAC9B,YAAQ,MAAM,CAAC,WAAW;AAAA,IAE1B,CAAC;AAAA,EACH;AAGA,SAAO,EAAE,SAAS,SAAS,OAAO;AACpC","sourcesContent":["/**\n * A deferred Promise.\n *\n * A deferred Promise is one that can be resolved or rejected independently of\n * the Promise construction.\n * @template Result - The result type of the Promise.\n */\nexport type DeferredPromise<Result = void> = {\n  /**\n   * The Promise that has been deferred.\n   */\n  promise: Promise<Result>;\n  /**\n   * A function that resolves the Promise.\n   */\n  resolve: (result: Result) => void;\n  /**\n   * A function that rejects the Promise.\n   */\n  reject: (error: unknown) => void;\n};\n\n/**\n * Create a defered Promise.\n *\n * If the Promise is rejected prior to a handler being added, this can result in an\n * `UnhandledPromiseRejection` error. Optionally this can be suppressed with the\n * `suppressUnhandledRejection` flag, as it's common to belatedly handle deferred Promises, or to\n * ignore them if they're no longer relevant (e.g. related to a cancelled request).\n *\n * However, be very careful that you have handled the Promise if you do this. Suppressing these\n * errors is dangerous, they exist for good reason. An unhandled rejection can hide errors, making\n * debugging extremely difficult. They should only be suppressed if you're confident that the\n * Promise is always handled correctly, in both the success and failure cases.\n *\n * @param args - The arguments.\n * @param args.suppressUnhandledRejection - This option adds an empty error handler\n * to the Promise to suppress the UnhandledPromiseRejection error. This can be\n * useful if the deferred Promise is sometimes intentionally not used.\n * @returns A deferred Promise.\n * @template Result - The result type of the Promise.\n */\nexport function createDeferredPromise<Result = void>({\n  suppressUnhandledRejection = false,\n}: {\n  suppressUnhandledRejection?: boolean;\n} = {}): DeferredPromise<Result> {\n  let resolve: DeferredPromise<Result>['resolve'];\n  let reject: DeferredPromise<Result>['reject'];\n  const promise = new Promise<Result>(\n    (\n      innerResolve: DeferredPromise<Result>['resolve'],\n      innerReject: DeferredPromise<Result>['reject'],\n    ) => {\n      resolve = innerResolve;\n      reject = innerReject;\n    },\n  );\n\n  if (suppressUnhandledRejection) {\n    promise.catch((_error) => {\n      // This handler is used to suppress the UnhandledPromiseRejection error\n    });\n  }\n\n  // @ts-expect-error We know that these are assigned, but TypeScript doesn't\n  return { promise, resolve, reject };\n}\n"]}

package/dist/chunk-DHVKFDHQ.js

@@ -1,95 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-var _chunkQEPVHEP7js = require('./chunk-QEPVHEP7.js');
-
-
-var _chunk6ZDHSOUVjs = require('./chunk-6ZDHSOUV.js');
-
-// src/coercers.ts
-
-
-
-
-
-
-
-
-
-var _superstruct = require('superstruct');
-var NumberLikeStruct = _superstruct.union.call(void 0, [_superstruct.number.call(void 0, ), _superstruct.bigint.call(void 0, ), _superstruct.string.call(void 0, ), _chunkQEPVHEP7js.StrictHexStruct]);
-var NumberCoercer = _superstruct.coerce.call(void 0, _superstruct.number.call(void 0, ), NumberLikeStruct, Number);
-var BigIntCoercer = _superstruct.coerce.call(void 0, _superstruct.bigint.call(void 0, ), NumberLikeStruct, BigInt);
-var BytesLikeStruct = _superstruct.union.call(void 0, [_chunkQEPVHEP7js.StrictHexStruct, _superstruct.instance.call(void 0, Uint8Array)]);
-var BytesCoercer = _superstruct.coerce.call(void 0, 
-  _superstruct.instance.call(void 0, Uint8Array),
-  _superstruct.union.call(void 0, [_chunkQEPVHEP7js.StrictHexStruct]),
-  _chunkQEPVHEP7js.hexToBytes
-);
-var HexCoercer = _superstruct.coerce.call(void 0, _chunkQEPVHEP7js.StrictHexStruct, _superstruct.instance.call(void 0, Uint8Array), _chunkQEPVHEP7js.bytesToHex);
-function createNumber(value) {
-  try {
-    const result = _superstruct.create.call(void 0, value, NumberCoercer);
-    _chunk6ZDHSOUVjs.assert.call(void 0, 
-      Number.isFinite(result),
-      `Expected a number-like value, got "${value}".`
-    );
-    return result;
-  } catch (error) {
-    if (error instanceof _superstruct.StructError) {
-      throw new Error(`Expected a number-like value, got "${value}".`);
-    }
-    throw error;
-  }
-}
-function createBigInt(value) {
-  try {
-    return _superstruct.create.call(void 0, value, BigIntCoercer);
-  } catch (error) {
-    if (error instanceof _superstruct.StructError) {
-      throw new Error(
-        `Expected a number-like value, got "${String(error.value)}".`
-      );
-    }
-    throw error;
-  }
-}
-function createBytes(value) {
-  if (typeof value === "string" && value.toLowerCase() === "0x") {
-    return new Uint8Array();
-  }
-  try {
-    return _superstruct.create.call(void 0, value, BytesCoercer);
-  } catch (error) {
-    if (error instanceof _superstruct.StructError) {
-      throw new Error(
-        `Expected a bytes-like value, got "${String(error.value)}".`
-      );
-    }
-    throw error;
-  }
-}
-function createHex(value) {
-  if (value instanceof Uint8Array && value.length === 0 || typeof value === "string" && value.toLowerCase() === "0x") {
-    return "0x";
-  }
-  try {
-    return _superstruct.create.call(void 0, value, HexCoercer);
-  } catch (error) {
-    if (error instanceof _superstruct.StructError) {
-      throw new Error(
-        `Expected a bytes-like value, got "${String(error.value)}".`
-      );
-    }
-    throw error;
-  }
-}
-
-
-
-
-
-
-exports.createNumber = createNumber; exports.createBigInt = createBigInt; exports.createBytes = createBytes; exports.createHex = createHex;
-//# sourceMappingURL=chunk-DHVKFDHQ.js.map

package/dist/chunk-DHVKFDHQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/coercers.ts"],"names":[],"mappings":";;;;;;;;;;AACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOP,IAAM,mBAAmB,MAAM,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,eAAe,CAAC;AAC9E,IAAM,gBAAgB,OAAO,OAAO,GAAG,kBAAkB,MAAM;AAC/D,IAAM,gBAAgB,OAAO,OAAO,GAAG,kBAAkB,MAAM;AAE/D,IAAM,kBAAkB,MAAM,CAAC,iBAAiB,SAAS,UAAU,CAAC,CAAC;AACrE,IAAM,eAAe;AAAA,EACnB,SAAS,UAAU;AAAA,EACnB,MAAM,CAAC,eAAe,CAAC;AAAA,EACvB;AACF;AAEA,IAAM,aAAa,OAAO,iBAAiB,SAAS,UAAU,GAAG,UAAU;AA8BpE,SAAS,aAAa,OAA2B;AACtD,MAAI;AACF,UAAM,SAAS,OAAO,OAAO,aAAa;AAE1C;AAAA,MACE,OAAO,SAAS,MAAM;AAAA,MACtB,sCAAsC,KAAK;AAAA,IAC7C;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,IAAI,MAAM,sCAAsC,KAAK,IAAI;AAAA,IACjE;AAGA,UAAM;AAAA,EACR;AACF;AAwBO,SAAS,aAAa,OAA2B;AACtD,MAAI;AAGF,WAAO,OAAO,OAAO,aAAa;AAAA,EACpC,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,IAAI;AAAA,QACR,sCAAsC,OAAO,MAAM,KAAK,CAAC;AAAA,MAC3D;AAAA,IACF;AAGA,UAAM;AAAA,EACR;AACF;AAqBO,SAAS,YAAY,OAA8B;AACxD,MAAI,OAAO,UAAU,YAAY,MAAM,YAAY,MAAM,MAAM;AAC7D,WAAO,IAAI,WAAW;AAAA,EACxB;AAEA,MAAI;AACF,WAAO,OAAO,OAAO,YAAY;AAAA,EACnC,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,IAAI;AAAA,QACR,qCAAqC,OAAO,MAAM,KAAK,CAAC;AAAA,MAC1D;AAAA,IACF;AAGA,UAAM;AAAA,EACR;AACF;AAqBO,SAAS,UAAU,OAAuB;AAC/C,MACG,iBAAiB,cAAc,MAAM,WAAW,KAChD,OAAO,UAAU,YAAY,MAAM,YAAY,MAAM,MACtD;AACA,WAAO;AAAA,EACT;AAEA,MAAI;AACF,WAAO,OAAO,OAAO,UAAU;AAAA,EACjC,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,IAAI;AAAA,QACR,qCAAqC,OAAO,MAAM,KAAK,CAAC;AAAA,MAC1D;AAAA,IACF;AAGA,UAAM;AAAA,EACR;AACF","sourcesContent":["import type { Infer } from 'superstruct';\nimport {\n  bigint,\n  coerce,\n  create,\n  instance,\n  number,\n  string,\n  StructError,\n  union,\n} from 'superstruct';\n\nimport { assert } from './assert';\nimport { bytesToHex, hexToBytes } from './bytes';\nimport type { Hex } from './hex';\nimport { StrictHexStruct } from './hex';\n\nconst NumberLikeStruct = union([number(), bigint(), string(), StrictHexStruct]);\nconst NumberCoercer = coerce(number(), NumberLikeStruct, Number);\nconst BigIntCoercer = coerce(bigint(), NumberLikeStruct, BigInt);\n\nconst BytesLikeStruct = union([StrictHexStruct, instance(Uint8Array)]);\nconst BytesCoercer = coerce(\n  instance(Uint8Array),\n  union([StrictHexStruct]),\n  hexToBytes,\n);\n\nconst HexCoercer = coerce(StrictHexStruct, instance(Uint8Array), bytesToHex);\n\nexport type NumberLike = Infer<typeof NumberLikeStruct>;\nexport type BytesLike = Infer<typeof BytesLikeStruct>;\n\n/**\n * Create a number from a number-like value.\n *\n * - If the value is a number, it is returned as-is.\n * - If the value is a `bigint`, it is converted to a number.\n * - If the value is a string, it is interpreted as a decimal number.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is\n * interpreted as a hexadecimal number.\n *\n * This validates that the value is a number-like value, and that the resulting\n * number is not `NaN` or `Infinity`.\n *\n * @example\n * ```typescript\n * const value = createNumber('0x010203');\n * console.log(value); // 66051\n *\n * const otherValue = createNumber(123n);\n * console.log(otherValue); // 123\n * ```\n * @param value - The value to create the number from.\n * @returns The created number.\n * @throws If the value is not a number-like value, or if the resulting number\n * is `NaN` or `Infinity`.\n */\nexport function createNumber(value: NumberLike): number {\n  try {\n    const result = create(value, NumberCoercer);\n\n    assert(\n      Number.isFinite(result),\n      `Expected a number-like value, got \"${value}\".`,\n    );\n\n    return result;\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(`Expected a number-like value, got \"${value}\".`);\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a `bigint` from a number-like value.\n *\n * - If the value is a number, it is converted to a `bigint`.\n * - If the value is a `bigint`, it is returned as-is.\n * - If the value is a string, it is interpreted as a decimal number and\n * converted to a `bigint`.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is\n * interpreted as a hexadecimal number and converted to a `bigint`.\n *\n * @example\n * ```typescript\n * const value = createBigInt('0x010203');\n * console.log(value); // 16909060n\n *\n * const otherValue = createBigInt(123);\n * console.log(otherValue); // 123n\n * ```\n * @param value - The value to create the bigint from.\n * @returns The created bigint.\n * @throws If the value is not a number-like value.\n */\nexport function createBigInt(value: NumberLike): bigint {\n  try {\n    // The `BigInt` constructor throws if the value is not a number-like value.\n    // There is no need to validate the value manually.\n    return create(value, BigIntCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a number-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a byte array from a bytes-like value.\n *\n * - If the value is a byte array, it is returned as-is.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is interpreted\n * as a hexadecimal number and converted to a byte array.\n *\n * @example\n * ```typescript\n * const value = createBytes('0x010203');\n * console.log(value); // Uint8Array [ 1, 2, 3 ]\n *\n * const otherValue = createBytes('0x010203');\n * console.log(otherValue); // Uint8Array [ 1, 2, 3 ]\n * ```\n * @param value - The value to create the byte array from.\n * @returns The created byte array.\n * @throws If the value is not a bytes-like value.\n */\nexport function createBytes(value: BytesLike): Uint8Array {\n  if (typeof value === 'string' && value.toLowerCase() === '0x') {\n    return new Uint8Array();\n  }\n\n  try {\n    return create(value, BytesCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a bytes-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a hexadecimal string from a bytes-like value.\n *\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is returned\n * as-is.\n * - If the value is a `Uint8Array`, it is converted to a hex string.\n *\n * @example\n * ```typescript\n * const value = createHex(new Uint8Array([1, 2, 3]));\n * console.log(value); // '0x010203'\n *\n * const otherValue = createHex('0x010203');\n * console.log(otherValue); // '0x010203'\n * ```\n * @param value - The value to create the hex string from.\n * @returns The created hex string.\n * @throws If the value is not a bytes-like value.\n */\nexport function createHex(value: BytesLike): Hex {\n  if (\n    (value instanceof Uint8Array && value.length === 0) ||\n    (typeof value === 'string' && value.toLowerCase() === '0x')\n  ) {\n    return '0x';\n  }\n\n  try {\n    return create(value, HexCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a bytes-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n"]}