@metamask/utils 5.0.2 → 6.0.0

package/dist/json.js.map

@@ -1 +1 @@
-{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  array,\n  boolean,\n  define,\n  Infer,\n  integer,\n  is,\n  lazy,\n  literal,\n  nullable,\n  number,\n  object,\n  omit,\n  optional,\n  record,\n  string,\n  Struct,\n  union,\n  unknown,\n} from 'superstruct';\n\nimport { AssertionErrorConstructor, assertStruct } from './assert';\n\n/**\n * Any JSON-compatible value.\n */\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [prop: string]: Json };\n\n/**\n * A struct to check if the given value is finite number. Superstruct's\n * `number()` struct does not check if the value is finite.\n *\n * @returns A struct to check if the given value is finite number.\n */\nconst finiteNumber = () =>\n  define<number>('finite number', (value) => {\n    return is(value, number()) && Number.isFinite(value);\n  });\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * Note that this struct is unsafe. For safe validation, use {@link JsonStruct}.\n */\n// We cannot infer the type of the struct, because it is recursive.\nexport const UnsafeJsonStruct: Struct<Json> = union([\n  literal(null),\n  boolean(),\n  finiteNumber(),\n  string(),\n  array(lazy(() => UnsafeJsonStruct)),\n  record(\n    string(),\n    lazy(() => UnsafeJsonStruct),\n  ),\n]);\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * This struct sanitizes the value before validating it, so that it is safe to\n * use with untrusted input.\n */\nexport const JsonStruct = define<Json>('Json', (value, context) => {\n  /**\n   * Helper function that runs the given struct validator and returns the\n   * validation errors, if any. If the value is valid, it returns `true`.\n   *\n   * @param innerValue - The value to validate.\n   * @param struct - The struct to use for validation.\n   * @returns The validation errors, or `true` if the value is valid.\n   */\n  function checkStruct<Type>(innerValue: unknown, struct: Struct<Type>) {\n    const iterator = struct.validator(innerValue, context);\n    const errors = [...iterator];\n\n    if (errors.length > 0) {\n      return errors;\n    }\n\n    return true;\n  }\n\n  try {\n    // The plain value must be a valid JSON value, but it may be altered in the\n    // process of JSON serialization, so we need to validate it again after\n    // serialization. This has the added benefit that the returned error messages\n    // will be more helpful, as they will point to the exact location of the\n    // invalid value.\n    //\n    // This seems overcomplicated, but without checking the plain value first,\n    // there are some cases where the validation passes, even though the value is\n    // not valid JSON. For example, `undefined` is not valid JSON, but serializing\n    // it will remove it from the object, so the validation will pass.\n    const unsafeResult = checkStruct(value, UnsafeJsonStruct);\n    if (unsafeResult !== true) {\n      return unsafeResult;\n    }\n\n    // JavaScript engines are highly optimized for this specific use case of\n    // JSON parsing and stringifying, so there should be no performance impact.\n    return checkStruct(JSON.parse(JSON.stringify(value)), UnsafeJsonStruct);\n  } catch (error) {\n    if (error instanceof RangeError) {\n      return 'Circular reference detected';\n    }\n\n    return false;\n  }\n});\n\n/**\n * Check if the given value is a valid {@link Json} value, i.e., a value that is\n * serializable to JSON.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link Json} value.\n */\nexport function isValidJson(value: unknown): value is Json {\n  return is(value, JsonStruct);\n}\n\n/**\n * Get the size of a JSON value in bytes. This also validates the value.\n *\n * @param value - The JSON value to get the size of.\n * @returns The size of the JSON value in bytes.\n */\nexport function getJsonSize(value: unknown): number {\n  assertStruct(value, JsonStruct, 'Invalid JSON value');\n\n  const json = JSON.stringify(value);\n  return new TextEncoder().encode(json).byteLength;\n}\n\n/**\n * The string '2.0'.\n */\nexport const jsonrpc2 = '2.0' as const;\nexport const JsonRpcVersionStruct = literal(jsonrpc2);\n\n/**\n * A String specifying the version of the JSON-RPC protocol.\n * MUST be exactly \"2.0\".\n */\nexport type JsonRpcVersion2 = typeof jsonrpc2;\n\nexport const JsonRpcIdStruct = nullable(union([number(), string()]));\n\n/**\n * An identifier established by the Client that MUST contain a String, Number,\n * or NULL value if included. If it is not included it is assumed to be a\n * notification. The value SHOULD normally not be Null and Numbers SHOULD\n * NOT contain fractional parts.\n */\nexport type JsonRpcId = Infer<typeof JsonRpcIdStruct>;\n\nexport const JsonRpcErrorStruct = object({\n  code: integer(),\n  message: string(),\n  data: optional(JsonStruct),\n  stack: optional(string()),\n});\n\n/**\n * Mark a certain key of a type as optional.\n */\nexport type OptionalField<\n  Type extends Record<string, unknown>,\n  Key extends keyof Type,\n> = Omit<Type, Key> & Partial<Pick<Type, Key>>;\n\n/**\n * A JSON-RPC error object.\n *\n * Note that TypeScript infers `unknown | undefined` as `unknown`, meaning that\n * the `data` field is not optional. To make it optional, we use the\n * `OptionalField` helper, to explicitly make it optional.\n */\nexport type JsonRpcError = OptionalField<\n  Infer<typeof JsonRpcErrorStruct>,\n  'data'\n>;\n\nexport const JsonRpcParamsStruct = optional(\n  union([record(string(), JsonStruct), array(JsonStruct)]),\n);\nexport type JsonRpcParams = Infer<typeof JsonRpcParamsStruct>;\n\nexport const JsonRpcRequestStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  method: string(),\n  params: JsonRpcParamsStruct,\n});\n\nexport type InferWithParams<\n  Type extends Struct<any>,\n  Params extends JsonRpcParams,\n> = Omit<Infer<Type>, 'params'> &\n  (keyof Params extends undefined\n    ? {\n        params?: Params;\n      }\n    : {\n        params: Params;\n      });\n\n/**\n * A JSON-RPC request object.\n */\nexport type JsonRpcRequest<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcRequestStruct, Params>;\n\nexport const JsonRpcNotificationStruct = omit(JsonRpcRequestStruct, ['id']);\n\n/**\n * A JSON-RPC notification object.\n */\nexport type JsonRpcNotification<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcNotificationStruct, Params>;\n\n/**\n * Check if the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcNotification}\n * object.\n */\nexport function isJsonRpcNotification(\n  value: unknown,\n): value is JsonRpcNotification {\n  return is(value, JsonRpcNotificationStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcNotification} object.\n */\nexport function assertIsJsonRpcNotification(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcNotification {\n  assertStruct(\n    value,\n    JsonRpcNotificationStruct,\n    'Invalid JSON-RPC notification',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcRequest} object.\n */\nexport function isJsonRpcRequest(value: unknown): value is JsonRpcRequest {\n  return is(value, JsonRpcRequestStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The JSON-RPC request or notification to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcRequest} object.\n */\nexport function assertIsJsonRpcRequest(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcRequest {\n  assertStruct(\n    value,\n    JsonRpcRequestStruct,\n    'Invalid JSON-RPC request',\n    ErrorWrapper,\n  );\n}\n\nexport const PendingJsonRpcResponseStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: optional(unknown()),\n  error: optional(JsonRpcErrorStruct),\n});\n\n/**\n * A JSON-RPC response object that has not yet been resolved.\n */\nexport type PendingJsonRpcResponse<Result extends Json> = Omit<\n  Infer<typeof PendingJsonRpcResponseStruct>,\n  'result'\n> & {\n  result?: Result;\n};\n\nexport const JsonRpcSuccessStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: JsonStruct,\n});\n\n/**\n * A successful JSON-RPC response object.\n */\nexport type JsonRpcSuccess<Result extends Json> = Omit<\n  Infer<typeof JsonRpcSuccessStruct>,\n  'result'\n> & {\n  result: Result;\n};\n\nexport const JsonRpcFailureStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  error: JsonRpcErrorStruct as Struct<JsonRpcError>,\n});\n\n/**\n * A failed JSON-RPC response object.\n */\nexport type JsonRpcFailure = Infer<typeof JsonRpcFailureStruct>;\n\nexport const JsonRpcResponseStruct = union([\n  JsonRpcSuccessStruct,\n  JsonRpcFailureStruct,\n]);\n\n/**\n * A JSON-RPC response object. Must be checked to determine whether it's a\n * success or failure.\n *\n * @template Result - The type of the result.\n */\nexport type JsonRpcResponse<Result extends Json> =\n  | JsonRpcSuccess<Result>\n  | JsonRpcFailure;\n\n/**\n * Type guard to check whether specified JSON-RPC response is a\n * {@link PendingJsonRpcResponse}.\n *\n * @param response - The JSON-RPC response to check.\n * @returns Whether the specified JSON-RPC response is pending.\n */\nexport function isPendingJsonRpcResponse(\n  response: unknown,\n): response is PendingJsonRpcResponse<Json> {\n  return is(response, PendingJsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link PendingJsonRpcResponse} object.\n *\n * @param response - The JSON-RPC response to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link PendingJsonRpcResponse}\n * object.\n */\nexport function assertIsPendingJsonRpcResponse(\n  response: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts response is PendingJsonRpcResponse<Json> {\n  assertStruct(\n    response,\n    PendingJsonRpcResponseStruct,\n    'Invalid pending JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Type guard to check if a value is a {@link JsonRpcResponse}.\n *\n * @param response - The object to check.\n * @returns Whether the object is a JsonRpcResponse.\n */\nexport function isJsonRpcResponse(\n  response: unknown,\n): response is JsonRpcResponse<Json> {\n  return is(response, JsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcResponse} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcResponse} object.\n */\nexport function assertIsJsonRpcResponse(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcResponse<Json> {\n  assertStruct(\n    value,\n    JsonRpcResponseStruct,\n    'Invalid JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcSuccess} object.\n */\nexport function isJsonRpcSuccess(\n  value: unknown,\n): value is JsonRpcSuccess<Json> {\n  return is(value, JsonRpcSuccessStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcSuccess} object.\n */\nexport function assertIsJsonRpcSuccess(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcSuccess<Json> {\n  assertStruct(\n    value,\n    JsonRpcSuccessStruct,\n    'Invalid JSON-RPC success response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcFailure} object.\n */\nexport function isJsonRpcFailure(value: unknown): value is JsonRpcFailure {\n  return is(value, JsonRpcFailureStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcFailure} object.\n */\nexport function assertIsJsonRpcFailure(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcFailure {\n  assertStruct(\n    value,\n    JsonRpcFailureStruct,\n    'Invalid JSON-RPC failure response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcError} object.\n */\nexport function isJsonRpcError(value: unknown): value is JsonRpcError {\n  return is(value, JsonRpcErrorStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcError} object.\n */\nexport function assertIsJsonRpcError(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcError {\n  assertStruct(\n    value,\n    JsonRpcErrorStruct,\n    'Invalid JSON-RPC error',\n    ErrorWrapper,\n  );\n}\n\ntype JsonRpcValidatorOptions = {\n  permitEmptyString?: boolean;\n  permitFractions?: boolean;\n  permitNull?: boolean;\n};\n\n/**\n * Gets a function for validating JSON-RPC request / response `id` values.\n *\n * By manipulating the options of this factory, you can control the behavior\n * of the resulting validator for some edge cases. This is useful because e.g.\n * `null` should sometimes but not always be permitted.\n *\n * Note that the empty string (`''`) is always permitted by the JSON-RPC\n * specification, but that kind of sucks and you may want to forbid it in some\n * instances anyway.\n *\n * For more details, see the\n * [JSON-RPC Specification](https://www.jsonrpc.org/specification).\n *\n * @param options - An options object.\n * @param options.permitEmptyString - Whether the empty string (i.e. `''`)\n * should be treated as a valid ID. Default: `true`\n * @param options.permitFractions - Whether fractional numbers (e.g. `1.2`)\n * should be treated as valid IDs. Default: `false`\n * @param options.permitNull - Whether `null` should be treated as a valid ID.\n * Default: `true`\n * @returns The JSON-RPC ID validator function.\n */\nexport function getJsonRpcIdValidator(options?: JsonRpcValidatorOptions) {\n  const { permitEmptyString, permitFractions, permitNull } = {\n    permitEmptyString: true,\n    permitFractions: false,\n    permitNull: true,\n    ...options,\n  };\n\n  /**\n   * Type guard for {@link JsonRpcId}.\n   *\n   * @param id - The JSON-RPC ID value to check.\n   * @returns Whether the given ID is valid per the options given to the\n   * factory.\n   */\n  const isValidJsonRpcId = (id: unknown): id is JsonRpcId => {\n    return Boolean(\n      (typeof id === 'number' && (permitFractions || Number.isInteger(id))) ||\n        (typeof id === 'string' && (permitEmptyString || id.length > 0)) ||\n        (permitNull && id === null),\n    );\n  };\n\n  return isValidJsonRpcId;\n}\n"]}
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  any,\n  array,\n  boolean,\n  coerce,\n  create,\n  define,\n  Infer,\n  integer,\n  is,\n  lazy,\n  literal,\n  nullable,\n  number,\n  object,\n  omit,\n  optional,\n  record,\n  string,\n  Struct,\n  union,\n  unknown,\n} from 'superstruct';\n\nimport { AssertionErrorConstructor, assertStruct } from './assert';\n\n/**\n * Any JSON-compatible value.\n */\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [prop: string]: Json };\n\n/**\n * A struct to check if the given value is finite number. Superstruct's\n * `number()` struct does not check if the value is finite.\n *\n * @returns A struct to check if the given value is finite number.\n */\nconst finiteNumber = () =>\n  define<number>('finite number', (value) => {\n    return is(value, number()) && Number.isFinite(value);\n  });\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * Note that this struct is unsafe. For safe validation, use {@link JsonStruct}.\n */\n// We cannot infer the type of the struct, because it is recursive.\nexport const UnsafeJsonStruct: Struct<Json> = union([\n  literal(null),\n  boolean(),\n  finiteNumber(),\n  string(),\n  array(lazy(() => UnsafeJsonStruct)),\n  record(\n    string(),\n    lazy(() => UnsafeJsonStruct),\n  ),\n]);\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * This struct sanitizes the value before validating it, so that it is safe to\n * use with untrusted input.\n */\nexport const JsonStruct = coerce(UnsafeJsonStruct, any(), (value) => {\n  assertStruct(value, UnsafeJsonStruct);\n  return JSON.parse(JSON.stringify(value));\n});\n\n/**\n * Check if the given value is a valid {@link Json} value, i.e., a value that is\n * serializable to JSON.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link Json} value.\n */\nexport function isValidJson(value: unknown): value is Json {\n  try {\n    getSafeJson(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate and return sanitized JSON.\n *\n * Note:\n * This function uses sanitized JsonStruct for validation\n * that applies stringify and then parse of a value provided\n * to ensure that there are no getters which can have side effects\n * that can cause security issues.\n *\n * @param value - JSON structure to be processed.\n * @returns Sanitized JSON structure.\n */\nexport function getSafeJson<Type extends Json = Json>(value: unknown): Type {\n  return create(value, JsonStruct) as Type;\n}\n\n/**\n * Get the size of a JSON value in bytes. This also validates the value.\n *\n * @param value - The JSON value to get the size of.\n * @returns The size of the JSON value in bytes.\n */\nexport function getJsonSize(value: unknown): number {\n  assertStruct(value, JsonStruct, 'Invalid JSON value');\n\n  const json = JSON.stringify(value);\n  return new TextEncoder().encode(json).byteLength;\n}\n\n/**\n * The string '2.0'.\n */\nexport const jsonrpc2 = '2.0' as const;\nexport const JsonRpcVersionStruct = literal(jsonrpc2);\n\n/**\n * A String specifying the version of the JSON-RPC protocol.\n * MUST be exactly \"2.0\".\n */\nexport type JsonRpcVersion2 = typeof jsonrpc2;\n\nexport const JsonRpcIdStruct = nullable(union([number(), string()]));\n\n/**\n * An identifier established by the Client that MUST contain a String, Number,\n * or NULL value if included. If it is not included it is assumed to be a\n * notification. The value SHOULD normally not be Null and Numbers SHOULD\n * NOT contain fractional parts.\n */\nexport type JsonRpcId = Infer<typeof JsonRpcIdStruct>;\n\nexport const JsonRpcErrorStruct = object({\n  code: integer(),\n  message: string(),\n  data: optional(JsonStruct),\n  stack: optional(string()),\n});\n\n/**\n * Mark a certain key of a type as optional.\n */\nexport type OptionalField<\n  Type extends Record<string, unknown>,\n  Key extends keyof Type,\n> = Omit<Type, Key> & Partial<Pick<Type, Key>>;\n\n/**\n * A JSON-RPC error object.\n *\n * Note that TypeScript infers `unknown | undefined` as `unknown`, meaning that\n * the `data` field is not optional. To make it optional, we use the\n * `OptionalField` helper, to explicitly make it optional.\n */\nexport type JsonRpcError = OptionalField<\n  Infer<typeof JsonRpcErrorStruct>,\n  'data'\n>;\n\nexport const JsonRpcParamsStruct = optional(\n  union([record(string(), JsonStruct), array(JsonStruct)]),\n);\nexport type JsonRpcParams = Infer<typeof JsonRpcParamsStruct>;\n\nexport const JsonRpcRequestStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  method: string(),\n  params: JsonRpcParamsStruct,\n});\n\nexport type InferWithParams<\n  Type extends Struct<any>,\n  Params extends JsonRpcParams,\n> = Omit<Infer<Type>, 'params'> &\n  (keyof Params extends undefined\n    ? {\n        params?: Params;\n      }\n    : {\n        params: Params;\n      });\n\n/**\n * A JSON-RPC request object.\n */\nexport type JsonRpcRequest<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcRequestStruct, Params>;\n\nexport const JsonRpcNotificationStruct = omit(JsonRpcRequestStruct, ['id']);\n\n/**\n * A JSON-RPC notification object.\n */\nexport type JsonRpcNotification<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcNotificationStruct, Params>;\n\n/**\n * Check if the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcNotification}\n * object.\n */\nexport function isJsonRpcNotification(\n  value: unknown,\n): value is JsonRpcNotification {\n  return is(value, JsonRpcNotificationStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcNotification} object.\n */\nexport function assertIsJsonRpcNotification(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcNotification {\n  assertStruct(\n    value,\n    JsonRpcNotificationStruct,\n    'Invalid JSON-RPC notification',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcRequest} object.\n */\nexport function isJsonRpcRequest(value: unknown): value is JsonRpcRequest {\n  return is(value, JsonRpcRequestStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The JSON-RPC request or notification to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcRequest} object.\n */\nexport function assertIsJsonRpcRequest(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcRequest {\n  assertStruct(\n    value,\n    JsonRpcRequestStruct,\n    'Invalid JSON-RPC request',\n    ErrorWrapper,\n  );\n}\n\nexport const PendingJsonRpcResponseStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: optional(unknown()),\n  error: optional(JsonRpcErrorStruct),\n});\n\n/**\n * A JSON-RPC response object that has not yet been resolved.\n */\nexport type PendingJsonRpcResponse<Result extends Json> = Omit<\n  Infer<typeof PendingJsonRpcResponseStruct>,\n  'result'\n> & {\n  result?: Result;\n};\n\nexport const JsonRpcSuccessStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: JsonStruct,\n});\n\n/**\n * A successful JSON-RPC response object.\n */\nexport type JsonRpcSuccess<Result extends Json> = Omit<\n  Infer<typeof JsonRpcSuccessStruct>,\n  'result'\n> & {\n  result: Result;\n};\n\nexport const JsonRpcFailureStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  error: JsonRpcErrorStruct as Struct<JsonRpcError>,\n});\n\n/**\n * A failed JSON-RPC response object.\n */\nexport type JsonRpcFailure = Infer<typeof JsonRpcFailureStruct>;\n\nexport const JsonRpcResponseStruct = union([\n  JsonRpcSuccessStruct,\n  JsonRpcFailureStruct,\n]);\n\n/**\n * A JSON-RPC response object. Must be checked to determine whether it's a\n * success or failure.\n *\n * @template Result - The type of the result.\n */\nexport type JsonRpcResponse<Result extends Json> =\n  | JsonRpcSuccess<Result>\n  | JsonRpcFailure;\n\n/**\n * Type guard to check whether specified JSON-RPC response is a\n * {@link PendingJsonRpcResponse}.\n *\n * @param response - The JSON-RPC response to check.\n * @returns Whether the specified JSON-RPC response is pending.\n */\nexport function isPendingJsonRpcResponse(\n  response: unknown,\n): response is PendingJsonRpcResponse<Json> {\n  return is(response, PendingJsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link PendingJsonRpcResponse} object.\n *\n * @param response - The JSON-RPC response to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link PendingJsonRpcResponse}\n * object.\n */\nexport function assertIsPendingJsonRpcResponse(\n  response: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts response is PendingJsonRpcResponse<Json> {\n  assertStruct(\n    response,\n    PendingJsonRpcResponseStruct,\n    'Invalid pending JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Type guard to check if a value is a {@link JsonRpcResponse}.\n *\n * @param response - The object to check.\n * @returns Whether the object is a JsonRpcResponse.\n */\nexport function isJsonRpcResponse(\n  response: unknown,\n): response is JsonRpcResponse<Json> {\n  return is(response, JsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcResponse} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcResponse} object.\n */\nexport function assertIsJsonRpcResponse(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcResponse<Json> {\n  assertStruct(\n    value,\n    JsonRpcResponseStruct,\n    'Invalid JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcSuccess} object.\n */\nexport function isJsonRpcSuccess(\n  value: unknown,\n): value is JsonRpcSuccess<Json> {\n  return is(value, JsonRpcSuccessStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcSuccess} object.\n */\nexport function assertIsJsonRpcSuccess(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcSuccess<Json> {\n  assertStruct(\n    value,\n    JsonRpcSuccessStruct,\n    'Invalid JSON-RPC success response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcFailure} object.\n */\nexport function isJsonRpcFailure(value: unknown): value is JsonRpcFailure {\n  return is(value, JsonRpcFailureStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcFailure} object.\n */\nexport function assertIsJsonRpcFailure(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcFailure {\n  assertStruct(\n    value,\n    JsonRpcFailureStruct,\n    'Invalid JSON-RPC failure response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcError} object.\n */\nexport function isJsonRpcError(value: unknown): value is JsonRpcError {\n  return is(value, JsonRpcErrorStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcError} object.\n */\nexport function assertIsJsonRpcError(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcError {\n  assertStruct(\n    value,\n    JsonRpcErrorStruct,\n    'Invalid JSON-RPC error',\n    ErrorWrapper,\n  );\n}\n\ntype JsonRpcValidatorOptions = {\n  permitEmptyString?: boolean;\n  permitFractions?: boolean;\n  permitNull?: boolean;\n};\n\n/**\n * Gets a function for validating JSON-RPC request / response `id` values.\n *\n * By manipulating the options of this factory, you can control the behavior\n * of the resulting validator for some edge cases. This is useful because e.g.\n * `null` should sometimes but not always be permitted.\n *\n * Note that the empty string (`''`) is always permitted by the JSON-RPC\n * specification, but that kind of sucks and you may want to forbid it in some\n * instances anyway.\n *\n * For more details, see the\n * [JSON-RPC Specification](https://www.jsonrpc.org/specification).\n *\n * @param options - An options object.\n * @param options.permitEmptyString - Whether the empty string (i.e. `''`)\n * should be treated as a valid ID. Default: `true`\n * @param options.permitFractions - Whether fractional numbers (e.g. `1.2`)\n * should be treated as valid IDs. Default: `false`\n * @param options.permitNull - Whether `null` should be treated as a valid ID.\n * Default: `true`\n * @returns The JSON-RPC ID validator function.\n */\nexport function getJsonRpcIdValidator(options?: JsonRpcValidatorOptions) {\n  const { permitEmptyString, permitFractions, permitNull } = {\n    permitEmptyString: true,\n    permitFractions: false,\n    permitNull: true,\n    ...options,\n  };\n\n  /**\n   * Type guard for {@link JsonRpcId}.\n   *\n   * @param id - The JSON-RPC ID value to check.\n   * @returns Whether the given ID is valid per the options given to the\n   * factory.\n   */\n  const isValidJsonRpcId = (id: unknown): id is JsonRpcId => {\n    return Boolean(\n      (typeof id === 'number' && (permitFractions || Number.isInteger(id))) ||\n        (typeof id === 'string' && (permitEmptyString || id.length > 0)) ||\n        (permitNull && id === null),\n    );\n  };\n\n  return isValidJsonRpcId;\n}\n"]}

