typetify 2.1.0 → 2.4.0

package/dist/chunk-V6CWFDIJ.mjs

@@ -1,123 +0,0 @@
-import { ok, err } from './chunk-FXWYPHA3.mjs';
-import { __export } from './chunk-J5LGTIGS.mjs';
-
-// src/flow/index.ts
-var flow_exports = {};
-__export(flow_exports, {
-  compose: () => compose,
-  constant: () => constant,
-  ifElse: () => ifElse,
-  match: () => match,
-  pipe: () => pipe,
-  tap: () => tap,
-  tryCatch: () => tryCatch,
-  tryCatchAsync: () => tryCatchAsync,
-  unless: () => unless,
-  when: () => when
-});
-
-// src/flow/pipe.ts
-function pipe(value, ...fns) {
-  return fns.reduce((acc, fn) => fn(acc), value);
-}
-
-// src/flow/compose.ts
-function compose(...fns) {
-  return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
-}
-
-// src/flow/tap.ts
-function tap(fn) {
-  return (value) => {
-    fn(value);
-    return value;
-  };
-}
-
-// src/flow/when.ts
-function when(predicate, transform) {
-  return (value) => {
-    if (predicate(value)) {
-      return transform(value);
-    }
-    return value;
-  };
-}
-
-// src/flow/unless.ts
-function unless(predicate, transform) {
-  return (value) => {
-    if (!predicate(value)) {
-      return transform(value);
-    }
-    return value;
-  };
-}
-
-// src/flow/match.ts
-function match() {
-  const cases = [];
-  const builder = {
-    with(predicate, handler) {
-      cases.push({ when: predicate, then: handler });
-      return builder;
-    },
-    otherwise(handler) {
-      return (value) => {
-        for (const c of cases) {
-          if (c.when(value)) {
-            return c.then(value);
-          }
-        }
-        return handler(value);
-      };
-    },
-    run(value) {
-      for (const c of cases) {
-        if (c.when(value)) {
-          return c.then(value);
-        }
-      }
-      return void 0;
-    }
-  };
-  return builder;
-}
-
-// src/flow/tryCatch.ts
-function tryCatch(fn) {
-  try {
-    return ok(fn());
-  } catch (error) {
-    return err(error instanceof Error ? error : new Error(String(error)));
-  }
-}
-
-// src/flow/tryCatchAsync.ts
-async function tryCatchAsync(fn) {
-  try {
-    const value = await fn();
-    return ok(value);
-  } catch (error) {
-    return err(error instanceof Error ? error : new Error(String(error)));
-  }
-}
-
-// src/flow/ifElse.ts
-function ifElse(predicate, onTrue, onFalse) {
-  return (value) => {
-    if (predicate(value)) {
-      return onTrue(value);
-    }
-    return onFalse(value);
-  };
-}
-
-// src/flow/constant.ts
-function constant(value) {
-  return () => value;
-}
-
-export { compose, constant, flow_exports, ifElse, match, pipe, tap, tryCatch, tryCatchAsync, unless, when };
-//# sourceMappingURL=chunk-V6CWFDIJ.mjs.map
-//# sourceMappingURL=chunk-V6CWFDIJ.mjs.map

