@metamask/snaps-utils 6.1.0 → 7.0.1

package/dist/chunk-GTAYOKI4.mjs

@@ -0,0 +1,211 @@
+import {
+  indent
+} from "./chunk-IV3FSWZ7.mjs";
+
+// src/structs.ts
+import { union } from "@metamask/snaps-sdk";
+import { assert, isObject } from "@metamask/utils";
+import { bold, green, red } from "chalk";
+import {
+  is,
+  validate,
+  type as superstructType,
+  Struct,
+  StructError,
+  create
+} from "superstruct";
+function color(value, colorFunction, enabled) {
+  if (enabled) {
+    return colorFunction(value);
+  }
+  return value;
+}
+function named(name, struct) {
+  return new Struct({
+    ...struct,
+    type: name
+  });
+}
+var SnapsStructError = class extends StructError {
+  constructor(struct, prefix, suffix, failure, failures, colorize = true) {
+    super(failure, failures);
+    this.name = "SnapsStructError";
+    this.message = `${prefix}.
+
+${getStructErrorMessage(
+      struct,
+      [...failures()],
+      colorize
+    )}${suffix ? `
+
+${suffix}` : ""}`;
+  }
+};
+function* arrayToGenerator(array) {
+  for (const item of array) {
+    yield item;
+  }
+}
+function getError({
+  struct,
+  prefix,
+  suffix = "",
+  error,
+  colorize
+}) {
+  return new SnapsStructError(
+    struct,
+    prefix,
+    suffix,
+    error,
+    () => arrayToGenerator(error.failures()),
+    colorize
+  );
+}
+function createFromStruct(value, struct, prefix, suffix = "") {
+  try {
+    return create(value, struct);
+  } catch (error) {
+    if (error instanceof StructError) {
+      throw getError({ struct, prefix, suffix, error });
+    }
+    throw error;
+  }
+}
+function getStructFromPath(struct, path) {
+  return path.reduce((result, key) => {
+    if (isObject(struct.schema) && struct.schema[key]) {
+      return struct.schema[key];
+    }
+    return result;
+  }, struct);
+}
+function getUnionStructNames(struct, colorize = true) {
+  if (Array.isArray(struct.schema)) {
+    return struct.schema.map(({ type }) => color(type, green, colorize));
+  }
+  return null;
+}
+function getStructErrorPrefix(failure, colorize = true) {
+  if (failure.type === "never" || failure.path.length === 0) {
+    return "";
+  }
+  return `At path: ${color(failure.path.join("."), bold, colorize)} \u2014 `;
+}
+function getStructFailureMessage(struct, failure, colorize = true) {
+  const received = color(JSON.stringify(failure.value), red, colorize);
+  const prefix = getStructErrorPrefix(failure, colorize);
+  if (failure.type === "union") {
+    const childStruct = getStructFromPath(struct, failure.path);
+    const unionNames = getUnionStructNames(childStruct, colorize);
+    if (unionNames) {
+      return `${prefix}Expected the value to be one of: ${unionNames.join(
+        ", "
+      )}, but received: ${received}.`;
+    }
+    return `${prefix}${failure.message}.`;
+  }
+  if (failure.type === "literal") {
+    const message = failure.message.replace(
+      /the literal `(.+)`,/u,
+      `the value to be \`${color("$1", green, colorize)}\`,`
+    ).replace(
+      /, but received: (.+)/u,
+      `, but received: ${color("$1", red, colorize)}`
+    );
+    return `${prefix}${message}.`;
+  }
+  if (failure.type === "never") {
+    return `Unknown key: ${color(
+      failure.path.join("."),
+      bold,
+      colorize
+    )}, received: ${received}.`;
+  }
+  if (failure.refinement === "size") {
+    const message = failure.message.replace(
+      /length between `(\d+)` and `(\d+)`/u,
+      `length between ${color("$1", green, colorize)} and ${color(
+        "$2",
+        green,
+        colorize
+      )},`
+    ).replace(/length of `(\d+)`/u, `length of ${color("$1", red, colorize)}`).replace(/a array/u, "an array");
+    return `${prefix}${message}.`;
+  }
+  return `${prefix}Expected a value of type ${color(
+    failure.type,
+    green,
+    colorize
+  )}, but received: ${received}.`;
+}
+function getStructErrorMessage(struct, failures, colorize = true) {
+  const formattedFailures = failures.map(
+    (failure) => indent(`\u2022 ${getStructFailureMessage(struct, failure, colorize)}`)
+  );
+  return formattedFailures.join("\n");
+}
+function validateUnion(value, struct, structKey, coerce = false) {
+  assert(
+    struct.schema,
+    "Expected a struct with a schema. Make sure to use `union` from `@metamask/snaps-sdk`."
+  );
+  assert(struct.schema.length > 0, "Expected a non-empty array of structs.");
+  const keyUnion = struct.schema.map(
+    (innerStruct) => innerStruct.schema[structKey]
+    // This is guaranteed to be a non-empty array by the assertion above. We
+    // need to cast it since `superstruct` requires a non-empty array of structs
+    // for the `union` struct.
+  );
+  const key = superstructType({
+    [structKey]: union(keyUnion)
+  });
+  const [keyError] = validate(value, key, { coerce });
+  if (keyError) {
+    throw new Error(
+      getStructFailureMessage(key, keyError.failures()[0], false)
+    );
+  }
+  const objectValue = value;
+  const objectStructs = struct.schema.filter(
+    (innerStruct) => is(objectValue[structKey], innerStruct.schema[structKey])
+  );
+  assert(objectStructs.length > 0, "Expected a struct to match the value.");
+  const validationResults = objectStructs.map(
+    (objectStruct) => validate(objectValue, objectStruct, { coerce })
+  );
+  const validatedValue = validationResults.find(([error]) => !error);
+  if (validatedValue) {
+    return validatedValue[1];
+  }
+  assert(validationResults[0][0], "Expected at least one error.");
+  const validationError = validationResults.reduce((error, [innerError]) => {
+    assert(innerError, "Expected an error.");
+    if (innerError.failures().length < error.failures().length) {
+      return innerError;
+    }
+    return error;
+  }, validationResults[0][0]);
+  throw new Error(
+    getStructFailureMessage(struct, validationError.failures()[0], false)
+  );
+}
+function createUnion(value, struct, structKey) {
+  return validateUnion(value, struct, structKey, true);
+}
+
+export {
+  named,
+  SnapsStructError,
+  arrayToGenerator,
+  getError,
+  createFromStruct,
+  getStructFromPath,
+  getUnionStructNames,
+  getStructErrorPrefix,
+  getStructFailureMessage,
+  getStructErrorMessage,
+  validateUnion,
+  createUnion
+};
+//# sourceMappingURL=chunk-GTAYOKI4.mjs.map

