@mnaoumov/typescript-lib 1.2.0 → 1.4.0

package/dist/lib/esm/debug-switches.d.mts

@@ -0,0 +1,124 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * A registry of debug switches: named, app-wide booleans that change behavior while debugging.
+ *
+ * A debug namespace (see `debug.ts`) controls logging only. Behavior that should differ while debugging, such as
+ * not terminating an operation paused on a breakpoint, is a debug switch instead, so turning logging on never
+ * changes what the code does.
+ *
+ * The definitions, the values and the change listeners all live in the shared state bag (`typescript-lib-state.ts`)
+ * as plain data, so every copy of this library loaded in one realm, such as the copy each Obsidian plugin bundles,
+ * sees one value per switch. A tool such as a debug-settings UI lists every registered switch with
+ * {@link getDebugSwitches} and needs no change when a library or plugin adds one.
+ */
+import type { DisposableEx } from './disposable.mjs';
+/**
+ * A handle to a registered debug switch.
+ */
+export interface DebugSwitch extends DebugSwitchDefinition {
+    /**
+     * Gets the current value.
+     *
+     * @returns `true` if the switch is on.
+     */
+    isEnabled: () => boolean;
+    /**
+     * Sets the value, notifying the {@link onDebugSwitchChanged} listeners if it changed.
+     *
+     * @param isEnabled - The new value.
+     */
+    setEnabled: (isEnabled: boolean) => void;
+}
+/**
+ * A change of a debug switch's value, passed to an {@link onDebugSwitchChanged} listener.
+ */
+export interface DebugSwitchChange {
+    /**
+     * The id of the switch that changed.
+     */
+    readonly id: string;
+    /**
+     * The new value.
+     */
+    readonly isEnabled: boolean;
+}
+/**
+ * The listener of {@link onDebugSwitchChanged}.
+ */
+export type DebugSwitchChangeListener = (change: DebugSwitchChange) => void;
+/**
+ * The definition of a debug switch.
+ */
+export interface DebugSwitchDefinition {
+    /**
+     * What the switch does, for a settings UI.
+     */
+    readonly description: string;
+    /**
+     * The unique id, namespaced by the library or plugin that owns the switch, e.g.
+     * `typescript-lib:terminate-on-timeout`.
+     */
+    readonly id: string;
+    /**
+     * The value the switch has until something sets it.
+     */
+    readonly isEnabledByDefault: boolean;
+    /**
+     * The human-readable name, for a settings UI.
+     */
+    readonly name: string;
+}
+/**
+ * Gets a registered debug switch.
+ *
+ * @param id - The id of the switch.
+ * @returns The switch, or `undefined` if no switch with that id is registered.
+ */
+export declare function getDebugSwitch(id: string): DebugSwitch | undefined;
+/**
+ * Gets every registered debug switch, sorted by id.
+ *
+ * @returns The registered switches.
+ */
+export declare function getDebugSwitches(): DebugSwitch[];
+/**
+ * Gets the debug switch that decides whether a `runWithTimeout` call without its own `onTimeout` terminates the
+ * operation when it times out.
+ *
+ * Its id is `typescript-lib:terminate-on-timeout` and it is on by default. Switch it off while debugging, so an
+ * operation paused on a breakpoint is not terminated under the debugger. The timeout is still logged through the
+ * `Async:runWithTimeout` debugger.
+ *
+ * @returns The debug switch.
+ */
+export declare function getTerminateOnTimeoutDebugSwitch(): DebugSwitch;
+/**
+ * Adds a listener called whenever a debug switch's value changes, in any loaded copy of this library.
+ *
+ * @param listener - The listener.
+ * @returns A disposable that removes the listener.
+ */
+export declare function onDebugSwitchChanged(listener: DebugSwitchChangeListener): DisposableEx;
+/**
+ * Registers a debug switch.
+ *
+ * Registering an id again is idempotent: the first definition is kept, and the returned handle reads the same
+ * value. A value set with {@link setDebugSwitch} before the switch was registered is kept, not reset to the
+ * default.
+ *
+ * @param definition - The definition of the switch.
+ * @returns The handle to the switch.
+ */
+export declare function registerDebugSwitch(definition: DebugSwitchDefinition): DebugSwitch;
+/**
+ * Sets the value of a debug switch, notifying the {@link onDebugSwitchChanged} listeners if it changed.
+ *
+ * The switch does not have to be registered yet: the value is kept, and the switch takes it when it registers. That
+ * lets a settings store re-apply saved values before every library or plugin that owns a switch has loaded.
+ *
+ * @param id - The id of the switch.
+ * @param isEnabled - The new value.
+ */
+export declare function setDebugSwitch(id: string, isEnabled: boolean): void;

package/dist/lib/esm/debug-switches.mjs