package/dist/chunk-V6CWFDIJ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/flow/index.ts","../src/flow/pipe.ts","../src/flow/compose.ts","../src/flow/tap.ts","../src/flow/when.ts","../src/flow/unless.ts","../src/flow/match.ts","../src/flow/tryCatch.ts","../src/flow/tryCatchAsync.ts","../src/flow/ifElse.ts","../src/flow/constant.ts"],"names":[],"mappings":";;;;AAAA,IAAA,YAAA,GAAA;AAAA,QAAA,CAAA,YAAA,EAAA;AAAA,EAAA,OAAA,EAAA,MAAA,OAAA;AAAA,EAAA,QAAA,EAAA,MAAA,QAAA;AAAA,EAAA,MAAA,EAAA,MAAA,MAAA;AAAA,EAAA,KAAA,EAAA,MAAA,KAAA;AAAA,EAAA,IAAA,EAAA,MAAA,IAAA;AAAA,EAAA,GAAA,EAAA,MAAA,GAAA;AAAA,EAAA,QAAA,EAAA,MAAA,QAAA;AAAA,EAAA,aAAA,EAAA,MAAA,aAAA;AAAA,EAAA,MAAA,EAAA,MAAA,MAAA;AAAA,EAAA,IAAA,EAAA,MAAA;AAAA,CAAA,CAAA;;;ACmEO,SAAS,IAAA,CACd,UACG,GAAA,EACM;AACT,EAAA,OAAO,GAAA,CAAI,OAAO,CAAC,GAAA,EAAK,OAAO,EAAA,CAAG,GAAG,GAAG,KAAK,CAAA;AAC/C;;;ACvCO,SAAS,WACX,GAAA,EACwB;AAC3B,EAAA,OAAO,CAAC,GAAA,KAAiB,GAAA,CAAI,WAAA,CAAY,CAAC,KAAK,EAAA,KAAO,EAAA,CAAG,GAAG,CAAA,EAAG,GAAG,CAAA;AACpE;;;ACzBO,SAAS,IAAO,EAAA,EAAyC;AAC9D,EAAA,OAAO,CAAC,KAAA,KAAgB;AACtB,IAAA,EAAA,CAAG,KAAK,CAAA;AACR,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;;;ACLO,SAAS,IAAA,CACd,WACA,SAAA,EACiB;AACjB,EAAA,OAAO,CAAC,KAAA,KAAgB;AACtB,IAAA,IAAI,SAAA,CAAU,KAAK,CAAA,EAAG;AACpB,MAAA,OAAO,UAAU,KAAK,CAAA;AAAA,IACxB;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;;;ACVO,SAAS,MAAA,CACd,WACA,SAAA,EACiB;AACjB,EAAA,OAAO,CAAC,KAAA,KAAgB;AACtB,IAAA,IAAI,CAAC,SAAA,CAAU,KAAK,CAAA,EAAG;AACrB,MAAA,OAAO,UAAU,KAAK,CAAA;AAAA,IACxB;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;;;ACKO,SAAS,KAAA,GAAsC;AACpD,EAAA,MAAM,QAA2B,EAAC;AAElC,EAAA,MAAM,OAAA,GAA8B;AAAA,IAClC,IAAA,CAAK,WAAW,OAAA,EAAS;AACvB,MAAA,KAAA,CAAM,KAAK,EAAE,IAAA,EAAM,SAAA,EAAW,IAAA,EAAM,SAAS,CAAA;AAC7C,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,IAEA,UAAU,OAAA,EAAS;AACjB,MAAA,OAAO,CAAC,KAAA,KAAgB;AACtB,QAAA,KAAA,MAAW,KAAK,KAAA,EAAO;AACrB,UAAA,IAAI,CAAA,CAAE,IAAA,CAAK,KAAK,CAAA,EAAG;AACjB,YAAA,OAAO,CAAA,CAAE,KAAK,KAAK,CAAA;AAAA,UACrB;AAAA,QACF;AACA,QAAA,OAAO,QAAQ,KAAK,CAAA;AAAA,MACtB,CAAA;AAAA,IACF,CAAA;AAAA,IAEA,IAAI,KAAA,EAAyB;AAC3B,MAAA,KAAA,MAAW,KAAK,KAAA,EAAO;AACrB,QAAA,IAAI,CAAA,CAAE,IAAA,CAAK,KAAK,CAAA,EAAG;AACjB,UAAA,OAAO,CAAA,CAAE,KAAK,KAAK,CAAA;AAAA,QACrB;AAAA,MACF;AACA,MAAA,OAAO,MAAA;AAAA,IACT;AAAA,GACF;AAEA,EAAA,OAAO,OAAA;AACT;;;ACtCO,SAAS,SAAY,EAAA,EAA+B;AACzD,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,CAAG,IAAI,CAAA;AAAA,EAChB,SAAS,KAAA,EAAO;AACd,IAAA,OAAO,GAAA,CAAI,iBAAiB,KAAA,GAAQ,KAAA,GAAQ,IAAI,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC,CAAC,CAAA;AAAA,EACtE;AACF;;;ACNA,eAAsB,cACpB,EAAA,EAC2B;AAC3B,EAAA,IAAI;AACF,IAAA,MAAM,KAAA,GAAQ,MAAM,EAAA,EAAG;AACvB,IAAA,OAAO,GAAG,KAAK,CAAA;AAAA,EACjB,SAAS,KAAA,EAAO;AACd,IAAA,OAAO,GAAA,CAAI,iBAAiB,KAAA,GAAQ,KAAA,GAAQ,IAAI,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC,CAAC,CAAA;AAAA,EACtE;AACF;;;AChBO,SAAS,MAAA,CACd,SAAA,EACA,MAAA,EACA,OAAA,EACiB;AACjB,EAAA,OAAO,CAAC,KAAA,KAAgB;AACtB,IAAA,IAAI,SAAA,CAAU,KAAK,CAAA,EAAG;AACpB,MAAA,OAAO,OAAO,KAAK,CAAA;AAAA,IACrB;AACA,IAAA,OAAO,QAAQ,KAAK,CAAA;AAAA,EACtB,CAAA;AACF;;;ACdO,SAAS,SAAY,KAAA,EAAmB;AAC7C,EAAA,OAAO,MAAM,KAAA;AACf","file":"chunk-V6CWFDIJ.mjs","sourcesContent":["export { pipe } from './pipe'\nexport { compose } from './compose'\nexport { tap } from './tap'\nexport { when } from './when'\nexport { unless } from './unless'\nexport { match } from './match'\nexport { tryCatch } from './tryCatch'\nexport type { TryCatchResult } from './tryCatch'\nexport { tryCatchAsync } from './tryCatchAsync'\nexport type { TryCatchAsyncResult } from './tryCatchAsync'\nexport { ifElse } from './ifElse'\nexport { constant } from './constant'\n","/**\n * Pipes a value through a series of functions.\n * Each function receives the result of the previous one.\n *\n * @example\n * const result = pipe(\n *   5,\n *   (n) => n * 2,\n *   (n) => n + 1,\n *   (n) => `Result: ${n}`\n * )\n * // 'Result: 11'\n */\nexport function pipe<A>(value: A): A\nexport function pipe<A, B>(value: A, fn1: (a: A) => B): B\nexport function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C\nexport function pipe<A, B, C, D>(\n  value: A,\n  fn1: (a: A) => B,\n  fn2: (b: B) => C,\n  fn3: (c: C) => D\n): D\nexport function pipe<A, B, C, D, E>(\n  value: A,\n  fn1: (a: A) => B,\n  fn2: (b: B) => C,\n  fn3: (c: C) => D,\n  fn4: (d: D) => E\n): E\nexport function pipe<A, B, C, D, E, F>(\n  value: A,\n  fn1: (a: A) => B,\n  fn2: (b: B) => C,\n  fn3: (c: C) => D,\n  fn4: (d: D) => E,\n  fn5: (e: E) => F\n): F\nexport function pipe<A, B, C, D, E, F, G>(\n  value: A,\n  fn1: (a: A) => B,\n  fn2: (b: B) => C,\n  fn3: (c: C) => D,\n  fn4: (d: D) => E,\n  fn5: (e: E) => F,\n  fn6: (f: F) => G\n): G\nexport function pipe<A, B, C, D, E, F, G, H>(\n  value: A,\n  fn1: (a: A) => B,\n  fn2: (b: B) => C,\n  fn3: (c: C) => D,\n  fn4: (d: D) => E,\n  fn5: (e: E) => F,\n  fn6: (f: F) => G,\n  fn7: (g: G) => H\n): H\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  value: A,\n  fn1: (a: A) => B,\n  fn2: (b: B) => C,\n  fn3: (c: C) => D,\n  fn4: (d: D) => E,\n  fn5: (e: E) => F,\n  fn6: (f: F) => G,\n  fn7: (g: G) => H,\n  fn8: (h: H) => I\n): I\nexport function pipe(\n  value: unknown,\n  ...fns: ((arg: unknown) => unknown)[]\n): unknown {\n  return fns.reduce((acc, fn) => fn(acc), value)\n}\n","/**\n * Composes functions from right to left.\n * The last function can take multiple arguments.\n *\n * @example\n * const addOne = (n: number) => n + 1\n * const double = (n: number) => n * 2\n * const addOneThenDouble = compose(double, addOne)\n * addOneThenDouble(5) // 12\n */\nexport function compose<A, B>(fn1: (a: A) => B): (a: A) => B\nexport function compose<A, B, C>(\n  fn2: (b: B) => C,\n  fn1: (a: A) => B\n): (a: A) => C\nexport function compose<A, B, C, D>(\n  fn3: (c: C) => D,\n  fn2: (b: B) => C,\n  fn1: (a: A) => B\n): (a: A) => D\nexport function compose<A, B, C, D, E>(\n  fn4: (d: D) => E,\n  fn3: (c: C) => D,\n  fn2: (b: B) => C,\n  fn1: (a: A) => B\n): (a: A) => E\nexport function compose<A, B, C, D, E, F>(\n  fn5: (e: E) => F,\n  fn4: (d: D) => E,\n  fn3: (c: C) => D,\n  fn2: (b: B) => C,\n  fn1: (a: A) => B\n): (a: A) => F\nexport function compose(\n  ...fns: ((arg: unknown) => unknown)[]\n): (arg: unknown) => unknown {\n  return (arg: unknown) => fns.reduceRight((acc, fn) => fn(acc), arg)\n}\n","/**\n * Executes a side effect and returns the original value.\n * Useful for debugging in a pipe chain.\n *\n * @example\n * pipe(\n *   data,\n *   tap(console.log), // logs data\n *   transform,\n *   tap(console.log), // logs transformed data\n * )\n */\nexport function tap<T>(fn: (value: T) => void): (value: T) => T {\n  return (value: T): T => {\n    fn(value)\n    return value\n  }\n}\n","/**\n * Conditionally applies a transformation.\n * If the predicate is true, applies the transform. Otherwise returns the value unchanged.\n *\n * @example\n * const maybeDouble = when(\n *   (n: number) => n > 10,\n *   (n) => n * 2\n * )\n * maybeDouble(5) // 5\n * maybeDouble(15) // 30\n */\nexport function when<T>(\n  predicate: (value: T) => boolean,\n  transform: (value: T) => T\n): (value: T) => T {\n  return (value: T): T => {\n    if (predicate(value)) {\n      return transform(value)\n    }\n    return value\n  }\n}\n","/**\n * Conditionally applies a transformation.\n * If the predicate is false, applies the transform. Otherwise returns the value unchanged.\n *\n * @example\n * const ensurePositive = unless(\n *   (n: number) => n > 0,\n *   () => 0\n * )\n * ensurePositive(-5) // 0\n * ensurePositive(5) // 5\n */\nexport function unless<T>(\n  predicate: (value: T) => boolean,\n  transform: (value: T) => T\n): (value: T) => T {\n  return (value: T): T => {\n    if (!predicate(value)) {\n      return transform(value)\n    }\n    return value\n  }\n}\n","type MatchCase<T, R> = {\n  when: (value: T) => boolean\n  then: (value: T) => R\n}\n\ntype MatchBuilder<T, R> = {\n  with: (\n    predicate: (value: T) => boolean,\n    handler: (value: T) => R\n  ) => MatchBuilder<T, R>\n  otherwise: (handler: (value: T) => R) => (value: T) => R\n  run: (value: T) => R | undefined\n}\n\n/**\n * Pattern matching helper. Chain .with() for cases and .otherwise() for default.\n *\n * @example\n * const getDiscount = match<number, string>()\n *   .with(n => n >= 100, () => '20% off')\n *   .with(n => n >= 50, () => '10% off')\n *   .otherwise(() => 'No discount')\n *\n * getDiscount(150) // '20% off'\n * getDiscount(75) // '10% off'\n * getDiscount(25) // 'No discount'\n */\nexport function match<T, R = T>(): MatchBuilder<T, R> {\n  const cases: MatchCase<T, R>[] = []\n\n  const builder: MatchBuilder<T, R> = {\n    with(predicate, handler) {\n      cases.push({ when: predicate, then: handler })\n      return builder\n    },\n\n    otherwise(handler) {\n      return (value: T): R => {\n        for (const c of cases) {\n          if (c.when(value)) {\n            return c.then(value)\n          }\n        }\n        return handler(value)\n      }\n    },\n\n    run(value: T): R | undefined {\n      for (const c of cases) {\n        if (c.when(value)) {\n          return c.then(value)\n        }\n      }\n      return undefined\n    },\n  }\n\n  return builder\n}\n","import type { Result } from '../result/types'\nimport { ok } from '../result/ok'\nimport { err } from '../result/err'\n\n/**\n * @deprecated Use Result<T> instead\n */\nexport type TryCatchResult<T> = Result<T, Error>\n\n/**\n * Wraps a function call in a try/catch and returns a Result.\n *\n * @example\n * const result = tryCatch(() => JSON.parse(input))\n * if (result.ok) {\n *   console.log(result.value)\n * } else {\n *   console.error(result.error)\n * }\n */\nexport function tryCatch<T>(fn: () => T): Result<T, Error> {\n  try {\n    return ok(fn())\n  } catch (error) {\n    return err(error instanceof Error ? error : new Error(String(error)))\n  }\n}\n","import type { Result } from '../result/types'\nimport { ok } from '../result/ok'\nimport { err } from '../result/err'\n\n/**\n * @deprecated Use Result<T> instead\n */\nexport type TryCatchAsyncResult<T> = Result<T, Error>\n\n/**\n * Wraps an async function call in a try/catch and returns a Result.\n *\n * @example\n * const result = await tryCatchAsync(() => fetchUser(id))\n * if (result.ok) {\n *   console.log(result.value)\n * } else {\n *   console.error(result.error)\n * }\n */\nexport async function tryCatchAsync<T>(\n  fn: () => Promise<T>\n): Promise<Result<T, Error>> {\n  try {\n    const value = await fn()\n    return ok(value)\n  } catch (error) {\n    return err(error instanceof Error ? error : new Error(String(error)))\n  }\n}\n","/**\n * Functional if/else. Returns a function that applies one of two transformations\n * based on a predicate.\n *\n * @example\n * const formatPrice = ifElse(\n *   (n: number) => n === 0,\n *   () => 'Free',\n *   (n) => `$${n.toFixed(2)}`\n * )\n * formatPrice(0) // 'Free'\n * formatPrice(9.99) // '$9.99'\n */\nexport function ifElse<T, R>(\n  predicate: (value: T) => boolean,\n  onTrue: (value: T) => R,\n  onFalse: (value: T) => R\n): (value: T) => R {\n  return (value: T): R => {\n    if (predicate(value)) {\n      return onTrue(value)\n    }\n    return onFalse(value)\n  }\n}\n","/**\n * Returns a function that always returns the same value.\n *\n * @example\n * const alwaysTrue = constant(true)\n * alwaysTrue() // true\n * alwaysTrue() // true\n *\n * [1, 2, 3].map(constant('x')) // ['x', 'x', 'x']\n */\nexport function constant<T>(value: T): () => T {\n  return () => value\n}\n"]}