package/dist/json.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/json.test-d.js

@@ -0,0 +1,62 @@
+"use strict";
+/* eslint-disable @typescript-eslint/consistent-type-definitions */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tsd_1 = require("tsd");
+// Valid Json:
+(0, tsd_1.expectAssignable)(null);
+(0, tsd_1.expectAssignable)(false);
+(0, tsd_1.expectAssignable)('');
+(0, tsd_1.expectAssignable)(0);
+(0, tsd_1.expectAssignable)([]);
+(0, tsd_1.expectAssignable)({});
+(0, tsd_1.expectAssignable)([0]);
+(0, tsd_1.expectAssignable)({ a: 0 });
+(0, tsd_1.expectAssignable)({ deeply: [{ nested: 1 }, 'mixed', 'types', 0] });
+(0, tsd_1.expectAssignable)(['array', { nested: { mixed: true, types: null } }, 0]);
+const jsonCompatibleType = { c: 0 };
+(0, tsd_1.expectAssignable)(jsonCompatibleType);
+// Invalid Json:
+(0, tsd_1.expectNotAssignable)(undefined);
+(0, tsd_1.expectNotAssignable)(new Date());
+(0, tsd_1.expectNotAssignable)(() => 0);
+(0, tsd_1.expectNotAssignable)(new Set());
+(0, tsd_1.expectNotAssignable)(new Map());
+(0, tsd_1.expectNotAssignable)(Symbol('test'));
+(0, tsd_1.expectNotAssignable)({ a: new Date() });
+(0, tsd_1.expectNotAssignable)(5);
+const interfaceWithOptionalProperty = { a: 0 };
+(0, tsd_1.expectNotAssignable)(interfaceWithOptionalProperty);
+const interfaceWithDate = { a: new Date() };
+(0, tsd_1.expectNotAssignable)(interfaceWithDate);
+const interfaceWithOptionalDate = { a: new Date() };
+(0, tsd_1.expectNotAssignable)(interfaceWithOptionalDate);
+const interfaceWithUndefinedTypeUnion = {
+    a: 0,
+};
+(0, tsd_1.expectNotAssignable)(interfaceWithUndefinedTypeUnion);
+const interfaceWithFunction = { a: () => 0 };
+(0, tsd_1.expectNotAssignable)(interfaceWithFunction);
+const typeWithDate = { a: new Date() };
+(0, tsd_1.expectNotAssignable)(typeWithDate);
+const typeWithOptionalDate = { a: new Date() };
+(0, tsd_1.expectNotAssignable)(typeWithOptionalDate);
+const typeWithUndefinedTypeUnion = {
+    a: 0,
+};
+(0, tsd_1.expectNotAssignable)(typeWithUndefinedTypeUnion);
+const typeWithFunction = { a: () => 0 };
+(0, tsd_1.expectNotAssignable)(typeWithFunction);
+const typeWithOptionalProperty = { a: undefined };
+(0, tsd_1.expectNotAssignable)(typeWithOptionalProperty);
+// Edge cases:
+// The Json type doesn't protect against the `any` type.
+(0, tsd_1.expectAssignable)(null);
+const a = { a: 0 };
+(0, tsd_1.expectNotAssignable)(a);
+// The Json type gets confused by classes. This class instance is valid Json,
+// but it's incompatible with the Json type.
+class Foo {
+}
+const foo = new Foo();
+(0, tsd_1.expectNotAssignable)(foo);
+//# sourceMappingURL=json.test-d.js.map