package/dist/chunk-GTAYOKI4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/structs.ts"],"sourcesContent":["import { union } from '@metamask/snaps-sdk';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assert, isObject } from '@metamask/utils';\nimport { bold, green, red } from 'chalk';\nimport type { Failure } from 'superstruct';\nimport {\n  is,\n  validate,\n  type as superstructType,\n  Struct,\n  StructError,\n  create,\n} from 'superstruct';\nimport type { AnyStruct } from 'superstruct/dist/utils';\n\nimport { indent } from './strings';\n\n/**\n * Infer a struct type, only if it matches the specified type. This is useful\n * for defining types and structs that are related to each other in separate\n * files.\n *\n * @example\n * ```typescript\n * // In file A\n * export type GetFileArgs = {\n *   path: string;\n *   encoding?: EnumToUnion<AuxiliaryFileEncoding>;\n * };\n *\n * // In file B\n * export const GetFileArgsStruct = object(...);\n *\n * // If the type and struct are in the same file, this will return the type.\n * // Otherwise, it will return `never`.\n * export type GetFileArgs =\n *   InferMatching<typeof GetFileArgsStruct, GetFileArgs>;\n * ```\n */\nexport type InferMatching<\n  StructType extends Struct<any, any>,\n  Type,\n> = StructType['TYPE'] extends Type ? Type : never;\n\n/**\n * Colorize a value with a color function. This is useful for colorizing values\n * in error messages. If colorization is disabled, the original value is\n * returned.\n *\n * @param value - The value to colorize.\n * @param colorFunction - The color function to use.\n * @param enabled - Whether to colorize the value.\n * @returns The colorized value, or the original value if colorization is\n * disabled.\n */\nfunction color(\n  value: string,\n  colorFunction: (value: string) => string,\n  enabled: boolean,\n) {\n  if (enabled) {\n    return colorFunction(value);\n  }\n\n  return value;\n}\n\n/**\n * Define a struct, and also define the name of the struct as the given name.\n *\n * This is useful for improving the error messages returned by `superstruct`.\n *\n * @param name - The name of the struct.\n * @param struct - The struct.\n * @returns The struct.\n */\nexport function named<Type, Schema>(\n  name: string,\n  struct: Struct<Type, Schema>,\n) {\n  return new Struct({\n    ...struct,\n    type: name,\n  });\n}\n\nexport class SnapsStructError<Type, Schema> extends StructError {\n  constructor(\n    struct: Struct<Type, Schema>,\n    prefix: string,\n    suffix: string,\n    failure: StructError,\n    failures: () => Generator<Failure>,\n    colorize = true,\n  ) {\n    super(failure, failures);\n\n    this.name = 'SnapsStructError';\n    this.message = `${prefix}.\\n\\n${getStructErrorMessage(\n      struct,\n      [...failures()],\n      colorize,\n    )}${suffix ? `\\n\\n${suffix}` : ''}`;\n  }\n}\n\ntype GetErrorOptions<Type, Schema> = {\n  struct: Struct<Type, Schema>;\n  prefix: string;\n  suffix?: string;\n  error: StructError;\n  colorize?: boolean;\n};\n\n/**\n * Converts an array to a generator function that yields the items in the\n * array.\n *\n * @param array - The array.\n * @returns A generator function.\n * @yields The items in the array.\n */\nexport function* arrayToGenerator<Type>(\n  array: Type[],\n): Generator<Type, void, undefined> {\n  for (const item of array) {\n    yield item;\n  }\n}\n\n/**\n * Returns a `SnapsStructError` with the given prefix and suffix.\n *\n * @param options - The options.\n * @param options.struct - The struct that caused the error.\n * @param options.prefix - The prefix to add to the error message.\n * @param options.suffix - The suffix to add to the error message. Defaults to\n * an empty string.\n * @param options.error - The `superstruct` error to wrap.\n * @param options.colorize - Whether to colorize the value. Defaults to `true`.\n * @returns The `SnapsStructError`.\n */\nexport function getError<Type, Schema>({\n  struct,\n  prefix,\n  suffix = '',\n  error,\n  colorize,\n}: GetErrorOptions<Type, Schema>) {\n  return new SnapsStructError(\n    struct,\n    prefix,\n    suffix,\n    error,\n    () => arrayToGenerator(error.failures()),\n    colorize,\n  );\n}\n\n/**\n * A wrapper of `superstruct`'s `create` function that throws a\n * `SnapsStructError` instead of a `StructError`. This is useful for improving\n * the error messages returned by `superstruct`.\n *\n * @param value - The value to validate.\n * @param struct - The `superstruct` struct to validate the value against.\n * @param prefix - The prefix to add to the error message.\n * @param suffix - The suffix to add to the error message. Defaults to an empty\n * string.\n * @returns The validated value.\n */\nexport function createFromStruct<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  prefix: string,\n  suffix = '',\n) {\n  try {\n    return create(value, struct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw getError({ struct, prefix, suffix, error });\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Get a struct from a failure path.\n *\n * @param struct - The struct.\n * @param path - The failure path.\n * @returns The struct at the failure path.\n */\nexport function getStructFromPath<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  path: string[],\n) {\n  return path.reduce<AnyStruct>((result, key) => {\n    if (isObject(struct.schema) && struct.schema[key]) {\n      return struct.schema[key] as AnyStruct;\n    }\n\n    return result;\n  }, struct);\n}\n\n/**\n * Get the union struct names from a struct.\n *\n * @param struct - The struct.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns The union struct names, or `null` if the struct is not a union\n * struct.\n */\nexport function getUnionStructNames<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  colorize = true,\n) {\n  if (Array.isArray(struct.schema)) {\n    return struct.schema.map(({ type }) => color(type, green, colorize));\n  }\n\n  return null;\n}\n\n/**\n * Get an error prefix from a `superstruct` failure. This is useful for\n * formatting the error message returned by `superstruct`.\n *\n * @param failure - The `superstruct` failure.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns The error prefix.\n */\nexport function getStructErrorPrefix(failure: Failure, colorize = true) {\n  if (failure.type === 'never' || failure.path.length === 0) {\n    return '';\n  }\n\n  return `At path: ${color(failure.path.join('.'), bold, colorize)} — `;\n}\n\n/**\n * Get a string describing the failure. This is similar to the `message`\n * property of `superstruct`'s `Failure` type, but formats the value in a more\n * readable way.\n *\n * @param struct - The struct that caused the failure.\n * @param failure - The `superstruct` failure.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns A string describing the failure.\n */\nexport function getStructFailureMessage<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  failure: Failure,\n  colorize = true,\n) {\n  const received = color(JSON.stringify(failure.value), red, colorize);\n  const prefix = getStructErrorPrefix(failure, colorize);\n\n  if (failure.type === 'union') {\n    const childStruct = getStructFromPath(struct, failure.path);\n    const unionNames = getUnionStructNames(childStruct, colorize);\n\n    if (unionNames) {\n      return `${prefix}Expected the value to be one of: ${unionNames.join(\n        ', ',\n      )}, but received: ${received}.`;\n    }\n\n    return `${prefix}${failure.message}.`;\n  }\n\n  if (failure.type === 'literal') {\n    // Superstruct's failure does not provide information about which literal\n    // value was expected, so we need to parse the message to get the literal.\n    const message = failure.message\n      .replace(\n        /the literal `(.+)`,/u,\n        `the value to be \\`${color('$1', green, colorize)}\\`,`,\n      )\n      .replace(\n        /, but received: (.+)/u,\n        `, but received: ${color('$1', red, colorize)}`,\n      );\n\n    return `${prefix}${message}.`;\n  }\n\n  if (failure.type === 'never') {\n    return `Unknown key: ${color(\n      failure.path.join('.'),\n      bold,\n      colorize,\n    )}, received: ${received}.`;\n  }\n\n  if (failure.refinement === 'size') {\n    const message = failure.message\n      .replace(\n        /length between `(\\d+)` and `(\\d+)`/u,\n        `length between ${color('$1', green, colorize)} and ${color(\n          '$2',\n          green,\n          colorize,\n        )},`,\n      )\n      .replace(/length of `(\\d+)`/u, `length of ${color('$1', red, colorize)}`)\n      .replace(/a array/u, 'an array');\n\n    return `${prefix}${message}.`;\n  }\n\n  return `${prefix}Expected a value of type ${color(\n    failure.type,\n    green,\n    colorize,\n  )}, but received: ${received}.`;\n}\n\n/**\n * Get a string describing the errors. This formats all the errors in a\n * human-readable way.\n *\n * @param struct - The struct that caused the failures.\n * @param failures - The `superstruct` failures.\n * @param colorize - Whether to colorize the value. Defaults to `true`.\n * @returns A string describing the errors.\n */\nexport function getStructErrorMessage<Type, Schema>(\n  struct: Struct<Type, Schema>,\n  failures: Failure[],\n  colorize = true,\n) {\n  const formattedFailures = failures.map((failure) =>\n    indent(`• ${getStructFailureMessage(struct, failure, colorize)}`),\n  );\n\n  return formattedFailures.join('\\n');\n}\n\n/**\n * Validate a union struct, and throw readable errors if the value does not\n * satisfy the struct. This is useful for improving the error messages returned\n * by `superstruct`.\n *\n * @param value - The value to validate.\n * @param struct - The `superstruct` union struct to validate the value against.\n * This struct must be a union of object structs, and must have at least one\n * shared key to validate against.\n * @param structKey - The key to validate against. This key must be present in\n * all the object structs in the union struct, and is expected to be a literal\n * value.\n * @param coerce - Whether to coerce the value to satisfy the struct. Defaults\n * to `false`.\n * @returns The validated value.\n * @throws If the value does not satisfy the struct.\n * @example\n * const struct = union([\n *   object({ type: literal('a'), value: string() }),\n *   object({ type: literal('b'), value: number() }),\n *   object({ type: literal('c'), value: boolean() }),\n *   // ...\n * ]);\n *\n * // At path: type — Expected the value to be one of: \"a\", \"b\", \"c\", but received: \"d\".\n * validateUnion({ type: 'd', value: 'foo' }, struct, 'type');\n *\n * // At path: value — Expected a value of type string, but received: 42.\n * validateUnion({ type: 'a', value: 42 }, struct, 'value');\n */\nexport function validateUnion<Type, Schema extends readonly Struct<any, any>[]>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  structKey: keyof Type,\n  coerce = false,\n) {\n  assert(\n    struct.schema,\n    'Expected a struct with a schema. Make sure to use `union` from `@metamask/snaps-sdk`.',\n  );\n  assert(struct.schema.length > 0, 'Expected a non-empty array of structs.');\n\n  const keyUnion = struct.schema.map(\n    (innerStruct) => innerStruct.schema[structKey],\n    // This is guaranteed to be a non-empty array by the assertion above. We\n    // need to cast it since `superstruct` requires a non-empty array of structs\n    // for the `union` struct.\n  ) as NonEmptyArray<Struct>;\n\n  const key = superstructType({\n    [structKey]: union(keyUnion),\n  });\n\n  const [keyError] = validate(value, key, { coerce });\n  if (keyError) {\n    throw new Error(\n      getStructFailureMessage(key, keyError.failures()[0], false),\n    );\n  }\n\n  // At this point it's guaranteed that the value is an object, so we can safely\n  // cast it to a Record.\n  const objectValue = value as Record<PropertyKey, unknown>;\n  const objectStructs = struct.schema.filter((innerStruct) =>\n    is(objectValue[structKey], innerStruct.schema[structKey]),\n  );\n\n  assert(objectStructs.length > 0, 'Expected a struct to match the value.');\n\n  // We need to validate the value against all the object structs that match the\n  // struct key, and return the first validated value.\n  const validationResults = objectStructs.map((objectStruct) =>\n    validate(objectValue, objectStruct, { coerce }),\n  );\n\n  const validatedValue = validationResults.find(([error]) => !error);\n  if (validatedValue) {\n    return validatedValue[1];\n  }\n\n  assert(validationResults[0][0], 'Expected at least one error.');\n\n  // If there is no validated value, we need to find the error with the least\n  // number of failures (with the assumption that it's the most specific error).\n  const validationError = validationResults.reduce((error, [innerError]) => {\n    assert(innerError, 'Expected an error.');\n    if (innerError.failures().length < error.failures().length) {\n      return innerError;\n    }\n\n    return error;\n  }, validationResults[0][0]);\n\n  throw new Error(\n    getStructFailureMessage(struct, validationError.failures()[0], false),\n  );\n}\n\n/**\n * Create a value with the coercion logic of a union struct, and throw readable\n * errors if the value does not satisfy the struct. This is useful for improving\n * the error messages returned by `superstruct`.\n *\n * @param value - The value to validate.\n * @param struct - The `superstruct` union struct to validate the value against.\n * This struct must be a union of object structs, and must have at least one\n * shared key to validate against.\n * @param structKey - The key to validate against. This key must be present in\n * all the object structs in the union struct, and is expected to be a literal\n * value.\n * @returns The validated value.\n * @throws If the value does not satisfy the struct.\n * @see validateUnion\n */\nexport function createUnion<Type, Schema extends readonly Struct<any, any>[]>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  structKey: keyof Type,\n) {\n  return validateUnion(value, struct, structKey, true);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-HF7HUZ5Z.js

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/json.ts
+var _utils = require('@metamask/utils');
+function parseJson(json) {
+  return _utils.getSafeJson.call(void 0, JSON.parse(json));
+}
+
+
+
+exports.parseJson = parseJson;
+//# sourceMappingURL=chunk-HF7HUZ5Z.js.map

package/dist/chunk-HF7HUZ5Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/json.ts"],"names":[],"mappings":";AACA,SAAS,mBAAmB;AAerB,SAAS,UAAoC,MAAc;AAChE,SAAO,YAAkB,KAAK,MAAM,IAAI,CAAC;AAC3C","sourcesContent":["import type { Json } from '@metamask/utils';\nimport { getSafeJson } from '@metamask/utils';\n\n// TODO: Upstream this to @metamask/utils\n\n/**\n * Parse JSON safely.\n *\n * Does multiple kinds of validation and strips unwanted properties like\n * `__proto__` and `constructor`.\n *\n * @param json - A JSON string to be parsed.\n * @returns The parsed JSON object.\n * @template Type - The type of the JSON object. The type is not actually\n * checked, but it is used to infer the return type.\n */\nexport function parseJson<Type extends Json = Json>(json: string) {\n  return getSafeJson<Type>(JSON.parse(json));\n}\n"]}

package/dist/chunk-HJRCBSNA.mjs

@@ -0,0 +1,32 @@
+import {
+  getBytes
+} from "./chunk-6YRUDGNL.mjs";
+
+// src/checksum.ts
+import { assert, concatBytes } from "@metamask/utils";
+import { sha256 } from "@noble/hashes/sha256";
+async function checksum(bytes) {
+  const value = getBytes(bytes);
+  if ("crypto" in globalThis && typeof globalThis.crypto === "object" && crypto.subtle?.digest) {
+    return new Uint8Array(await crypto.subtle.digest("SHA-256", value));
+  }
+  return sha256(value);
+}
+async function checksumFiles(files) {
+  const checksums = await Promise.all(
+    [...files].sort((a, b) => {
+      assert(a.path !== b.path, "Tried to sort files with non-unique paths.");
+      if (a.path < b.path) {
+        return -1;
+      }
+      return 1;
+    }).map(async (file) => checksum(file))
+  );
+  return checksum(concatBytes(checksums));
+}
+
+export {
+  checksum,
+  checksumFiles
+};
+//# sourceMappingURL=chunk-HJRCBSNA.mjs.map

package/dist/chunk-HJRCBSNA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/checksum.ts"],"sourcesContent":["import { assert, concatBytes } from '@metamask/utils';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport { getBytes } from './bytes';\nimport type { VirtualFile } from './virtual-file';\n\n/**\n * Calculates checksum for a single byte array.\n *\n * @param bytes - The byte array to calculate the checksum for.\n * @returns A single sha-256 checksum.\n */\nexport async function checksum(\n  bytes: VirtualFile | Uint8Array | string,\n): Promise<Uint8Array> {\n  const value = getBytes(bytes);\n  // Use crypto.subtle.digest whenever possible as it is faster.\n  if (\n    'crypto' in globalThis &&\n    typeof globalThis.crypto === 'object' &&\n    crypto.subtle?.digest\n  ) {\n    return new Uint8Array(await crypto.subtle.digest('SHA-256', value));\n  }\n  return sha256(value);\n}\n\n/**\n * Calculates checksum over multiple files in a reproducible way.\n *\n * 1. Sort all the files by their paths.\n * 2. Calculate sha-256 checksum of each file separately.\n * 3. Concatenate all the checksums into one buffer and sha-256 that buffer.\n *\n * The sorting of paths is done using {@link https://tc39.es/ecma262/#sec-islessthan UTF-16 Code Units}.\n *\n * @param files - The files over which to calculate the checksum.\n * @returns A single sha-256 checksum.\n */\nexport async function checksumFiles(files: VirtualFile[]) {\n  const checksums = await Promise.all(\n    [...files]\n      .sort((a, b) => {\n        assert(a.path !== b.path, 'Tried to sort files with non-unique paths.');\n        if (a.path < b.path) {\n          return -1;\n        }\n        return 1;\n      })\n      .map(async (file) => checksum(file)),\n  );\n\n  return checksum(concatBytes(checksums));\n}\n"],"mappings":";;;;;AAAA,SAAS,QAAQ,mBAAmB;AACpC,SAAS,cAAc;AAWvB,eAAsB,SACpB,OACqB;AACrB,QAAM,QAAQ,SAAS,KAAK;AAE5B,MACE,YAAY,cACZ,OAAO,WAAW,WAAW,YAC7B,OAAO,QAAQ,QACf;AACA,WAAO,IAAI,WAAW,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,CAAC;AAAA,EACpE;AACA,SAAO,OAAO,KAAK;AACrB;AAcA,eAAsB,cAAc,OAAsB;AACxD,QAAM,YAAY,MAAM,QAAQ;AAAA,IAC9B,CAAC,GAAG,KAAK,EACN,KAAK,CAAC,GAAG,MAAM;AACd,aAAO,EAAE,SAAS,EAAE,MAAM,4CAA4C;AACtE,UAAI,EAAE,OAAO,EAAE,MAAM;AACnB,eAAO;AAAA,MACT;AACA,aAAO;AAAA,IACT,CAAC,EACA,IAAI,OAAO,SAAS,SAAS,IAAI,CAAC;AAAA,EACvC;AAEA,SAAO,SAAS,YAAY,SAAS,CAAC;AACxC;","names":[]}

package/dist/chunk-HJYRGKCX.js

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkNUCLSR2Gjs = require('./chunk-NUCLSR2G.js');
+
+// src/virtual-file/VirtualFile.ts
+var _utils = require('@metamask/utils');
+var _base = require('@scure/base');
+var VirtualFile = class _VirtualFile {
+  constructor(value) {
+    let options;
+    if (typeof value === "string" || value instanceof Uint8Array) {
+      options = { value };
+    } else {
+      options = value;
+    }
+    this.value = options?.value ?? "";
+    this.result = options?.result ?? void 0;
+    this.data = options?.data ?? {};
+    this.path = options?.path ?? "/";
+  }
+  toString(encoding) {
+    if (typeof this.value === "string") {
+      _utils.assert.call(void 0, encoding === void 0, "Tried to encode string.");
+      return this.value;
+    } else if (this.value instanceof Uint8Array && encoding === "hex") {
+      return _utils.bytesToHex.call(void 0, this.value);
+    } else if (this.value instanceof Uint8Array && encoding === "base64") {
+      return _base.base64.encode(this.value);
+    }
+    const decoder = new TextDecoder(encoding);
+    return decoder.decode(this.value);
+  }
+  clone() {
+    const vfile = new _VirtualFile();
+    if (typeof this.value === "string") {
+      vfile.value = this.value;
+    } else {
+      vfile.value = this.value.slice(0);
+    }
+    vfile.result = _chunkNUCLSR2Gjs.deepClone.call(void 0, this.result);
+    vfile.data = _chunkNUCLSR2Gjs.deepClone.call(void 0, this.data);
+    vfile.path = this.path;
+    return vfile;
+  }
+};
+
+
+
+exports.VirtualFile = VirtualFile;
+//# sourceMappingURL=chunk-HJYRGKCX.js.map

package/dist/chunk-HJYRGKCX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/virtual-file/VirtualFile.ts"],"names":[],"mappings":";;;;;AAQA,SAAS,QAAQ,kBAAkB;AACnC,SAAS,cAAc;AAiChB,IAAM,cAAN,MAAM,aAA8B;AAAA,EACzC,YAAY,OAA4B;AACtC,QAAI;AACJ,QAAI,OAAO,UAAU,YAAY,iBAAiB,YAAY;AAC5D,gBAAU,EAAE,MAAM;AAAA,IACpB,OAAO;AACL,gBAAU;AAAA,IACZ;AAEA,SAAK,QAAQ,SAAS,SAAS;AAU/B,SAAK,SAAS,SAAS,UAAW;AAClC,SAAK,OAAO,SAAS,QAAQ,CAAC;AAC9B,SAAK,OAAO,SAAS,QAAQ;AAAA,EAC/B;AAAA,EAUA,SAAS,UAAmB;AAC1B,QAAI,OAAO,KAAK,UAAU,UAAU;AAClC,aAAO,aAAa,QAAW,yBAAyB;AACxD,aAAO,KAAK;AAAA,IACd,WAAW,KAAK,iBAAiB,cAAc,aAAa,OAAO;AACjE,aAAO,WAAW,KAAK,KAAK;AAAA,IAC9B,WAAW,KAAK,iBAAiB,cAAc,aAAa,UAAU;AAGpE,aAAO,OAAO,OAAO,KAAK,KAAK;AAAA,IACjC;AACA,UAAM,UAAU,IAAI,YAAY,QAAQ;AACxC,WAAO,QAAQ,OAAO,KAAK,KAAK;AAAA,EAClC;AAAA,EAEA,QAAQ;AACN,UAAM,QAAQ,IAAI,aAAoB;AACtC,QAAI,OAAO,KAAK,UAAU,UAAU;AAClC,YAAM,QAAQ,KAAK;AAAA,IACrB,OAAO;AAEL,YAAM,QAAQ,KAAK,MAAM,MAAM,CAAC;AAAA,IAClC;AACA,UAAM,SAAS,UAAU,KAAK,MAAM;AACpC,UAAM,OAAO,UAAU,KAAK,IAAI;AAChC,UAAM,OAAO,KAAK;AAClB,WAAO;AAAA,EACT;AACF","sourcesContent":["// TODO(ritave): Move into separate package @metamask/vfile / @metamask/utils + @metamask/to-vfile when passes code review\n// TODO(ritave): Streaming vfile contents similar to vinyl maybe?\n// TODO(ritave): Move fixing manifest in cli and bundler plugins to write messages to vfile\n//               similar to unified instead of throwing \"ProgrammaticallyFixableErrors\".\n//\n// Using https://github.com/vfile/vfile would be helpful, but they only support ESM and we need to support CommonJS.\n// https://github.com/gulpjs/vinyl is also good, but they normalize paths, which we can't do, because\n// we're calculating checksums based on original path.\nimport { assert, bytesToHex } from '@metamask/utils';\nimport { base64 } from '@scure/base';\n\nimport { deepClone } from '../deep-clone';\n\n/**\n * This map registers the type of the {@link VirtualFile.data} key of a {@link VirtualFile}.\n *\n * This type can be augmented to register custom `data` types.\n *\n * @example\n * declare module '@metamask/snaps-utils' {\n *   interface DataMap {\n *     // `file.data.name` is typed as `string`\n *     name: string\n *   }\n * }\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions, @typescript-eslint/no-empty-interface\nexport interface DataMap {}\n\nexport type Value = string | Uint8Array;\nexport type Compatible<Result = unknown> =\n  | string\n  | Uint8Array\n  | Options<Result>;\nexport type Data = Record<string, unknown> & Partial<DataMap>;\nexport type Options<Result = unknown> = {\n  value: Value;\n  path?: string;\n  data?: Data;\n  result?: Result;\n};\n\nexport class VirtualFile<Result = unknown> {\n  constructor(value?: Compatible<Result>) {\n    let options: Options | undefined;\n    if (typeof value === 'string' || value instanceof Uint8Array) {\n      options = { value };\n    } else {\n      options = value;\n    }\n\n    this.value = options?.value ?? '';\n    // This situations happens when there's no .result used,\n    // we expect the file to have default generic in that situation:\n    // VirtualFile<unknown> which will handle undefined properly\n    //\n    // While not 100% type safe, it'll be way less frustrating to work with.\n    // The alternative would be to have VirtualFile.result be Result | undefined\n    // and that would result in needing to branch out and check in all situations.\n    //\n    // In short, optimizing for most common use case.\n    this.result = options?.result ?? (undefined as any);\n    this.data = options?.data ?? {};\n    this.path = options?.path ?? '/';\n  }\n\n  value: Value;\n\n  result: Result;\n\n  data: Data;\n\n  path: string;\n\n  toString(encoding?: string) {\n    if (typeof this.value === 'string') {\n      assert(encoding === undefined, 'Tried to encode string.');\n      return this.value;\n    } else if (this.value instanceof Uint8Array && encoding === 'hex') {\n      return bytesToHex(this.value);\n    } else if (this.value instanceof Uint8Array && encoding === 'base64') {\n      // For large files, this is quite slow, instead use `encodeBase64()`\n      // TODO: Use @metamask/utils for this\n      return base64.encode(this.value);\n    }\n    const decoder = new TextDecoder(encoding);\n    return decoder.decode(this.value);\n  }\n\n  clone() {\n    const vfile = new VirtualFile<Result>();\n    if (typeof this.value === 'string') {\n      vfile.value = this.value;\n    } else {\n      // deep-clone doesn't clone Buffer properly, even if it's a sub-class of Uint8Array\n      vfile.value = this.value.slice(0);\n    }\n    vfile.result = deepClone(this.result);\n    vfile.data = deepClone(this.data);\n    vfile.path = this.path;\n    return vfile;\n  }\n}\n"]}

package/dist/chunk-HYF7Q6VY.mjs

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

package/dist/chunk-HYF7Q6VY.mjs.map

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

package/dist/chunk-I77AVJKV.mjs

@@ -0,0 +1,152 @@
+// src/handlers.ts
+import { SeverityLevel, ComponentStruct } from "@metamask/snaps-sdk";
+import {
+  assign,
+  literal,
+  nullable,
+  object,
+  optional,
+  string,
+  array,
+  size,
+  union
+} from "superstruct";
+var SNAP_EXPORTS = {
+  ["onRpcRequest" /* OnRpcRequest */]: {
+    type: "onRpcRequest" /* OnRpcRequest */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onTransaction" /* OnTransaction */]: {
+    type: "onTransaction" /* OnTransaction */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onCronjob" /* OnCronjob */]: {
+    type: "onCronjob" /* OnCronjob */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onNameLookup" /* OnNameLookup */]: {
+    type: "onNameLookup" /* OnNameLookup */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onInstall" /* OnInstall */]: {
+    type: "onInstall" /* OnInstall */,
+    required: false,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onUpdate" /* OnUpdate */]: {
+    type: "onUpdate" /* OnUpdate */,
+    required: false,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onKeyringRequest" /* OnKeyringRequest */]: {
+    type: "onKeyringRequest" /* OnKeyringRequest */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onHomePage" /* OnHomePage */]: {
+    type: "onHomePage" /* OnHomePage */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onSignature" /* OnSignature */]: {
+    type: "onSignature" /* OnSignature */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  },
+  ["onUserInput" /* OnUserInput */]: {
+    type: "onUserInput" /* OnUserInput */,
+    required: true,
+    validator: (snapExport) => {
+      return typeof snapExport === "function";
+    }
+  }
+};
+var OnTransactionSeverityResponseStruct = object({
+  severity: optional(literal(SeverityLevel.Critical))
+});
+var OnTransactionResponseWithIdStruct = assign(
+  OnTransactionSeverityResponseStruct,
+  object({
+    id: string()
+  })
+);
+var OnTransactionResponseWithContentStruct = assign(
+  OnTransactionSeverityResponseStruct,
+  object({
+    content: ComponentStruct
+  })
+);
+var OnTransactionResponseStruct = nullable(
+  union([
+    OnTransactionResponseWithContentStruct,
+    OnTransactionResponseWithIdStruct
+  ])
+);
+var OnSignatureResponseStruct = OnTransactionResponseStruct;
+var OnHomePageResponseWithContentStruct = object({
+  content: ComponentStruct
+});
+var OnHomePageResponseWithIdStruct = object({
+  id: string()
+});
+var OnHomePageResponseStruct = union([
+  OnHomePageResponseWithContentStruct,
+  OnHomePageResponseWithIdStruct
+]);
+var AddressResolutionStruct = object({
+  protocol: string(),
+  resolvedDomain: string()
+});
+var DomainResolutionStruct = object({
+  protocol: string(),
+  resolvedAddress: string()
+});
+var AddressResolutionResponseStruct = object({
+  resolvedDomains: size(array(AddressResolutionStruct), 1, Infinity)
+});
+var DomainResolutionResponseStruct = object({
+  resolvedAddresses: size(array(DomainResolutionStruct), 1, Infinity)
+});
+var OnNameLookupResponseStruct = nullable(
+  union([AddressResolutionResponseStruct, DomainResolutionResponseStruct])
+);
+
+export {
+  SNAP_EXPORTS,
+  OnTransactionSeverityResponseStruct,
+  OnTransactionResponseWithIdStruct,
+  OnTransactionResponseWithContentStruct,
+  OnTransactionResponseStruct,
+  OnSignatureResponseStruct,
+  OnHomePageResponseWithContentStruct,
+  OnHomePageResponseWithIdStruct,
+  OnHomePageResponseStruct,
+  AddressResolutionStruct,
+  DomainResolutionStruct,
+  AddressResolutionResponseStruct,
+  DomainResolutionResponseStruct,
+  OnNameLookupResponseStruct
+};
+//# sourceMappingURL=chunk-I77AVJKV.mjs.map

package/dist/chunk-I77AVJKV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/handlers.ts"],"sourcesContent":["import type {\n  OnCronjobHandler,\n  OnHomePageHandler,\n  OnInstallHandler,\n  OnKeyringRequestHandler,\n  OnNameLookupHandler,\n  OnRpcRequestHandler,\n  OnSignatureHandler,\n  OnTransactionHandler,\n  OnUpdateHandler,\n  OnUserInputHandler,\n} from '@metamask/snaps-sdk';\nimport { SeverityLevel, ComponentStruct } from '@metamask/snaps-sdk';\nimport {\n  assign,\n  literal,\n  nullable,\n  object,\n  optional,\n  string,\n  array,\n  size,\n  union,\n} from 'superstruct';\n\nimport type { SnapHandler } from './handler-types';\nimport { HandlerType } from './handler-types';\n\nexport type SnapRpcHookArgs = {\n  origin: string;\n  handler: HandlerType;\n  request: Record<string, unknown>;\n};\n\nexport const SNAP_EXPORTS = {\n  [HandlerType.OnRpcRequest]: {\n    type: HandlerType.OnRpcRequest,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnRpcRequestHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnTransaction]: {\n    type: HandlerType.OnTransaction,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnTransactionHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnCronjob]: {\n    type: HandlerType.OnCronjob,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnCronjobHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnNameLookup]: {\n    type: HandlerType.OnNameLookup,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnNameLookupHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnInstall]: {\n    type: HandlerType.OnInstall,\n    required: false,\n    validator: (snapExport: unknown): snapExport is OnInstallHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnUpdate]: {\n    type: HandlerType.OnUpdate,\n    required: false,\n    validator: (snapExport: unknown): snapExport is OnUpdateHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnKeyringRequest]: {\n    type: HandlerType.OnKeyringRequest,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnKeyringRequestHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnHomePage]: {\n    type: HandlerType.OnHomePage,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnHomePageHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnSignature]: {\n    type: HandlerType.OnSignature,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnSignatureHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n  [HandlerType.OnUserInput]: {\n    type: HandlerType.OnUserInput,\n    required: true,\n    validator: (snapExport: unknown): snapExport is OnUserInputHandler => {\n      return typeof snapExport === 'function';\n    },\n  },\n} as const;\n\nexport const OnTransactionSeverityResponseStruct = object({\n  severity: optional(literal(SeverityLevel.Critical)),\n});\n\nexport const OnTransactionResponseWithIdStruct = assign(\n  OnTransactionSeverityResponseStruct,\n  object({\n    id: string(),\n  }),\n);\n\nexport const OnTransactionResponseWithContentStruct = assign(\n  OnTransactionSeverityResponseStruct,\n  object({\n    content: ComponentStruct,\n  }),\n);\n\nexport const OnTransactionResponseStruct = nullable(\n  union([\n    OnTransactionResponseWithContentStruct,\n    OnTransactionResponseWithIdStruct,\n  ]),\n);\n\nexport const OnSignatureResponseStruct = OnTransactionResponseStruct;\n\nexport const OnHomePageResponseWithContentStruct = object({\n  content: ComponentStruct,\n});\n\nexport const OnHomePageResponseWithIdStruct = object({\n  id: string(),\n});\n\nexport const OnHomePageResponseStruct = union([\n  OnHomePageResponseWithContentStruct,\n  OnHomePageResponseWithIdStruct,\n]);\n\nexport const AddressResolutionStruct = object({\n  protocol: string(),\n  resolvedDomain: string(),\n});\n\nexport const DomainResolutionStruct = object({\n  protocol: string(),\n  resolvedAddress: string(),\n});\n\nexport const AddressResolutionResponseStruct = object({\n  resolvedDomains: size(array(AddressResolutionStruct), 1, Infinity),\n});\n\nexport const DomainResolutionResponseStruct = object({\n  resolvedAddresses: size(array(DomainResolutionStruct), 1, Infinity),\n});\n\nexport const OnNameLookupResponseStruct = nullable(\n  union([AddressResolutionResponseStruct, DomainResolutionResponseStruct]),\n);\n\n/**\n * Utility type for getting the handler function type from a handler type.\n */\nexport type HandlerFunction<Type extends SnapHandler> =\n  Type['validator'] extends (snapExport: unknown) => snapExport is infer Handler\n    ? Handler\n    : never;\n\n/**\n * All the function-based handlers that a snap can implement.\n */\nexport type SnapFunctionExports = {\n  [Key in keyof typeof SNAP_EXPORTS]?: HandlerFunction<\n    (typeof SNAP_EXPORTS)[Key]\n  >;\n};\n\n/**\n * All handlers that a snap can implement.\n */\nexport type SnapExports = SnapFunctionExports;\n"],"mappings":"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","names":[]}

package/dist/chunk-IGMAXVPP.mjs

@@ -0,0 +1,21 @@
+import {
+  VirtualFile
+} from "./chunk-ZJRWU4AJ.mjs";
+
+// src/virtual-file/toVirtualFile.ts
+import { promises as fsPromises } from "fs";
+async function readVirtualFile(path, encoding = null) {
+  return new VirtualFile({
+    path,
+    value: await fsPromises.readFile(path, { encoding })
+  });
+}
+async function writeVirtualFile(vfile, options) {
+  return fsPromises.writeFile(vfile.path, vfile.value, options);
+}
+
+export {
+  readVirtualFile,
+  writeVirtualFile
+};
+//# sourceMappingURL=chunk-IGMAXVPP.mjs.map

package/dist/chunk-IGMAXVPP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/virtual-file/toVirtualFile.ts"],"sourcesContent":["import { promises as fsPromises } from 'fs';\n\nimport { VirtualFile } from './VirtualFile';\n\n/**\n * Reads a file from filesystem and creates a vfile.\n *\n * @param path - Filesystem path to load the contents from.\n * @param encoding - Optional encoding to pass down to fs.readFile.\n * @returns Promise returning VFile with loaded file contents.\n */\nexport async function readVirtualFile(\n  path: string,\n  encoding: BufferEncoding | null = null,\n) {\n  return new VirtualFile({\n    path,\n    value: await fsPromises.readFile(path, { encoding }),\n  });\n}\n\ntype WriteVFileOptions = Exclude<\n  Parameters<(typeof fsPromises)['writeFile']>[2],\n  undefined\n>;\n\n/**\n * Writes vfile to filesystem.\n *\n * @param vfile - The vfile to write.\n * @param options - Options to pass down to fs.writeFile.\n */\nexport async function writeVirtualFile(\n  vfile: VirtualFile,\n  options?: WriteVFileOptions,\n) {\n  return fsPromises.writeFile(vfile.path, vfile.value, options);\n}\n"],"mappings":";;;;;AAAA,SAAS,YAAY,kBAAkB;AAWvC,eAAsB,gBACpB,MACA,WAAkC,MAClC;AACA,SAAO,IAAI,YAAY;AAAA,IACrB;AAAA,IACA,OAAO,MAAM,WAAW,SAAS,MAAM,EAAE,SAAS,CAAC;AAAA,EACrD,CAAC;AACH;AAaA,eAAsB,iBACpB,OACA,SACA;AACA,SAAO,WAAW,UAAU,MAAM,MAAM,MAAM,OAAO,OAAO;AAC9D;","names":[]}

package/dist/chunk-IHQPAJ2B.js

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk473MIETWjs = require('./chunk-473MIETW.js');
+
+// src/base64.ts
+var _utils = require('@metamask/utils');
+async function encodeBase64(input) {
+  const bytes = _chunk473MIETWjs.getBytes.call(void 0, input);
+  if ("FileReader" in globalThis) {
+    return await new Promise((resolve, reject) => {
+      const reader = Object.assign(new FileReader(), {
+        onload: () => resolve(
+          reader.result.replace(
+            "data:application/octet-stream;base64,",
+            ""
+          )
+        ),
+        onerror: () => reject(reader.error)
+      });
+      reader.readAsDataURL(
+        new File([bytes], "", { type: "application/octet-stream" })
+      );
+    });
+  }
+  return _utils.bytesToBase64.call(void 0, bytes);
+}
+async function decodeBase64(base64) {
+  const response = await fetch(
+    `data:application/octet-stream;base64,${base64}`
+  );
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+
+
+
+exports.encodeBase64 = encodeBase64; exports.decodeBase64 = decodeBase64;
+//# sourceMappingURL=chunk-IHQPAJ2B.js.map

package/dist/chunk-IHQPAJ2B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/base64.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,qBAAqB;AAW9B,eAAsB,aAAa,OAA0C;AAC3E,QAAM,QAAQ,SAAS,KAAK;AAE5B,MAAI,gBAAgB,YAAY;AAC9B,WAAO,MAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,YAAM,SAAS,OAAO,OAAO,IAAI,WAAW,GAAG;AAAA,QAC7C,QAAQ,MACN;AAAA,UACG,OAAO,OAAkB;AAAA,YACxB;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,QACF,SAAS,MAAM,OAAO,OAAO,KAAK;AAAA,MACpC,CAAC;AACD,aAAO;AAAA,QACL,IAAI,KAAK,CAAC,KAAK,GAAG,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAAA,MAC5D;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO,cAAc,KAAK;AAC5B;AAQA,eAAsB,aAAa,QAAgB;AACjD,QAAM,WAAW,MAAM;AAAA,IACrB,wCAAwC,MAAM;AAAA,EAChD;AACA,SAAO,IAAI,WAAW,MAAM,SAAS,YAAY,CAAC;AACpD","sourcesContent":["import { bytesToBase64 } from '@metamask/utils';\n\nimport { getBytes } from './bytes';\nimport type { VirtualFile } from './virtual-file';\n\n/**\n * Provides fast, asynchronous base64 encoding.\n *\n * @param input - The input value, assumed to be coercable to bytes.\n * @returns A base64 string.\n */\nexport async function encodeBase64(input: Uint8Array | VirtualFile | string) {\n  const bytes = getBytes(input);\n  // In the browser, FileReader is much faster than bytesToBase64.\n  if ('FileReader' in globalThis) {\n    return await new Promise((resolve, reject) => {\n      const reader = Object.assign(new FileReader(), {\n        onload: () =>\n          resolve(\n            (reader.result as string).replace(\n              'data:application/octet-stream;base64,',\n              '',\n            ),\n          ),\n        onerror: () => reject(reader.error),\n      });\n      reader.readAsDataURL(\n        new File([bytes], '', { type: 'application/octet-stream' }),\n      );\n    });\n  }\n  return bytesToBase64(bytes);\n}\n\n/**\n * Provides fast, asynchronous base64 decoding.\n *\n * @param base64 - A base64 string.\n * @returns A Uint8Array of bytes.\n */\nexport async function decodeBase64(base64: string) {\n  const response = await fetch(\n    `data:application/octet-stream;base64,${base64}`,\n  );\n  return new Uint8Array(await response.arrayBuffer());\n}\n"]}

package/dist/chunk-IJX3CXOY.js

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/strings.ts
+function indent(message, spaces = 2) {
+  return message.replace(/^/gmu, " ".repeat(spaces));
+}
+
+
+
+exports.indent = indent;
+//# sourceMappingURL=chunk-IJX3CXOY.js.map

package/dist/chunk-IJX3CXOY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/strings.ts"],"names":[],"mappings":";AAOO,SAAS,OAAO,SAAiB,SAAS,GAAG;AAClD,SAAO,QAAQ,QAAQ,QAAQ,IAAI,OAAO,MAAM,CAAC;AACnD","sourcesContent":["/**\n * Indent a message by adding a number of spaces to the beginning of each line.\n *\n * @param message - The message to indent.\n * @param spaces - The number of spaces to indent by. Defaults to 2.\n * @returns The indented message.\n */\nexport function indent(message: string, spaces = 2) {\n  return message.replace(/^/gmu, ' '.repeat(spaces));\n}\n"]}