package/dist/chunk-X55EORNF.js

@@ -1,259 +0,0 @@
-'use strict';
-
-var chunkPZ5AY32C_js = require('./chunk-PZ5AY32C.js');
-
-// src/narrowing/index.ts
-var narrowing_exports = {};
-chunkPZ5AY32C_js.__export(narrowing_exports, {
-  allOf: () => allOf,
-  arrayOf: () => arrayOf,
-  assertCondition: () => assertCondition,
-  assertDefined: () => assertDefined,
-  assertNotNull: () => assertNotNull,
-  assertType: () => assertType,
-  chainNullable: () => chainNullable,
-  createAssertion: () => createAssertion,
-  createDiscriminantGuard: () => createDiscriminantGuard,
-  excludeNull: () => excludeNull,
-  excludeNullish: () => excludeNullish,
-  excludeUndefined: () => excludeUndefined,
-  exhaustiveCheck: () => exhaustiveCheck,
-  filterBy: () => filterBy,
-  filterByGuard: () => filterByGuard,
-  filterByRefinement: () => filterByRefinement,
-  filterDefined: () => filterDefined,
-  filterDefinedFn: () => filterDefinedFn,
-  filterTruthy: () => filterTruthy,
-  filterTruthyFn: () => filterTruthyFn,
-  literal: () => literal,
-  mapNullable: () => mapNullable,
-  narrowUnion: () => narrowUnion,
-  not: () => not,
-  nullable: () => nullable,
-  objectOf: () => objectOf,
-  oneOf: () => oneOf,
-  optional: () => optional,
-  partitionByGuard: () => partitionByGuard,
-  refine: () => refine,
-  switchUnion: () => switchUnion,
-  withDefault: () => withDefault,
-  withDefaultLazy: () => withDefaultLazy
-});
-
-// src/narrowing/filterDefined.ts
-function filterDefined(array) {
-  return array.filter(
-    (item) => item !== null && item !== void 0
-  );
-}
-function filterDefinedFn() {
-  return (array) => filterDefined(array);
-}
-
-// src/narrowing/filterTruthy.ts
-function filterTruthy(array) {
-  return array.filter((item) => Boolean(item));
-}
-function filterTruthyFn() {
-  return (array) => filterTruthy(array);
-}
-
-// src/narrowing/filterByGuard.ts
-function filterByGuard(array, guard) {
-  return array.filter(guard);
-}
-function filterByRefinement(array, refinement) {
-  return array.filter(refinement);
-}
-function filterBy(guard) {
-  return (array) => filterByGuard(array, guard);
-}
-function partitionByGuard(array, guard) {
-  const matches = [];
-  const nonMatches = [];
-  for (const item of array) {
-    if (guard(item)) {
-      matches.push(item);
-    } else {
-      nonMatches.push(item);
-    }
-  }
-  return [matches, nonMatches];
-}
-
-// src/narrowing/assertType.ts
-function assertType(value, guard, message) {
-  if (!guard(value)) {
-    if (typeof message === "function") {
-      throw message();
-    }
-    throw new TypeError(message ?? `Type assertion failed`);
-  }
-}
-function assertDefined(value, message) {
-  if (value === null || value === void 0) {
-    throw new TypeError(message ?? "Expected value to be defined");
-  }
-}
-function assertNotNull(value, message) {
-  if (value === null) {
-    throw new TypeError(message ?? "Expected value to not be null");
-  }
-}
-function assertCondition(condition, message) {
-  if (!condition) {
-    throw new TypeError(message ?? "Assertion failed");
-  }
-}
-function createAssertion(guard, defaultMessage) {
-  return (value, message) => {
-    assertType(value, guard, message ?? defaultMessage);
-  };
-}
-
-// src/narrowing/narrowUnion.ts
-function narrowUnion(value, key, expected) {
-  return value[key] === expected;
-}
-function createDiscriminantGuard() {
-  return (key, value) => {
-    return (obj) => obj[key] === value;
-  };
-}
-function switchUnion(value, key, handlers) {
-  const discriminant = value[key];
-  const handler = handlers[discriminant];
-  return handler(value);
-}
-function exhaustiveCheck(value, message) {
-  throw new Error(
-    message ?? `Exhaustive check failed: unexpected value ${JSON.stringify(value)}`
-  );
-}
-
-// src/narrowing/excludeNull.ts
-function excludeNull(value, message) {
-  if (value === null) {
-    throw new Error(message ?? "Unexpected null value");
-  }
-  return value;
-}
-function excludeUndefined(value, message) {
-  if (value === void 0) {
-    throw new Error(message ?? "Unexpected undefined value");
-  }
-  return value;
-}
-function excludeNullish(value, message) {
-  if (value === null || value === void 0) {
-    throw new Error(message ?? "Unexpected null or undefined value");
-  }
-  return value;
-}
-function withDefault(value, defaultValue) {
-  return value ?? defaultValue;
-}
-function withDefaultLazy(value, factory) {
-  return value ?? factory();
-}
-function mapNullable(value, fn) {
-  if (value === null) return null;
-  if (value === void 0) return void 0;
-  return fn(value);
-}
-function chainNullable(value, ...fns) {
-  let result = value;
-  for (const fn of fns) {
-    if (result === null || result === void 0) {
-      return result;
-    }
-    result = fn(result);
-  }
-  return result;
-}
-
-// src/narrowing/refine.ts
-function refine(guard1, ...guards) {
-  return ((value) => {
-    if (!guard1(value)) return false;
-    for (const guard of guards) {
-      if (!guard(value)) return false;
-    }
-    return true;
-  });
-}
-function oneOf(...guards) {
-  return ((value) => {
-    return guards.some((guard) => guard(value));
-  });
-}
-function allOf(...guards) {
-  return ((value) => {
-    return guards.every((guard) => guard(value));
-  });
-}
-function not(guard) {
-  return ((value) => !guard(value));
-}
-function arrayOf(guard) {
-  return (value) => {
-    return Array.isArray(value) && value.every(guard);
-  };
-}
-function objectOf(shape) {
-  return (value) => {
-    if (typeof value !== "object" || value === null) return false;
-    const obj = value;
-    return Object.entries(shape).every(([key, guard]) => guard(obj[key]));
-  };
-}
-function literal(expected) {
-  return (value) => value === expected;
-}
-function optional(guard) {
-  return (value) => {
-    return value === void 0 || guard(value);
-  };
-}
-function nullable(guard) {
-  return (value) => {
-    return value === null || guard(value);
-  };
-}
-
-exports.allOf = allOf;
-exports.arrayOf = arrayOf;
-exports.assertCondition = assertCondition;
-exports.assertDefined = assertDefined;
-exports.assertNotNull = assertNotNull;
-exports.assertType = assertType;
-exports.chainNullable = chainNullable;
-exports.createAssertion = createAssertion;
-exports.createDiscriminantGuard = createDiscriminantGuard;
-exports.excludeNull = excludeNull;
-exports.excludeNullish = excludeNullish;
-exports.excludeUndefined = excludeUndefined;
-exports.exhaustiveCheck = exhaustiveCheck;
-exports.filterBy = filterBy;
-exports.filterByGuard = filterByGuard;
-exports.filterByRefinement = filterByRefinement;
-exports.filterDefined = filterDefined;
-exports.filterDefinedFn = filterDefinedFn;
-exports.filterTruthy = filterTruthy;
-exports.filterTruthyFn = filterTruthyFn;
-exports.literal = literal;
-exports.mapNullable = mapNullable;
-exports.narrowUnion = narrowUnion;
-exports.narrowing_exports = narrowing_exports;
-exports.not = not;
-exports.nullable = nullable;
-exports.objectOf = objectOf;
-exports.oneOf = oneOf;
-exports.optional = optional;
-exports.partitionByGuard = partitionByGuard;
-exports.refine = refine;
-exports.switchUnion = switchUnion;
-exports.withDefault = withDefault;
-exports.withDefaultLazy = withDefaultLazy;
-//# sourceMappingURL=chunk-X55EORNF.js.map
-//# sourceMappingURL=chunk-X55EORNF.js.map