package/dist/json.test-d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.test-d.js","sourceRoot":"","sources":["../src/json.test-d.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/consistent-type-definitions */\n\nimport { expectAssignable, expectNotAssignable } from 'tsd';\n\nimport type { Json } from '.';\n\n// Valid Json:\n\nexpectAssignable<Json>(null);\n\nexpectAssignable<Json>(false);\n\nexpectAssignable<Json>('');\n\nexpectAssignable<Json>(0);\n\nexpectAssignable<Json>([]);\n\nexpectAssignable<Json>({});\n\nexpectAssignable<Json>([0]);\n\nexpectAssignable<Json>({ a: 0 });\n\nexpectAssignable<Json>({ deeply: [{ nested: 1 }, 'mixed', 'types', 0] });\n\nexpectAssignable<Json>(['array', { nested: { mixed: true, types: null } }, 0]);\n\ntype JsonCompatibleType = {\n  c: number;\n};\nconst jsonCompatibleType: JsonCompatibleType = { c: 0 };\nexpectAssignable<Json>(jsonCompatibleType);\n\n// Invalid Json:\n\nexpectNotAssignable<Json>(undefined);\n\nexpectNotAssignable<Json>(new Date());\n\nexpectNotAssignable<Json>(() => 0);\n\nexpectNotAssignable<Json>(new Set());\n\nexpectNotAssignable<Json>(new Map());\n\nexpectNotAssignable<Json>(Symbol('test'));\n\nexpectNotAssignable<Json>({ a: new Date() });\n\nexpectNotAssignable<Json>(5 as number | undefined);\n\ninterface InterfaceWithOptionalProperty {\n  a?: number;\n}\nconst interfaceWithOptionalProperty: InterfaceWithOptionalProperty = { a: 0 };\nexpectNotAssignable<Json>(interfaceWithOptionalProperty);\n\ninterface InterfaceWithDate {\n  a: Date;\n}\nconst interfaceWithDate: InterfaceWithDate = { a: new Date() };\nexpectNotAssignable<Json>(interfaceWithDate);\n\ninterface InterfaceWithOptionalDate {\n  a?: Date;\n}\nconst interfaceWithOptionalDate: InterfaceWithOptionalDate = { a: new Date() };\nexpectNotAssignable<Json>(interfaceWithOptionalDate);\n\ninterface InterfaceWithUndefinedTypeUnion {\n  a: number | undefined;\n}\nconst interfaceWithUndefinedTypeUnion: InterfaceWithUndefinedTypeUnion = {\n  a: 0,\n};\nexpectNotAssignable<Json>(interfaceWithUndefinedTypeUnion);\n\ninterface InterfaceWithFunction {\n  a: () => number;\n}\nconst interfaceWithFunction: InterfaceWithFunction = { a: () => 0 };\nexpectNotAssignable<Json>(interfaceWithFunction);\n\ntype TypeWithDate = {\n  a: Date;\n};\nconst typeWithDate: TypeWithDate = { a: new Date() };\nexpectNotAssignable<Json>(typeWithDate);\n\ntype TypeWithOptionalDate = {\n  a?: Date;\n};\nconst typeWithOptionalDate: TypeWithOptionalDate = { a: new Date() };\nexpectNotAssignable<Json>(typeWithOptionalDate);\n\ntype TypeWithUndefinedTypeUnion = {\n  a: number | undefined;\n};\nconst typeWithUndefinedTypeUnion: TypeWithUndefinedTypeUnion = {\n  a: 0,\n};\nexpectNotAssignable<Json>(typeWithUndefinedTypeUnion);\n\ntype TypeWithFunction = {\n  a: () => number;\n};\nconst typeWithFunction: TypeWithFunction = { a: () => 0 };\nexpectNotAssignable<Json>(typeWithFunction);\n\ntype TypeWithOptionalProperty = {\n  a?: number | undefined;\n};\nconst typeWithOptionalProperty: TypeWithOptionalProperty = { a: undefined };\nexpectNotAssignable<Json>(typeWithOptionalProperty);\n\n// Edge cases:\n\n// The Json type doesn't protect against the `any` type.\nexpectAssignable<Json>(null as any);\n\n// The Json type gets confused by interfaces. This interface is valid Json,\n// but it's incompatible with the Json type.\ninterface A {\n  a: number;\n}\nconst a: A = { a: 0 };\nexpectNotAssignable<Json>(a);\n\n// The Json type gets confused by classes. This class instance is valid Json,\n// but it's incompatible with the Json type.\nclass Foo {\n  a!: number;\n}\nconst foo = new Foo();\nexpectNotAssignable<Json>(foo);\n"]}