@@ -0,0 +1,96 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { CallbackDisposable } from "./disposable.mjs";
+import { getTypescriptLibState } from "./typescript-lib-state.mjs";
+const LEGACY_STATE_KEYS = {
+  "typescript-lib:terminate-on-timeout": "isTerminationOnTimeoutEnabled"
+};
+const TERMINATE_ON_TIMEOUT_DEFINITION = {
+  description: "Terminate an operation that times out. Switch it off so an operation paused on a breakpoint keeps running.",
+  id: "typescript-lib:terminate-on-timeout",
+  isEnabledByDefault: true,
+  name: "Terminate operations on timeout"
+};
+const BUILT_IN_DEFINITIONS = [TERMINATE_ON_TIMEOUT_DEFINITION];
+function getDebugSwitch(id) {
+  const definition = getDefinitions().get(id);
+  return definition ? createHandle(definition) : void 0;
+}
+function getDebugSwitches() {
+  return [...getDefinitions().values()].sort((a, b) => a.id.localeCompare(b.id)).map((definition) => createHandle(definition));
+}
+function getTerminateOnTimeoutDebugSwitch() {
+  return registerDebugSwitch(TERMINATE_ON_TIMEOUT_DEFINITION);
+}
+function onDebugSwitchChanged(listener) {
+  const listeners = getListeners();
+  listeners.add(listener);
+  return new CallbackDisposable({
+    callback() {
+      listeners.delete(listener);
+    }
+  });
+}
+function registerDebugSwitch(definition) {
+  const definitions = getDefinitions();
+  let registeredDefinition = definitions.get(definition.id);
+  if (!registeredDefinition) {
+    registeredDefinition = {
+      description: definition.description,
+      id: definition.id,
+      isEnabledByDefault: definition.isEnabledByDefault,
+      name: definition.name
+    };
+    definitions.set(definition.id, registeredDefinition);
+  }
+  return createHandle(registeredDefinition);
+}
+function setDebugSwitch(id, isEnabled) {
+  const definition = getDefinitions().get(id);
+  const wrapper = getValueWrapper(id, definition?.isEnabledByDefault ?? !isEnabled);
+  if (wrapper.value === isEnabled) {
+    return;
+  }
+  wrapper.value = isEnabled;
+  for (const listener of getListeners()) {
+    listener({ id, isEnabled });
+  }
+}
+function createHandle(definition) {
+  return {
+    ...definition,
+    isEnabled() {
+      return getValueWrapper(definition.id, definition.isEnabledByDefault).value;
+    },
+    setEnabled(isEnabled) {
+      setDebugSwitch(definition.id, isEnabled);
+    }
+  };
+}
+function getDefinitions() {
+  const definitions = getTypescriptLibState("debugSwitchDefinitions", /* @__PURE__ */ new Map()).value;
+  for (const definition of BUILT_IN_DEFINITIONS) {
+    if (!definitions.has(definition.id)) {
+      definitions.set(definition.id, definition);
+    }
+  }
+  return definitions;
+}
+function getListeners() {
+  return getTypescriptLibState("debugSwitchListeners", /* @__PURE__ */ new Set()).value;
+}
+function getValueWrapper(id, isEnabledByDefault) {
+  return getTypescriptLibState(LEGACY_STATE_KEYS[id] ?? `debugSwitch:${id}`, isEnabledByDefault);
+}
+export {
+  getDebugSwitch,
+  getDebugSwitches,
+  getTerminateOnTimeoutDebugSwitch,
+  onDebugSwitchChanged,
+  registerDebugSwitch,
+  setDebugSwitch
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/debug-switches.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A registry of debug switches: named, app-wide booleans that change behavior while debugging.\n *\n * A debug namespace (see `debug.ts`) controls logging only. Behavior that should differ while debugging, such as\n * not terminating an operation paused on a breakpoint, is a debug switch instead, so turning logging on never\n * changes what the code does.\n *\n * The definitions, the values and the change listeners all live in the shared state bag (`typescript-lib-state.ts`)\n * as plain data, so every copy of this library loaded in one realm, such as the copy each Obsidian plugin bundles,\n * sees one value per switch. A tool such as a debug-settings UI lists every registered switch with\n * {@link getDebugSwitches} and needs no change when a library or plugin adds one.\n */\n\nimport type { DisposableEx } from './disposable.ts';\nimport type { ValueWrapper } from './value-wrapper.ts';\n\nimport { CallbackDisposable } from './disposable.ts';\nimport { getTypescriptLibState } from './typescript-lib-state.ts';\n\n/**\n * A handle to a registered debug switch.\n */\nexport interface DebugSwitch extends DebugSwitchDefinition {\n  /**\n   * Gets the current value.\n   *\n   * @returns `true` if the switch is on.\n   */\n  isEnabled: () => boolean;\n\n  /**\n   * Sets the value, notifying the {@link onDebugSwitchChanged} listeners if it changed.\n   *\n   * @param isEnabled - The new value.\n   */\n  setEnabled: (isEnabled: boolean) => void;\n}\n\n/**\n * A change of a debug switch's value, passed to an {@link onDebugSwitchChanged} listener.\n */\nexport interface DebugSwitchChange {\n  /**\n   * The id of the switch that changed.\n   */\n  readonly id: string;\n\n  /**\n   * The new value.\n   */\n  readonly isEnabled: boolean;\n}\n\n/**\n * The listener of {@link onDebugSwitchChanged}.\n */\nexport type DebugSwitchChangeListener = (change: DebugSwitchChange) => void;\n\n/**\n * The definition of a debug switch.\n */\nexport interface DebugSwitchDefinition {\n  /**\n   * What the switch does, for a settings UI.\n   */\n  readonly description: string;\n\n  /**\n   * The unique id, namespaced by the library or plugin that owns the switch, e.g.\n   * `typescript-lib:terminate-on-timeout`.\n   */\n  readonly id: string;\n\n  /**\n   * The value the switch has until something sets it.\n   */\n  readonly isEnabledByDefault: boolean;\n\n  /**\n   * The human-readable name, for a settings UI.\n   */\n  readonly name: string;\n}\n\n// A switch whose value an earlier version of this library kept under its own shared-state key keeps that key, so a\n// copy of that version loaded beside this one still reads and writes the same value.\nconst LEGACY_STATE_KEYS: Readonly<Record<string, string>> = {\n  'typescript-lib:terminate-on-timeout': 'isTerminationOnTimeoutEnabled'\n};\n\nconst TERMINATE_ON_TIMEOUT_DEFINITION: DebugSwitchDefinition = {\n  description: 'Terminate an operation that times out. Switch it off so an operation paused on a breakpoint keeps running.',\n  id: 'typescript-lib:terminate-on-timeout',\n  isEnabledByDefault: true,\n  name: 'Terminate operations on timeout'\n};\n\n// This library's own switches, always registered, so a settings UI lists them before any code that reads them runs.\nconst BUILT_IN_DEFINITIONS: readonly DebugSwitchDefinition[] = [TERMINATE_ON_TIMEOUT_DEFINITION];\n\n/**\n * Gets a registered debug switch.\n *\n * @param id - The id of the switch.\n * @returns The switch, or `undefined` if no switch with that id is registered.\n */\nexport function getDebugSwitch(id: string): DebugSwitch | undefined {\n  const definition = getDefinitions().get(id);\n  return definition ? createHandle(definition) : undefined;\n}\n\n/**\n * Gets every registered debug switch, sorted by id.\n *\n * @returns The registered switches.\n */\nexport function getDebugSwitches(): DebugSwitch[] {\n  return [...getDefinitions().values()]\n    .sort((a, b) => a.id.localeCompare(b.id))\n    .map((definition) => createHandle(definition));\n}\n\n/**\n * Gets the debug switch that decides whether a `runWithTimeout` call without its own `onTimeout` terminates the\n * operation when it times out.\n *\n * Its id is `typescript-lib:terminate-on-timeout` and it is on by default. Switch it off while debugging, so an\n * operation paused on a breakpoint is not terminated under the debugger. The timeout is still logged through the\n * `Async:runWithTimeout` debugger.\n *\n * @returns The debug switch.\n */\nexport function getTerminateOnTimeoutDebugSwitch(): DebugSwitch {\n  return registerDebugSwitch(TERMINATE_ON_TIMEOUT_DEFINITION);\n}\n\n/**\n * Adds a listener called whenever a debug switch's value changes, in any loaded copy of this library.\n *\n * @param listener - The listener.\n * @returns A disposable that removes the listener.\n */\nexport function onDebugSwitchChanged(listener: DebugSwitchChangeListener): DisposableEx {\n  const listeners = getListeners();\n  listeners.add(listener);\n  return new CallbackDisposable({\n    callback(): void {\n      listeners.delete(listener);\n    }\n  });\n}\n\n/**\n * Registers a debug switch.\n *\n * Registering an id again is idempotent: the first definition is kept, and the returned handle reads the same\n * value. A value set with {@link setDebugSwitch} before the switch was registered is kept, not reset to the\n * default.\n *\n * @param definition - The definition of the switch.\n * @returns The handle to the switch.\n */\nexport function registerDebugSwitch(definition: DebugSwitchDefinition): DebugSwitch {\n  const definitions = getDefinitions();\n  let registeredDefinition = definitions.get(definition.id);\n  if (!registeredDefinition) {\n    registeredDefinition = {\n      description: definition.description,\n      id: definition.id,\n      isEnabledByDefault: definition.isEnabledByDefault,\n      name: definition.name\n    };\n    definitions.set(definition.id, registeredDefinition);\n  }\n  return createHandle(registeredDefinition);\n}\n\n/**\n * Sets the value of a debug switch, notifying the {@link onDebugSwitchChanged} listeners if it changed.\n *\n * The switch does not have to be registered yet: the value is kept, and the switch takes it when it registers. That\n * lets a settings store re-apply saved values before every library or plugin that owns a switch has loaded.\n *\n * @param id - The id of the switch.\n * @param isEnabled - The new value.\n */\nexport function setDebugSwitch(id: string, isEnabled: boolean): void {\n  const definition = getDefinitions().get(id);\n  // An unregistered switch with no value yet has no previous value, so its first set counts as a change.\n  const wrapper = getValueWrapper(id, definition?.isEnabledByDefault ?? !isEnabled);\n  if (wrapper.value === isEnabled) {\n    return;\n  }\n  wrapper.value = isEnabled;\n  for (const listener of getListeners()) {\n    listener({ id, isEnabled });\n  }\n}\n\nfunction createHandle(definition: DebugSwitchDefinition): DebugSwitch {\n  return {\n    ...definition,\n    isEnabled(): boolean {\n      return getValueWrapper(definition.id, definition.isEnabledByDefault).value;\n    },\n    setEnabled(isEnabled: boolean): void {\n      setDebugSwitch(definition.id, isEnabled);\n    }\n  };\n}\n\nfunction getDefinitions(): Map<string, DebugSwitchDefinition> {\n  const definitions = getTypescriptLibState('debugSwitchDefinitions', new Map<string, DebugSwitchDefinition>()).value;\n  // Checked on every read, because the map may have been created by a copy of this library that predates a switch.\n  for (const definition of BUILT_IN_DEFINITIONS) {\n    if (!definitions.has(definition.id)) {\n      definitions.set(definition.id, definition);\n    }\n  }\n  return definitions;\n}\n\nfunction getListeners(): Set<DebugSwitchChangeListener> {\n  return getTypescriptLibState('debugSwitchListeners', new Set<DebugSwitchChangeListener>()).value;\n}\n\nfunction getValueWrapper(id: string, isEnabledByDefault: boolean): ValueWrapper<boolean> {\n  return getTypescriptLibState(LEGACY_STATE_KEYS[id] ?? `debugSwitch:${id}`, isEnabledByDefault);\n}\n"],
  "mappings": ";;;;;AAkBA,SAAS,0BAA0B;AACnC,SAAS,6BAA6B;AAqEtC,MAAM,oBAAsD;AAAA,EAC1D,uCAAuC;AACzC;AAEA,MAAM,kCAAyD;AAAA,EAC7D,aAAa;AAAA,EACb,IAAI;AAAA,EACJ,oBAAoB;AAAA,EACpB,MAAM;AACR;AAGA,MAAM,uBAAyD,CAAC,+BAA+B;AAQxF,SAAS,eAAe,IAAqC;AAClE,QAAM,aAAa,eAAe,EAAE,IAAI,EAAE;AAC1C,SAAO,aAAa,aAAa,UAAU,IAAI;AACjD;AAOO,SAAS,mBAAkC;AAChD,SAAO,CAAC,GAAG,eAAe,EAAE,OAAO,CAAC,EACjC,KAAK,CAAC,GAAG,MAAM,EAAE,GAAG,cAAc,EAAE,EAAE,CAAC,EACvC,IAAI,CAAC,eAAe,aAAa,UAAU,CAAC;AACjD;AAYO,SAAS,mCAAgD;AAC9D,SAAO,oBAAoB,+BAA+B;AAC5D;AAQO,SAAS,qBAAqB,UAAmD;AACtF,QAAM,YAAY,aAAa;AAC/B,YAAU,IAAI,QAAQ;AACtB,SAAO,IAAI,mBAAmB;AAAA,IAC5B,WAAiB;AACf,gBAAU,OAAO,QAAQ;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAYO,SAAS,oBAAoB,YAAgD;AAClF,QAAM,cAAc,eAAe;AACnC,MAAI,uBAAuB,YAAY,IAAI,WAAW,EAAE;AACxD,MAAI,CAAC,sBAAsB;AACzB,2BAAuB;AAAA,MACrB,aAAa,WAAW;AAAA,MACxB,IAAI,WAAW;AAAA,MACf,oBAAoB,WAAW;AAAA,MAC/B,MAAM,WAAW;AAAA,IACnB;AACA,gBAAY,IAAI,WAAW,IAAI,oBAAoB;AAAA,EACrD;AACA,SAAO,aAAa,oBAAoB;AAC1C;AAWO,SAAS,eAAe,IAAY,WAA0B;AACnE,QAAM,aAAa,eAAe,EAAE,IAAI,EAAE;AAE1C,QAAM,UAAU,gBAAgB,IAAI,YAAY,sBAAsB,CAAC,SAAS;AAChF,MAAI,QAAQ,UAAU,WAAW;AAC/B;AAAA,EACF;AACA,UAAQ,QAAQ;AAChB,aAAW,YAAY,aAAa,GAAG;AACrC,aAAS,EAAE,IAAI,UAAU,CAAC;AAAA,EAC5B;AACF;AAEA,SAAS,aAAa,YAAgD;AACpE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,YAAqB;AACnB,aAAO,gBAAgB,WAAW,IAAI,WAAW,kBAAkB,EAAE;AAAA,IACvE;AAAA,IACA,WAAW,WAA0B;AACnC,qBAAe,WAAW,IAAI,SAAS;AAAA,IACzC;AAAA,EACF;AACF;AAEA,SAAS,iBAAqD;AAC5D,QAAM,cAAc,sBAAsB,0BAA0B,oBAAI,IAAmC,CAAC,EAAE;AAE9G,aAAW,cAAc,sBAAsB;AAC7C,QAAI,CAAC,YAAY,IAAI,WAAW,EAAE,GAAG;AACnC,kBAAY,IAAI,WAAW,IAAI,UAAU;AAAA,IAC3C;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,eAA+C;AACtD,SAAO,sBAAsB,wBAAwB,oBAAI,IAA+B,CAAC,EAAE;AAC7F;AAEA,SAAS,gBAAgB,IAAY,oBAAoD;AACvF,SAAO,sBAAsB,kBAAkB,EAAE,KAAK,eAAe,EAAE,IAAI,kBAAkB;AAC/F;",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -11,6 +11,7 @@ export * as 'beeper' from './beeper.mjs';
 export * as 'blob' from './blob.mjs';
 export * as 'bytes' from './bytes.mjs';
 export * as 'debug-controller' from './debug-controller.mjs';
+export * as 'debug-switches' from './debug-switches.mjs';
 export * as 'debug' from './debug.mjs';
 export * as 'desktop-zip-extractor' from './desktop-zip-extractor.mjs';
 export * as 'disposable' from './disposable.mjs';

package/dist/lib/esm/index.mjs

@@ -15,6 +15,7 @@ import * as beeper from "./beeper.mjs";
 import * as blob from "./blob.mjs";
 import * as bytes from "./bytes.mjs";
 import * as debug_controller from "./debug-controller.mjs";
+import * as debug_switches from "./debug-switches.mjs";
 import * as debug from "./debug.mjs";
 import * as desktop_zip_extractor from "./desktop-zip-extractor.mjs";
 import * as disposable from "./disposable.mjs";
@@ -50,6 +51,7 @@ export {
   bytes,
   debug,
   debug_controller as "debug-controller",
+  debug_switches as "debug-switches",
   desktop_zip_extractor as "desktop-zip-extractor",
   disposable,
   enum2 as enum,
@@ -71,4 +73,4 @@ export {
   value_provider as "value-provider",
   value_wrapper as "value-wrapper"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/type-guards.d.mts

@@ -2,15 +2,66 @@
 /**
  * @file
  *
- * Contains utility functions for type guards.
+ * Contains utility functions for type guards, and combinators that build a {@link TypeGuard} out of others.
+ *
+ * The combinators here work on bare type guards. Their `api-contract` counterparts (`arrayGuard`, `optionalGuard`,
+ * ...) work on an `ExpectedTypeGuard`, a type guard paired with the text an issue message reports, and their names
+ * drop the `Type` this layer's names carry.
  */
+import type { GenericFunction } from './function.mjs';
 /**
  * A type that represents a generic object.
  *
  * @typeParam T - The base type to intersect with.
  */
 export type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;
+/**
+ * The type a {@link TypeGuard} narrows to. Distributes over a union of guards.
+ *
+ * @typeParam TTypeGuard - The type guard.
+ */
+export type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => value is infer T ? T : never;
+/**
+ * A value {@link literalTypeGuard} can compare against.
+ */
+export type Literal = bigint | boolean | null | number | string | symbol | undefined;
+/**
+ * Options for {@link objectTypeGuard}.
+ */
+export interface ObjectTypeGuardOptions {
+    /**
+     * Whether a value carrying an own enumerable string key that no property guard names is refused.
+     *
+     * @default `false`
+     */
+    readonly shouldRejectUnknownKeys?: boolean;
+}
+/**
+ * One type guard per property of an object type, as {@link objectTypeGuard} takes them. Every key of `T` must be
+ * listed. The guard of an optional property is typed to narrow to `undefined` as well, but a guard that refuses
+ * `undefined` still compiles there, so widen it with {@link optionalTypeGuard}: an absent property reads as
+ * `undefined`, and a guard refusing it refuses the object.
+ *
+ * @typeParam T - The object type.
+ */
+export type PropertyTypeGuards<T extends object> = {
+    readonly [TKey in keyof T]-?: TypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;
+};
+/**
+ * A function deciding whether a value is a `T`.
+ *
+ * @typeParam T - The type the guard narrows to.
+ */
+export type TypeGuard<T> = (value: unknown) => value is T;
 type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
+/**
+ * Builds a guard accepting an array whose every item the item guard accepts.
+ *
+ * @typeParam T - The type of an item.
+ * @param isItem - The guard for one item.
+ * @returns The guard.
+ */
+export declare function arrayTypeGuard<T>(isItem: TypeGuard<T>): TypeGuard<T[]>;
 /**
  * Asserts that a condition is `true`. Throws if it is not.
  *
@@ -81,6 +132,22 @@ export declare function ensureGenericObject<T>($object: T): GenericObject<T>;
  * @throws If the value is `null` or `undefined`.
  */
 export declare function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T>;
+/**
+ * Builds a guard accepting any function, narrowed to the signature `TFunction`. Only that the value is a function
+ * is checked: a signature cannot be checked at runtime, so the guard trusts it.
+ *
+ * @typeParam TFunction - The signature the guard narrows to.
+ * @returns The guard.
+ */
+export declare function functionTypeGuard<TFunction extends GenericFunction>(): TypeGuard<TFunction>;
+/**
+ * Builds a guard accepting an instance of a class, or of a class derived from it.
+ *
+ * @typeParam T - The type of an instance.
+ * @param constructor - The class.
+ * @returns The guard.
+ */
+export declare function instanceOfTypeGuard<T>(constructor: abstract new (...arguments_: never[]) => T): TypeGuard<T>;
 /**
  * Checks whether a value is a boolean.
  *
@@ -88,6 +155,20 @@ export declare function ensureNonNullable<T extends NullableConstraint<T>>(value
  * @returns Whether the value is a boolean.
  */
 export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks whether a value is a function.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a function.
+ */
+export declare function isFunction(value: unknown): value is GenericFunction;
+/**
+ * Checks whether a value is `null`.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is `null`.
+ */
+export declare function isNull(value: unknown): value is null;
 /**
  * Checks whether a value is a number.
  *
@@ -95,6 +176,13 @@ export declare function isBoolean(value: unknown): value is boolean;
  * @returns Whether the value is a number.
  */
 export declare function isNumber(value: unknown): value is number;
+/**
+ * Checks whether a value is an object: not `null`, and not a primitive or a function.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is an object.
+ */
+export declare function isObject(value: unknown): value is object;
 /**
  * Checks whether a value is a string.
  *
@@ -116,4 +204,57 @@ export declare function isStringArray(value: unknown): value is string[];
  * @returns Whether the value is `undefined`.
  */
 export declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Builds a guard accepting exactly the keys of a record. Typing the record over a union, as
+ * `literalTypeGuard<Mode>({ A: true, B: true })`, makes a member later added to the union fail to compile until
+ * it is listed.
+ *
+ * @typeParam T - The accepted strings.
+ * @param literals - A record whose keys are the accepted strings.
+ * @returns The guard.
+ */
+export declare function literalTypeGuard<T extends string>(literals: Readonly<Record<T, true>>): TypeGuard<T>;
+/**
+ * Builds a guard accepting exactly the listed values, compared as `Array.prototype.includes` compares them.
+ *
+ * @typeParam T - The accepted values.
+ * @param literals - The accepted values.
+ * @returns The guard.
+ */
+export declare function literalTypeGuard<T extends Literal>(literals: readonly T[]): TypeGuard<T>;
+/**
+ * Widens a guard to also accept `null`.
+ *
+ * @typeParam T - The type the guard narrows to.
+ * @param isValue - The guard to widen.
+ * @returns A guard accepting what `isValue` accepts, or `null`.
+ */
+export declare function nullableTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<null | T>;
+/**
+ * Builds a guard accepting an object whose every listed property its guard accepts. A property is read with
+ * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`.
+ *
+ * @typeParam T - The object type.
+ * @param propertyTypeGuards - One guard per property of `T`.
+ * @param options - The options for the guard.
+ * @returns The guard.
+ */
+export declare function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions): TypeGuard<T>;
+/**
+ * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is
+ * left out.
+ *
+ * @typeParam T - The type the guard narrows to.
+ * @param isValue - The guard to widen.
+ * @returns A guard accepting what `isValue` accepts, or `undefined`.
+ */
+export declare function optionalTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<T | undefined>;
+/**
+ * Builds a guard accepting what any of the given guards accepts.
+ *
+ * @typeParam TTypeGuards - The guards.
+ * @param typeGuards - The guards, tried in order.
+ * @returns The guard.
+ */
+export declare function unionTypeGuard<const TTypeGuards extends readonly TypeGuard<unknown>[]>(...typeGuards: TTypeGuards): TypeGuard<GuardedType<TTypeGuards[number]>>;
 export {};

package/dist/lib/esm/type-guards.mjs

@@ -4,6 +4,9 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 import { noop } from "./function.mjs";
+function arrayTypeGuard(isItem) {
+  return (value) => Array.isArray(value) && value.every((item) => isItem(item));
+}
 function assert(isTrue, errorOrMessage) {
   if (!isTrue) {
     throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
@@ -30,12 +33,27 @@ function ensureNonNullable(value, errorOrMessage) {
   assertNonNullable(value, errorOrMessage);
   return value;
 }
+function functionTypeGuard() {
+  return (value) => isFunction(value);
+}
+function instanceOfTypeGuard(constructor) {
+  return (value) => value instanceof constructor;
+}
 function isBoolean(value) {
   return typeof value === "boolean";
 }
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isNull(value) {
+  return value === null;
+}
 function isNumber(value) {
   return typeof value === "number";
 }
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
 function isString(value) {
   return typeof value === "string";
 }
@@ -45,17 +63,64 @@ function isStringArray(value) {
 function isUndefined(value) {
   return value === void 0;
 }
+function literalTypeGuard(literals) {
+  if (isReadonlyArray(literals)) {
+    const literalList = literals;
+    return (value) => literalList.includes(value);
+  }
+  return (value) => isString(value) && Object.hasOwn(literals, value);
+}
+function nullableTypeGuard(isValue) {
+  return unionTypeGuard(isNull, isValue);
+}
+function objectTypeGuard(propertyTypeGuards, options) {
+  const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;
+  return (value) => {
+    if (!isObject(value)) {
+      return false;
+    }
+    if (shouldRejectUnknownKeys && Object.keys(value).some((key) => !Object.hasOwn(propertyTypeGuards, key))) {
+      return false;
+    }
+    for (const key in propertyTypeGuards) {
+      if (!propertyTypeGuards[key](Reflect.get(value, key))) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function optionalTypeGuard(isValue) {
+  return unionTypeGuard(isUndefined, isValue);
+}
+function unionTypeGuard(...typeGuards) {
+  return (value) => typeGuards.some((typeGuard) => typeGuard(value));
+}
+function isReadonlyArray(value) {
+  return Array.isArray(value);
+}
 export {
+  arrayTypeGuard,
   assert,
   assertGenericObject,
   assertNever,
   assertNonNullable,
   ensureGenericObject,
   ensureNonNullable,
+  functionTypeGuard,
+  instanceOfTypeGuard,
   isBoolean,
+  isFunction,
+  isNull,
   isNumber,
+  isObject,
   isString,
   isStringArray,
-  isUndefined
+  isUndefined,
+  literalTypeGuard,
+  nullableTypeGuard,
+  objectTypeGuard,
+  optionalTypeGuard,
+  unionTypeGuard
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type-guards.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for type guards.\n */\n\nimport { noop } from './function.ts';\n\n/**\n * A type that represents a generic object.\n *\n * @typeParam T - The base type to intersect with.\n */\nexport type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;\n\ntype NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;\n\n/**\n * Asserts that a condition is `true`. Throws if it is not.\n *\n * Use in place of `/* v8 ignore *\\/` for defensive guards that should\n * never trigger at runtime but would otherwise create uncovered branches.\n *\n * @param isTrue - The condition to assert.\n * @param errorOrMessage - The error or message to throw if the condition is `false`.\n */\nexport function assert(isTrue: boolean, errorOrMessage: Error | string): asserts isTrue {\n  if (!isTrue) {\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  }\n}\n\n/**\n * Asserts that a value is a generic object, narrowing its type in place.\n *\n * @typeParam T - The type of the value.\n * @param _object - The value to assert.\n */\nexport function assertGenericObject<T>(_object: T): asserts _object is GenericObject<T> {\n  noop();\n}\n\n/**\n * Asserts at compile time that every case of a discriminated union has been\n * handled. Place at the `default` branch of a `switch` over a union or enum.\n *\n * If a new variant is added to the union without a matching `case`, the call\n * to {@link assertNever} fails to compile because `value` is no longer `never`.\n * If reached at runtime (e.g. because the value was bypassed via JSON or a\n * type assertion), it throws a descriptive `Error`.\n *\n * @example\n * ```ts\n * switch (mode) {\n *   case 'a': return doA();\n *   case 'b': return doB();\n *   default: assertNever(mode);\n * }\n * ```\n *\n * @param value - The exhaustively-handled value, narrowed to `never` by control flow.\n * @throws Always, if reached at runtime.\n */\nexport function assertNever(value: never): never {\n  throw new Error(`Unhandled value: ${String(value)}`);\n}\n\n/**\n * Asserts that a value is not `null` or `undefined`, narrowing its type in place.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @throws If the value is `null` or `undefined`.\n */\nexport function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T> {\n  if (value !== null && value !== undefined) {\n    return;\n  }\n\n  errorOrMessage ??= value === null ? 'Value is null' : 'Value is undefined';\n  const error = typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  throw error;\n}\n\n/**\n * Ensures that a value is a generic object, returning it with narrowed type.\n *\n * @typeParam T - The type of the value.\n * @param $object - The value to ensure.\n * @returns The value as a generic object.\n */\nexport function ensureGenericObject<T>($object: T): GenericObject<T> {\n  return $object as GenericObject<T>;\n}\n\n/**\n * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @returns The value with `null` and `undefined` excluded from its type.\n * @throws If the value is `null` or `undefined`.\n */\nexport function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T> {\n  assertNonNullable(value, errorOrMessage);\n  return value;\n}\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value - The value to check.\n * @returns Whether the value is a boolean.\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Checks whether a value is a number.\n *\n * @param value - The value to check.\n * @returns Whether the value is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number';\n}\n\n/**\n * Checks whether a value is a string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Checks whether a value is an array of strings.\n *\n * @param value - The value to check.\n * @returns Whether the value is an array whose every item is a string.\n */\nexport function isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every(isString);\n}\n\n/**\n * Checks whether a value is `undefined`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `undefined`.\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n"],
  "mappings": ";;;;;AAMA,SAAS,YAAY;AAoBd,SAAS,OAAO,QAAiB,gBAAgD;AACtF,MAAI,CAAC,QAAQ;AACX,UAAM,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAAA,EACzE;AACF;AAQO,SAAS,oBAAuB,SAAiD;AACtF,OAAK;AACP;AAuBO,SAAS,YAAY,OAAqB;AAC/C,QAAM,IAAI,MAAM,oBAAoB,OAAO,KAAK,CAAC,EAAE;AACrD;AAYO,SAAS,kBAAmD,OAAU,gBAAkE;AAC7I,MAAI,UAAU,QAAQ,UAAU,QAAW;AACzC;AAAA,EACF;AAEA,qBAAmB,UAAU,OAAO,kBAAkB;AACtD,QAAM,QAAQ,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAC/E,QAAM;AACR;AASO,SAAS,oBAAuB,SAA8B;AACnE,SAAO;AACT;AAaO,SAAS,kBAAmD,OAAU,gBAAiD;AAC5H,oBAAkB,OAAO,cAAc;AACvC,SAAO;AACT;AAQO,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,cAAc,OAAmC;AAC/D,SAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,QAAQ;AACrD;AAQO,SAAS,YAAY,OAAoC;AAC9D,SAAO,UAAU;AACnB;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type-guards.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for type guards, and combinators that build a {@link TypeGuard} out of others.\n *\n * The combinators here work on bare type guards. Their `api-contract` counterparts (`arrayGuard`, `optionalGuard`,\n * ...) work on an `ExpectedTypeGuard`, a type guard paired with the text an issue message reports, and their names\n * drop the `Type` this layer's names carry.\n */\n\nimport type { GenericFunction } from './function.ts';\n\nimport { noop } from './function.ts';\n\n/**\n * A type that represents a generic object.\n *\n * @typeParam T - The base type to intersect with.\n */\nexport type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;\n\n/**\n * The type a {@link TypeGuard} narrows to. Distributes over a union of guards.\n *\n * @typeParam TTypeGuard - The type guard.\n */\nexport type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => value is infer T ? T : never;\n\n/**\n * A value {@link literalTypeGuard} can compare against.\n */\nexport type Literal = bigint | boolean | null | number | string | symbol | undefined;\n\n/**\n * Options for {@link objectTypeGuard}.\n */\nexport interface ObjectTypeGuardOptions {\n  /**\n   * Whether a value carrying an own enumerable string key that no property guard names is refused.\n   *\n   * @default `false`\n   */\n  readonly shouldRejectUnknownKeys?: boolean;\n}\n\n/**\n * One type guard per property of an object type, as {@link objectTypeGuard} takes them. Every key of `T` must be\n * listed. The guard of an optional property is typed to narrow to `undefined` as well, but a guard that refuses\n * `undefined` still compiles there, so widen it with {@link optionalTypeGuard}: an absent property reads as\n * `undefined`, and a guard refusing it refuses the object.\n *\n * @typeParam T - The object type.\n */\nexport type PropertyTypeGuards<T extends object> = {\n  readonly [TKey in keyof T]-?: TypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;\n};\n\n/**\n * A function deciding whether a value is a `T`.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport type TypeGuard<T> = (value: unknown) => value is T;\n\ntype NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;\n\n/**\n * Builds a guard accepting an array whose every item the item guard accepts.\n *\n * @typeParam T - The type of an item.\n * @param isItem - The guard for one item.\n * @returns The guard.\n */\nexport function arrayTypeGuard<T>(isItem: TypeGuard<T>): TypeGuard<T[]> {\n  return (value): value is T[] => Array.isArray(value) && value.every((item) => isItem(item));\n}\n\n/**\n * Asserts that a condition is `true`. Throws if it is not.\n *\n * Use in place of `/* v8 ignore *\\/` for defensive guards that should\n * never trigger at runtime but would otherwise create uncovered branches.\n *\n * @param isTrue - The condition to assert.\n * @param errorOrMessage - The error or message to throw if the condition is `false`.\n */\nexport function assert(isTrue: boolean, errorOrMessage: Error | string): asserts isTrue {\n  if (!isTrue) {\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  }\n}\n\n/**\n * Asserts that a value is a generic object, narrowing its type in place.\n *\n * @typeParam T - The type of the value.\n * @param _object - The value to assert.\n */\nexport function assertGenericObject<T>(_object: T): asserts _object is GenericObject<T> {\n  noop();\n}\n\n/**\n * Asserts at compile time that every case of a discriminated union has been\n * handled. Place at the `default` branch of a `switch` over a union or enum.\n *\n * If a new variant is added to the union without a matching `case`, the call\n * to {@link assertNever} fails to compile because `value` is no longer `never`.\n * If reached at runtime (e.g. because the value was bypassed via JSON or a\n * type assertion), it throws a descriptive `Error`.\n *\n * @example\n * ```ts\n * switch (mode) {\n *   case 'a': return doA();\n *   case 'b': return doB();\n *   default: assertNever(mode);\n * }\n * ```\n *\n * @param value - The exhaustively-handled value, narrowed to `never` by control flow.\n * @throws Always, if reached at runtime.\n */\nexport function assertNever(value: never): never {\n  throw new Error(`Unhandled value: ${String(value)}`);\n}\n\n/**\n * Asserts that a value is not `null` or `undefined`, narrowing its type in place.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @throws If the value is `null` or `undefined`.\n */\nexport function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T> {\n  if (value !== null && value !== undefined) {\n    return;\n  }\n\n  errorOrMessage ??= value === null ? 'Value is null' : 'Value is undefined';\n  const error = typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  throw error;\n}\n\n/**\n * Ensures that a value is a generic object, returning it with narrowed type.\n *\n * @typeParam T - The type of the value.\n * @param $object - The value to ensure.\n * @returns The value as a generic object.\n */\nexport function ensureGenericObject<T>($object: T): GenericObject<T> {\n  return $object as GenericObject<T>;\n}\n\n/**\n * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @returns The value with `null` and `undefined` excluded from its type.\n * @throws If the value is `null` or `undefined`.\n */\nexport function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T> {\n  assertNonNullable(value, errorOrMessage);\n  return value;\n}\n\n/**\n * Builds a guard accepting any function, narrowed to the signature `TFunction`. Only that the value is a function\n * is checked: a signature cannot be checked at runtime, so the guard trusts it.\n *\n * @typeParam TFunction - The signature the guard narrows to.\n * @returns The guard.\n */\nexport function functionTypeGuard<TFunction extends GenericFunction>(): TypeGuard<TFunction> {\n  return (value): value is TFunction => isFunction(value);\n}\n\n/**\n * Builds a guard accepting an instance of a class, or of a class derived from it.\n *\n * @typeParam T - The type of an instance.\n * @param constructor - The class.\n * @returns The guard.\n */\nexport function instanceOfTypeGuard<T>(constructor: abstract new (...arguments_: never[]) => T): TypeGuard<T> {\n  return (value): value is T => value instanceof constructor;\n}\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value - The value to check.\n * @returns Whether the value is a boolean.\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Checks whether a value is a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is a function.\n */\nexport function isFunction(value: unknown): value is GenericFunction {\n  return typeof value === 'function';\n}\n\n/**\n * Checks whether a value is `null`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `null`.\n */\nexport function isNull(value: unknown): value is null {\n  return value === null;\n}\n\n/**\n * Checks whether a value is a number.\n *\n * @param value - The value to check.\n * @returns Whether the value is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number';\n}\n\n/**\n * Checks whether a value is an object: not `null`, and not a primitive or a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is an object.\n */\nexport function isObject(value: unknown): value is object {\n  return typeof value === 'object' && value !== null;\n}\n\n/**\n * Checks whether a value is a string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Checks whether a value is an array of strings.\n *\n * @param value - The value to check.\n * @returns Whether the value is an array whose every item is a string.\n */\nexport function isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every(isString);\n}\n\n/**\n * Checks whether a value is `undefined`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `undefined`.\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n\n/**\n * Builds a guard accepting exactly the keys of a record. Typing the record over a union, as\n * `literalTypeGuard<Mode>({ A: true, B: true })`, makes a member later added to the union fail to compile until\n * it is listed.\n *\n * @typeParam T - The accepted strings.\n * @param literals - A record whose keys are the accepted strings.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends string>(literals: Readonly<Record<T, true>>): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values, compared as `Array.prototype.includes` compares them.\n *\n * @typeParam T - The accepted values.\n * @param literals - The accepted values.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends Literal>(literals: readonly T[]): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values.\n *\n * @param literals - The accepted values, as a list or as the keys of a record.\n * @returns The guard.\n */\nexport function literalTypeGuard(literals: Readonly<Record<string, true>> | readonly Literal[]): TypeGuard<Literal> {\n  if (isReadonlyArray(literals)) {\n    const literalList: readonly unknown[] = literals;\n    return (value): value is Literal => literalList.includes(value);\n  }\n\n  return (value): value is Literal => isString(value) && Object.hasOwn(literals, value);\n}\n\n/**\n * Widens a guard to also accept `null`.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `null`.\n */\nexport function nullableTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<null | T> {\n  return unionTypeGuard(isNull, isValue);\n}\n\n/**\n * Builds a guard accepting an object whose every listed property its guard accepts. A property is read with\n * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`.\n *\n * @typeParam T - The object type.\n * @param propertyTypeGuards - One guard per property of `T`.\n * @param options - The options for the guard.\n * @returns The guard.\n */\nexport function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions): TypeGuard<T> {\n  const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;\n  return (value): value is T => {\n    if (!isObject(value)) {\n      return false;\n    }\n\n    if (shouldRejectUnknownKeys && Object.keys(value).some((key) => !Object.hasOwn(propertyTypeGuards, key))) {\n      return false;\n    }\n\n    for (const key in propertyTypeGuards) {\n      if (!propertyTypeGuards[key](Reflect.get(value, key))) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n\n/**\n * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is\n * left out.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `undefined`.\n */\nexport function optionalTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<T | undefined> {\n  return unionTypeGuard(isUndefined, isValue);\n}\n\n/**\n * Builds a guard accepting what any of the given guards accepts.\n *\n * @typeParam TTypeGuards - The guards.\n * @param typeGuards - The guards, tried in order.\n * @returns The guard.\n */\nexport function unionTypeGuard<const TTypeGuards extends readonly TypeGuard<unknown>[]>(\n  ...typeGuards: TTypeGuards\n): TypeGuard<GuardedType<TTypeGuards[number]>> {\n  return (value): value is GuardedType<TTypeGuards[number]> => typeGuards.some((typeGuard) => typeGuard(value));\n}\n\nfunction isReadonlyArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value);\n}\n"],
  "mappings": ";;;;;AAYA,SAAS,YAAY;AA6Dd,SAAS,eAAkB,QAAsC;AACtE,SAAO,CAAC,UAAwB,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,CAAC,SAAS,OAAO,IAAI,CAAC;AAC5F;AAWO,SAAS,OAAO,QAAiB,gBAAgD;AACtF,MAAI,CAAC,QAAQ;AACX,UAAM,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAAA,EACzE;AACF;AAQO,SAAS,oBAAuB,SAAiD;AACtF,OAAK;AACP;AAuBO,SAAS,YAAY,OAAqB;AAC/C,QAAM,IAAI,MAAM,oBAAoB,OAAO,KAAK,CAAC,EAAE;AACrD;AAYO,SAAS,kBAAmD,OAAU,gBAAkE;AAC7I,MAAI,UAAU,QAAQ,UAAU,QAAW;AACzC;AAAA,EACF;AAEA,qBAAmB,UAAU,OAAO,kBAAkB;AACtD,QAAM,QAAQ,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAC/E,QAAM;AACR;AASO,SAAS,oBAAuB,SAA8B;AACnE,SAAO;AACT;AAaO,SAAS,kBAAmD,OAAU,gBAAiD;AAC5H,oBAAkB,OAAO,cAAc;AACvC,SAAO;AACT;AASO,SAAS,oBAA6E;AAC3F,SAAO,CAAC,UAA8B,WAAW,KAAK;AACxD;AASO,SAAS,oBAAuB,aAAuE;AAC5G,SAAO,CAAC,UAAsB,iBAAiB;AACjD;AAQO,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,WAAW,OAA0C;AACnE,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,OAAO,OAA+B;AACpD,SAAO,UAAU;AACnB;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,cAAc,OAAmC;AAC/D,SAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,QAAQ;AACrD;AAQO,SAAS,YAAY,OAAoC;AAC9D,SAAO,UAAU;AACnB;AA0BO,SAAS,iBAAiB,UAAmF;AAClH,MAAI,gBAAgB,QAAQ,GAAG;AAC7B,UAAM,cAAkC;AACxC,WAAO,CAAC,UAA4B,YAAY,SAAS,KAAK;AAAA,EAChE;AAEA,SAAO,CAAC,UAA4B,SAAS,KAAK,KAAK,OAAO,OAAO,UAAU,KAAK;AACtF;AASO,SAAS,kBAAqB,SAA4C;AAC/E,SAAO,eAAe,QAAQ,OAAO;AACvC;AAWO,SAAS,gBAAkC,oBAA2C,SAAgD;AAC3I,QAAM,0BAA0B,SAAS,2BAA2B;AACpE,SAAO,CAAC,UAAsB;AAC5B,QAAI,CAAC,SAAS,KAAK,GAAG;AACpB,aAAO;AAAA,IACT;AAEA,QAAI,2BAA2B,OAAO,KAAK,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,OAAO,oBAAoB,GAAG,CAAC,GAAG;AACxG,aAAO;AAAA,IACT;AAEA,eAAW,OAAO,oBAAoB;AACpC,UAAI,CAAC,mBAAmB,GAAG,EAAE,QAAQ,IAAI,OAAO,GAAG,CAAC,GAAG;AACrD,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AAUO,SAAS,kBAAqB,SAAiD;AACpF,SAAO,eAAe,aAAa,OAAO;AAC5C;AASO,SAAS,kBACX,YAC0C;AAC7C,SAAO,CAAC,UAAqD,WAAW,KAAK,CAAC,cAAc,UAAU,KAAK,CAAC;AAC9G;AAEA,SAAS,gBAAgB,OAA6C;AACpE,SAAO,MAAM,QAAQ,KAAK;AAC5B;",
  "names": []
}
