@metamask-previews/keyring-utils 0.0.1-672cc7b → 0.0.1-b85bfaa

package/dist/{index.js → index.cjs}

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./typing"), exports);
-__exportStar(require("./superstruct"), exports);
-//# sourceMappingURL=index.js.map
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./typing.cjs"), exports);
+__exportStar(require("./superstruct.cjs"), exports);
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAAwB;AACxB,+CAAyB;AACzB,oDAA8B","sourcesContent":["export * from './types';\nexport * from './typing';\nexport * from './superstruct';\n"]}

package/dist/index.d.cts

@@ -0,0 +1,4 @@
+export * from "./types.cjs";
+export * from "./typing.cjs";
+export * from "./superstruct.cjs";
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4BAAwB;AACxB,6BAAyB;AACzB,kCAA8B"}

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+export * from "./types.mjs";
+export * from "./typing.mjs";
+export * from "./superstruct.mjs";
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4BAAwB;AACxB,6BAAyB;AACzB,kCAA8B"}

package/dist/index.mjs

@@ -0,0 +1,4 @@
+export * from "./types.mjs";
+export * from "./typing.mjs";
+export * from "./superstruct.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4BAAwB;AACxB,6BAAyB;AACzB,kCAA8B","sourcesContent":["export * from './types';\nexport * from './typing';\nexport * from './superstruct';\n"]}