package/dist/misc.js

@@ -111,7 +111,6 @@ exports.isASCII = isASCII;
  * @returns Number of bytes used to store whole string value.
  */
 function calculateStringSize(value) {
-    var _a;
     const size = value.split('').reduce((total, character) => {
         if (isASCII(character)) {
             return total + 1;
@@ -119,7 +118,7 @@ function calculateStringSize(value) {
         return total + 2;
     }, 0);
     // Also detect characters that need backslash escape
-    return size + ((_a = value.match(exports.ESCAPE_CHARACTERS_REGEXP)) !== null && _a !== void 0 ? _a : []).length;
+    return size + (value.match(exports.ESCAPE_CHARACTERS_REGEXP) ?? []).length;
 }
 exports.calculateStringSize = calculateStringSize;
 /**

package/dist/misc.js.map

@@ -1 +1 @@
-{"version":3,"file":"misc.js","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,QAAQ;AACR,EAAE;;;AAoCF,EAAE;AACF,cAAc;AACd,EAAE;AAEF;;;;;;GAMG;AACH,SAAgB,eAAe,CAC7B,KAAgB;IAEhB,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AAClD,CAAC;AAJD,0CAIC;AAED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC;AAC/C,CAAC;AAFD,8CAEC;AAED;;;;;;GAMG;AACH,SAAgB,QAAQ,CAAC,KAAc;IACrC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAFD,4BAEC;AAED,EAAE;AACF,0BAA0B;AAC1B,EAAE;AAEF;;;;;;;GAOG;AACI,MAAM,WAAW,GAAG,CAKzB,aAA4B,EAC5B,IAAc,EAKZ,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;AAX1C,QAAA,WAAW,eAW+B;AAIvD;;GAEG;AACH,IAAY,QAUX;AAVD,WAAY,QAAQ;IAClB,uCAAQ,CAAA;IACR,yCAAS,CAAA;IACT,6CAAW,CAAA;IACX,uCAAQ,CAAA;IACR,yCAAS,CAAA;IACT,yCAAS,CAAA;IACT,yCAAS,CAAA;IACT,wDAAwD;IACxD,wCAAS,CAAA;AACX,CAAC,EAVW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAUnB;AAED;;GAEG;AACU,QAAA,wBAAwB,GAAG,iBAAiB,CAAC;AAE1D;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,KAAc;IAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE;QAC/C,OAAO,KAAK,CAAC;KACd;IAED,IAAI;QACF,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,OAAO,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE;YAC5C,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;SACtC;QAED,OAAO,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;KAC/C;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAfD,sCAeC;AAED;;;;;GAKG;AACH,SAAgB,OAAO,CAAC,SAAiB;IACvC,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;AACxC,CAAC;AAFD,0BAEC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,KAAa;;IAC/C,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;QACvD,IAAI,OAAO,CAAC,SAAS,CAAC,EAAE;YACtB,OAAO,KAAK,GAAG,CAAC,CAAC;SAClB;QACD,OAAO,KAAK,GAAG,CAAC,CAAC;IACnB,CAAC,EAAE,CAAC,CAAC,CAAC;IAEN,oDAAoD;IACpD,OAAO,IAAI,GAAG,CAAC,MAAA,KAAK,CAAC,KAAK,CAAC,gCAAwB,CAAC,mCAAI,EAAE,CAAC,CAAC,MAAM,CAAC;AACrE,CAAC;AAVD,kDAUC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,KAAa;IAC/C,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC;AACjC,CAAC;AAFD,kDAEC","sourcesContent":["//\n// Types\n//\n\n/**\n * Makes every specified property of the specified object type mutable.\n *\n * @template ObjectValue - The object whose readonly properties to make mutable.\n * @template TargetKey - The property key(s) to make mutable.\n */\nexport type Mutable<\n  ObjectValue extends Record<string, unknown>,\n  TargetKey extends keyof ObjectValue,\n> = {\n  -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];\n} & {\n  [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];\n};\n\n/**\n * Useful for representing some value that _might_ be present and / or complete.\n *\n * @template Value - The value that might be present or complete.\n */\nexport type PartialOrAbsent<Value> = Partial<Value> | null | undefined;\n\n/**\n * Like {@link Array}, but always non-empty.\n *\n * @template Element - The non-empty array member type.\n */\nexport type NonEmptyArray<Element> = [Element, ...Element[]];\n\n/**\n * A JavaScript object that is not `null`, a function, or an array.\n */\nexport type RuntimeObject = Record<PropertyKey, unknown>;\n\n//\n// Type Guards\n//\n\n/**\n * A {@link NonEmptyArray} type guard.\n *\n * @template Element - The non-empty array member type.\n * @param value - The value to check.\n * @returns Whether the value is a non-empty array.\n */\nexport function isNonEmptyArray<Element>(\n  value: Element[],\n): value is NonEmptyArray<Element> {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard for \"nullishness\".\n *\n * @param value - Any value.\n * @returns `true` if the value is null or undefined, `false` otherwise.\n */\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * A type guard for {@link RuntimeObject}.\n *\n * @param value - The value to check.\n * @returns Whether the specified value has a runtime type of `object` and is\n * neither `null` nor an `Array`.\n */\nexport function isObject(value: unknown): value is RuntimeObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\n//\n// Other utility functions\n//\n\n/**\n * A type guard for ensuring an object has a property.\n *\n * @param objectToCheck - The object to check.\n * @param name - The property name to check for.\n * @returns Whether the specified object has an own property with the specified\n * name, regardless of whether it is enumerable or not.\n */\nexport const hasProperty = <\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  ObjectToCheck extends Object,\n  Property extends PropertyKey,\n>(\n  objectToCheck: ObjectToCheck,\n  name: Property,\n): objectToCheck is ObjectToCheck &\n  Record<\n    Property,\n    Property extends keyof ObjectToCheck ? ObjectToCheck[Property] : unknown\n  > => Object.hasOwnProperty.call(objectToCheck, name);\n\nexport type PlainObject = Record<number | string | symbol, unknown>;\n\n/**\n * Predefined sizes (in Bytes) of specific parts of JSON structure.\n */\nexport enum JsonSize {\n  Null = 4,\n  Comma = 1,\n  Wrapper = 1,\n  True = 4,\n  False = 5,\n  Quote = 1,\n  Colon = 1,\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  Date = 24,\n}\n\n/**\n * Regular expression with pattern matching for (special) escaped characters.\n */\nexport const ESCAPE_CHARACTERS_REGEXP = /\"|\\\\|\\n|\\r|\\t/gu;\n\n/**\n * Check if the value is plain object.\n *\n * @param value - Value to be checked.\n * @returns True if an object is the plain JavaScript object,\n * false if the object is not plain (e.g. function).\n */\nexport function isPlainObject(value: unknown): value is PlainObject {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  try {\n    let proto = value;\n    while (Object.getPrototypeOf(proto) !== null) {\n      proto = Object.getPrototypeOf(proto);\n    }\n\n    return Object.getPrototypeOf(value) === proto;\n  } catch (_) {\n    return false;\n  }\n}\n\n/**\n * Check if character is ASCII.\n *\n * @param character - Character.\n * @returns True if a character code is ASCII, false if not.\n */\nexport function isASCII(character: string) {\n  return character.charCodeAt(0) <= 127;\n}\n\n/**\n * Calculate string size.\n *\n * @param value - String value to calculate size.\n * @returns Number of bytes used to store whole string value.\n */\nexport function calculateStringSize(value: string): number {\n  const size = value.split('').reduce((total, character) => {\n    if (isASCII(character)) {\n      return total + 1;\n    }\n    return total + 2;\n  }, 0);\n\n  // Also detect characters that need backslash escape\n  return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;\n}\n\n/**\n * Calculate size of a number ofter JSON serialization.\n *\n * @param value - Number value to calculate size.\n * @returns Number of bytes used to store whole number in JSON.\n */\nexport function calculateNumberSize(value: number): number {\n  return value.toString().length;\n}\n"]}
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,QAAQ;AACR,EAAE;;;AAoCF,EAAE;AACF,cAAc;AACd,EAAE;AAEF;;;;;;GAMG;AACH,SAAgB,eAAe,CAC7B,KAAgB;IAEhB,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;AAClD,CAAC;AAJD,0CAIC;AAED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC;AAC/C,CAAC;AAFD,8CAEC;AAED;;;;;;GAMG;AACH,SAAgB,QAAQ,CAAC,KAAc;IACrC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAFD,4BAEC;AAED,EAAE;AACF,0BAA0B;AAC1B,EAAE;AAEF;;;;;;;GAOG;AACI,MAAM,WAAW,GAAG,CAKzB,aAA4B,EAC5B,IAAc,EAKZ,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;AAX1C,QAAA,WAAW,eAW+B;AAIvD;;GAEG;AACH,IAAY,QAUX;AAVD,WAAY,QAAQ;IAClB,uCAAQ,CAAA;IACR,yCAAS,CAAA;IACT,6CAAW,CAAA;IACX,uCAAQ,CAAA;IACR,yCAAS,CAAA;IACT,yCAAS,CAAA;IACT,yCAAS,CAAA;IACT,wDAAwD;IACxD,wCAAS,CAAA;AACX,CAAC,EAVW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAUnB;AAED;;GAEG;AACU,QAAA,wBAAwB,GAAG,iBAAiB,CAAC;AAE1D;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,KAAc;IAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE;QAC/C,OAAO,KAAK,CAAC;KACd;IAED,IAAI;QACF,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,OAAO,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE;YAC5C,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;SACtC;QAED,OAAO,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;KAC/C;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAfD,sCAeC;AAED;;;;;GAKG;AACH,SAAgB,OAAO,CAAC,SAAiB;IACvC,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;AACxC,CAAC;AAFD,0BAEC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,KAAa;IAC/C,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;QACvD,IAAI,OAAO,CAAC,SAAS,CAAC,EAAE;YACtB,OAAO,KAAK,GAAG,CAAC,CAAC;SAClB;QACD,OAAO,KAAK,GAAG,CAAC,CAAC;IACnB,CAAC,EAAE,CAAC,CAAC,CAAC;IAEN,oDAAoD;IACpD,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,gCAAwB,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;AACrE,CAAC;AAVD,kDAUC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,KAAa;IAC/C,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC;AACjC,CAAC;AAFD,kDAEC","sourcesContent":["//\n// Types\n//\n\n/**\n * Makes every specified property of the specified object type mutable.\n *\n * @template ObjectValue - The object whose readonly properties to make mutable.\n * @template TargetKey - The property key(s) to make mutable.\n */\nexport type Mutable<\n  ObjectValue extends Record<string, unknown>,\n  TargetKey extends keyof ObjectValue,\n> = {\n  -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];\n} & {\n  [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];\n};\n\n/**\n * Useful for representing some value that _might_ be present and / or complete.\n *\n * @template Value - The value that might be present or complete.\n */\nexport type PartialOrAbsent<Value> = Partial<Value> | null | undefined;\n\n/**\n * Like {@link Array}, but always non-empty.\n *\n * @template Element - The non-empty array member type.\n */\nexport type NonEmptyArray<Element> = [Element, ...Element[]];\n\n/**\n * A JavaScript object that is not `null`, a function, or an array.\n */\nexport type RuntimeObject = Record<PropertyKey, unknown>;\n\n//\n// Type Guards\n//\n\n/**\n * A {@link NonEmptyArray} type guard.\n *\n * @template Element - The non-empty array member type.\n * @param value - The value to check.\n * @returns Whether the value is a non-empty array.\n */\nexport function isNonEmptyArray<Element>(\n  value: Element[],\n): value is NonEmptyArray<Element> {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard for \"nullishness\".\n *\n * @param value - Any value.\n * @returns `true` if the value is null or undefined, `false` otherwise.\n */\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * A type guard for {@link RuntimeObject}.\n *\n * @param value - The value to check.\n * @returns Whether the specified value has a runtime type of `object` and is\n * neither `null` nor an `Array`.\n */\nexport function isObject(value: unknown): value is RuntimeObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\n//\n// Other utility functions\n//\n\n/**\n * A type guard for ensuring an object has a property.\n *\n * @param objectToCheck - The object to check.\n * @param name - The property name to check for.\n * @returns Whether the specified object has an own property with the specified\n * name, regardless of whether it is enumerable or not.\n */\nexport const hasProperty = <\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  ObjectToCheck extends Object,\n  Property extends PropertyKey,\n>(\n  objectToCheck: ObjectToCheck,\n  name: Property,\n): objectToCheck is ObjectToCheck &\n  Record<\n    Property,\n    Property extends keyof ObjectToCheck ? ObjectToCheck[Property] : unknown\n  > => Object.hasOwnProperty.call(objectToCheck, name);\n\nexport type PlainObject = Record<number | string | symbol, unknown>;\n\n/**\n * Predefined sizes (in Bytes) of specific parts of JSON structure.\n */\nexport enum JsonSize {\n  Null = 4,\n  Comma = 1,\n  Wrapper = 1,\n  True = 4,\n  False = 5,\n  Quote = 1,\n  Colon = 1,\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  Date = 24,\n}\n\n/**\n * Regular expression with pattern matching for (special) escaped characters.\n */\nexport const ESCAPE_CHARACTERS_REGEXP = /\"|\\\\|\\n|\\r|\\t/gu;\n\n/**\n * Check if the value is plain object.\n *\n * @param value - Value to be checked.\n * @returns True if an object is the plain JavaScript object,\n * false if the object is not plain (e.g. function).\n */\nexport function isPlainObject(value: unknown): value is PlainObject {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  try {\n    let proto = value;\n    while (Object.getPrototypeOf(proto) !== null) {\n      proto = Object.getPrototypeOf(proto);\n    }\n\n    return Object.getPrototypeOf(value) === proto;\n  } catch (_) {\n    return false;\n  }\n}\n\n/**\n * Check if character is ASCII.\n *\n * @param character - Character.\n * @returns True if a character code is ASCII, false if not.\n */\nexport function isASCII(character: string) {\n  return character.charCodeAt(0) <= 127;\n}\n\n/**\n * Calculate string size.\n *\n * @param value - String value to calculate size.\n * @returns Number of bytes used to store whole string value.\n */\nexport function calculateStringSize(value: string): number {\n  const size = value.split('').reduce((total, character) => {\n    if (isASCII(character)) {\n      return total + 1;\n    }\n    return total + 2;\n  }, 0);\n\n  // Also detect characters that need backslash escape\n  return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;\n}\n\n/**\n * Calculate size of a number ofter JSON serialization.\n *\n * @param value - Number value to calculate size.\n * @returns Number of bytes used to store whole number in JSON.\n */\nexport function calculateNumberSize(value: number): number {\n  return value.toString().length;\n}\n"]}

package/dist/misc.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/misc.test-d.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tsd_1 = require("tsd");
+const misc_1 = require("./misc");
+//=============================================================================
+// isObject
+//=============================================================================
+// eslint-disable-next-line @typescript-eslint/ban-types
+const unknownValue = {};
+(0, tsd_1.expectNotAssignable)(unknownValue);
+if ((0, misc_1.isObject)(unknownValue)) {
+    (0, tsd_1.expectAssignable)(unknownValue);
+}
+// Does not interfere with satisfaction of static type
+const constObjectType = { foo: 'foo' };
+if ((0, misc_1.hasProperty)(constObjectType, 'foo')) {
+    (0, tsd_1.expectAssignable)(constObjectType);
+}
+//=============================================================================
+// hasProperty
+//=============================================================================
+// eslint-disable-next-line @typescript-eslint/ban-types
+const unknownObject = {};
+// Establish that `Object` is not accepted when a specific property is needed.
+(0, tsd_1.expectNotAssignable)(unknownObject);
+// Establish that `RuntimeObject` is not accepted when a specific property is needed.
+if ((0, misc_1.isObject)(unknownObject)) {
+    (0, tsd_1.expectNotAssignable)(unknownObject);
+}
+// An object is accepted after `hasProperty` is used to prove that it has the required property.
+if ((0, misc_1.isObject)(unknownObject) && (0, misc_1.hasProperty)(unknownObject, 'foo')) {
+    (0, tsd_1.expectAssignable)(unknownObject);
+}
+// An object is accepted after `hasProperty` is used to prove that it has all required properties.
+if ((0, misc_1.isObject)(unknownObject) &&
+    (0, misc_1.hasProperty)(unknownObject, 'foo') &&
+    (0, misc_1.hasProperty)(unknownObject, 'bar')) {
+    (0, tsd_1.expectAssignable)(unknownObject);
+}
+// An object is not accepted after `hasProperty` has only been used to establish that some required properties exist.
+if ((0, misc_1.isObject)(unknownObject) && (0, misc_1.hasProperty)(unknownObject, 'foo')) {
+    (0, tsd_1.expectNotAssignable)(unknownObject);
+}
+// Does not interfere with satisfaction of non-overlapping types
+const overlappingTypesExample = { foo: 'foo', baz: 'baz' };
+if ((0, misc_1.hasProperty)(overlappingTypesExample, 'foo')) {
+    (0, tsd_1.expectAssignable)(overlappingTypesExample);
+}
+const exampleErrorWithCode = new Error('test');
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+exampleErrorWithCode.code = 999;
+// Establish that trying to check for a custom property on an error results in failure
+(0, tsd_1.expectNotAssignable)(exampleErrorWithCode);
+// Using custom Error property is allowed after checking with `hasProperty`
+if ((0, misc_1.hasProperty)(exampleErrorWithCode, 'code')) {
+    (0, tsd_1.expectType)(exampleErrorWithCode.code);
+}
+const hasPropertyInterfaceExample = { a: 0 };
+(0, misc_1.hasProperty)(hasPropertyInterfaceExample, 'a');
+// `hasProperty` is compatible with classes
+class HasPropertyClassExample {
+}
+const hasPropertyClassExample = new HasPropertyClassExample();
+(0, misc_1.hasProperty)(hasPropertyClassExample, 'a');
+// It keeps the original type when defined.
+const hasPropertyTypeExample = {};
+if ((0, misc_1.hasProperty)(hasPropertyTypeExample, 'a')) {
+    (0, tsd_1.expectType)(hasPropertyTypeExample.a);
+}
+//=============================================================================
+// RuntimeObject
+//=============================================================================
+// Valid runtime objects:
+(0, tsd_1.expectAssignable)({});
+(0, tsd_1.expectAssignable)({ foo: 'foo' });
+// eslint-disable-next-line @typescript-eslint/naming-convention
+(0, tsd_1.expectAssignable)({ 0: 'foo' });
+(0, tsd_1.expectAssignable)({ [Symbol('foo')]: 'foo' });
+// Invalid runtime objects:
+(0, tsd_1.expectNotAssignable)(null);
+(0, tsd_1.expectNotAssignable)(undefined);
+(0, tsd_1.expectNotAssignable)('foo');
+(0, tsd_1.expectNotAssignable)(0);
+(0, tsd_1.expectNotAssignable)([]);
+(0, tsd_1.expectNotAssignable)(new Date());
+(0, tsd_1.expectNotAssignable)(() => 0);
+(0, tsd_1.expectNotAssignable)(new Set());
+(0, tsd_1.expectNotAssignable)(new Map());
+(0, tsd_1.expectNotAssignable)(Symbol('test'));
+const runtimeObjectInterfaceExample = { a: 0 };
+(0, tsd_1.expectNotAssignable)(runtimeObjectInterfaceExample);
+class RuntimeObjectClassExample {
+}
+const runtimeObjectClassExample = new RuntimeObjectClassExample();
+(0, tsd_1.expectNotAssignable)(runtimeObjectClassExample);
+//# sourceMappingURL=misc.test-d.js.map

package/dist/misc.test-d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.test-d.js","sourceRoot":"","sources":["../src/misc.test-d.ts"],"names":[],"mappings":";;AAAA,6BAAwE;AAExE,iCAA8D;AAE9D,+EAA+E;AAC/E,WAAW;AACX,+EAA+E;AAE/E,wDAAwD;AACxD,MAAM,YAAY,GAAG,EAAa,CAAC;AAEnC,IAAA,yBAAmB,EAAgB,YAAY,CAAC,CAAC;AAEjD,IAAI,IAAA,eAAQ,EAAC,YAAY,CAAC,EAAE;IAC1B,IAAA,sBAAgB,EAAgB,YAAY,CAAC,CAAC;CAC/C;AAED,sDAAsD;AACtD,MAAM,eAAe,GAAG,EAAE,GAAG,EAAE,KAAK,EAAW,CAAC;AAChD,IAAI,IAAA,kBAAW,EAAC,eAAe,EAAE,KAAK,CAAC,EAAE;IACvC,IAAA,sBAAgB,EAAiB,eAAe,CAAC,CAAC;CACnD;AAED,+EAA+E;AAC/E,cAAc;AACd,+EAA+E;AAE/E,wDAAwD;AACxD,MAAM,aAAa,GAAG,EAAY,CAAC;AAEnC,8EAA8E;AAC9E,IAAA,yBAAmB,EAAyB,aAAa,CAAC,CAAC;AAE3D,qFAAqF;AACrF,IAAI,IAAA,eAAQ,EAAC,aAAa,CAAC,EAAE;IAC3B,IAAA,yBAAmB,EAAyB,aAAa,CAAC,CAAC;CAC5D;AAED,gGAAgG;AAChG,IAAI,IAAA,eAAQ,EAAC,aAAa,CAAC,IAAI,IAAA,kBAAW,EAAC,aAAa,EAAE,KAAK,CAAC,EAAE;IAChE,IAAA,sBAAgB,EAAyB,aAAa,CAAC,CAAC;CACzD;AAED,kGAAkG;AAClG,IACE,IAAA,eAAQ,EAAC,aAAa,CAAC;IACvB,IAAA,kBAAW,EAAC,aAAa,EAAE,KAAK,CAAC;IACjC,IAAA,kBAAW,EAAC,aAAa,EAAE,KAAK,CAAC,EACjC;IACA,IAAA,sBAAgB,EAAiC,aAAa,CAAC,CAAC;CACjE;AAED,qHAAqH;AACrH,IAAI,IAAA,eAAQ,EAAC,aAAa,CAAC,IAAI,IAAA,kBAAW,EAAC,aAAa,EAAE,KAAK,CAAC,EAAE;IAChE,IAAA,yBAAmB,EAAiC,aAAa,CAAC,CAAC;CACpE;AAED,gEAAgE;AAChE,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;AAC3D,IAAI,IAAA,kBAAW,EAAC,uBAAuB,EAAE,KAAK,CAAC,EAAE;IAC/C,IAAA,sBAAgB,EAAyB,uBAAuB,CAAC,CAAC;CACnE;AAED,MAAM,oBAAoB,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;AAC/C,6DAA6D;AAC7D,aAAa;AACb,oBAAoB,CAAC,IAAI,GAAG,GAAG,CAAC;AAEhC,sFAAsF;AACtF,IAAA,yBAAmB,EAAgB,oBAAoB,CAAC,CAAC;AAEzD,2EAA2E;AAC3E,IAAI,IAAA,kBAAW,EAAC,oBAAoB,EAAE,MAAM,CAAC,EAAE;IAC7C,IAAA,gBAAU,EAAU,oBAAoB,CAAC,IAAI,CAAC,CAAC;CAChD;AAOD,MAAM,2BAA2B,GAAgC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAC1E,IAAA,kBAAW,EAAC,2BAA2B,EAAE,GAAG,CAAC,CAAC;AAE9C,2CAA2C;AAC3C,MAAM,uBAAuB;CAE5B;AACD,MAAM,uBAAuB,GAAG,IAAI,uBAAuB,EAAE,CAAC;AAC9D,IAAA,kBAAW,EAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC;AAM1C,2CAA2C;AAC3C,MAAM,sBAAsB,GAA2B,EAAE,CAAC;AAC1D,IAAI,IAAA,kBAAW,EAAC,sBAAsB,EAAE,GAAG,CAAC,EAAE;IAC5C,IAAA,gBAAU,EAAqB,sBAAsB,CAAC,CAAC,CAAC,CAAC;CAC1D;AAED,+EAA+E;AAC/E,gBAAgB;AAChB,+EAA+E;AAE/E,yBAAyB;AAEzB,IAAA,sBAAgB,EAAgB,EAAE,CAAC,CAAC;AAEpC,IAAA,sBAAgB,EAAgB,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;AAEhD,gEAAgE;AAChE,IAAA,sBAAgB,EAAgB,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAE9C,IAAA,sBAAgB,EAAgB,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAE5D,2BAA2B;AAE3B,IAAA,yBAAmB,EAAgB,IAAI,CAAC,CAAC;AAEzC,IAAA,yBAAmB,EAAgB,SAAS,CAAC,CAAC;AAE9C,IAAA,yBAAmB,EAAgB,KAAK,CAAC,CAAC;AAE1C,IAAA,yBAAmB,EAAgB,CAAC,CAAC,CAAC;AAEtC,IAAA,yBAAmB,EAAgB,EAAE,CAAC,CAAC;AAEvC,IAAA,yBAAmB,EAAgB,IAAI,IAAI,EAAE,CAAC,CAAC;AAE/C,IAAA,yBAAmB,EAAgB,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAE5C,IAAA,yBAAmB,EAAgB,IAAI,GAAG,EAAE,CAAC,CAAC;AAE9C,IAAA,yBAAmB,EAAgB,IAAI,GAAG,EAAE,CAAC,CAAC;AAE9C,IAAA,yBAAmB,EAAgB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAQnD,MAAM,6BAA6B,GAAkC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAC9E,IAAA,yBAAmB,EAAgB,6BAA6B,CAAC,CAAC;AAElE,MAAM,yBAAyB;CAE9B;AACD,MAAM,yBAAyB,GAAG,IAAI,yBAAyB,EAAE,CAAC;AAClE,IAAA,yBAAmB,EAAgB,yBAAyB,CAAC,CAAC","sourcesContent":["import { expectAssignable, expectNotAssignable, expectType } from 'tsd';\n\nimport { isObject, hasProperty, RuntimeObject } from './misc';\n\n//=============================================================================\n// isObject\n//=============================================================================\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nconst unknownValue = {} as unknown;\n\nexpectNotAssignable<RuntimeObject>(unknownValue);\n\nif (isObject(unknownValue)) {\n  expectAssignable<RuntimeObject>(unknownValue);\n}\n\n// Does not interfere with satisfaction of static type\nconst constObjectType = { foo: 'foo' } as const;\nif (hasProperty(constObjectType, 'foo')) {\n  expectAssignable<{ foo: 'foo' }>(constObjectType);\n}\n\n//=============================================================================\n// hasProperty\n//=============================================================================\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nconst unknownObject = {} as Object;\n\n// Establish that `Object` is not accepted when a specific property is needed.\nexpectNotAssignable<Record<'foo', unknown>>(unknownObject);\n\n// Establish that `RuntimeObject` is not accepted when a specific property is needed.\nif (isObject(unknownObject)) {\n  expectNotAssignable<Record<'foo', unknown>>(unknownObject);\n}\n\n// An object is accepted after `hasProperty` is used to prove that it has the required property.\nif (isObject(unknownObject) && hasProperty(unknownObject, 'foo')) {\n  expectAssignable<Record<'foo', unknown>>(unknownObject);\n}\n\n// An object is accepted after `hasProperty` is used to prove that it has all required properties.\nif (\n  isObject(unknownObject) &&\n  hasProperty(unknownObject, 'foo') &&\n  hasProperty(unknownObject, 'bar')\n) {\n  expectAssignable<Record<'foo' | 'bar', unknown>>(unknownObject);\n}\n\n// An object is not accepted after `hasProperty` has only been used to establish that some required properties exist.\nif (isObject(unknownObject) && hasProperty(unknownObject, 'foo')) {\n  expectNotAssignable<Record<'foo' | 'bar', unknown>>(unknownObject);\n}\n\n// Does not interfere with satisfaction of non-overlapping types\nconst overlappingTypesExample = { foo: 'foo', baz: 'baz' };\nif (hasProperty(overlappingTypesExample, 'foo')) {\n  expectAssignable<Record<'baz', unknown>>(overlappingTypesExample);\n}\n\nconst exampleErrorWithCode = new Error('test');\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nexampleErrorWithCode.code = 999;\n\n// Establish that trying to check for a custom property on an error results in failure\nexpectNotAssignable<{ code: any }>(exampleErrorWithCode);\n\n// Using custom Error property is allowed after checking with `hasProperty`\nif (hasProperty(exampleErrorWithCode, 'code')) {\n  expectType<unknown>(exampleErrorWithCode.code);\n}\n\n// `hasProperty` is compatible with interfaces\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\ninterface HasPropertyInterfaceExample {\n  a: number;\n}\nconst hasPropertyInterfaceExample: HasPropertyInterfaceExample = { a: 0 };\nhasProperty(hasPropertyInterfaceExample, 'a');\n\n// `hasProperty` is compatible with classes\nclass HasPropertyClassExample {\n  a!: number;\n}\nconst hasPropertyClassExample = new HasPropertyClassExample();\nhasProperty(hasPropertyClassExample, 'a');\n\ntype HasPropertyTypeExample = {\n  a?: number;\n};\n\n// It keeps the original type when defined.\nconst hasPropertyTypeExample: HasPropertyTypeExample = {};\nif (hasProperty(hasPropertyTypeExample, 'a')) {\n  expectType<number | undefined>(hasPropertyTypeExample.a);\n}\n\n//=============================================================================\n// RuntimeObject\n//=============================================================================\n\n// Valid runtime objects:\n\nexpectAssignable<RuntimeObject>({});\n\nexpectAssignable<RuntimeObject>({ foo: 'foo' });\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexpectAssignable<RuntimeObject>({ 0: 'foo' });\n\nexpectAssignable<RuntimeObject>({ [Symbol('foo')]: 'foo' });\n\n// Invalid runtime objects:\n\nexpectNotAssignable<RuntimeObject>(null);\n\nexpectNotAssignable<RuntimeObject>(undefined);\n\nexpectNotAssignable<RuntimeObject>('foo');\n\nexpectNotAssignable<RuntimeObject>(0);\n\nexpectNotAssignable<RuntimeObject>([]);\n\nexpectNotAssignable<RuntimeObject>(new Date());\n\nexpectNotAssignable<RuntimeObject>(() => 0);\n\nexpectNotAssignable<RuntimeObject>(new Set());\n\nexpectNotAssignable<RuntimeObject>(new Map());\n\nexpectNotAssignable<RuntimeObject>(Symbol('test'));\n\n// The RuntimeObject type gets confused by interfaces. This interface is a valid object,\n// but it's incompatible with the RuntimeObject type.\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\ninterface RuntimeObjectInterfaceExample {\n  a: number;\n}\nconst runtimeObjectInterfaceExample: RuntimeObjectInterfaceExample = { a: 0 };\nexpectNotAssignable<RuntimeObject>(runtimeObjectInterfaceExample);\n\nclass RuntimeObjectClassExample {\n  a!: number;\n}\nconst runtimeObjectClassExample = new RuntimeObjectClassExample();\nexpectNotAssignable<RuntimeObject>(runtimeObjectClassExample);\n"]}

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@metamask/utils",
-  "version": "5.0.2",
-  "description": "Various JavaScript/TypeScript utilities of wide relevance to the MetaMask codebase.",
+  "version": "6.0.0",
+  "description": "Various JavaScript/TypeScript utilities of wide relevance to the MetaMask codebase",
+  "homepage": "https://github.com/MetaMask/utils#readme",
+  "bugs": {
+    "url": "https://github.com/MetaMask/utils/issues"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/MetaMask/utils.git"
   },
   "license": "ISC",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist/"
   ],
