@metamask/snaps-utils 6.1.0 → 7.0.1

package/dist/chunk-A6E325SZ.js

@@ -0,0 +1,211 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkIJX3CXOYjs = require('./chunk-IJX3CXOY.js');
+
+// src/structs.ts
+var _snapssdk = require('@metamask/snaps-sdk');
+var _utils = require('@metamask/utils');
+var _chalk = require('chalk');
+
+
+
+
+
+
+
+var _superstruct = require('superstruct');
+function color(value, colorFunction, enabled) {
+  if (enabled) {
+    return colorFunction(value);
+  }
+  return value;
+}
+function named(name, struct) {
+  return new (0, _superstruct.Struct)({
+    ...struct,
+    type: name
+  });
+}
+var SnapsStructError = class extends _superstruct.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 _superstruct.create.call(void 0, value, struct);
+  } catch (error) {
+    if (error instanceof _superstruct.StructError) {
+      throw getError({ struct, prefix, suffix, error });
+    }
+    throw error;
+  }
+}
+function getStructFromPath(struct, path) {
+  return path.reduce((result, key) => {
+    if (_utils.isObject.call(void 0, 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, _chalk.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("."), _chalk.bold, colorize)} \u2014 `;
+}
+function getStructFailureMessage(struct, failure, colorize = true) {
+  const received = color(JSON.stringify(failure.value), _chalk.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", _chalk.green, colorize)}\`,`
+    ).replace(
+      /, but received: (.+)/u,
+      `, but received: ${color("$1", _chalk.red, colorize)}`
+    );
+    return `${prefix}${message}.`;
+  }
+  if (failure.type === "never") {
+    return `Unknown key: ${color(
+      failure.path.join("."),
+      _chalk.bold,
+      colorize
+    )}, received: ${received}.`;
+  }
+  if (failure.refinement === "size") {
+    const message = failure.message.replace(
+      /length between `(\d+)` and `(\d+)`/u,
+      `length between ${color("$1", _chalk.green, colorize)} and ${color(
+        "$2",
+        _chalk.green,
+        colorize
+      )},`
+    ).replace(/length of `(\d+)`/u, `length of ${color("$1", _chalk.red, colorize)}`).replace(/a array/u, "an array");
+    return `${prefix}${message}.`;
+  }
+  return `${prefix}Expected a value of type ${color(
+    failure.type,
+    _chalk.green,
+    colorize
+  )}, but received: ${received}.`;
+}
+function getStructErrorMessage(struct, failures, colorize = true) {
+  const formattedFailures = failures.map(
+    (failure) => _chunkIJX3CXOYjs.indent.call(void 0, `\u2022 ${getStructFailureMessage(struct, failure, colorize)}`)
+  );
+  return formattedFailures.join("\n");
+}
+function validateUnion(value, struct, structKey, coerce = false) {
+  _utils.assert.call(void 0, 
+    struct.schema,
+    "Expected a struct with a schema. Make sure to use `union` from `@metamask/snaps-sdk`."
+  );
+  _utils.assert.call(void 0, 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 = _superstruct.type.call(void 0, {
+    [structKey]: _snapssdk.union.call(void 0, keyUnion)
+  });
+  const [keyError] = _superstruct.validate.call(void 0, value, key, { coerce });
+  if (keyError) {
+    throw new Error(
+      getStructFailureMessage(key, keyError.failures()[0], false)
+    );
+  }
+  const objectValue = value;
+  const objectStructs = struct.schema.filter(
+    (innerStruct) => _superstruct.is.call(void 0, objectValue[structKey], innerStruct.schema[structKey])
+  );
+  _utils.assert.call(void 0, objectStructs.length > 0, "Expected a struct to match the value.");
+  const validationResults = objectStructs.map(
+    (objectStruct) => _superstruct.validate.call(void 0, objectValue, objectStruct, { coerce })
+  );
+  const validatedValue = validationResults.find(([error]) => !error);
+  if (validatedValue) {
+    return validatedValue[1];
+  }
+  _utils.assert.call(void 0, validationResults[0][0], "Expected at least one error.");
+  const validationError = validationResults.reduce((error, [innerError]) => {
+    _utils.assert.call(void 0, 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);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.named = named; exports.SnapsStructError = SnapsStructError; exports.arrayToGenerator = arrayToGenerator; exports.getError = getError; exports.createFromStruct = createFromStruct; exports.getStructFromPath = getStructFromPath; exports.getUnionStructNames = getUnionStructNames; exports.getStructErrorPrefix = getStructErrorPrefix; exports.getStructFailureMessage = getStructFailureMessage; exports.getStructErrorMessage = getStructErrorMessage; exports.validateUnion = validateUnion; exports.createUnion = createUnion;
+//# sourceMappingURL=chunk-A6E325SZ.js.map

package/dist/chunk-A6E325SZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/structs.ts"],"names":[],"mappings":"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","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"]}

package/dist/chunk-AFQY2CNY.js

@@ -0,0 +1,109 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkHF7HUZ5Zjs = require('./chunk-HF7HUZ5Z.js');
+
+// src/localization.ts
+var _snapssdk = require('@metamask/snaps-sdk');
+
+
+
+
+
+
+
+var _superstruct = require('superstruct');
+var LOCALIZABLE_FIELDS = ["description", "proposedName"];
+var LocalizationFileStruct = _superstruct.object.call(void 0, {
+  locale: _superstruct.string.call(void 0, ),
+  messages: _superstruct.record.call(void 0, 
+    _superstruct.string.call(void 0, ),
+    _superstruct.object.call(void 0, {
+      message: _superstruct.string.call(void 0, ),
+      description: _superstruct.optional.call(void 0, _superstruct.string.call(void 0, ))
+    })
+  )
+});
+function getValidatedLocalizationFiles(localizationFiles) {
+  for (const file of localizationFiles) {
+    try {
+      file.result = _superstruct.create.call(void 0, _chunkHF7HUZ5Zjs.parseJson.call(void 0, file.toString()), LocalizationFileStruct);
+    } catch (error) {
+      if (error instanceof _superstruct.StructError) {
+        throw new Error(
+          `Failed to validate localization file "${file.path}": ${error.message}.`
+        );
+      }
+      if (error instanceof SyntaxError) {
+        throw new Error(
+          `Failed to parse localization file "${file.path}" as JSON.`
+        );
+      }
+      throw error;
+    }
+  }
+  return localizationFiles;
+}
+function getLocalizationFile(locale, localizationFiles) {
+  const file = localizationFiles.find(
+    (localizationFile) => localizationFile.locale === locale
+  );
+  if (!file) {
+    return localizationFiles.find(
+      (localizationFile) => localizationFile.locale === "en"
+    );
+  }
+  return file;
+}
+var TRANSLATION_REGEX = /\{\{\s?([a-zA-Z0-9-_\s]+)\s?\}\}/gu;
+function translate(value, file) {
+  const matches = value.matchAll(TRANSLATION_REGEX);
+  const array = Array.from(matches);
+  return array.reduce((result, [match, key]) => {
+    if (!file) {
+      throw new Error(
+        `Failed to translate "${value}": No localization file found.`
+      );
+    }
+    const translation = file.messages[key.trim()];
+    if (!translation) {
+      throw new Error(
+        `Failed to translate "${value}": No translation found for "${key.trim()}" in "${file.locale}" file.`
+      );
+    }
+    return result.replace(match, translation.message);
+  }, value);
+}
+function getLocalizedSnapManifest(snapManifest, locale, localizationFiles) {
+  const file = getLocalizationFile(locale, localizationFiles);
+  return LOCALIZABLE_FIELDS.reduce((manifest, field) => {
+    const translation = translate(manifest[field], file);
+    return {
+      ...manifest,
+      [field]: translation
+    };
+  }, snapManifest);
+}
+function validateSnapManifestLocalizations(snapManifest, localizationFiles) {
+  try {
+    localizationFiles.filter((file) => file.locale !== "en").forEach((file) => {
+      getLocalizedSnapManifest(snapManifest, file.locale, localizationFiles);
+    });
+    getLocalizedSnapManifest(snapManifest, "en", localizationFiles);
+  } catch (error) {
+    throw new Error(
+      `Failed to localize Snap manifest: ${_snapssdk.getErrorMessage.call(void 0, error)}`
+    );
+  }
+}
+
+
+
+
+
+
+
+
+
+
+exports.LOCALIZABLE_FIELDS = LOCALIZABLE_FIELDS; exports.LocalizationFileStruct = LocalizationFileStruct; exports.getValidatedLocalizationFiles = getValidatedLocalizationFiles; exports.getLocalizationFile = getLocalizationFile; exports.TRANSLATION_REGEX = TRANSLATION_REGEX; exports.translate = translate; exports.getLocalizedSnapManifest = getLocalizedSnapManifest; exports.validateSnapManifestLocalizations = validateSnapManifestLocalizations;
+//# sourceMappingURL=chunk-AFQY2CNY.js.map

package/dist/chunk-AFQY2CNY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/localization.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,uBAAuB;AAEhC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMA,IAAM,qBAAqB,CAAC,eAAe,cAAc;AAEzD,IAAM,yBAAyB,OAAO;AAAA,EAC3C,QAAQ,OAAO;AAAA,EACf,UAAU;AAAA,IACR,OAAO;AAAA,IACP,OAAO;AAAA,MACL,SAAS,OAAO;AAAA,MAChB,aAAa,SAAS,OAAO,CAAC;AAAA,IAChC,CAAC;AAAA,EACH;AACF,CAAC;AAWM,SAAS,8BACd,mBACiC;AACjC,aAAW,QAAQ,mBAAmB;AACpC,QAAI;AACF,WAAK,SAAS,OAAO,UAAU,KAAK,SAAS,CAAC,GAAG,sBAAsB;AAAA,IACzE,SAAS,OAAO;AACd,UAAI,iBAAiB,aAAa;AAChC,cAAM,IAAI;AAAA,UACR,yCAAyC,KAAK,IAAI,MAAM,MAAM,OAAO;AAAA,QACvE;AAAA,MACF;AAEA,UAAI,iBAAiB,aAAa;AAChC,cAAM,IAAI;AAAA,UACR,sCAAsC,KAAK,IAAI;AAAA,QACjD;AAAA,MACF;AAEA,YAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AACT;AAWO,SAAS,oBACd,QACA,mBACA;AACA,QAAM,OAAO,kBAAkB;AAAA,IAC7B,CAAC,qBAAqB,iBAAiB,WAAW;AAAA,EACpD;AAEA,MAAI,CAAC,MAAM;AACT,WAAO,kBAAkB;AAAA,MACvB,CAAC,qBAAqB,iBAAiB,WAAW;AAAA,IACpD;AAAA,EACF;AAEA,SAAO;AACT;AAEO,IAAM,oBAAoB;AAa1B,SAAS,UAAU,OAAe,MAAoC;AAC3E,QAAM,UAAU,MAAM,SAAS,iBAAiB;AAChD,QAAM,QAAQ,MAAM,KAAK,OAAO;AAEhC,SAAO,MAAM,OAAe,CAAC,QAAQ,CAAC,OAAO,GAAG,MAAM;AACpD,QAAI,CAAC,MAAM;AACT,YAAM,IAAI;AAAA,QACR,wBAAwB,KAAK;AAAA,MAC/B;AAAA,IACF;AAEA,UAAM,cAAc,KAAK,SAAS,IAAI,KAAK,CAAC;AAC5C,QAAI,CAAC,aAAa;AAChB,YAAM,IAAI;AAAA,QACR,wBAAwB,KAAK,gCAAgC,IAAI,KAAK,CAAC,SACrE,KAAK,MACP;AAAA,MACF;AAAA,IACF;AAEA,WAAO,OAAO,QAAQ,OAAO,YAAY,OAAO;AAAA,EAClD,GAAG,KAAK;AACV;AAWO,SAAS,yBACd,cACA,QACA,mBACA;AACA,QAAM,OAAO,oBAAoB,QAAQ,iBAAiB;AAE1D,SAAO,mBAAmB,OAAO,CAAC,UAAU,UAAU;AACpD,UAAM,cAAc,UAAU,SAAS,KAAK,GAAG,IAAI;AACnD,WAAO;AAAA,MACL,GAAG;AAAA,MACH,CAAC,KAAK,GAAG;AAAA,IACX;AAAA,EACF,GAAG,YAAY;AACjB;AASO,SAAS,kCACd,cACA,mBACA;AACA,MAAI;AAGF,sBACG,OAAO,CAAC,SAAS,KAAK,WAAW,IAAI,EACrC,QAAQ,CAAC,SAAS;AACjB,+BAAyB,cAAc,KAAK,QAAQ,iBAAiB;AAAA,IACvE,CAAC;AAGH,6BAAyB,cAAc,MAAM,iBAAiB;AAAA,EAChE,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,qCAAqC,gBAAgB,KAAK,CAAC;AAAA,IAC7D;AAAA,EACF;AACF","sourcesContent":["import { getErrorMessage } from '@metamask/snaps-sdk';\nimport type { Infer } from 'superstruct';\nimport {\n  create,\n  object,\n  optional,\n  record,\n  string,\n  StructError,\n} from 'superstruct';\n\nimport { parseJson } from './json';\nimport type { SnapManifest } from './manifest';\nimport type { VirtualFile } from './virtual-file';\n\nexport const LOCALIZABLE_FIELDS = ['description', 'proposedName'] as const;\n\nexport const LocalizationFileStruct = object({\n  locale: string(),\n  messages: record(\n    string(),\n    object({\n      message: string(),\n      description: optional(string()),\n    }),\n  ),\n});\n\nexport type LocalizationFile = Infer<typeof LocalizationFileStruct>;\n\n/**\n * Validate a list of localization files.\n *\n * @param localizationFiles - The localization files to validate.\n * @returns The validated localization files.\n * @throws If any of the files are considered invalid.\n */\nexport function getValidatedLocalizationFiles(\n  localizationFiles: VirtualFile[],\n): VirtualFile<LocalizationFile>[] {\n  for (const file of localizationFiles) {\n    try {\n      file.result = create(parseJson(file.toString()), LocalizationFileStruct);\n    } catch (error) {\n      if (error instanceof StructError) {\n        throw new Error(\n          `Failed to validate localization file \"${file.path}\": ${error.message}.`,\n        );\n      }\n\n      if (error instanceof SyntaxError) {\n        throw new Error(\n          `Failed to parse localization file \"${file.path}\" as JSON.`,\n        );\n      }\n\n      throw error;\n    }\n  }\n\n  return localizationFiles as VirtualFile<LocalizationFile>[];\n}\n\n/**\n * Get the localization file for a given locale. If the locale is not found,\n * the English localization file will be returned.\n *\n * @param locale - The locale to use.\n * @param localizationFiles - The localization files to use.\n * @returns The localization file, or `undefined` if no localization file was\n * found.\n */\nexport function getLocalizationFile(\n  locale: string,\n  localizationFiles: LocalizationFile[],\n) {\n  const file = localizationFiles.find(\n    (localizationFile) => localizationFile.locale === locale,\n  );\n\n  if (!file) {\n    return localizationFiles.find(\n      (localizationFile) => localizationFile.locale === 'en',\n    );\n  }\n\n  return file;\n}\n\nexport const TRANSLATION_REGEX = /\\{\\{\\s?([a-zA-Z0-9-_\\s]+)\\s?\\}\\}/gu;\n\n/**\n * Translate a string using a localization file. This will replace all instances\n * of `{{key}}` with the localized version of `key`.\n *\n * @param value - The string to translate.\n * @param file - The localization file to use, or `undefined` if no localization\n * file was found.\n * @returns The translated string.\n * @throws If the string contains a key that is not present in the localization\n * file, or if no localization file was found.\n */\nexport function translate(value: string, file: LocalizationFile | undefined) {\n  const matches = value.matchAll(TRANSLATION_REGEX);\n  const array = Array.from(matches);\n\n  return array.reduce<string>((result, [match, key]) => {\n    if (!file) {\n      throw new Error(\n        `Failed to translate \"${value}\": No localization file found.`,\n      );\n    }\n\n    const translation = file.messages[key.trim()];\n    if (!translation) {\n      throw new Error(\n        `Failed to translate \"${value}\": No translation found for \"${key.trim()}\" in \"${\n          file.locale\n        }\" file.`,\n      );\n    }\n\n    return result.replace(match, translation.message);\n  }, value);\n}\n\n/**\n * Get the localized Snap manifest for a given locale. This will replace all\n * localized strings in the manifest with the localized version.\n *\n * @param snapManifest - The Snap manifest to localize.\n * @param locale - The locale to use.\n * @param localizationFiles - The localization files to use.\n * @returns The localized Snap manifest.\n */\nexport function getLocalizedSnapManifest(\n  snapManifest: SnapManifest,\n  locale: string,\n  localizationFiles: LocalizationFile[],\n) {\n  const file = getLocalizationFile(locale, localizationFiles);\n\n  return LOCALIZABLE_FIELDS.reduce((manifest, field) => {\n    const translation = translate(manifest[field], file);\n    return {\n      ...manifest,\n      [field]: translation,\n    };\n  }, snapManifest);\n}\n\n/**\n * Validate the localization files for a Snap manifest.\n *\n * @param snapManifest - The Snap manifest to validate.\n * @param localizationFiles - The localization files to validate.\n * @throws If the manifest cannot be localized.\n */\nexport function validateSnapManifestLocalizations(\n  snapManifest: SnapManifest,\n  localizationFiles: LocalizationFile[],\n) {\n  try {\n    // `translate` throws if the manifest cannot be localized, so we just attempt\n    // to translate the manifest using all localization files.\n    localizationFiles\n      .filter((file) => file.locale !== 'en')\n      .forEach((file) => {\n        getLocalizedSnapManifest(snapManifest, file.locale, localizationFiles);\n      });\n\n    // The manifest must be localizable in English.\n    getLocalizedSnapManifest(snapManifest, 'en', localizationFiles);\n  } catch (error) {\n    throw new Error(\n      `Failed to localize Snap manifest: ${getErrorMessage(error)}`,\n    );\n  }\n}\n"]}

package/dist/chunk-AOGVLPQZ.js

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/path.ts
+var _utils = require('@metamask/utils');
+function normalizeRelative(path) {
+  _utils.assert.call(void 0, !path.startsWith("/"));
+  _utils.assert.call(void 0, 
+    path.search(/:|\/\//u) === -1,
+    `Path "${path}" potentially an URI instead of local relative`
+  );
+  if (path.startsWith("./")) {
+    return path.slice(2);
+  }
+  return path;
+}
+
+
+
+exports.normalizeRelative = normalizeRelative;
+//# sourceMappingURL=chunk-AOGVLPQZ.js.map

package/dist/chunk-AOGVLPQZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/path.ts"],"names":[],"mappings":";AAAA,SAAS,cAAc;AAShB,SAAS,kBAAkB,MAAsB;AACtD,SAAO,CAAC,KAAK,WAAW,GAAG,CAAC;AAC5B;AAAA,IACE,KAAK,OAAO,SAAS,MAAM;AAAA,IAC3B,SAAS,IAAI;AAAA,EACf;AAEA,MAAI,KAAK,WAAW,IAAI,GAAG;AACzB,WAAO,KAAK,MAAM,CAAC;AAAA,EACrB;AACA,SAAO;AACT","sourcesContent":["import { assert } from '@metamask/utils';\n\n/**\n * Normalizes relative paths by optionally removing `./` prefix.\n *\n * @param path - Path to make normalize.\n * @returns The same path, with `./` prefix remove.\n */\n// TODO(ritave): Include NodeJS path polyfill and use path.normalize as well\nexport function normalizeRelative(path: string): string {\n  assert(!path.startsWith('/'));\n  assert(\n    path.search(/:|\\/\\//u) === -1,\n    `Path \"${path}\" potentially an URI instead of local relative`,\n  );\n\n  if (path.startsWith('./')) {\n    return path.slice(2);\n  }\n  return path;\n}\n"]}

package/dist/chunk-AS5P6JRP.mjs

@@ -0,0 +1,9 @@
+// src/entropy.ts
+var SIP_6_MAGIC_VALUE = `1399742832'`;
+var STATE_ENCRYPTION_MAGIC_VALUE = `572232532'`;
+
+export {
+  SIP_6_MAGIC_VALUE,
+  STATE_ENCRYPTION_MAGIC_VALUE
+};
+//# sourceMappingURL=chunk-AS5P6JRP.mjs.map

package/dist/chunk-AS5P6JRP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/entropy.ts"],"sourcesContent":["// 0xd36e6170 - 0x80000000\nexport const SIP_6_MAGIC_VALUE = `1399742832'` as `${number}'`;\n\n// `${bytesToNumber(keccak256('Snaps state encryption').slice(0, 4))}'`\nexport const STATE_ENCRYPTION_MAGIC_VALUE = `572232532'` as `${number}'`;\n\nexport type MagicValue =\n  | typeof SIP_6_MAGIC_VALUE\n  | typeof STATE_ENCRYPTION_MAGIC_VALUE;\n"],"mappings":";AACO,IAAM,oBAAoB;AAG1B,IAAM,+BAA+B;","names":[]}

package/dist/chunk-ASZWZ7JT.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/caveats.ts
+var SnapCaveatType = /* @__PURE__ */ ((SnapCaveatType2) => {
+  SnapCaveatType2["PermittedDerivationPaths"] = "permittedDerivationPaths";
+  SnapCaveatType2["PermittedCoinTypes"] = "permittedCoinTypes";
+  SnapCaveatType2["SnapCronjob"] = "snapCronjob";
+  SnapCaveatType2["TransactionOrigin"] = "transactionOrigin";
+  SnapCaveatType2["SignatureOrigin"] = "signatureOrigin";
+  SnapCaveatType2["RpcOrigin"] = "rpcOrigin";
+  SnapCaveatType2["KeyringOrigin"] = "keyringOrigin";
+  SnapCaveatType2["SnapIds"] = "snapIds";
+  SnapCaveatType2["ChainIds"] = "chainIds";
+  SnapCaveatType2["LookupMatchers"] = "lookupMatchers";
+  SnapCaveatType2["MaxRequestTime"] = "maxRequestTime";
+  return SnapCaveatType2;
+})(SnapCaveatType || {});
+
+
+
+exports.SnapCaveatType = SnapCaveatType;
+//# sourceMappingURL=chunk-ASZWZ7JT.js.map

package/dist/chunk-ASZWZ7JT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/caveats.ts"],"names":["SnapCaveatType"],"mappings":";AAAO,IAAK,iBAAL,kBAAKA,oBAAL;AAIL,EAAAA,gBAAA,8BAA2B;AAK3B,EAAAA,gBAAA,wBAAqB;AAKrB,EAAAA,gBAAA,iBAAc;AAKd,EAAAA,gBAAA,uBAAoB;AAKpB,EAAAA,gBAAA,qBAAkB;AAKlB,EAAAA,gBAAA,eAAY;AAKZ,EAAAA,gBAAA,mBAAgB;AAKhB,EAAAA,gBAAA,aAAU;AAKV,EAAAA,gBAAA,cAAW;AAKX,EAAAA,gBAAA,oBAAiB;AAKjB,EAAAA,gBAAA,oBAAiB;AAtDP,SAAAA;AAAA,GAAA","sourcesContent":["export enum SnapCaveatType {\n  /**\n   * Permitted derivation paths, used by `snap_getBip32Entropy`.\n   */\n  PermittedDerivationPaths = 'permittedDerivationPaths',\n\n  /**\n   * Permitted coin types, used by `snap_getBip44Entropy`.\n   */\n  PermittedCoinTypes = 'permittedCoinTypes',\n\n  /**\n   * Caveat specifying a snap cronjob.\n   */\n  SnapCronjob = 'snapCronjob',\n\n  /**\n   * Caveat specifying access to the transaction origin, used by `endowment:transaction-insight`.\n   */\n  TransactionOrigin = 'transactionOrigin',\n\n  /**\n   * Caveat specifying access to the signature origin, used by `endowment:signature-insight`.\n   */\n  SignatureOrigin = 'signatureOrigin',\n\n  /**\n   * The origins that a Snap can receive JSON-RPC messages from.\n   */\n  RpcOrigin = 'rpcOrigin',\n\n  /**\n   * The origins that a Snap can receive keyring messages from.\n   */\n  KeyringOrigin = 'keyringOrigin',\n\n  /**\n   * Caveat specifying the snap IDs that can be interacted with.\n   */\n  SnapIds = 'snapIds',\n\n  /**\n   * Caveat specifying the CAIP-2 chain IDs that a snap can service, currently limited to `endowment:name-lookup`.\n   */\n  ChainIds = 'chainIds',\n\n  /**\n   * Caveat specifying the input that a name lookup snap can service, currently limited to `endowment:name-lookup`.\n   */\n  LookupMatchers = 'lookupMatchers',\n\n  /**\n   * Caveat specifying the max request time for a handler endowment.\n   */\n  MaxRequestTime = 'maxRequestTime',\n}\n"]}

package/dist/chunk-BGSO2GQC.mjs

@@ -0,0 +1,41 @@
+// src/default-endowments.ts
+var DEFAULT_ENDOWMENTS = Object.freeze([
+  "atob",
+  "btoa",
+  "BigInt",
+  "console",
+  "crypto",
+  "Date",
+  "Math",
+  "setTimeout",
+  "clearTimeout",
+  "SubtleCrypto",
+  "TextDecoder",
+  "TextEncoder",
+  "URL",
+  "setInterval",
+  "clearInterval",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "DataView",
+  "ArrayBuffer",
+  // Used by fetch, but also as API for some packages that don't do network connections
+  // https://github.com/MetaMask/snaps-monorepo/issues/662
+  // https://github.com/MetaMask/snaps-monorepo/discussions/678
+  "AbortController",
+  "AbortSignal"
+]);
+
+export {
+  DEFAULT_ENDOWMENTS
+};
+//# sourceMappingURL=chunk-BGSO2GQC.mjs.map

package/dist/chunk-BGSO2GQC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/default-endowments.ts"],"sourcesContent":["/**\n * Global JavaScript APIs exposed by default to all snaps.\n */\nexport const DEFAULT_ENDOWMENTS: readonly string[] = Object.freeze([\n  'atob',\n  'btoa',\n  'BigInt',\n  'console',\n  'crypto',\n  'Date',\n  'Math',\n  'setTimeout',\n  'clearTimeout',\n  'SubtleCrypto',\n  'TextDecoder',\n  'TextEncoder',\n  'URL',\n  'setInterval',\n  'clearInterval',\n  'Int8Array',\n  'Uint8Array',\n  'Uint8ClampedArray',\n  'Int16Array',\n  'Uint16Array',\n  'Int32Array',\n  'Uint32Array',\n  'Float32Array',\n  'Float64Array',\n  'BigInt64Array',\n  'BigUint64Array',\n  'DataView',\n  'ArrayBuffer',\n  // Used by fetch, but also as API for some packages that don't do network connections\n  // https://github.com/MetaMask/snaps-monorepo/issues/662\n  // https://github.com/MetaMask/snaps-monorepo/discussions/678\n  'AbortController',\n  'AbortSignal',\n]);\n"],"mappings":";AAGO,IAAM,qBAAwC,OAAO,OAAO;AAAA,EACjE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA,EACA;AACF,CAAC;","names":[]}

package/dist/chunk-CMOSYNZR.js

@@ -0,0 +1,95 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/types.ts
+var _utils = require('@metamask/utils');
+
+
+
+
+
+
+
+
+
+
+
+
+var _superstruct = require('superstruct');
+var NpmSnapFileNames = /* @__PURE__ */ ((NpmSnapFileNames2) => {
+  NpmSnapFileNames2["PackageJson"] = "package.json";
+  NpmSnapFileNames2["Manifest"] = "snap.manifest.json";
+  return NpmSnapFileNames2;
+})(NpmSnapFileNames || {});
+var NameStruct = _superstruct.size.call(void 0, 
+  _superstruct.pattern.call(void 0, 
+    _superstruct.string.call(void 0, ),
+    /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/u
+  ),
+  1,
+  214
+);
+var NpmSnapPackageJsonStruct = _superstruct.type.call(void 0, {
+  version: _utils.VersionStruct,
+  name: NameStruct,
+  main: _superstruct.optional.call(void 0, _superstruct.size.call(void 0, _superstruct.string.call(void 0, ), 1, Infinity)),
+  repository: _superstruct.optional.call(void 0, 
+    _superstruct.object.call(void 0, {
+      type: _superstruct.size.call(void 0, _superstruct.string.call(void 0, ), 1, Infinity),
+      url: _superstruct.size.call(void 0, _superstruct.string.call(void 0, ), 1, Infinity)
+    })
+  )
+});
+function isNpmSnapPackageJson(value) {
+  return _superstruct.is.call(void 0, value, NpmSnapPackageJsonStruct);
+}
+function assertIsNpmSnapPackageJson(value) {
+  _utils.assertStruct.call(void 0, 
+    value,
+    NpmSnapPackageJsonStruct,
+    `"${"package.json" /* PackageJson */}" is invalid`
+  );
+}
+var SnapIdPrefixes = /* @__PURE__ */ ((SnapIdPrefixes2) => {
+  SnapIdPrefixes2["npm"] = "npm:";
+  SnapIdPrefixes2["local"] = "local:";
+  return SnapIdPrefixes2;
+})(SnapIdPrefixes || {});
+var SnapValidationFailureReason = /* @__PURE__ */ ((SnapValidationFailureReason2) => {
+  SnapValidationFailureReason2["NameMismatch"] = '"name" field mismatch';
+  SnapValidationFailureReason2["VersionMismatch"] = '"version" field mismatch';
+  SnapValidationFailureReason2["RepositoryMismatch"] = '"repository" field mismatch';
+  SnapValidationFailureReason2["ShasumMismatch"] = '"shasum" field mismatch';
+  return SnapValidationFailureReason2;
+})(SnapValidationFailureReason || {});
+var SNAP_STREAM_NAMES = /* @__PURE__ */ ((SNAP_STREAM_NAMES2) => {
+  SNAP_STREAM_NAMES2["JSON_RPC"] = "jsonRpc";
+  SNAP_STREAM_NAMES2["COMMAND"] = "command";
+  return SNAP_STREAM_NAMES2;
+})(SNAP_STREAM_NAMES || {});
+var uri = (opts = {}) => _superstruct.refine.call(void 0, _superstruct.union.call(void 0, [_superstruct.string.call(void 0, ), _superstruct.instance.call(void 0, URL)]), "uri", (value) => {
+  try {
+    const url = new URL(value);
+    const UrlStruct = _superstruct.type.call(void 0, opts);
+    _superstruct.assert.call(void 0, url, UrlStruct);
+    return true;
+  } catch {
+    return `Expected URL, got "${value.toString()}".`;
+  }
+});
+function isValidUrl(url, opts = {}) {
+  return _superstruct.is.call(void 0, url, uri(opts));
+}
+var WALLET_SNAP_PERMISSION_KEY = "wallet_snap";
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.NpmSnapFileNames = NpmSnapFileNames; exports.NameStruct = NameStruct; exports.NpmSnapPackageJsonStruct = NpmSnapPackageJsonStruct; exports.isNpmSnapPackageJson = isNpmSnapPackageJson; exports.assertIsNpmSnapPackageJson = assertIsNpmSnapPackageJson; exports.SnapIdPrefixes = SnapIdPrefixes; exports.SnapValidationFailureReason = SnapValidationFailureReason; exports.SNAP_STREAM_NAMES = SNAP_STREAM_NAMES; exports.uri = uri; exports.isValidUrl = isValidUrl; exports.WALLET_SNAP_PERMISSION_KEY = WALLET_SNAP_PERMISSION_KEY;
+//# sourceMappingURL=chunk-CMOSYNZR.js.map

package/dist/chunk-CMOSYNZR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"names":["NpmSnapFileNames","SnapIdPrefixes","SnapValidationFailureReason","SNAP_STREAM_NAMES"],"mappings":";AACA,SAAS,cAAc,qBAAqB;AAE5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,UAAU;AAAA,OACL;AAQA,IAAK,mBAAL,kBAAKA,sBAAL;AACL,EAAAA,kBAAA,iBAAc;AACd,EAAAA,kBAAA,cAAW;AAFD,SAAAA;AAAA,GAAA;AAKL,IAAM,aAAa;AAAA,EACxB;AAAA,IACE,OAAO;AAAA,IACP;AAAA,EACF;AAAA,EACA;AAAA,EACA;AACF;AAIO,IAAM,2BAA2B,KAAK;AAAA,EAC3C,SAAS;AAAA,EACT,MAAM;AAAA,EACN,MAAM,SAAS,KAAK,OAAO,GAAG,GAAG,QAAQ,CAAC;AAAA,EAC1C,YAAY;AAAA,IACV,OAAO;AAAA,MACL,MAAM,KAAK,OAAO,GAAG,GAAG,QAAQ;AAAA,MAChC,KAAK,KAAK,OAAO,GAAG,GAAG,QAAQ;AAAA,IACjC,CAAC;AAAA,EACH;AACF,CAAC;AAWM,SAAS,qBACd,OAC6B;AAC7B,SAAO,GAAG,OAAO,wBAAwB;AAC3C;AAQO,SAAS,2BACd,OACqC;AACrC;AAAA,IACE;AAAA,IACA;AAAA,IACA,IAAI,gCAA4B;AAAA,EAClC;AACF;AAuCO,IAAK,iBAAL,kBAAKC,oBAAL;AACL,EAAAA,gBAAA,SAAM;AACN,EAAAA,gBAAA,WAAQ;AAFE,SAAAA;AAAA,GAAA;AAUL,IAAK,8BAAL,kBAAKC,iCAAL;AACL,EAAAA,6BAAA,kBAAe;AACf,EAAAA,6BAAA,qBAAkB;AAClB,EAAAA,6BAAA,wBAAqB;AACrB,EAAAA,6BAAA,oBAAiB;AAJP,SAAAA;AAAA,GAAA;AAQL,IAAK,oBAAL,kBAAKC,uBAAL;AACL,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,aAAU;AAFA,SAAAA;AAAA,GAAA;AAwBL,IAAM,MAAM,CAAC,OAAwB,CAAC,MAC3C,OAAO,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU;AACzD,MAAI;AACF,UAAM,MAAM,IAAI,IAAI,KAAK;AAEzB,UAAM,YAAY,KAAK,IAAI;AAC3B,sBAAkB,KAAK,SAAS;AAChC,WAAO;AAAA,EACT,QAAQ;AACN,WAAO,sBAAsB,MAAM,SAAS,CAAC;AAAA,EAC/C;AACF,CAAC;AASI,SAAS,WACd,KACA,OAAwB,CAAC,GACJ;AACrB,SAAO,GAAG,KAAK,IAAI,IAAI,CAAC;AAC1B;AAGO,IAAM,6BAA6B","sourcesContent":["import type { Json } from '@metamask/utils';\nimport { assertStruct, VersionStruct } from '@metamask/utils';\nimport type { Infer, Struct } from 'superstruct';\nimport {\n  instance,\n  is,\n  object,\n  optional,\n  pattern,\n  refine,\n  size,\n  string,\n  type,\n  union,\n  assert as assertSuperstruct,\n} from 'superstruct';\n\nimport type { SnapCaveatType } from './caveats';\nimport type { SnapFunctionExports, SnapRpcHookArgs } from './handlers';\nimport type { LocalizationFile } from './localization';\nimport type { SnapManifest } from './manifest';\nimport type { VirtualFile } from './virtual-file';\n\nexport enum NpmSnapFileNames {\n  PackageJson = 'package.json',\n  Manifest = 'snap.manifest.json',\n}\n\nexport const NameStruct = size(\n  pattern(\n    string(),\n    /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\\/)?[a-z0-9-~][a-z0-9-._~]*$/u,\n  ),\n  1,\n  214,\n);\n\n// Note we use `type` instead of `object` here, because the latter does not\n// allow unknown keys.\nexport const NpmSnapPackageJsonStruct = type({\n  version: VersionStruct,\n  name: NameStruct,\n  main: optional(size(string(), 1, Infinity)),\n  repository: optional(\n    object({\n      type: size(string(), 1, Infinity),\n      url: size(string(), 1, Infinity),\n    }),\n  ),\n});\n\nexport type NpmSnapPackageJson = Infer<typeof NpmSnapPackageJsonStruct> &\n  Record<string, any>;\n\n/**\n * Check if the given value is a valid {@link NpmSnapPackageJson} object.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link NpmSnapPackageJson} object.\n */\nexport function isNpmSnapPackageJson(\n  value: unknown,\n): value is NpmSnapPackageJson {\n  return is(value, NpmSnapPackageJsonStruct);\n}\n\n/**\n * Asserts that the given value is a valid {@link NpmSnapPackageJson} object.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid {@link NpmSnapPackageJson} object.\n */\nexport function assertIsNpmSnapPackageJson(\n  value: unknown,\n): asserts value is NpmSnapPackageJson {\n  assertStruct(\n    value,\n    NpmSnapPackageJsonStruct,\n    `\"${NpmSnapFileNames.PackageJson}\" is invalid`,\n  );\n}\n\n/**\n * An object for storing parsed but unvalidated Snap file contents.\n */\nexport type UnvalidatedSnapFiles = {\n  manifest?: VirtualFile<Json>;\n  packageJson?: VirtualFile<Json>;\n  sourceCode?: VirtualFile;\n  svgIcon?: VirtualFile;\n  auxiliaryFiles: VirtualFile[];\n  localizationFiles: VirtualFile[];\n};\n\n/**\n * An object for storing the contents of Snap files that have passed JSON\n * Schema validation, or are non-empty if they are strings.\n */\nexport type SnapFiles = {\n  manifest: VirtualFile<SnapManifest>;\n  packageJson: VirtualFile<NpmSnapPackageJson>;\n  sourceCode: VirtualFile;\n  svgIcon?: VirtualFile;\n  auxiliaryFiles: VirtualFile[];\n  localizationFiles: VirtualFile<LocalizationFile>[];\n};\n\n/**\n * A subset of snap files extracted from a fetched snap.\n */\nexport type FetchedSnapFiles = Pick<\n  SnapFiles,\n  'manifest' | 'sourceCode' | 'svgIcon' | 'auxiliaryFiles' | 'localizationFiles'\n>;\n\n/**\n * The possible prefixes for snap ids.\n */\n/* eslint-disable @typescript-eslint/naming-convention */\nexport enum SnapIdPrefixes {\n  npm = 'npm:',\n  local = 'local:',\n}\n/* eslint-enable @typescript-eslint/naming-convention */\n\n/**\n * Snap validation failure reason codes that are programmatically fixable\n * if validation occurs during development.\n */\nexport enum SnapValidationFailureReason {\n  NameMismatch = '\"name\" field mismatch',\n  VersionMismatch = '\"version\" field mismatch',\n  RepositoryMismatch = '\"repository\" field mismatch',\n  ShasumMismatch = '\"shasum\" field mismatch',\n}\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport enum SNAP_STREAM_NAMES {\n  JSON_RPC = 'jsonRpc',\n  COMMAND = 'command',\n}\n/* eslint-enable @typescript-eslint/naming-convention */\n\n// The snap is the callee\nexport type SnapRpcHook = (options: SnapRpcHookArgs) => Promise<unknown>;\n\ntype ObjectParameters<\n  Type extends Record<string, (...args: any[]) => unknown>,\n> = Parameters<Type[keyof Type]>;\n\nexport type SnapExportsParameters = ObjectParameters<SnapFunctionExports>;\n\ntype UriOptions<Type extends string> = {\n  protocol?: Struct<Type>;\n  hash?: Struct<Type>;\n  port?: Struct<Type>;\n  hostname?: Struct<Type>;\n  pathname?: Struct<Type>;\n  search?: Struct<Type>;\n};\n\nexport const uri = (opts: UriOptions<any> = {}) =>\n  refine(union([string(), instance(URL)]), 'uri', (value) => {\n    try {\n      const url = new URL(value);\n\n      const UrlStruct = type(opts);\n      assertSuperstruct(url, UrlStruct);\n      return true;\n    } catch {\n      return `Expected URL, got \"${value.toString()}\".`;\n    }\n  });\n\n/**\n * Returns whether a given value is a valid URL.\n *\n * @param url - The value to check.\n * @param opts - Optional constraints for url checking.\n * @returns Whether `url` is valid URL or not.\n */\nexport function isValidUrl(\n  url: unknown,\n  opts: UriOptions<any> = {},\n): url is string | URL {\n  return is(url, uri(opts));\n}\n\n// redefining here to avoid circular dependency\nexport const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';\n\nexport type SnapsPermissionRequest = {\n  [WALLET_SNAP_PERMISSION_KEY]: {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapIds;\n        value: Record<string, Json>;\n      },\n    ];\n  };\n};\n"]}