package/dist/{superstruct.js → superstruct.cjs}

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.strictMask = exports.definePattern = exports.exactOptional = exports.object = void 0;
+exports.object = object;
+exports.exactOptional = exactOptional;
+exports.definePattern = definePattern;
+exports.strictMask = strictMask;
 const superstruct_1 = require("@metamask/superstruct");
 /**
  * Change the return type of a superstruct object struct to support exact
@@ -12,7 +15,6 @@ const superstruct_1 = require("@metamask/superstruct");
 function object(schema) {
     return (0, superstruct_1.object)(schema);
 }
-exports.object = object;
 /**
  * Check if the current property is present in its parent object.
  *
@@ -44,7 +46,6 @@ function exactOptional(struct) {
         refiner: (value, ctx) => !hasOptional(ctx) || struct.refiner(value, ctx),
     });
 }
-exports.exactOptional = exactOptional;
 /**
  * Defines a new string-struct matching a regular expression.
  *
@@ -61,7 +62,6 @@ exports.exactOptional = exactOptional;
 function definePattern(name, pattern) {
     return (0, superstruct_1.define)(name, (value) => typeof value === 'string' && pattern.test(value));
 }
-exports.definePattern = definePattern;
 /**
  * Assert that a value is valid according to a struct.
  *
@@ -77,5 +77,4 @@ function strictMask(value, struct, message) {
     (0, superstruct_1.assert)(value, struct, message);
     return value;
 }
-exports.strictMask = strictMask;
-//# sourceMappingURL=superstruct.js.map
+//# sourceMappingURL=superstruct.cjs.map

package/dist/superstruct.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.cjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":";;AAiEA,wBAIC;AA4BD,sCAYC;AAeD,sCASC;AAaD,gCAOC;AAzJD,uDAK+B;AAqD/B;;;;;;GAMG;AACH,SAAgB,MAAM,CACpB,MAAc;IAEd,OAAO,IAAA,oBAAQ,EAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,oBAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,IAAY,EACZ,OAAe;IAEf,OAAO,IAAA,oBAAM,EACX,IAAI,EACJ,CAAC,KAAc,EAAW,EAAE,CAC1B,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CACnD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,IAAA,oBAAM,EAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import {\n  Struct,\n  assert,\n  define,\n  object as stObject,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n} from '@metamask/superstruct';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct object struct to support exact\n * optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Defines a new string-struct matching a regular expression.\n *\n * Example:\n *\n * ```ts\n * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);\n * ```\n *\n * @param name - Type name.\n * @param pattern - Regular expression to match.\n * @returns A new string-struct that matches the given pattern.\n */\nexport function definePattern(\n  name: string,\n  pattern: RegExp,\n): Struct<string, null> {\n  return define<string>(\n    name,\n    (value: unknown): boolean =>\n      typeof value === 'string' && pattern.test(value),\n  );\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n"]}

package/dist/{superstruct.d.ts → superstruct.d.cts}

@@ -1,7 +1,7 @@
-import { Struct } from '@metamask/superstruct';
-import type { Infer, ObjectSchema, OmitBy, Optionalize, PickBy, Simplify } from '@metamask/superstruct';
+import { Struct } from "@metamask/superstruct";
+import type { Infer, ObjectSchema, OmitBy, Optionalize, PickBy, Simplify } from "@metamask/superstruct";
 declare const ExactOptionalSymbol: unique symbol;
-export declare type ExactOptionalTag = {
+export type ExactOptionalTag = {
     type: typeof ExactOptionalSymbol;
 };
 /**
@@ -13,7 +13,7 @@ export declare type ExactOptionalTag = {
  * // Bar = { a: string, b: number }
  * ```
  */
-export declare type ExcludeType<Obj, Type> = {
+export type ExcludeType<Obj, Type> = {
     [K in keyof Obj]: Exclude<Obj[K], Type>;
 };
 /**
@@ -25,11 +25,11 @@ export declare type ExcludeType<Obj, Type> = {
  * // Bar = { a?: string; b: number}
  * ```
  */
-export declare type ExactOptionalize<Schema extends object> = OmitBy<Schema, ExactOptionalTag> & Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;
+export type ExactOptionalize<Schema extends object> = OmitBy<Schema, ExactOptionalTag> & Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;
 /**
  * Infer a type from an superstruct object schema.
  */
-export declare type ObjectType<Schema extends ObjectSchema> = Simplify<ExactOptionalize<Optionalize<{
+export type ObjectType<Schema extends ObjectSchema> = Simplify<ExactOptionalize<Optionalize<{
     [K in keyof Schema]: Infer<Schema[K]>;
 }>>>;
 /**
@@ -81,3 +81,4 @@ export declare function definePattern(name: string, pattern: RegExp): Struct<str
  */
 export declare function strictMask<Type, Schema>(value: unknown, struct: Struct<Type, Schema>, message?: string): Type;
 export {};
+//# sourceMappingURL=superstruct.d.cts.map

package/dist/superstruct.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.d.cts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACT,8BAA8B;AAG/B,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAMtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN"}

package/dist/superstruct.d.mts

@@ -0,0 +1,84 @@
+import { Struct } from "@metamask/superstruct";
+import type { Infer, ObjectSchema, OmitBy, Optionalize, PickBy, Simplify } from "@metamask/superstruct";
+declare const ExactOptionalSymbol: unique symbol;
+export type ExactOptionalTag = {
+    type: typeof ExactOptionalSymbol;
+};
+/**
+ * Exclude type `Type` from the properties of `Obj`.
+ *
+ * ```ts
+ * type Foo = { a: string | null; b: number };
+ * type Bar = ExcludeType<Foo, null>;
+ * // Bar = { a: string, b: number }
+ * ```
+ */
+export type ExcludeType<Obj, Type> = {
+    [K in keyof Obj]: Exclude<Obj[K], Type>;
+};
+/**
+ * Make optional all properties that have the `ExactOptionalTag` type.
+ *
+ * ```ts
+ * type Foo = { a: string | ExactOptionalTag; b: number};
+ * type Bar = ExactOptionalize<Foo>;
+ * // Bar = { a?: string; b: number}
+ * ```
+ */
+export type ExactOptionalize<Schema extends object> = OmitBy<Schema, ExactOptionalTag> & Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;
+/**
+ * Infer a type from an superstruct object schema.
+ */
+export type ObjectType<Schema extends ObjectSchema> = Simplify<ExactOptionalize<Optionalize<{
+    [K in keyof Schema]: Infer<Schema[K]>;
+}>>>;
+/**
+ * Change the return type of a superstruct object struct to support exact
+ * optional properties.
+ *
+ * @param schema - The object schema.
+ * @returns A struct representing an object with a known set of properties.
+ */
+export declare function object<Schema extends ObjectSchema>(schema: Schema): Struct<ObjectType<Schema>, Schema>;
+/**
+ * Augment a struct to allow exact-optional values. Exact-optional values can
+ * be omitted but cannot be `undefined`.
+ *
+ * ```ts
+ * const foo = object({ bar: exactOptional(string()) });
+ * type Foo = Infer<typeof foo>;
+ * // Foo = { bar?: string }
+ * ```
+ *
+ * @param struct - The struct to augment.
+ * @returns The augmented struct.
+ */
+export declare function exactOptional<Type, Schema>(struct: Struct<Type, Schema>): Struct<Type | ExactOptionalTag, Schema>;
+/**
+ * Defines a new string-struct matching a regular expression.
+ *
+ * Example:
+ *
+ * ```ts
+ * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);
+ * ```
+ *
+ * @param name - Type name.
+ * @param pattern - Regular expression to match.
+ * @returns A new string-struct that matches the given pattern.
+ */
+export declare function definePattern(name: string, pattern: RegExp): Struct<string, null>;
+/**
+ * Assert that a value is valid according to a struct.
+ *
+ * It is similar to superstruct's mask function, but it does not ignore extra
+ * properties.
+ *
+ * @param value - Value to check.
+ * @param struct - Struct to validate the value against.
+ * @param message - Error message to throw if the value is not valid.
+ * @returns The value if it is valid.
+ */
+export declare function strictMask<Type, Schema>(value: unknown, struct: Struct<Type, Schema>, message?: string): Type;
+export {};
+//# sourceMappingURL=superstruct.d.mts.map

package/dist/superstruct.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.d.mts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACT,8BAA8B;AAG/B,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAMtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN"}

package/dist/superstruct.mjs

@@ -0,0 +1,74 @@
+import { Struct, assert, define, object as stObject } from "@metamask/superstruct";
+/**
+ * Change the return type of a superstruct object struct to support exact
+ * optional properties.
+ *
+ * @param schema - The object schema.
+ * @returns A struct representing an object with a known set of properties.
+ */
+export function object(schema) {
+    return stObject(schema);
+}
+/**
+ * Check if the current property is present in its parent object.
+ *
+ * @param ctx - The context to check.
+ * @returns `true` if the property is present, `false` otherwise.
+ */
+function hasOptional(ctx) {
+    const property = ctx.path[ctx.path.length - 1];
+    const parent = ctx.branch[ctx.branch.length - 2];
+    return property in parent;
+}
+/**
+ * Augment a struct to allow exact-optional values. Exact-optional values can
+ * be omitted but cannot be `undefined`.
+ *
+ * ```ts
+ * const foo = object({ bar: exactOptional(string()) });
+ * type Foo = Infer<typeof foo>;
+ * // Foo = { bar?: string }
+ * ```
+ *
+ * @param struct - The struct to augment.
+ * @returns The augmented struct.
+ */
+export function exactOptional(struct) {
+    return new Struct({
+        ...struct,
+        validator: (value, ctx) => !hasOptional(ctx) || struct.validator(value, ctx),
+        refiner: (value, ctx) => !hasOptional(ctx) || struct.refiner(value, ctx),
+    });
+}
+/**
+ * Defines a new string-struct matching a regular expression.
+ *
+ * Example:
+ *
+ * ```ts
+ * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);
+ * ```
+ *
+ * @param name - Type name.
+ * @param pattern - Regular expression to match.
+ * @returns A new string-struct that matches the given pattern.
+ */
+export function definePattern(name, pattern) {
+    return define(name, (value) => typeof value === 'string' && pattern.test(value));
+}
+/**
+ * Assert that a value is valid according to a struct.
+ *
+ * It is similar to superstruct's mask function, but it does not ignore extra
+ * properties.
+ *
+ * @param value - Value to check.
+ * @param struct - Struct to validate the value against.
+ * @param message - Error message to throw if the value is not valid.
+ * @returns The value if it is valid.
+ */
+export function strictMask(value, struct, message) {
+    assert(value, struct, message);
+    return value;
+}
+//# sourceMappingURL=superstruct.mjs.map

package/dist/superstruct.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.mjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,MAAM,EACN,MAAM,EACN,MAAM,IAAI,QAAQ,EACnB,8BAA8B;AAqD/B;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CACpB,MAAc;IAEd,OAAO,QAAQ,CAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,MAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAY,EACZ,OAAe;IAEf,OAAO,MAAM,CACX,IAAI,EACJ,CAAC,KAAc,EAAW,EAAE,CAC1B,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CACnD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import {\n  Struct,\n  assert,\n  define,\n  object as stObject,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n} from '@metamask/superstruct';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct object struct to support exact\n * optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Defines a new string-struct matching a regular expression.\n *\n * Example:\n *\n * ```ts\n * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);\n * ```\n *\n * @param name - Type name.\n * @param pattern - Regular expression to match.\n * @returns A new string-struct that matches the given pattern.\n */\nexport function definePattern(\n  name: string,\n  pattern: RegExp,\n): Struct<string, null> {\n  return define<string>(\n    name,\n    (value: unknown): boolean =>\n      typeof value === 'string' && pattern.test(value),\n  );\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n"]}

package/dist/{types.js → types.cjs}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringNumberStruct = exports.UrlStruct = exports.UuidStruct = void 0;
 const superstruct_1 = require("@metamask/superstruct");
-const superstruct_2 = require("./superstruct");
+const superstruct_2 = require("./superstruct.cjs");
 /**
  * UUIDv4 struct.
  */
@@ -18,12 +18,12 @@ exports.UrlStruct = (0, superstruct_1.define)('Url', (value) => {
         const url = new URL(value);
         return url.protocol === 'http:' || url.protocol === 'https:';
     }
-    catch (_) {
+    catch {
         return false;
     }
 });
 /**
  * A string which contains a positive float number.
  */
-exports.StringNumberStruct = (0, superstruct_2.definePattern)('StringNumber', /^\d+(\.\d+)?$/u);
-//# sourceMappingURL=types.js.map
+exports.StringNumberStruct = (0, superstruct_2.definePattern)('StringNumber', /^\d*(\.\d+)?$/u);
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,uDAA2D;AAE3D,mDAA8C;AAE9C;;GAEG;AACU,QAAA,UAAU,GAAG,IAAA,2BAAa,EACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AAEF;;;;;GAKG;AACU,QAAA,SAAS,GAAG,IAAA,oBAAM,EAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,kBAAkB,GAAG,IAAA,2BAAa,EAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\n\nimport { definePattern } from './superstruct';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d*(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n"]}

package/dist/{types.d.ts → types.d.cts}

@@ -1,4 +1,4 @@
-import { type Infer } from '@metamask/superstruct';
+import { type Infer } from "@metamask/superstruct";
 /**
  * UUIDv4 struct.
  */
@@ -14,4 +14,5 @@ export declare const UrlStruct: import("@metamask/superstruct").Struct<string, n
  * A string which contains a positive float number.
  */
 export declare const StringNumberStruct: import("@metamask/superstruct").Struct<string, null>;
-export declare type StringNumber = Infer<typeof StringNumberStruct>;
+export type StringNumber = Infer<typeof StringNumberStruct>;
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,KAAK,EAAE,8BAA8B;AAI3D;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/types.d.mts

@@ -0,0 +1,18 @@
+import { type Infer } from "@metamask/superstruct";
+/**
+ * UUIDv4 struct.
+ */
+export declare const UuidStruct: import("@metamask/superstruct").Struct<string, null>;
+/**
+ * Validates if a given value is a valid URL.
+ *
+ * @param value - The value to be validated.
+ * @returns A boolean indicating if the value is a valid URL.
+ */
+export declare const UrlStruct: import("@metamask/superstruct").Struct<string, null>;
+/**
+ * A string which contains a positive float number.
+ */
+export declare const StringNumberStruct: import("@metamask/superstruct").Struct<string, null>;
+export type StringNumber = Infer<typeof StringNumberStruct>;
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,KAAK,EAAE,8BAA8B;AAI3D;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/types.mjs

@@ -0,0 +1,26 @@
+import { define } from "@metamask/superstruct";
+import { definePattern } from "./superstruct.mjs";
+/**
+ * UUIDv4 struct.
+ */
+export const UuidStruct = definePattern('UuidV4', /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu);
+/**
+ * Validates if a given value is a valid URL.
+ *
+ * @param value - The value to be validated.
+ * @returns A boolean indicating if the value is a valid URL.
+ */
+export const UrlStruct = define('Url', (value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+});
+/**
+ * A string which contains a positive float number.
+ */
+export const StringNumberStruct = definePattern('StringNumber', /^\d*(\.\d+)?$/u);
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,8BAA8B;AAE3D,OAAO,EAAE,aAAa,EAAE,0BAAsB;AAE9C;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\n\nimport { definePattern } from './superstruct';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d*(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n"]}

package/dist/{typing.js → typing.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectTrue = void 0;
+exports.expectTrue = expectTrue;
 /**
  * Assert that a type extends `true`. It can be used, for example, to assert
  * that a given type extends another type.
@@ -17,5 +17,4 @@ exports.expectTrue = void 0;
 function expectTrue() {
     // Intentionally empty
 }
-exports.expectTrue = expectTrue;
-//# sourceMappingURL=typing.js.map
+//# sourceMappingURL=typing.cjs.map

package/dist/{typing.js.map → typing.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"typing.js","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":";;;AAuBA;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,SAAgB,UAAU;IACxB,sBAAsB;AACxB,CAAC;AAFD,gCAEC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}
+{"version":3,"file":"typing.cjs","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":";;AAoCA,gCAEC;AAfD;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,SAAgB,UAAU;IACxB,sBAAsB;AACxB,CAAC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}

package/dist/{typing.d.ts → typing.d.cts}

@@ -6,7 +6,7 @@
  *
  * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>
  */
-export declare type OmitUnion<Type, Key extends keyof any> = Type extends any ? Omit<Type, Key> : never;
+export type OmitUnion<Type, Key extends keyof any> = Type extends any ? Omit<Type, Key> : never;
 /**
  * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.
  *
@@ -16,7 +16,7 @@ export declare type OmitUnion<Type, Key extends keyof any> = Type extends any ?
  * type B = Extends<{a: string}, {a: string, b: string}>; // false
  * ```
  */
-export declare type Extends<Child, Base> = Child extends Base ? true : false;
+export type Extends<Child, Base> = Child extends Base ? true : false;
 /**
  * Assert that a type extends `true`. It can be used, for example, to assert
  * that a given type extends another type.
@@ -30,3 +30,4 @@ export declare type Extends<Child, Base> = Child extends Base ? true : false;
  * This function follows the naming pattern used on `tsd`.
  */
 export declare function expectTrue<Type extends true>(): void;
+//# sourceMappingURL=typing.d.cts.map

package/dist/typing.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing.d.cts","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,CAAC,IAAI,EAAE,GAAG,SAAS,MAAM,GAAG,IAAI,IAAI,SAAS,GAAG,GACjE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,GACf,KAAK,CAAC;AAEV;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CAAC,KAAK,EAAE,IAAI,IAAI,KAAK,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC;AAErE;;;;;;;;;;;GAWG;AAEH,wBAAgB,UAAU,CAAC,IAAI,SAAS,IAAI,KAAK,IAAI,CAEpD"}

package/dist/typing.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Omit keys from a union type.
+ *
+ * The normal `Omit` type does not distribute over unions. So we use this
+ * workaround that applies `Omit` to each member of the union.
+ *
+ * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>
+ */
+export type OmitUnion<Type, Key extends keyof any> = Type extends any ? Omit<Type, Key> : never;
+/**
+ * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * type A = Extends<{a: string, b: string}, {a: string}>; // true
+ * type B = Extends<{a: string}, {a: string, b: string}>; // false
+ * ```
+ */
+export type Extends<Child, Base> = Child extends Base ? true : false;
+/**
+ * Assert that a type extends `true`. It can be used, for example, to assert
+ * that a given type extends another type.
+ *
+ * @example
+ * ```ts
+ * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok
+ * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error
+ * ```
+ *
+ * This function follows the naming pattern used on `tsd`.
+ */
+export declare function expectTrue<Type extends true>(): void;
+//# sourceMappingURL=typing.d.mts.map

package/dist/typing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing.d.mts","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,CAAC,IAAI,EAAE,GAAG,SAAS,MAAM,GAAG,IAAI,IAAI,SAAS,GAAG,GACjE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,GACf,KAAK,CAAC;AAEV;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CAAC,KAAK,EAAE,IAAI,IAAI,KAAK,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC;AAErE;;;;;;;;;;;GAWG;AAEH,wBAAgB,UAAU,CAAC,IAAI,SAAS,IAAI,KAAK,IAAI,CAEpD"}

package/dist/typing.mjs

@@ -0,0 +1,17 @@
+/**
+ * Assert that a type extends `true`. It can be used, for example, to assert
+ * that a given type extends another type.
+ *
+ * @example
+ * ```ts
+ * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok
+ * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error
+ * ```
+ *
+ * This function follows the naming pattern used on `tsd`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function expectTrue() {
+    // Intentionally empty
+}
+//# sourceMappingURL=typing.mjs.map

package/dist/typing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing.mjs","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,MAAM,UAAU,UAAU;IACxB,sBAAsB;AACxB,CAAC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask-previews/keyring-utils",
-  "version": "0.0.1-672cc7b",
+  "version": "0.0.1-b85bfaa",
   "description": "MetaMask Keyring utils",
   "keywords": [
     "metamask",
@@ -14,49 +14,59 @@
     "type": "git",
     "url": "https://github.com/MetaMask/accounts.git"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist/"
   ],
   "scripts": {
-    "build": "tsc --build tsconfig.build.json",
-    "build:clean": "rimraf dist && yarn build",
+    "build": "ts-bridge --project tsconfig.build.json --no-references",
+    "build:clean": "yarn build --clean",
     "build:docs": "typedoc",
-    "build:force": "tsc --build tsconfig.build.json --force",
     "changelog:update": "../../scripts/update-changelog.sh @metamask/keyring-utils",
     "changelog:validate": "../../scripts/validate-changelog.sh @metamask/keyring-utils",
     "publish:preview": "yarn npm publish --tag preview",
     "test": "yarn test:source && yarn test:types",
     "test:clean": "jest --clearCache",
     "test:source": "jest && jest-it-up",
-    "test:types": "tsd",
-    "test:verbose": "jest --verbose",
+    "test:types": "../../scripts/tsd-test.sh ./src",
     "test:watch": "jest --watch"
   },
   "dependencies": {
     "@metamask/superstruct": "^3.1.0",
-    "@metamask/utils": "^9.1.0",
+    "@metamask/utils": "^9.2.1",
     "@types/uuid": "^9.0.8",
     "deepmerge": "^4.2.2",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@lavamoat/allow-scripts": "^3.0.4",
-    "@lavamoat/preinstall-always-fail": "^2.0.0",
+    "@lavamoat/allow-scripts": "^3.2.1",
+    "@lavamoat/preinstall-always-fail": "^2.1.0",
     "@metamask/auto-changelog": "^3.4.4",
-    "@metamask/providers": "^17.1.1",
+    "@ts-bridge/cli": "^0.6.0",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.12",
     "depcheck": "^1.4.7",
-    "jest": "^28.1.3",
+    "jest": "^29.5.0",
     "jest-it-up": "^3.1.0",
     "rimraf": "^5.0.7",
-    "ts-jest": "^28.0.8",
+    "ts-jest": "^29.0.5",
     "ts-node": "^10.9.2",
     "tsd": "^0.31.0",
     "typedoc": "^0.25.13",
-    "typescript": "~4.8.4"
+    "typescript": "~5.6.3"
   },
   "engines": {
     "node": "^18.18 || >=20"
@@ -71,6 +81,9 @@
     }
   },
   "tsd": {
-    "directory": "src"
+    "directory": "src",
+    "compilerOptions": {
+      "composite": "false"
+    }
   }
 }

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export * from './types';
-export * from './typing';
-export * from './superstruct';

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,2CAAyB;AACzB,gDAA8B","sourcesContent":["export * from './types';\nexport * from './typing';\nexport * from './superstruct';\n"]}

package/dist/superstruct.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"superstruct.js","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":";;;AAAA,uDAK+B;AAoD/B;;;;;;GAMG;AACH,SAAgB,MAAM,CACpB,MAAc;IAEd,OAAO,IAAA,oBAAQ,EAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAJD,wBAIC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,oBAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAZD,sCAYC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,IAAY,EACZ,OAAe;IAEf,OAAO,IAAA,oBAAM,EACX,IAAI,EACJ,CAAC,KAAc,EAAW,EAAE,CAC1B,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CACnD,CAAC;AACJ,CAAC;AATD,sCASC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,IAAA,oBAAM,EAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAPD,gCAOC","sourcesContent":["import {\n  Struct,\n  assert,\n  define,\n  object as stObject,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n} from '@metamask/superstruct';\n\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct object struct to support exact\n * optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Defines a new string-struct matching a regular expression.\n *\n * Example:\n *\n * ```ts\n * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);\n * ```\n *\n * @param name - Type name.\n * @param pattern - Regular expression to match.\n * @returns A new string-struct that matches the given pattern.\n */\nexport function definePattern(\n  name: string,\n  pattern: RegExp,\n): Struct<string, null> {\n  return define<string>(\n    name,\n    (value: unknown): boolean =>\n      typeof value === 'string' && pattern.test(value),\n  );\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n"]}

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,uDAA2D;AAE3D,+CAA8C;AAE9C;;GAEG;AACU,QAAA,UAAU,GAAG,IAAA,2BAAa,EACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AAEF;;;;;GAKG;AACU,QAAA,SAAS,GAAG,IAAA,oBAAM,EAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI;QACF,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;KAC9D;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,KAAK,CAAC;KACd;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,kBAAkB,GAAG,IAAA,2BAAa,EAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\n\nimport { definePattern } from './superstruct';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch (_) {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n"]}