@@ -16,13 +20,16 @@
     "build": "tsc --project tsconfig.build.json",
     "build:clean": "rimraf dist && yarn build",
     "build:docs": "typedoc",
-    "lint": "yarn lint:eslint && yarn lint:misc --check",
+    "lint": "yarn lint:eslint && yarn lint:misc --check && yarn lint:dependencies --check && yarn lint:changelog && yarn lint:constraints",
+    "lint:changelog": "auto-changelog validate",
+    "lint:constraints": "yarn constraints",
+    "lint:dependencies": "depcheck && yarn dedupe",
     "lint:eslint": "eslint . --cache --ext js,ts",
-    "lint:fix": "yarn lint:eslint --fix && yarn lint:misc --write",
+    "lint:fix": "yarn lint:eslint --fix && yarn lint:misc --write && yarn lint:dependencies && yarn lint:changelog && yarn lint:constraints --fix",
     "lint:misc": "prettier '**/*.json' '**/*.md' '!CHANGELOG.md' '**/*.yml' '!.yarnrc.yml' --ignore-path .gitignore --no-error-on-unmatched-pattern",
     "prepack": "./scripts/prepack.sh",
     "test": "yarn test:source && yarn test:types",
-    "test:source": "jest",
+    "test:source": "jest && jest-it-up",
     "test:types": "tsd",
     "test:watch": "jest --watch"
   },
