@cuppachino/ts-pattern/dist/index.cjs.map

The exhaustive Pattern Matching library for TypeScript.

{"version":3,"file":"index.cjs","sources":["../src/internals/symbols.ts","../src/internals/helpers.ts","../src/patterns.ts","../src/match.ts","../src/is-matching.ts"],"sourcesContent":["/**\n * Symbols used internally within ts-pattern to construct and discriminate\n * Guard, Not, and Select, and AnonymousSelect patterns\n *\n * Symbols have the advantage of not appearing in auto-complete suggestions in\n * user defined patterns, and eliminate the risk of property\n * overlap between ts-pattern internals and user defined patterns.\n *\n * These symbols have to be visible to tsc for type inference to work, but\n * users should not import them\n * @module\n * @private\n * @internal\n */\n\nexport const toExclude = Symbol('@ts-pattern/to-exclude');\nexport type toExclude = typeof toExclude;\n\nexport const matcher = Symbol('@ts-pattern/matcher');\nexport type matcher = typeof matcher;\n\nexport const unset = Symbol('@ts-pattern/unset');\nexport type unset = typeof unset;\n\nexport const anonymousSelectKey = '@ts-pattern/anonymous-select-key';\nexport type anonymousSelectKey = typeof anonymousSelectKey;\n","/**\n * @module\n * @private\n * @internal\n */\n\nimport * as symbols from './symbols.js';\nimport { SelectionType } from '../types/FindSelected.js';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern.js';\n\n// @internal\nexport const isObject = (value: unknown): value is Object =>\n  Boolean(value && typeof value === 'object');\n\n//   @internal\nexport const isMatcher = (\n  x: unknown\n): x is Matcher<unknown, unknown, MatcherType, SelectionType> => {\n  const pattern = x as Matcher<unknown, unknown, MatcherType, SelectionType>;\n  return pattern && !!pattern[symbols.matcher];\n};\n\n// @internal\nconst isOptionalPattern = (\n  x: unknown\n): x is Matcher<unknown, unknown, 'optional', SelectionType> => {\n  return isMatcher(x) && x[symbols.matcher]().matcherType === 'optional';\n};\n\n// tells us if the value matches a given pattern.\n// @internal\nexport const matchPattern = (\n  pattern: Pattern<any>,\n  value: any,\n  select: (key: string, value: unknown) => void\n): boolean => {\n  if (isObject(pattern)) {\n    if (isMatcher(pattern)) {\n      const matcher = pattern[symbols.matcher]();\n      const { matched, selections } = matcher.match(value);\n      if (matched && selections) {\n        Object.keys(selections).forEach((key) => select(key, selections[key]));\n      }\n      return matched;\n    }\n\n    if (!isObject(value)) return false;\n\n    if (Array.isArray(pattern)) {\n      if (!Array.isArray(value)) return false;\n      // Tuple pattern\n      return pattern.length === value.length\n        ? pattern.every((subPattern, i) =>\n            matchPattern(subPattern, value[i], select)\n          )\n        : false;\n    }\n\n    if (pattern instanceof Map) {\n      if (!(value instanceof Map)) return false;\n      return Array.from(pattern.keys()).every((key) =>\n        matchPattern(pattern.get(key), value.get(key), select)\n      );\n    }\n\n    if (pattern instanceof Set) {\n      if (!(value instanceof Set)) return false;\n\n      if (pattern.size === 0) return value.size === 0;\n\n      if (pattern.size === 1) {\n        const [subPattern] = Array.from(pattern.values());\n        return isMatcher(subPattern)\n          ? Array.from(value.values()).every((v) =>\n              matchPattern(subPattern, v, select)\n            )\n          : value.has(subPattern);\n      }\n\n      return Array.from(pattern.values()).every((subPattern) =>\n        value.has(subPattern)\n      );\n    }\n\n    return Object.keys(pattern).every((k: string): boolean => {\n      // @ts-ignore\n      const subPattern = pattern[k];\n\n      return (\n        (k in value || isOptionalPattern(subPattern)) &&\n        matchPattern(\n          subPattern,\n          // @ts-ignore\n          value[k],\n          select\n        )\n      );\n    });\n  }\n\n  return Object.is(value, pattern);\n};\n\n// @internal\nexport const getSelectionKeys = (pattern: Pattern<any>): string[] => {\n  if (isObject(pattern)) {\n    if (isMatcher(pattern)) {\n      return pattern[symbols.matcher]().getSelectionKeys?.() ?? [];\n    }\n    if (Array.isArray(pattern)) return flatMap(pattern, getSelectionKeys);\n    return flatMap(Object.values(pattern), getSelectionKeys);\n  }\n  return [];\n};\n\n// @internal\nexport const flatMap = <a, b>(xs: a[], f: (v: a) => b[]): b[] =>\n  xs.reduce<b[]>((acc, p) => acc.concat(f(p)), []);\n","import {\n  matchPattern,\n  getSelectionKeys,\n  flatMap,\n} from './internals/helpers.js';\nimport * as symbols from './internals/symbols.js';\nimport { GuardFunction, IsNever, Primitives } from './types/helpers.js';\nimport { InvertPattern } from './types/InvertPattern.js';\nimport {\n  Pattern,\n  UnknownPattern,\n  OptionalP,\n  ArrayP,\n  AndP,\n  OrP,\n  NotP,\n  GuardP,\n  SelectP,\n  AnonymousSelectP,\n  GuardExcludeP,\n} from './types/Pattern.js';\n\nexport { Pattern };\n\n/**\n * `P.infer<typeof somePattern>` will return the type of the value\n * matched by this pattern.\n *\n * [Read documentation for `P.infer` on GitHub](https://github.com/gvergnaud/ts-pattern#Pinfer)\n *\n * @example\n * const userPattern = { name: P.string }\n * type User = P.infer<typeof userPattern>\n */\nexport type infer<p extends Pattern<any>> = InvertPattern<p>;\n\n/**\n * `P.optional(subpattern)` takes a sub pattern and returns a pattern which matches if the\n * key is undefined or if it is defined and the sub pattern matches its value.\n *\n * [Read documentation for `P.optional` on GitHub](https://github.com/gvergnaud/ts-pattern#Poptional-patterns)\n\n* @example\n *  match(value)\n *   .with({ greeting: P.optional('Hello') }, () => 'will match { greeting?: \"Hello\" }')\n */\nexport function optional<\n  input,\n  p extends unknown extends input ? UnknownPattern : Pattern<input>\n>(pattern: p): OptionalP<input, p> {\n  return {\n    [symbols.matcher]() {\n      return {\n        match: <I>(value: I | input) => {\n          let selections: Record<string, unknown[]> = {};\n          const selector = (key: string, value: any) => {\n            selections[key] = value;\n          };\n          if (value === undefined) {\n            getSelectionKeys(pattern).forEach((key) =>\n              selector(key, undefined)\n            );\n            return { matched: true, selections };\n          }\n          const matched = matchPattern(pattern, value, selector);\n          return { matched, selections };\n        },\n        getSelectionKeys: () => getSelectionKeys(pattern),\n        matcherType: 'optional',\n      };\n    },\n  };\n}\n\ntype Elem<xs> = xs extends readonly (infer x)[] ? x : never;\n\n/**\n * `P.array(subpattern)` takes a sub pattern and returns a pattern, which matches\n * arrays if all their elements match the sub pattern.\n *\n * [Read documentation for `P.array` on GitHub](https://github.com/gvergnaud/ts-pattern#Parray-patterns)\n *\n * @example\n *  match(value)\n *   .with({ users: P.array({ name: P.string }) }, () => 'will match { name: string }[]')\n */\nexport function array<\n  input,\n  p extends unknown extends input ? UnknownPattern : Pattern<Elem<input>>\n>(pattern: p): ArrayP<input, p> {\n  return {\n    [symbols.matcher]() {\n      return {\n        match: <I>(value: I | input) => {\n          if (!Array.isArray(value)) return { matched: false };\n\n          let selections: Record<string, unknown[]> = {};\n\n          if (value.length === 0) {\n            getSelectionKeys(pattern).forEach((key) => {\n              selections[key] = [];\n            });\n            return { matched: true, selections };\n          }\n\n          const selector = (key: string, value: unknown) => {\n            selections[key] = (selections[key] || []).concat([value]);\n          };\n\n          const matched = value.every((v) =>\n            matchPattern(pattern, v, selector)\n          );\n\n          return { matched, selections };\n        },\n        getSelectionKeys: () => getSelectionKeys(pattern),\n      };\n    },\n  };\n}\n\n/**\n * `P.intersection(...patterns)` returns a pattern which matches\n * only if **every** patterns provided in parameter match the input.\n *\n * [Read documentation for `P.intersection` on GitHub](https://github.com/gvergnaud/ts-pattern#Pintersection-patterns)\n *\n * @example\n *  match(value)\n *   .with(\n *     {\n *       user: P.intersection(\n *         { firstname: P.string },\n *         { lastname: P.string },\n *         { age: P.when(age => age > 21) }\n *       )\n *     },\n *     ({ user }) => 'will match { firstname: string, lastname: string, age: number } if age > 21'\n *   )\n */\nexport function intersection<\n  input,\n  ps extends unknown extends input\n    ? [UnknownPattern, ...UnknownPattern[]]\n    : [Pattern<input>, ...Pattern<input>[]]\n>(...patterns: ps): AndP<input, ps> {\n  return {\n    [symbols.matcher]: () => ({\n      match: (value) => {\n        let selections: Record<string, unknown[]> = {};\n        const selector = (key: string, value: any) => {\n          selections[key] = value;\n        };\n        const matched = (patterns as UnknownPattern[]).every((p) =>\n          matchPattern(p, value, selector)\n        );\n        return { matched, selections };\n      },\n      getSelectionKeys: () =>\n        flatMap(patterns as UnknownPattern[], getSelectionKeys),\n      matcherType: 'and',\n    }),\n  };\n}\n\n/**\n * `P.union(...patterns)` returns a pattern which matches\n * if **at least one** of the patterns provided in parameter match the input.\n *\n * [Read documentation for `P.union` on GitHub](https://github.com/gvergnaud/ts-pattern#Punion-patterns)\n *\n * @example\n *  match(value)\n *   .with(\n *     { type: P.union('a', 'b', 'c') },\n *     ({ user }) => 'will match { type: \"a\" | \"b\" | \"c\" }'\n *   )\n */\nexport function union<\n  input,\n  ps extends unknown extends input\n    ? [UnknownPattern, ...UnknownPattern[]]\n    : [Pattern<input>, ...Pattern<input>[]]\n>(...patterns: ps): OrP<input, ps> {\n  return {\n    [symbols.matcher]: () => ({\n      match: <I>(value: I | input) => {\n        let selections: Record<string, unknown[]> = {};\n        const selector = (key: string, value: any) => {\n          selections[key] = value;\n        };\n        flatMap(patterns as UnknownPattern[], getSelectionKeys).forEach((key) =>\n          selector(key, undefined)\n        );\n        const matched = (patterns as UnknownPattern[]).some((p) =>\n          matchPattern(p, value, selector)\n        );\n        return { matched, selections };\n      },\n      getSelectionKeys: () =>\n        flatMap(patterns as UnknownPattern[], getSelectionKeys),\n      matcherType: 'or',\n    }),\n  };\n}\n\n/**\n * `P.not(pattern)` returns a pattern which matches if the sub pattern\n * doesn't match.\n *\n * [Read documentation for `P.not` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnot-patterns)\n *\n * @example\n *  match<{ a: string | number }>(value)\n *   .with({ a: P.not(P.string) }, (x) => 'will match { a: number }'\n *   )\n */\nexport function not<input, p extends Pattern<input> | Primitives>(\n  pattern: p\n): NotP<input, p> {\n  return {\n    [symbols.matcher]: () => ({\n      match: <I>(value: I | input) => ({\n        matched: !matchPattern(pattern, value, () => {}),\n      }),\n      getSelectionKeys: () => [],\n      matcherType: 'not',\n    }),\n  };\n}\n\n/**\n * `P.when((value) => boolean)` returns a pattern which matches\n * if the predicate returns true for the current input.\n *\n * [Read documentation for `P.when` on GitHub](https://github.com/gvergnaud/ts-pattern#Pwhen-patterns)\n *\n * @example\n *  match<{ age: number }>(value)\n *   .with({ age: P.when(age => age > 21) }, (x) => 'will match if value.age > 21'\n *   )\n */\nexport function when<input, p extends (value: input) => unknown>(\n  predicate: p\n): GuardP<\n  input,\n  p extends (value: any) => value is infer narrowed ? narrowed : never\n>;\nexport function when<input, narrowed extends input, excluded>(\n  predicate: (input: input) => input is narrowed\n): GuardExcludeP<input, narrowed, excluded>;\nexport function when<input, p extends (value: input) => unknown>(\n  predicate: p\n): GuardP<\n  input,\n  p extends (value: any) => value is infer narrowed ? narrowed : never\n> {\n  return {\n    [symbols.matcher]: () => ({\n      match: <I>(value: I | input) => ({\n        matched: Boolean(predicate(value as input)),\n      }),\n    }),\n  };\n}\n\n/**\n * `P.select()` is a pattern which will always match,\n * and will inject the selected piece of input in the handler function.\n *\n * [Read documentation for `P.select` on GitHub](https://github.com/gvergnaud/ts-pattern#Pselect-patterns)\n *\n * @example\n *  match<{ age: number }>(value)\n *   .with({ age: P.select() }, (age) => 'age: number'\n *   )\n */\nexport function select(): AnonymousSelectP;\nexport function select<\n  input,\n  patternOrKey extends\n    | string\n    | (unknown extends input ? UnknownPattern : Pattern<input>)\n>(\n  patternOrKey: patternOrKey\n): patternOrKey extends string\n  ? SelectP<patternOrKey>\n  : SelectP<symbols.anonymousSelectKey, input, patternOrKey>;\nexport function select<\n  input,\n  p extends unknown extends input ? UnknownPattern : Pattern<input>,\n  k extends string\n>(key: k, pattern: p): SelectP<k, input, p>;\nexport function select(\n  ...args: [keyOrPattern?: unknown | string, pattern?: unknown]\n): SelectP<string> {\n  const key: string | undefined =\n    typeof args[0] === 'string' ? args[0] : undefined;\n  const pattern: unknown =\n    args.length === 2\n      ? args[1]\n      : typeof args[0] === 'string'\n      ? undefined\n      : args[0];\n  return {\n    [symbols.matcher]() {\n      return {\n        match: (value) => {\n          let selections: Record<string, unknown> = {\n            [key ?? symbols.anonymousSelectKey]: value,\n          };\n          const selector = (key: string, value: any) => {\n            selections[key] = value;\n          };\n          return {\n            matched:\n              pattern === undefined\n                ? true\n                : matchPattern(pattern, value, selector),\n            selections: selections,\n          };\n        },\n        getSelectionKeys: () =>\n          [key ?? symbols.anonymousSelectKey].concat(\n            pattern === undefined ? [] : getSelectionKeys(pattern)\n          ),\n      };\n    },\n  };\n}\n\nfunction isUnknown(x: unknown): x is unknown {\n  return true;\n}\n\nfunction isNumber<T>(x: T | number): x is number {\n  return typeof x === 'number';\n}\n\nfunction isString<T>(x: T | string): x is string {\n  return typeof x === 'string';\n}\n\nfunction isBoolean<T>(x: T | boolean): x is boolean {\n  return typeof x === 'boolean';\n}\n\nfunction isBigInt<T>(x: T | bigint): x is bigint {\n  return typeof x === 'bigint';\n}\n\nfunction isSymbol<T>(x: T | symbol): x is symbol {\n  return typeof x === 'symbol';\n}\n\nfunction isNullish<T>(x: T | null | undefined): x is null | undefined {\n  return x === null || x === undefined;\n}\n\ntype AnyConstructor = abstract new (...args: any[]) => any;\n\nfunction isInstanceOf<T extends AnyConstructor>(classConstructor: T) {\n  return (val: unknown): val is InstanceType<T> =>\n    val instanceof classConstructor;\n}\n\n/**\n * `P.any` is a wildcard pattern, matching **any value**.\n *\n * [Read documentation for `P.any` on GitHub](https://github.com/gvergnaud/ts-pattern#P_-wildcard)\n *\n * @example\n *  match(value)\n *   .with(P.any, () => 'will always match')\n */\nexport const any = when(isUnknown);\n\n/**\n * `P._` is a wildcard pattern, matching **any value**.\n * It's an alias to `P.any`.\n *\n * [Read documentation for `P._` on GitHub](https://github.com/gvergnaud/ts-pattern#P_-wildcard)\n *\n * @example\n *  match(value)\n *   .with(P._, () => 'will always match')\n */\nexport const _ = any;\n\n/**\n * `P.string` is a wildcard pattern matching any **string**.\n *\n * [Read documentation for `P.string` on GitHub](https://github.com/gvergnaud/ts-pattern#Pstring-wildcard)\n *\n * @example\n *  match(value)\n *   .with(P.string, () => 'will match on strings')\n */\n\nexport const string = when(isString);\n\n/**\n * `P.number` is a wildcard pattern matching any **number**.\n *\n * [Read documentation for `P.number` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumber-wildcard)\n *\n * @example\n *  match(value)\n *   .with(P.number, () => 'will match on numbers')\n */\nexport const number = when(isNumber);\n\n/**\n * `P.boolean` is a wildcard pattern matching any **boolean**.\n *\n * [Read documentation for `P.boolean` on GitHub](https://github.com/gvergnaud/ts-pattern#boolean-wildcard)\n *\n * @example\n *   .with(P.boolean, () => 'will match on booleans')\n */\nexport const boolean = when(isBoolean);\n\n/**\n * `P.bigint` is a wildcard pattern matching any **bigint**.\n *\n * [Read documentation for `P.bigint` on GitHub](https://github.com/gvergnaud/ts-pattern#bigint-wildcard)\n *\n * @example\n *   .with(P.bigint, () => 'will match on bigints')\n */\nexport const bigint = when(isBigInt);\n\n/**\n * `P.symbol` is a wildcard pattern matching any **symbol**.\n *\n * [Read documentation for `P.symbol` on GitHub](https://github.com/gvergnaud/ts-pattern#symbol-wildcard)\n *\n * @example\n *   .with(P.symbol, () => 'will match on symbols')\n */\nexport const symbol = when(isSymbol);\n\n/**\n * `P.nullish` is a wildcard pattern matching **null** or **undefined**.\n *\n * [Read documentation for `P.nullish` on GitHub](https://github.com/gvergnaud/ts-pattern#nullish-wildcard)\n *\n * @example\n *   .with(P.nullish, () => 'will match on null or undefined')\n */\nexport const nullish = when(isNullish);\n\n/**\n * `P.instanceOf(SomeClass)` is a pattern matching instances of a given class.\n *\n * [Read documentation for `P.instanceOf` on GitHub](https://github.com/gvergnaud/ts-pattern#Pinstanceof-patterns)\n *\n *  @example\n *   .with(P.instanceOf(SomeClass), () => 'will match on SomeClass instances')\n */\nexport function instanceOf<T extends AnyConstructor>(\n  classConstructor: T\n): GuardP<unknown, InstanceType<T>> {\n  return when(isInstanceOf(classConstructor));\n}\n\n/**\n * `P.typed<SomeType>()` is a way to set the input type this\n * pattern should match on.\n *\n * It returns all utility functions to create patterns,\n * Like `array`, `union`, `intersection`, etc.\n *\n * [Read documentation for `P.typed` on GitHub](https://github.com/gvergnaud/ts-pattern#Ptyped)\n *\n * @example\n *  .with(\n *    P.typed<string | number[]>().array(P.string),\n *    (arrayOfString) => arrayOfString.join(', ')\n *  )\n */\nexport function typed<input>(): {\n  array<p extends Pattern<Elem<input>>>(pattern: p): ArrayP<input, p>;\n\n  optional<p extends Pattern<input>>(pattern: p): OptionalP<input, p>;\n\n  intersection<ps extends [Pattern<input>, ...Pattern<input>[]]>(\n    ...patterns: ps\n  ): AndP<input, ps>;\n\n  union<ps extends [Pattern<input>, ...Pattern<input>[]]>(\n    ...patterns: ps\n  ): OrP<input, ps>;\n\n  not<p extends Pattern<input>>(pattern: p): NotP<input, p>;\n\n  when<narrowed extends input = never>(\n    predicate: GuardFunction<input, narrowed>\n  ): GuardP<input, narrowed>;\n\n  select<pattern extends Pattern<input>>(\n    pattern: pattern\n  ): SelectP<symbols.anonymousSelectKey, input, pattern>;\n  select<p extends Pattern<input>, k extends string>(\n    key: k,\n    pattern: p\n  ): SelectP<k, input, p>;\n} {\n  return {\n    array: array as any,\n    optional: optional as any,\n    intersection: intersection as any,\n    union: union as any,\n    not: not as any,\n    select: select as any,\n    when: when as any,\n  };\n}\n","import { Pattern } from './types/Pattern.js';\nimport { GuardValue } from './types/helpers.js';\nimport { Match, PickReturnValue } from './types/Match.js';\nimport * as symbols from './internals/symbols.js';\nimport { matchPattern } from './internals/helpers.js';\n\n/**\n * `match` creates a **pattern matching expression**.\n *\n * Use `.with(pattern, handler)` to pattern match on the input.\n *\n * Use `.exhaustive()` or `.otherwise(() => defaultValue)` to end the expression and get the result.\n *\n * [Read documentation for `match` on GitHub](https://github.com/gvergnaud/ts-pattern#match)\n *\n * @example\n *  declare let input: \"A\" | \"B\";\n *\n *  return match(input)\n *    .with(\"A\", () => \"It's a A!\")\n *    .with(\"B\", () => \"It's a B!\")\n *    .exhaustive();\n *\n */\nexport function match<input extends [any, ...any], output = symbols.unset>(\n  value: input\n): Match<input, output>;\nexport function match<input, output = symbols.unset>(\n  value: input\n): Match<input, output>;\nexport function match<input, output = symbols.unset>(\n  value: input\n): Match<input, output> {\n  return new MatchExpression(value, []) as any;\n}\n\n/**\n * This class represents a match expression. It follows the\n * builder pattern, we chain methods to add features to the expression\n * until we call `.exhaustive`, `.otherwise` or the unsafe `.run`\n * method to execute it.\n *\n * The types of this class aren't public, the public type definition\n * can be found in src/types/Match.ts.\n */\nclass MatchExpression<i, o> {\n  constructor(\n    private value: i,\n    private cases: {\n      match: (value: i) => { matched: boolean; value: any };\n      handler: (...args: any) => any;\n    }[]\n  ) {}\n\n  with(...args: any[]) {\n    const handler = args[args.length - 1];\n\n    const patterns: Pattern<i>[] = [args[0]];\n    const predicates: ((value: i) => unknown)[] = [];\n\n    // case with guard as second argument\n    if (args.length === 3 && typeof args[1] === 'function') {\n      patterns.push(args[0]);\n      predicates.push(args[1]);\n    } else if (args.length > 2) {\n      // case with several patterns\n      patterns.push(...args.slice(1, args.length - 1));\n    }\n\n    return new MatchExpression(\n      this.value,\n      this.cases.concat([\n        {\n          match: (value: i) => {\n            let selected: Record<string, unknown> = {};\n            const matched = Boolean(\n              patterns.some((pattern) =>\n                matchPattern(pattern, value, (key, value) => {\n                  selected[key] = value;\n                })\n              ) && predicates.every((predicate) => predicate(value as any))\n            );\n            return {\n              matched,\n              value:\n                matched && Object.keys(selected).length\n                  ? symbols.anonymousSelectKey in selected\n                    ? selected[symbols.anonymousSelectKey]\n                    : selected\n                  : value,\n            };\n          },\n          handler,\n        },\n      ])\n    );\n  }\n\n  when<p extends (value: i) => unknown, c>(\n    predicate: p,\n    handler: (value: GuardValue<p>) => PickReturnValue<o, c>\n  ) {\n    return new MatchExpression<i, PickReturnValue<o, c>>(\n      this.value,\n      this.cases.concat([\n        {\n          match: (value) => ({\n            matched: Boolean(predicate(value)),\n            value,\n          }),\n          handler,\n        },\n      ])\n    );\n  }\n\n  otherwise<c>(\n    handler: (value: i) => PickReturnValue<o, c>\n  ): PickReturnValue<o, c> {\n    return new MatchExpression<i, PickReturnValue<o, c>>(\n      this.value,\n      this.cases.concat([\n        {\n          match: (value) => ({\n            matched: true,\n            value,\n          }),\n          handler,\n        },\n      ])\n    ).run();\n  }\n\n  exhaustive() {\n    return this.run();\n  }\n\n  run() {\n    let selected = this.value;\n    let handler: undefined | ((...args: any) => any) = undefined;\n\n    for (let i = 0; i < this.cases.length; i++) {\n      const entry = this.cases[i];\n      const matchResult = entry.match(this.value);\n      if (matchResult.matched) {\n        selected = matchResult.value;\n        handler = entry.handler;\n        break;\n      }\n    }\n    if (!handler) {\n      let displayedValue;\n      try {\n        displayedValue = JSON.stringify(this.value);\n      } catch (e) {\n        displayedValue = this.value;\n      }\n      throw new Error(\n        `Pattern matching error: no pattern matches value ${displayedValue}`\n      );\n    }\n    return handler(selected, this.value);\n  }\n}\n","import { Pattern } from './types/Pattern.js';\nimport { MatchedValue } from './types/Match.js';\nimport * as P from './patterns.js';\nimport { matchPattern } from './internals/helpers.js';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read  documentation for `isMatching` on GitHub](https://github.com/gvergnaud/ts-pattern#ismatching)\n *\n * @example\n *  const hasName = isMatching({ name: P.string })\n *\n *  declare let input: unknown\n *\n *  if (hasName(input)) {\n *    // `input` inferred as { name: string }\n *    return input.name\n *  }\n */\nexport function isMatching<p extends Pattern<any>>(\n  pattern: p\n): (value: any) => value is MatchedValue<any, P.infer<p>>;\n/**\n * `isMatching` takes pattern and a value and checks if the value matches this pattern.\n *\n * [Read  documentation for `isMatching` on GitHub](https://github.com/gvergnaud/ts-pattern#ismatching)\n *\n * @example\n *  declare let input: unknown\n *\n *  if (isMatching({ name: P.string }, input)) {\n *    // `input` inferred as { name: string }\n *    return input.name\n *  }\n */\nexport function isMatching<p extends Pattern<any>>(\n  pattern: p,\n  value: any\n): value is MatchedValue<any, P.infer<p>>;\n\nexport function isMatching<p extends Pattern<any>>(\n  ...args: [pattern: p, value?: any]\n): boolean | ((vale: any) => boolean) {\n  if (args.length === 1) {\n    const [pattern] = args;\n    return (value: any): value is MatchedValue<any, P.infer<p>> =>\n      matchPattern(pattern, value, () => {});\n  }\n  if (args.length === 2) {\n    const [pattern, value] = args;\n    return matchPattern(pattern, value, () => {});\n  }\n\n  throw new Error(\n    `isMatching wasn't given the right number of arguments: expected 1 or 2, received ${args.length}.`\n  );\n}\n"],"names":["matcher","Symbol","anonymousSelectKey","isObject","value","Boolean","isMatcher","x","symbols","matchPattern","pattern","select","_matcher$match","match","matched","selections","Object","keys","forEach","key","Array","isArray","length","every","subPattern","i","Map","from","get","Set","size","values","v","has","k","matcherType","is","getSelectionKeys","_pattern$symbols$matc","_pattern$symbols$matc2","_pattern$symbols$matc3","call","flatMap","xs","f","reduce","acc","p","concat","optional","_ref","undefined","selector","_getSelectionKeys","array","_ref2","intersection","patterns","_ref3","union","slice","arguments","_ref4","some","not","_ref5","when","predicate","_ref6","_ref7","args","_selections","any","_","string","number","boolean","bigint","symbol","nullish","classConstructor","val","isInstanceOf","typed","cases","this","handler","predicates","push","apply","MatchExpression","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching","_args2"],"mappings":"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"}