package/dist/chunk-X55EORNF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/narrowing/index.ts","../src/narrowing/filterDefined.ts","../src/narrowing/filterTruthy.ts","../src/narrowing/filterByGuard.ts","../src/narrowing/assertType.ts","../src/narrowing/narrowUnion.ts","../src/narrowing/excludeNull.ts","../src/narrowing/refine.ts"],"names":["__export"],"mappings":"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","file":"chunk-X55EORNF.js","sourcesContent":["/**\n * Narrowing Module\n * \n * Solutions for TypeScript's type narrowing pain points.\n * Each function transforms uncertain types into certain types.\n */\n\nexport { filterDefined, filterDefinedFn } from './filterDefined'\nexport { filterTruthy, filterTruthyFn } from './filterTruthy'\nexport { filterByGuard, filterByRefinement, filterBy, partitionByGuard } from './filterByGuard'\nexport { assertType, assertDefined, assertNotNull, assertCondition, createAssertion } from './assertType'\nexport { narrowUnion, createDiscriminantGuard, switchUnion, exhaustiveCheck } from './narrowUnion'\nexport { \n  excludeNull, \n  excludeUndefined, \n  excludeNullish, \n  withDefault, \n  withDefaultLazy, \n  mapNullable, \n  chainNullable \n} from './excludeNull'\nexport { \n  refine, \n  oneOf, \n  allOf, \n  not, \n  arrayOf, \n  objectOf, \n  literal, \n  optional, \n  nullable \n} from './refine'\nexport type { TypeGuard, Refinement, GuardedType, Falsy, Truthy, Defined } from './types'\n","import type { Defined } from './types'\n\n/**\n * Filters an array removing null and undefined values with proper type narrowing.\n * \n * This solves the pain point where `array.filter(x => x != null)` returns\n * `(T | null | undefined)[]` instead of `T[]`.\n * \n * @example\n * const users: (User | null | undefined)[] = [user1, null, user2, undefined]\n * const defined = filterDefined(users)\n * // Type: User[] (not (User | null | undefined)[])\n * \n * @example\n * // Works with complex union types\n * const mixed: (string | number | null)[] = ['a', 1, null, 'b', 2]\n * const result = filterDefined(mixed)\n * // Type: (string | number)[]\n */\nexport function filterDefined<T>(\n  array: readonly (T | null | undefined)[]\n): Defined<T>[] {\n  return array.filter(\n    (item): item is Defined<T> => item !== null && item !== undefined\n  )\n}\n\n/**\n * Curried version for use in pipelines\n * \n * @example\n * pipe(\n *   users,\n *   filterDefinedFn(),\n *   map(u => u.name)\n * )\n */\nexport function filterDefinedFn<T>(): (\n  array: readonly (T | null | undefined)[]\n) => Defined<T>[] {\n  return (array) => filterDefined(array)\n}\n","import type { Truthy } from './types'\n\n/**\n * Filters an array removing all falsy values with proper type narrowing.\n * \n * Removes: false, 0, 0n, '', null, undefined\n * \n * @example\n * const values: (string | number | null | undefined | false)[] = \n *   ['hello', 0, '', null, 'world', false, 42]\n * \n * const truthy = filterTruthy(values)\n * // Type: (string | number)[]\n * // Value: ['hello', 'world', 42]\n * \n * @example\n * // Useful for conditional rendering arrays\n * const items = filterTruthy([\n *   showHeader && <Header />,\n *   <Content />,\n *   showFooter && <Footer />\n * ])\n */\nexport function filterTruthy<T>(array: readonly T[]): Truthy<T>[] {\n  return array.filter((item): item is Truthy<T> => Boolean(item))\n}\n\n/**\n * Curried version for use in pipelines\n */\nexport function filterTruthyFn<T>(): (array: readonly T[]) => Truthy<T>[] {\n  return (array) => filterTruthy(array)\n}\n","import type { TypeGuard, Refinement } from './types'\n\n/**\n * Filters an array using a type guard with proper type narrowing.\n * \n * This is the generic solution for filtering with any type guard.\n * \n * @example\n * const items: unknown[] = [1, 'hello', 2, 'world', null]\n * \n * const strings = filterByGuard(items, isString)\n * // Type: string[]\n * \n * const numbers = filterByGuard(items, isNumber)\n * // Type: number[]\n * \n * @example\n * // With custom type guards\n * interface Admin { role: 'admin'; permissions: string[] }\n * interface User { role: 'user' }\n * type Person = Admin | User\n * \n * const isAdmin = (p: Person): p is Admin => p.role === 'admin'\n * const admins = filterByGuard(people, isAdmin)\n * // Type: Admin[]\n */\nexport function filterByGuard<T, S extends T>(\n  array: readonly T[],\n  guard: TypeGuard<T, S>\n): S[] {\n  return array.filter(guard)\n}\n\n/**\n * Filters with a refinement function that has access to index and array\n */\nexport function filterByRefinement<T, S extends T>(\n  array: readonly T[],\n  refinement: Refinement<T, S>\n): S[] {\n  return array.filter(refinement)\n}\n\n/**\n * Creates a filter function from a type guard for use in pipelines\n * \n * @example\n * pipe(\n *   items,\n *   filterBy(isString),\n *   map(s => s.toUpperCase())\n * )\n */\nexport function filterBy<T, S extends T>(\n  guard: TypeGuard<T, S>\n): (array: readonly T[]) => S[] {\n  return (array) => filterByGuard(array, guard)\n}\n\n/**\n * Partitions an array by a type guard into [matches, nonMatches]\n * \n * @example\n * const [strings, others] = partitionByGuard(items, isString)\n * // strings: string[]\n * // others: Exclude<typeof items[number], string>[]\n */\nexport function partitionByGuard<T, S extends T>(\n  array: readonly T[],\n  guard: TypeGuard<T, S>\n): [S[], Exclude<T, S>[]] {\n  const matches: S[] = []\n  const nonMatches: Exclude<T, S>[] = []\n  \n  for (const item of array) {\n    if (guard(item)) {\n      matches.push(item)\n    } else {\n      nonMatches.push(item as Exclude<T, S>)\n    }\n  }\n  \n  return [matches, nonMatches]\n}\n","import type { TypeGuard } from './types'\n\n/**\n * Asserts that a value matches a type guard, throwing if it doesn't.\n * This is an assertion function that narrows the type in the current scope.\n * \n * @example\n * function processUser(data: unknown) {\n *   assertType(data, isUser, 'Expected user data')\n *   // After this line, data is typed as User\n *   console.log(data.name)\n * }\n * \n * @example\n * // With custom error\n * assertType(response, isApiResponse, () => \n *   new ValidationError('Invalid API response', response)\n * )\n */\nexport function assertType<T, S extends T>(\n  value: T,\n  guard: TypeGuard<T, S>,\n  message?: string | (() => Error)\n): asserts value is S {\n  if (!guard(value)) {\n    if (typeof message === 'function') {\n      throw message()\n    }\n    throw new TypeError(message ?? `Type assertion failed`)\n  }\n}\n\n/**\n * Asserts that a value is defined (not null or undefined)\n * \n * @example\n * const user: User | null = findUser(id)\n * assertDefined(user, `User ${id} not found`)\n * // After this line, user is typed as User\n * console.log(user.name)\n */\nexport function assertDefined<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T {\n  if (value === null || value === undefined) {\n    throw new TypeError(message ?? 'Expected value to be defined')\n  }\n}\n\n/**\n * Asserts that a value is not null\n */\nexport function assertNotNull<T>(\n  value: T | null,\n  message?: string\n): asserts value is T {\n  if (value === null) {\n    throw new TypeError(message ?? 'Expected value to not be null')\n  }\n}\n\n/**\n * Asserts a condition and narrows the type\n * \n * @example\n * function process(value: string | number) {\n *   assertCondition(typeof value === 'string', 'Expected string')\n *   // value is now string\n *   return value.toUpperCase()\n * }\n */\nexport function assertCondition(\n  condition: boolean,\n  message?: string\n): asserts condition {\n  if (!condition) {\n    throw new TypeError(message ?? 'Assertion failed')\n  }\n}\n\n/**\n * Creates a type assertion function from a type guard\n * \n * @example\n * const assertUser = createAssertion(isUser, 'Expected User')\n * \n * function process(data: unknown) {\n *   assertUser(data)\n *   // data is now User\n * }\n */\nexport function createAssertion<T, S extends T>(\n  guard: TypeGuard<T, S>,\n  defaultMessage?: string\n): (value: T, message?: string) => asserts value is S {\n  return (value: T, message?: string): asserts value is S => {\n    assertType(value, guard, message ?? defaultMessage)\n  }\n}\n","/**\n * Narrows a discriminated union by its discriminant property.\n * \n * @example\n * type Event = \n *   | { type: 'click'; x: number; y: number }\n *   | { type: 'keypress'; key: string }\n *   | { type: 'scroll'; delta: number }\n * \n * const event: Event = getEvent()\n * \n * if (narrowUnion(event, 'type', 'click')) {\n *   // event is { type: 'click'; x: number; y: number }\n *   console.log(event.x, event.y)\n * }\n */\nexport function narrowUnion<\n  T extends Record<K, PropertyKey>,\n  K extends keyof T,\n  V extends T[K]\n>(\n  value: T,\n  key: K,\n  expected: V\n): value is Extract<T, Record<K, V>> {\n  return value[key] === expected\n}\n\n/**\n * Creates a type guard for a specific discriminant value\n * \n * @example\n * type Result = { status: 'ok'; data: string } | { status: 'error'; message: string }\n * \n * const isOk = createDiscriminantGuard<Result>()('status', 'ok')\n * const isError = createDiscriminantGuard<Result>()('status', 'error')\n * \n * if (isOk(result)) {\n *   console.log(result.data)\n * }\n */\nexport function createDiscriminantGuard<T extends Record<string, unknown>>() {\n  return <K extends keyof T, V extends T[K]>(\n    key: K,\n    value: V\n  ): ((obj: T) => obj is Extract<T, Record<K, V>>) => {\n    return (obj: T): obj is Extract<T, Record<K, V>> => obj[key] === value\n  }\n}\n\n/**\n * Exhaustive switch helper for discriminated unions\n * \n * @example\n * type Shape = \n *   | { kind: 'circle'; radius: number }\n *   | { kind: 'square'; side: number }\n *   | { kind: 'rectangle'; width: number; height: number }\n * \n * function area(shape: Shape): number {\n *   return switchUnion(shape, 'kind', {\n *     circle: (s) => Math.PI * s.radius ** 2,\n *     square: (s) => s.side ** 2,\n *     rectangle: (s) => s.width * s.height,\n *   })\n * }\n */\nexport function switchUnion<\n  T extends Record<K, string>,\n  K extends keyof T,\n  R\n>(\n  value: T,\n  key: K,\n  handlers: { [V in T[K]]: (value: Extract<T, Record<K, V>>) => R }\n): R {\n  const discriminant = value[key] as T[K]\n  const handler = handlers[discriminant]\n  return handler(value as Extract<T, Record<K, T[K]>>)\n}\n\n/**\n * Type-safe exhaustive check that ensures all union cases are handled\n * \n * @example\n * type Status = 'pending' | 'success' | 'error'\n * \n * function handleStatus(status: Status) {\n *   switch (status) {\n *     case 'pending': return 'Loading...'\n *     case 'success': return 'Done!'\n *     case 'error': return 'Failed'\n *     default: return exhaustiveCheck(status)\n *   }\n * }\n */\nexport function exhaustiveCheck(value: never, message?: string): never {\n  throw new Error(\n    message ?? `Exhaustive check failed: unexpected value ${JSON.stringify(value)}`\n  )\n}\n","/**\n * Excludes null from a value's type at runtime and compile time.\n * Throws if the value is null.\n * \n * @example\n * const element: HTMLElement | null = document.getElementById('app')\n * const el = excludeNull(element, 'App element not found')\n * // el is HTMLElement\n */\nexport function excludeNull<T>(\n  value: T | null,\n  message?: string\n): T {\n  if (value === null) {\n    throw new Error(message ?? 'Unexpected null value')\n  }\n  return value\n}\n\n/**\n * Excludes undefined from a value's type at runtime and compile time.\n * Throws if the value is undefined.\n */\nexport function excludeUndefined<T>(\n  value: T | undefined,\n  message?: string\n): T {\n  if (value === undefined) {\n    throw new Error(message ?? 'Unexpected undefined value')\n  }\n  return value\n}\n\n/**\n * Excludes null and undefined from a value's type.\n * Throws if the value is null or undefined.\n */\nexport function excludeNullish<T>(\n  value: T | null | undefined,\n  message?: string\n): T {\n  if (value === null || value === undefined) {\n    throw new Error(message ?? 'Unexpected null or undefined value')\n  }\n  return value\n}\n\n/**\n * Returns the value if defined, otherwise returns the default.\n * Type-safe alternative to the nullish coalescing operator with better inference.\n * \n * @example\n * const config: Config | undefined = loadConfig()\n * const safeConfig = withDefault(config, defaultConfig)\n * // safeConfig is Config (not Config | undefined)\n */\nexport function withDefault<T>(\n  value: T | null | undefined,\n  defaultValue: T\n): T {\n  return value ?? defaultValue\n}\n\n/**\n * Returns the value if defined, otherwise calls the factory function.\n * Useful when the default value is expensive to compute.\n * \n * @example\n * const cached = withDefaultLazy(cache.get(key), () => computeExpensiveValue())\n */\nexport function withDefaultLazy<T>(\n  value: T | null | undefined,\n  factory: () => T\n): T {\n  return value ?? factory()\n}\n\n/**\n * Maps a nullable value, returning null/undefined if the input is null/undefined.\n * \n * @example\n * const user: User | null = findUser(id)\n * const name = mapNullable(user, u => u.name)\n * // name is string | null\n */\nexport function mapNullable<T, U>(\n  value: T | null | undefined,\n  fn: (value: T) => U\n): U | null | undefined {\n  if (value === null) return null\n  if (value === undefined) return undefined\n  return fn(value)\n}\n\n/**\n * Chains nullable operations, similar to optional chaining but with functions.\n * \n * @example\n * const result = chainNullable(\n *   user,\n *   u => u.profile,\n *   p => p.settings,\n *   s => s.theme\n * )\n * // result is Theme | null | undefined\n */\nexport function chainNullable<T, A>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined\n): A | null | undefined\nexport function chainNullable<T, A, B>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined,\n  fn2: (v: A) => B | null | undefined\n): B | null | undefined\nexport function chainNullable<T, A, B, C>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined,\n  fn2: (v: A) => B | null | undefined,\n  fn3: (v: B) => C | null | undefined\n): C | null | undefined\nexport function chainNullable<T, A, B, C, D>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined,\n  fn2: (v: A) => B | null | undefined,\n  fn3: (v: B) => C | null | undefined,\n  fn4: (v: C) => D | null | undefined\n): D | null | undefined\nexport function chainNullable(\n  value: unknown,\n  ...fns: Array<(v: unknown) => unknown>\n): unknown {\n  let result = value\n  for (const fn of fns) {\n    if (result === null || result === undefined) {\n      return result\n    }\n    result = fn(result)\n  }\n  return result\n}\n","import type { TypeGuard } from './types'\n\n/**\n * Refines a type by applying multiple type guards in sequence.\n * Each guard further narrows the type.\n * \n * @example\n * const isPositiveNumber = refine(\n *   isNumber,\n *   (n): n is number => n > 0\n * )\n * \n * if (isPositiveNumber(value)) {\n *   // value is number and > 0\n * }\n */\nexport function refine<T, S extends T, R extends S>(\n  guard1: TypeGuard<T, S>,\n  guard2: TypeGuard<S, R>\n): TypeGuard<T, R>\nexport function refine<T, S extends T, R extends S, Q extends R>(\n  guard1: TypeGuard<T, S>,\n  guard2: TypeGuard<S, R>,\n  guard3: TypeGuard<R, Q>\n): TypeGuard<T, Q>\nexport function refine<T, S extends T>(\n  guard1: TypeGuard<T, S>,\n  ...guards: Array<(value: S) => boolean>\n): TypeGuard<T, S> {\n  return ((value: T): value is S => {\n    if (!guard1(value)) return false\n    for (const guard of guards) {\n      if (!guard(value)) return false\n    }\n    return true\n  }) as TypeGuard<T, S>\n}\n\n/**\n * Combines multiple type guards with OR logic.\n * Returns true if any guard matches.\n * \n * @example\n * const isStringOrNumber = oneOf(isString, isNumber)\n * \n * if (isStringOrNumber(value)) {\n *   // value is string | number\n * }\n */\nexport function oneOf<T, S1 extends T>(\n  guard1: TypeGuard<T, S1>\n): TypeGuard<T, S1>\nexport function oneOf<T, S1 extends T, S2 extends T>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<T, S2>\n): TypeGuard<T, S1 | S2>\nexport function oneOf<T, S1 extends T, S2 extends T, S3 extends T>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<T, S2>,\n  guard3: TypeGuard<T, S3>\n): TypeGuard<T, S1 | S2 | S3>\nexport function oneOf<T, S1 extends T, S2 extends T, S3 extends T, S4 extends T>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<T, S2>,\n  guard3: TypeGuard<T, S3>,\n  guard4: TypeGuard<T, S4>\n): TypeGuard<T, S1 | S2 | S3 | S4>\nexport function oneOf<T, S extends T>(\n  ...guards: Array<TypeGuard<T, S>>\n): TypeGuard<T, S> {\n  return ((value: T): value is S => {\n    return guards.some(guard => guard(value))\n  }) as TypeGuard<T, S>\n}\n\n/**\n * Combines multiple type guards with AND logic.\n * Returns true only if all guards match.\n * \n * @example\n * const isNonEmptyString = allOf(\n *   isString,\n *   (s): s is string => s.length > 0\n * )\n */\nexport function allOf<T, S1 extends T>(\n  guard1: TypeGuard<T, S1>\n): TypeGuard<T, S1>\nexport function allOf<T, S1 extends T, S2 extends S1>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<S1, S2>\n): TypeGuard<T, S2>\nexport function allOf<T, S1 extends T, S2 extends S1, S3 extends S2>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<S1, S2>,\n  guard3: TypeGuard<S2, S3>\n): TypeGuard<T, S3>\nexport function allOf<T, S extends T>(\n  ...guards: Array<TypeGuard<T, S>>\n): TypeGuard<T, S> {\n  return ((value: T): value is S => {\n    return guards.every(guard => guard(value))\n  }) as TypeGuard<T, S>\n}\n\n/**\n * Negates a type guard.\n * \n * @example\n * const isNotNull = not(isNull)\n * const items = array.filter(isNotNull)\n */\nexport function not<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<T, Exclude<T, S>> {\n  return ((value: T): value is Exclude<T, S> => !guard(value)) as TypeGuard<T, Exclude<T, S>>\n}\n\n/**\n * Creates a type guard for array elements.\n * \n * @example\n * const isStringArray = arrayOf(isString)\n * \n * if (isStringArray(value)) {\n *   // value is string[]\n * }\n */\nexport function arrayOf<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<unknown, S[]> {\n  return (value: unknown): value is S[] => {\n    return Array.isArray(value) && value.every(guard as TypeGuard<unknown, S>)\n  }\n}\n\n/**\n * Creates a type guard for objects with specific shape.\n * \n * @example\n * const isUser = objectOf({\n *   id: isNumber,\n *   name: isString,\n *   email: isString\n * })\n * \n * if (isUser(data)) {\n *   // data is { id: number; name: string; email: string }\n * }\n */\nexport function objectOf<T extends Record<string, TypeGuard<unknown, unknown>>>(\n  shape: T\n): TypeGuard<unknown, { [K in keyof T]: T[K] extends TypeGuard<unknown, infer S> ? S : never }> {\n  return (value: unknown): value is { [K in keyof T]: T[K] extends TypeGuard<unknown, infer S> ? S : never } => {\n    if (typeof value !== 'object' || value === null) return false\n    const obj = value as Record<string, unknown>\n    return Object.entries(shape).every(([key, guard]) => guard(obj[key]))\n  }\n}\n\n/**\n * Creates a type guard for literal values.\n * \n * @example\n * const isAdmin = literal('admin')\n * const isStatus = oneOf(literal('pending'), literal('done'), literal('error'))\n */\nexport function literal<T extends string | number | boolean>(\n  expected: T\n): TypeGuard<unknown, T> {\n  return (value: unknown): value is T => value === expected\n}\n\n/**\n * Creates a type guard for optional properties.\n * \n * @example\n * const isOptionalString = optional(isString)\n * // Matches string | undefined\n */\nexport function optional<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<T | undefined, S | undefined> {\n  return (value: T | undefined): value is S | undefined => {\n    return value === undefined || guard(value as T)\n  }\n}\n\n/**\n * Creates a type guard for nullable properties.\n * \n * @example\n * const isNullableString = nullable(isString)\n * // Matches string | null\n */\nexport function nullable<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<T | null, S | null> {\n  return (value: T | null): value is S | null => {\n    return value === null || guard(value as T)\n  }\n}\n"]}