@@ -38,14 +45,17 @@
   },
   "devDependencies": {
     "@lavamoat/allow-scripts": "^2.0.3",
-    "@metamask/auto-changelog": "^2.3.0",
+    "@lavamoat/preinstall-always-fail": "^1.0.0",
+    "@metamask/auto-changelog": "^3.1.0",
     "@metamask/eslint-config": "^11.0.1",
     "@metamask/eslint-config-jest": "^11.0.0",
     "@metamask/eslint-config-nodejs": "^11.0.1",
     "@metamask/eslint-config-typescript": "^11.0.0",
     "@types/jest": "^28.1.7",
-    "@typescript-eslint/eslint-plugin": "^5.42.1",
-    "@typescript-eslint/parser": "^5.42.1",
+    "@types/node": "^17.0.23",
+    "@typescript-eslint/eslint-plugin": "^5.43.0",
+    "@typescript-eslint/parser": "^5.43.0",
+    "depcheck": "^1.4.3",
     "eslint": "^8.27.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
@@ -54,19 +64,20 @@
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.2.2",
-    "json-bigint": "^1.0.0",
+    "jest-it-up": "^2.0.2",
     "prettier": "^2.7.1",
-    "prettier-plugin-packagejson": "^2.2.11",
+    "prettier-plugin-packagejson": "^2.3.0",
     "rimraf": "^3.0.2",
     "stdio-mock": "^1.2.0",
     "ts-jest": "^29.0.3",
+    "ts-node": "^10.7.0",
     "tsd": "^0.24.1",
-    "typedoc": "^0.23.10",
+    "typedoc": "^0.23.15",
     "typescript": "~4.8.4"
   },
   "packageManager": "yarn@3.2.3",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=16.0.0"
   },
   "publishConfig": {
     "access": "public",