Launch Week Day 5: Introducing Reachability for PHP.Learn More →
ts-pattern
Advanced tools
ts-pattern - npm Package Compare versions
| const e = Symbol('@ts-pattern/matcher'), | ||
| t = '@ts-pattern/anonymous-select-key', | ||
| n = (e) => Boolean(e && 'object' == typeof e), | ||
| r = (t) => t && !!t[e], | ||
| o = (t, c, a) => { | ||
| if (n(t)) { | ||
| if (r(t)) { | ||
| const n = t[e](), | ||
| { matched: r, selections: o } = n.match(c); | ||
| return r && o && Object.keys(o).forEach((e) => a(e, o[e])), r; | ||
| } | ||
| if (!n(c)) return !1; | ||
| if (Array.isArray(t)) | ||
| return ( | ||
| !!Array.isArray(c) && | ||
| t.length === c.length && | ||
| t.every((e, t) => o(e, c[t], a)) | ||
| ); | ||
| if (t instanceof Map) | ||
| return ( | ||
| c instanceof Map && | ||
| Array.from(t.keys()).every((e) => o(t.get(e), c.get(e), a)) | ||
| ); | ||
| if (t instanceof Set) { | ||
| if (!(c instanceof Set)) return !1; | ||
| if (0 === t.size) return 0 === c.size; | ||
| if (1 === t.size) { | ||
| const [e] = Array.from(t.values()); | ||
| return r(e) | ||
| ? Array.from(c.values()).every((t) => o(e, t, a)) | ||
| : c.has(e); | ||
| } | ||
| return Array.from(t.values()).every((e) => c.has(e)); | ||
| } | ||
| return Object.keys(t).every((n) => { | ||
| const s = t[n]; | ||
| return ( | ||
| (n in c || (r((i = s)) && 'optional' === i[e]().matcherType)) && | ||
| o(s, c[n], a) | ||
| ); | ||
| var i; | ||
| }); | ||
| } | ||
| return Object.is(c, t); | ||
| }, | ||
| c = (t) => { | ||
| var o, s, i; | ||
| return n(t) | ||
| ? r(t) | ||
| ? null != | ||
| (o = null == (s = (i = t[e]()).getSelectionKeys) ? void 0 : s.call(i)) | ||
| ? o | ||
| : [] | ||
| : Array.isArray(t) | ||
| ? a(t, c) | ||
| : a(Object.values(t), c) | ||
| : []; | ||
| }, | ||
| a = (e, t) => e.reduce((e, n) => e.concat(t(n)), []); | ||
| function s(t) { | ||
| return { | ||
| [e]: () => ({ | ||
| match: (e) => { | ||
| let n = {}; | ||
| const r = (e, t) => { | ||
| n[e] = t; | ||
| }; | ||
| return void 0 === e | ||
| ? (c(t).forEach((e) => r(e, void 0)), { matched: !0, selections: n }) | ||
| : { matched: o(t, e, r), selections: n }; | ||
| }, | ||
| getSelectionKeys: () => c(t), | ||
| matcherType: 'optional', | ||
| }), | ||
| }; | ||
| } | ||
| function i(t) { | ||
| return { | ||
| [e]: () => ({ | ||
| match: (e) => { | ||
| if (!Array.isArray(e)) return { matched: !1 }; | ||
| let n = {}; | ||
| if (0 === e.length) | ||
| return ( | ||
| c(t).forEach((e) => { | ||
| n[e] = []; | ||
| }), | ||
| { matched: !0, selections: n } | ||
| ); | ||
| const r = (e, t) => { | ||
| n[e] = (n[e] || []).concat([t]); | ||
| }; | ||
| return { matched: e.every((e) => o(t, e, r)), selections: n }; | ||
| }, | ||
| getSelectionKeys: () => c(t), | ||
| }), | ||
| }; | ||
| } | ||
| function u(...t) { | ||
| return { | ||
| [e]: () => ({ | ||
| match: (e) => { | ||
| let n = {}; | ||
| const r = (e, t) => { | ||
| n[e] = t; | ||
| }; | ||
| return { matched: t.every((t) => o(t, e, r)), selections: n }; | ||
| }, | ||
| getSelectionKeys: () => a(t, c), | ||
| matcherType: 'and', | ||
| }), | ||
| }; | ||
| } | ||
| function l(...t) { | ||
| return { | ||
| [e]: () => ({ | ||
| match: (e) => { | ||
| let n = {}; | ||
| const r = (e, t) => { | ||
| n[e] = t; | ||
| }; | ||
| return ( | ||
| a(t, c).forEach((e) => r(e, void 0)), | ||
| { matched: t.some((t) => o(t, e, r)), selections: n } | ||
| ); | ||
| }, | ||
| getSelectionKeys: () => a(t, c), | ||
| matcherType: 'or', | ||
| }), | ||
| }; | ||
| } | ||
| function h(t) { | ||
| return { | ||
| [e]: () => ({ | ||
| match: (e) => ({ matched: !o(t, e, () => {}) }), | ||
| getSelectionKeys: () => [], | ||
| matcherType: 'not', | ||
| }), | ||
| }; | ||
| } | ||
| function f(t) { | ||
| return { [e]: () => ({ match: (e) => ({ matched: Boolean(t(e)) }) }) }; | ||
| } | ||
| function y(...n) { | ||
| const r = 'string' == typeof n[0] ? n[0] : void 0, | ||
| a = 2 === n.length ? n[1] : 'string' == typeof n[0] ? void 0 : n[0]; | ||
| return { | ||
| [e]: () => ({ | ||
| match: (e) => { | ||
| let n = { [null != r ? r : t]: e }; | ||
| return { | ||
| matched: | ||
| void 0 === a || | ||
| o(a, e, (e, t) => { | ||
| n[e] = t; | ||
| }), | ||
| selections: n, | ||
| }; | ||
| }, | ||
| getSelectionKeys: () => | ||
| [null != r ? r : t].concat(void 0 === a ? [] : c(a)), | ||
| }), | ||
| }; | ||
| } | ||
| const m = f(function (e) { | ||
| return !0; | ||
| }), | ||
| v = m, | ||
| d = f(function (e) { | ||
| return 'string' == typeof e; | ||
| }), | ||
| g = f(function (e) { | ||
| return 'number' == typeof e; | ||
| }), | ||
| p = f(function (e) { | ||
| return 'boolean' == typeof e; | ||
| }), | ||
| b = f(function (e) { | ||
| return 'bigint' == typeof e; | ||
| }), | ||
| w = f(function (e) { | ||
| return 'symbol' == typeof e; | ||
| }), | ||
| A = f(function (e) { | ||
| return null == e; | ||
| }); | ||
| var S = { | ||
| __proto__: null, | ||
| optional: s, | ||
| array: i, | ||
| intersection: u, | ||
| union: l, | ||
| not: h, | ||
| when: f, | ||
| select: y, | ||
| any: m, | ||
| _: v, | ||
| string: d, | ||
| number: g, | ||
| boolean: p, | ||
| bigint: b, | ||
| symbol: w, | ||
| nullish: A, | ||
| instanceOf: function (e) { | ||
| return f( | ||
| (function (e) { | ||
| return (t) => t instanceof e; | ||
| })(e) | ||
| ); | ||
| }, | ||
| typed: function () { | ||
| return { | ||
| array: i, | ||
| optional: s, | ||
| intersection: u, | ||
| union: l, | ||
| not: h, | ||
| select: y, | ||
| when: f, | ||
| }; | ||
| }, | ||
| }; | ||
| const K = (e) => new O(e, []); | ||
| class O { | ||
| constructor(e, t) { | ||
| (this.value = void 0), | ||
| (this.cases = void 0), | ||
| (this.value = e), | ||
| (this.cases = t); | ||
| } | ||
| with(...e) { | ||
| const n = e[e.length - 1], | ||
| r = [e[0]], | ||
| c = []; | ||
| return ( | ||
| 3 === e.length && 'function' == typeof e[1] | ||
| ? (r.push(e[0]), c.push(e[1])) | ||
| : e.length > 2 && r.push(...e.slice(1, e.length - 1)), | ||
| new O( | ||
| this.value, | ||
| this.cases.concat([ | ||
| { | ||
| match: (e) => { | ||
| let n = {}; | ||
| const a = Boolean( | ||
| r.some((t) => | ||
| o(t, e, (e, t) => { | ||
| n[e] = t; | ||
| }) | ||
| ) && c.every((t) => t(e)) | ||
| ); | ||
| return { | ||
| matched: a, | ||
| value: a && Object.keys(n).length ? (t in n ? n[t] : n) : e, | ||
| }; | ||
| }, | ||
| handler: n, | ||
| }, | ||
| ]) | ||
| ) | ||
| ); | ||
| } | ||
| when(e, t) { | ||
| return new O( | ||
| this.value, | ||
| this.cases.concat([ | ||
| { match: (t) => ({ matched: Boolean(e(t)), value: t }), handler: t }, | ||
| ]) | ||
| ); | ||
| } | ||
| otherwise(e) { | ||
| return new O( | ||
| this.value, | ||
| this.cases.concat([ | ||
| { match: (e) => ({ matched: !0, value: e }), handler: e }, | ||
| ]) | ||
| ).run(); | ||
| } | ||
| exhaustive() { | ||
| return this.run(); | ||
| } | ||
| run() { | ||
| let e, | ||
| t = this.value; | ||
| for (let n = 0; n < this.cases.length; n++) { | ||
| const r = this.cases[n], | ||
| o = r.match(this.value); | ||
| if (o.matched) { | ||
| (t = o.value), (e = r.handler); | ||
| break; | ||
| } | ||
| } | ||
| if (!e) { | ||
| let e; | ||
| try { | ||
| e = JSON.stringify(this.value); | ||
| } catch (t) { | ||
| e = this.value; | ||
| } | ||
| throw new Error(`Pattern matching error: no pattern matches value ${e}`); | ||
| } | ||
| return e(t, this.value); | ||
| } | ||
| } | ||
| function j(...e) { | ||
| if (1 === e.length) { | ||
| const [t] = e; | ||
| return (e) => o(t, e, () => {}); | ||
| } | ||
| if (2 === e.length) { | ||
| const [t, n] = e; | ||
| return o(t, n, () => {}); | ||
| } | ||
| throw new Error( | ||
| `isMatching wasn't given the right number of arguments: expected 1 or 2, received ${e.length}.` | ||
| ); | ||
| } | ||
| export { S as P, S as Pattern, j as isMatching, K as match }; | ||
| //# sourceMappingURL=index.modern.mjs.map |
| {"version":3,"file":"index.modern.mjs","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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 = 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","matched","selections","match","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","selector","undefined","array","intersection","patterns","union","some","not","when","predicate","args","any","_","string","number","boolean","bigint","symbol","nullish","classConstructor","val","isInstanceOf","MatchExpression","constructor","cases","this","with","handler","predicates","push","slice","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching"],"mappings":"AAkBaA,MAAAA,EAAUC,OAAO,uBAMjBC,EAAqB,mCCbrBC,EAAYC,GACvBC,QAAQD,GAA0B,iBAAVA,GAGbE,EACXC,GAEgBA,OACYC,GAYjBC,EAAe,CAC1BC,EACAN,EACAO,KAEA,GAAIR,EAASO,GAAU,CACrB,GAAIJ,EAAUI,GAAU,CACtB,MAAMV,EAAUU,EAAQF,MAClBI,QAAEA,EAAFC,WAAWA,GAAeb,EAAQc,MAAMV,GAI9C,OAHIQ,GAAWC,GACbE,OAAOC,KAAKH,GAAYI,QAASC,GAAQP,EAAOO,EAAKL,EAAWK,KAE3DN,CACR,CAED,IAAKT,EAASC,GAAQ,OAAO,EAE7B,GAAIe,MAAMC,QAAQV,GAChB,QAAKS,MAAMC,QAAQhB,IAEZM,EAAQW,SAAWjB,EAAMiB,QAC5BX,EAAQY,MAAM,CAACC,EAAYC,IACzBf,EAAac,EAAYnB,EAAMoB,GAAIb,IAK3C,GAAID,aAAmBe,IACrB,OAAMrB,aAAiBqB,KAChBN,MAAMO,KAAKhB,EAAQM,QAAQM,MAAOJ,GACvCT,EAAaC,EAAQiB,IAAIT,GAAMd,EAAMuB,IAAIT,GAAMP,IAInD,GAAID,aAAmBkB,IAAK,CAC1B,KAAMxB,aAAiBwB,KAAM,OAAA,EAE7B,GAAqB,IAAjBlB,EAAQmB,KAAY,OAAsB,IAAfzB,EAAMyB,KAErC,GAAqB,IAAjBnB,EAAQmB,KAAY,CACtB,MAAON,GAAcJ,MAAMO,KAAKhB,EAAQoB,UACxC,OAAOxB,EAAUiB,GACbJ,MAAMO,KAAKtB,EAAM0B,UAAUR,MAAOS,GAChCtB,EAAac,EAAYQ,EAAGpB,IAE9BP,EAAM4B,IAAIT,EACf,CAED,OAAOJ,MAAMO,KAAKhB,EAAQoB,UAAUR,MAAOC,GACzCnB,EAAM4B,IAAIT,GAEb,CAED,OAAOR,OAAOC,KAAKN,GAASY,MAAOW,IAEjC,MAAMV,EAAab,EAAQuB,GAE3B,OACGA,KAAK7B,GA/DLE,EAFPC,EAiEuCgB,IA/DqB,aAArChB,EAAEC,KAAmB0B,cAgEtCzB,EACEc,EAEAnB,EAAM6B,GACNtB,GAtERJ,KAkEkB,EAQjB,CAED,OAAOQ,OAAOoB,GAAG/B,EAAOM,EAAjB,EAII0B,EAAoB1B,IAEL,IAAA2B,EAAAC,EAAAC,EAD1B,OAAIpC,EAASO,GACPJ,EAAUI,GAC8C,SAAnD,UAAAA,EAAAA,EAAQF,MAAmB4B,uBAA3B,EAAAE,EAAAE,KAAAD,IAAmDF,EAAA,GAExDlB,MAAMC,QAAQV,GAAiB+B,EAAQ/B,EAAS0B,GAC7CK,EAAQ1B,OAAOe,OAAOpB,GAAU0B,GAElC,EACR,EAGYK,EAAU,CAAOC,EAASC,IACrCD,EAAGE,OAAY,CAACC,EAAKC,IAAMD,EAAIE,OAAOJ,EAAEG,IAAK,IC3E/BE,SAAAA,EAGdtC,GACA,MAAO,CACLV,CAACQ,GAAgB,KACR,CACLM,MAAWV,IACT,IAAIS,EAAwC,CAAA,EAC5C,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,GAAOd,CAAAA,EAEpB,YAAc8C,IAAV9C,GACFgC,EAAiB1B,GAASO,QAASC,GACjC+B,EAAS/B,OAAKgC,IAET,CAAEtC,SAAS,EAAMC,eAGnB,CAAED,QADOH,EAAaC,EAASN,EAAO6C,GAC3BpC,aAAX,EAETuB,iBAAkB,IAAMA,EAAiB1B,GACzCwB,YAAa,aAIpB,CAcK,SAAUiB,EAGdzC,GACA,MAAO,CACLV,CAACQ,GAAD,KACS,CACLM,MAAWV,IACT,IAAKe,MAAMC,QAAQhB,GAAQ,MAAO,CAAEQ,SAAS,GAE7C,IAAIC,EAAwC,CAA5C,EAEA,GAAqB,IAAjBT,EAAMiB,OAIR,OAHAe,EAAiB1B,GAASO,QAASC,IACjCL,EAAWK,GAAO,EAAA,GAEb,CAAEN,SAAS,EAAMC,cAG1B,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,IAAQL,EAAWK,IAAQ,IAAI6B,OAAO,CAAC3C,KAOpD,MAAO,CAAEQ,QAJOR,EAAMkB,MAAOS,GAC3BtB,EAAaC,EAASqB,EAAGkB,IAGTpC,aAAX,EAETuB,iBAAkB,IAAMA,EAAiB1B,KAIhD,CAqBe,SAAA0C,KAKXC,GACH,MAAO,CACLrD,CAACQ,GAAkB,KAAO,CACxBM,MAAQV,IACN,IAAIS,EAAwC,CAA5C,EACA,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,GAAOd,CACnB,EAID,MAAO,CAAEQ,QAHQyC,EAA8B/B,MAAOwB,GACpDrC,EAAaqC,EAAG1C,EAAO6C,IAEPpC,aAAX,EAETuB,iBAAkB,IAChBK,EAAQY,EAA8BjB,GACxCF,YAAa,QAGlB,CAee,SAAAoB,KAKXD,GACH,MAAO,CACLrD,CAACQ,GAAkB,MACjBM,MAAWV,IACT,IAAIS,EAAwC,CAA5C,EACA,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,GAAOd,CACnB,EAOD,OANAqC,EAAQY,EAA8BjB,GAAkBnB,QAASC,GAC/D+B,EAAS/B,OAAKgC,IAKT,CAAEtC,QAHQyC,EAA8BE,KAAMT,GACnDrC,EAAaqC,EAAG1C,EAAO6C,IAEPpC,aAAX,EAETuB,iBAAkB,IAChBK,EAAQY,EAA8BjB,GACxCF,YAAa,OAGlB,CAaK,SAAUsB,EAGd9C,GACA,MAAO,CACLV,CAACQ,GAAkB,KAAA,CACjBM,MAAWV,IAAJ,CACLQ,SAAUH,EAAaC,EAASN,EAAO,UAEzCgC,iBAAkB,IAAM,GACxBF,YAAa,QAGlB,CAsBeuB,SAAAA,EACdC,GAKA,MAAO,CACL1D,CAACQ,GAAkB,KAAA,CACjBM,MAAWV,IAAsB,CAC/BQ,QAASP,QAAQqD,EAAUtD,QAIlC,CA6Be,SAAAO,KACXgD,GAEH,MAAMzC,EACe,iBAAZyC,EAAK,GAAkBA,EAAK,QAAKT,EACpCxC,EACY,IAAhBiD,EAAKtC,OACDsC,EAAK,GACc,iBAAZA,EAAK,QACZT,EACAS,EAAK,GACX,MAAO,CACL3D,CAACQ,GAAD,KACS,CACLM,MAAQV,IACN,IAAIS,EAAsC,CACxC,CAACK,MAAAA,EAAAA,EAAOV,GAA6BJ,GAKvC,MAAO,CACLQ,aACcsC,IAAZxC,GAEID,EAAaC,EAASN,EAPb,CAACc,EAAad,KAC7BS,EAAWK,GAAOd,CACnB,GAMCS,WAAYA,EALP,EAQTuB,iBAAkB,IAChB,CAAClB,MAAAA,EAAAA,EAAOV,GAA4BuC,YACtBG,IAAZxC,EAAwB,GAAK0B,EAAiB1B,MAKzD,CA8CYkD,MAAAA,EAAMH,EA5CnB,SAAmBlD,GACjB,OAAO,CACR,GAsDYsD,EAAID,EAYJE,EAASL,EA5DtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GAqEYwD,EAASN,EA3EtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GAmFYyD,EAAUP,EA7EvB,SAAsBlD,GACpB,MAAoB,kBAANA,CACf,GAqFY0D,EAASR,EAnFtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GA2FY2D,EAAST,EAzFtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GAiGY4D,EAAUV,EA/FvB,SAAsBlD,GACpB,OAAOA,OACR,sKAuGK,SACJ6D,GAEA,OAAOX,EAtGT,SAAgDW,GAC9C,OAAQC,GACNA,aAAeD,CAClB,CAmGaE,CAAaF,GAC1B,mBA4CC,MAAO,CACLjB,MAAOA,EACPH,SAAUA,EACVI,aAAcA,EACdE,MAAOA,EACPE,IAAKA,EACL7C,OAAQA,EACR8C,KAAMA,EAET,GC1eY3C,MAAAA,EACXV,GACyB,IAAImE,EAAgBnE,EAAO,IAWtD,MAAMmE,EACJC,YACUpE,EACAqE,GADArE,KAAAA,WACAqE,EAAAA,KAAAA,WADA,EAAAC,KAAKtE,MAALA,EACAsE,KAAKD,MAALA,CAIN,CAEJE,QAAQhB,GACN,MAAMiB,EAAUjB,EAAKA,EAAKtC,OAAS,GAE7BgC,EAAyB,CAACM,EAAK,IAC/BkB,EAAwC,GAW9C,OARoB,IAAhBlB,EAAKtC,QAAmC,mBAAZsC,EAAK,IACnCN,EAASyB,KAAKnB,EAAK,IACnBkB,EAAWC,KAAKnB,EAAK,KACZA,EAAKtC,OAAS,GAEvBgC,EAASyB,QAAQnB,EAAKoB,MAAM,EAAGpB,EAAKtC,OAAS,IAGxC,IAAIkD,EACTG,KAAKtE,MACLsE,KAAKD,MAAM1B,OAAO,CAChB,CACEjC,MAAQV,IACN,IAAI4E,EAAoC,CAAxC,EACA,MAAMpE,EAAUP,QACdgD,EAASE,KAAM7C,GACbD,EAAaC,EAASN,EAAO,CAACc,EAAKd,KACjC4E,EAAS9D,GAAOd,CACjB,KACEyE,EAAWvD,MAAOoC,GAAcA,EAAUtD,KAEjD,MAAO,CACLQ,UACAR,MACEQ,GAAWG,OAAOC,KAAKgE,GAAU3D,OAC7Bb,KAA8BwE,EAC5BA,EAASxE,GACTwE,EACF5E,EAPD,EAUTwE,aAIP,CAEDnB,KACEC,EACAkB,GAEA,WAAWL,EACTG,KAAKtE,MACLsE,KAAKD,MAAM1B,OAAO,CAChB,CACEjC,MAAQV,IAAW,CACjBQ,QAASP,QAAQqD,EAAUtD,IAC3BA,UAEFwE,aAIP,CAEDK,UACEL,GAEA,OAAO,IAAIL,EACTG,KAAKtE,MACLsE,KAAKD,MAAM1B,OAAO,CAChB,CACEjC,MAAQV,IAAD,CACLQ,SAAS,EACTR,UAEFwE,cAGJM,KACH,CAEDC,aACE,OAAOT,KAAKQ,KACb,CAEDA,MACE,IACIN,EADAI,EAAWN,KAAKtE,MAGpB,IAAK,IAAIoB,EAAI,EAAGA,EAAIkD,KAAKD,MAAMpD,OAAQG,IAAK,CAC1C,MAAM4D,EAAQV,KAAKD,MAAMjD,GACnB6D,EAAcD,EAAMtE,MAAM4D,KAAKtE,OACrC,GAAIiF,EAAYzE,QAAS,CACvBoE,EAAWK,EAAYjF,MACvBwE,EAAUQ,EAAMR,QAChB,KACD,CACF,CACD,IAAKA,EAAS,CACZ,IAAIU,EACJ,IACEA,EAAiBC,KAAKC,UAAUd,KAAKtE,MAGtC,CAFC,MAAOqF,GACPH,EAAiBZ,KAAKtE,KACvB,CACD,MAAUsF,IAAAA,0DAC4CJ,IAEvD,CACD,OAAOV,EAAQI,EAAUN,KAAKtE,MAC/B,WCjHauF,KACXhC,GAEH,GAAoB,IAAhBA,EAAKtC,OAAc,CACrB,MAAOX,GAAWiD,EAClB,OAAQvD,GACNK,EAAaC,EAASN,EAAO,OAChC,CACD,GAAoB,IAAhBuD,EAAKtC,OAAc,CACrB,MAAOX,EAASN,GAASuD,EACzB,OAAOlD,EAAaC,EAASN,EAAO,OACrC,CAED,MAAUsF,IAAAA,MACR,oFAAoF/B,EAAKtC,UAE5F"} |
@@ -1,1 +0,1 @@ | ||
| {"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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","match","matched","_matcher$match","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","selector","undefined","array","_ref2","intersection","_ref3","patterns","slice","arguments","union","_ref4","some","not","_ref5","when","predicate","_ref6","_ref7","args","_selections","any","_","string","number","boolean","bigint","symbol","nullish","classConstructor","val","isInstanceOf","MatchExpression","cases","this","_proto","prototype","handler","predicates","push","apply","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error"],"mappings":"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"} | ||
| {"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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","MatchExpression","cases","this","handler","predicates","push","apply","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching","_args2"],"mappings":"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"} |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"index.modern.js","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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","matched","selections","match","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","selector","undefined","array","intersection","patterns","union","some","not","when","predicate","args","any","_","string","number","boolean","bigint","symbol","nullish","classConstructor","val","isInstanceOf","MatchExpression","constructor","cases","this","with","handler","predicates","push","slice","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching"],"mappings":"AAkBaA,MAAAA,EAAUC,OAAO,uBAMjBC,EAAqB,mCCbrBC,EAAYC,GACvBC,QAAQD,GAA0B,iBAAVA,GAGbE,EACXC,GAEgBA,OACYC,GAYjBC,EAAe,CAC1BC,EACAN,EACAO,KAEA,GAAIR,EAASO,GAAU,CACrB,GAAIJ,EAAUI,GAAU,CACtB,MAAMV,EAAUU,EAAQF,MAClBI,QAAEA,EAAFC,WAAWA,GAAeb,EAAQc,MAAMV,GAI9C,OAHIQ,GAAWC,GACbE,OAAOC,KAAKH,GAAYI,QAASC,GAAQP,EAAOO,EAAKL,EAAWK,KAE3DN,CACR,CAED,IAAKT,EAASC,GAAQ,OAAO,EAE7B,GAAIe,MAAMC,QAAQV,GAChB,QAAKS,MAAMC,QAAQhB,IAEZM,EAAQW,SAAWjB,EAAMiB,QAC5BX,EAAQY,MAAM,CAACC,EAAYC,IACzBf,EAAac,EAAYnB,EAAMoB,GAAIb,IAK3C,GAAID,aAAmBe,IACrB,OAAMrB,aAAiBqB,KAChBN,MAAMO,KAAKhB,EAAQM,QAAQM,MAAOJ,GACvCT,EAAaC,EAAQiB,IAAIT,GAAMd,EAAMuB,IAAIT,GAAMP,IAInD,GAAID,aAAmBkB,IAAK,CAC1B,KAAMxB,aAAiBwB,KAAM,OAAA,EAE7B,GAAqB,IAAjBlB,EAAQmB,KAAY,OAAsB,IAAfzB,EAAMyB,KAErC,GAAqB,IAAjBnB,EAAQmB,KAAY,CACtB,MAAON,GAAcJ,MAAMO,KAAKhB,EAAQoB,UACxC,OAAOxB,EAAUiB,GACbJ,MAAMO,KAAKtB,EAAM0B,UAAUR,MAAOS,GAChCtB,EAAac,EAAYQ,EAAGpB,IAE9BP,EAAM4B,IAAIT,EACf,CAED,OAAOJ,MAAMO,KAAKhB,EAAQoB,UAAUR,MAAOC,GACzCnB,EAAM4B,IAAIT,GAEb,CAED,OAAOR,OAAOC,KAAKN,GAASY,MAAOW,IAEjC,MAAMV,EAAab,EAAQuB,GAE3B,OACGA,KAAK7B,GA/DLE,EAFPC,EAiEuCgB,IA/DqB,aAArChB,EAAEC,KAAmB0B,cAgEtCzB,EACEc,EAEAnB,EAAM6B,GACNtB,GAtERJ,KAkEkB,EAQjB,CAED,OAAOQ,OAAOoB,GAAG/B,EAAOM,EAAjB,EAII0B,EAAoB1B,IAEL,IAAA2B,EAAAC,EAAAC,EAD1B,OAAIpC,EAASO,GACPJ,EAAUI,GAC8C,SAAnD,UAAAA,EAAAA,EAAQF,MAAmB4B,uBAA3B,EAAAE,EAAAE,KAAAD,IAAmDF,EAAA,GAExDlB,MAAMC,QAAQV,GAAiB+B,EAAQ/B,EAAS0B,GAC7CK,EAAQ1B,OAAOe,OAAOpB,GAAU0B,GAElC,EACR,EAGYK,EAAU,CAAOC,EAASC,IACrCD,EAAGE,OAAY,CAACC,EAAKC,IAAMD,EAAIE,OAAOJ,EAAEG,IAAK,IC3E/BE,SAAAA,EAGdtC,GACA,MAAO,CACLV,CAACQ,GAAgB,KACR,CACLM,MAAWV,IACT,IAAIS,EAAwC,CAAA,EAC5C,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,GAAOd,CAAAA,EAEpB,YAAc8C,IAAV9C,GACFgC,EAAiB1B,GAASO,QAASC,GACjC+B,EAAS/B,OAAKgC,IAET,CAAEtC,SAAS,EAAMC,eAGnB,CAAED,QADOH,EAAaC,EAASN,EAAO6C,GAC3BpC,aAAX,EAETuB,iBAAkB,IAAMA,EAAiB1B,GACzCwB,YAAa,aAIpB,CAcK,SAAUiB,EAGdzC,GACA,MAAO,CACLV,CAACQ,GAAD,KACS,CACLM,MAAWV,IACT,IAAKe,MAAMC,QAAQhB,GAAQ,MAAO,CAAEQ,SAAS,GAE7C,IAAIC,EAAwC,CAA5C,EAEA,GAAqB,IAAjBT,EAAMiB,OAIR,OAHAe,EAAiB1B,GAASO,QAASC,IACjCL,EAAWK,GAAO,EAAA,GAEb,CAAEN,SAAS,EAAMC,cAG1B,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,IAAQL,EAAWK,IAAQ,IAAI6B,OAAO,CAAC3C,KAOpD,MAAO,CAAEQ,QAJOR,EAAMkB,MAAOS,GAC3BtB,EAAaC,EAASqB,EAAGkB,IAGTpC,aAAX,EAETuB,iBAAkB,IAAMA,EAAiB1B,KAIhD,CAqBe,SAAA0C,KAKXC,GACH,MAAO,CACLrD,CAACQ,GAAkB,KAAO,CACxBM,MAAQV,IACN,IAAIS,EAAwC,CAA5C,EACA,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,GAAOd,CACnB,EAID,MAAO,CAAEQ,QAHQyC,EAA8B/B,MAAOwB,GACpDrC,EAAaqC,EAAG1C,EAAO6C,IAEPpC,aAAX,EAETuB,iBAAkB,IAChBK,EAAQY,EAA8BjB,GACxCF,YAAa,QAGlB,CAee,SAAAoB,KAKXD,GACH,MAAO,CACLrD,CAACQ,GAAkB,MACjBM,MAAWV,IACT,IAAIS,EAAwC,CAA5C,EACA,MAAMoC,EAAW,CAAC/B,EAAad,KAC7BS,EAAWK,GAAOd,CACnB,EAOD,OANAqC,EAAQY,EAA8BjB,GAAkBnB,QAASC,GAC/D+B,EAAS/B,OAAKgC,IAKT,CAAEtC,QAHQyC,EAA8BE,KAAMT,GACnDrC,EAAaqC,EAAG1C,EAAO6C,IAEPpC,aAAX,EAETuB,iBAAkB,IAChBK,EAAQY,EAA8BjB,GACxCF,YAAa,OAGlB,CAaK,SAAUsB,EAGd9C,GACA,MAAO,CACLV,CAACQ,GAAkB,KAAA,CACjBM,MAAWV,IAAJ,CACLQ,SAAUH,EAAaC,EAASN,EAAO,UAEzCgC,iBAAkB,IAAM,GACxBF,YAAa,QAGlB,CAsBeuB,SAAAA,EACdC,GAKA,MAAO,CACL1D,CAACQ,GAAkB,KAAA,CACjBM,MAAWV,IAAsB,CAC/BQ,QAASP,QAAQqD,EAAUtD,QAIlC,CA6Be,SAAAO,KACXgD,GAEH,MAAMzC,EACe,iBAAZyC,EAAK,GAAkBA,EAAK,QAAKT,EACpCxC,EACY,IAAhBiD,EAAKtC,OACDsC,EAAK,GACc,iBAAZA,EAAK,QACZT,EACAS,EAAK,GACX,MAAO,CACL3D,CAACQ,GAAD,KACS,CACLM,MAAQV,IACN,IAAIS,EAAsC,CACxC,CAACK,MAAAA,EAAAA,EAAOV,GAA6BJ,GAKvC,MAAO,CACLQ,aACcsC,IAAZxC,GAEID,EAAaC,EAASN,EAPb,CAACc,EAAad,KAC7BS,EAAWK,GAAOd,CACnB,GAMCS,WAAYA,EALP,EAQTuB,iBAAkB,IAChB,CAAClB,MAAAA,EAAAA,EAAOV,GAA4BuC,YACtBG,IAAZxC,EAAwB,GAAK0B,EAAiB1B,MAKzD,CA8CYkD,MAAAA,EAAMH,EA5CnB,SAAmBlD,GACjB,OAAO,CACR,GAsDYsD,EAAID,EAYJE,EAASL,EA5DtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GAqEYwD,EAASN,EA3EtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GAmFYyD,EAAUP,EA7EvB,SAAsBlD,GACpB,MAAoB,kBAANA,CACf,GAqFY0D,EAASR,EAnFtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GA2FY2D,EAAST,EAzFtB,SAAqBlD,GACnB,MAAoB,iBAANA,CACf,GAiGY4D,EAAUV,EA/FvB,SAAsBlD,GACpB,OAAOA,OACR,sKAuGK,SACJ6D,GAEA,OAAOX,EAtGT,SAAgDW,GAC9C,OAAQC,GACNA,aAAeD,CAClB,CAmGaE,CAAaF,GAC1B,mBA4CC,MAAO,CACLjB,MAAOA,EACPH,SAAUA,EACVI,aAAcA,EACdE,MAAOA,EACPE,IAAKA,EACL7C,OAAQA,EACR8C,KAAMA,EAET,GC1eY3C,MAAAA,EACXV,GACyB,IAAImE,EAAgBnE,EAAO,IAWtD,MAAMmE,EACJC,YACUpE,EACAqE,GADArE,KAAAA,WACAqE,EAAAA,KAAAA,WADA,EAAAC,KAAKtE,MAALA,EACAsE,KAAKD,MAALA,CAIN,CAEJE,QAAQhB,GACN,MAAMiB,EAAUjB,EAAKA,EAAKtC,OAAS,GAE7BgC,EAAyB,CAACM,EAAK,IAC/BkB,EAAwC,GAW9C,OARoB,IAAhBlB,EAAKtC,QAAmC,mBAAZsC,EAAK,IACnCN,EAASyB,KAAKnB,EAAK,IACnBkB,EAAWC,KAAKnB,EAAK,KACZA,EAAKtC,OAAS,GAEvBgC,EAASyB,QAAQnB,EAAKoB,MAAM,EAAGpB,EAAKtC,OAAS,IAGxC,IAAIkD,EACTG,KAAKtE,MACLsE,KAAKD,MAAM1B,OAAO,CAChB,CACEjC,MAAQV,IACN,IAAI4E,EAAoC,CAAxC,EACA,MAAMpE,EAAUP,QACdgD,EAASE,KAAM7C,GACbD,EAAaC,EAASN,EAAO,CAACc,EAAKd,KACjC4E,EAAS9D,GAAOd,CACjB,KACEyE,EAAWvD,MAAOoC,GAAcA,EAAUtD,KAEjD,MAAO,CACLQ,UACAR,MACEQ,GAAWG,OAAOC,KAAKgE,GAAU3D,OAC7Bb,KAA8BwE,EAC5BA,EAASxE,GACTwE,EACF5E,EAPD,EAUTwE,aAIP,CAEDnB,KACEC,EACAkB,GAEA,WAAWL,EACTG,KAAKtE,MACLsE,KAAKD,MAAM1B,OAAO,CAChB,CACEjC,MAAQV,IAAW,CACjBQ,QAASP,QAAQqD,EAAUtD,IAC3BA,UAEFwE,aAIP,CAEDK,UACEL,GAEA,OAAO,IAAIL,EACTG,KAAKtE,MACLsE,KAAKD,MAAM1B,OAAO,CAChB,CACEjC,MAAQV,IAAD,CACLQ,SAAS,EACTR,UAEFwE,cAGJM,KACH,CAEDC,aACE,OAAOT,KAAKQ,KACb,CAEDA,MACE,IACIN,EADAI,EAAWN,KAAKtE,MAGpB,IAAK,IAAIoB,EAAI,EAAGA,EAAIkD,KAAKD,MAAMpD,OAAQG,IAAK,CAC1C,MAAM4D,EAAQV,KAAKD,MAAMjD,GACnB6D,EAAcD,EAAMtE,MAAM4D,KAAKtE,OACrC,GAAIiF,EAAYzE,QAAS,CACvBoE,EAAWK,EAAYjF,MACvBwE,EAAUQ,EAAMR,QAChB,KACD,CACF,CACD,IAAKA,EAAS,CACZ,IAAIU,EACJ,IACEA,EAAiBC,KAAKC,UAAUd,KAAKtE,MAGtC,CAFC,MAAOqF,GACPH,EAAiBZ,KAAKtE,KACvB,CACD,MAAUsF,IAAAA,0DAC4CJ,IAEvD,CACD,OAAOV,EAAQI,EAAUN,KAAKtE,MAC/B,WCjHauF,KACXhC,GAEH,GAAoB,IAAhBA,EAAKtC,OAAc,CACrB,MAAOX,GAAWiD,EAClB,OAAQvD,GACNK,EAAaC,EAASN,EAAO,OAChC,CACD,GAAoB,IAAhBuD,EAAKtC,OAAc,CACrB,MAAOX,EAASN,GAASuD,EACzB,OAAOlD,EAAaC,EAASN,EAAO,OACrC,CAED,MAAUsF,IAAAA,MACR,oFAAoF/B,EAAKtC,UAE5F"} | ||
| {"version":3,"file":"index.modern.js","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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","matched","selections","match","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","selector","undefined","array","patterns","union","some","not","when","predicate","args","any","_","string","number","boolean","bigint","symbol","nullish","classConstructor","val","isInstanceOf","typed","intersection","MatchExpression","constructor","cases","this","with","handler","predicates","push","slice","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching"],"mappings":"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"} |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"index.module.js","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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","match","matched","_matcher$match","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","selector","undefined","array","_ref2","intersection","_ref3","patterns","slice","arguments","union","_ref4","some","not","_ref5","when","predicate","_ref6","_ref7","args","_selections","any","_","string","number","boolean","bigint","symbol","nullish","classConstructor","val","isInstanceOf","MatchExpression","cases","this","_proto","prototype","handler","predicates","push","apply","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching"],"mappings":"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"} | ||
| {"version":3,"file":"index.module.js","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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","MatchExpression","cases","this","handler","predicates","push","apply","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching","_args2"],"mappings":"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"} |
@@ -1,1 +0,1 @@ | ||
| {"version":3,"file":"index.umd.js","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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","match","matched","_matcher$match","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","selector","undefined","array","_ref2","intersection","_ref3","patterns","slice","arguments","union","_ref4","some","not","_ref5","when","predicate","_ref6","_ref7","args","_selections","any","_","string","number","boolean","bigint","symbol","nullish","classConstructor","val","isInstanceOf","MatchExpression","cases","this","_proto","prototype","handler","predicates","push","apply","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error"],"mappings":"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"} | ||
| {"version":3,"file":"index.umd.js","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';\nimport { SelectionType } from '../types/FindSelected';\nimport { Pattern, Matcher, MatcherType } from '../types/Pattern';\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 { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';\nimport * as symbols from './internals/symbols';\nimport { GuardFunction } from './types/helpers';\nimport { InvertPattern } from './types/InvertPattern';\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';\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 `P.infer` documentation 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 `P.optional` documentation 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 Array<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 `P.array` documentation 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 `P.intersection` documentation 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 `P.union` documentation 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 `P.not` documentation 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<\n input,\n p extends unknown extends input ? UnknownPattern : Pattern<input> | undefined\n>(pattern: p): 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 `P.when` documentation 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 `P.select` documentation 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 `P.any` documentation 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 `P._` documentation 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 `P.string` documentation 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 `P.number` documentation 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 `P.boolean` documentation 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 `P.bigint` documentation 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 `P.symbol` documentation 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 `P.nullish` documentation 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 `P.instanceOf` documentation 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 `P.typed` documentation 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';\nimport { GuardValue } from './types/helpers';\nimport { Match, PickReturnValue } from './types/Match';\nimport * as symbols from './internals/symbols';\nimport { matchPattern } from './internals/helpers';\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 `match` documentation 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 const match = <input, output = symbols.unset>(\n value: input\n): Match<input, output> => new MatchExpression(value, []) as any;\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';\nimport { MatchedValue } from './types/Match';\nimport * as P from './patterns';\nimport { matchPattern } from './internals/helpers';\n\n/**\n * `isMatching` takes pattern and returns a **type guard** function, cheching if a value matches this pattern.\n *\n * [Read `isMatching` documentation 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 `isMatching` documentation 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","MatchExpression","cases","this","handler","predicates","push","apply","selected","otherwise","run","exhaustive","entry","matchResult","displayedValue","JSON","stringify","e","Error","isMatching","_args2"],"mappings":"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"} |
@@ -55,1 +55,3 @@ export declare type ValueOf<a> = a extends any[] ? a[number] : a[keyof a]; | ||
| export declare type GuardFunction<input, narrowed> = ((value: input) => value is Cast<narrowed, input>) | ((value: input) => boolean); | ||
| export declare type Some<bools extends boolean[]> = true extends bools[number] ? true : false; | ||
| export declare type All<bools extends boolean[]> = bools[number] extends true ? true : false; |
| import { DeepExclude } from './DeepExclude'; | ||
| import { IsPlainObject, Primitives, IsLiteral, ValueOf, Compute, Cast, Equal } from './helpers'; | ||
| import type { Matcher, ToExclude } from './Pattern'; | ||
| import type { Matcher, Pattern, ToExclude } from './Pattern'; | ||
| declare type OptionalKeys<p> = ValueOf<{ | ||
@@ -43,41 +43,44 @@ [k in keyof p]: p[k] extends Matcher<any, any, infer matcherType> ? matcherType extends 'optional' ? k : never : never; | ||
| }> : never : p; | ||
| export declare type ReduceIntersectionForExclude<tuple extends any[], i, output = unknown> = tuple extends readonly [infer p, ...infer tail] ? ReduceIntersectionForExclude<tail, i, output & InvertPatternForExclude<p, i, unknown>> : output; | ||
| export declare type ReduceUnionForExclude<tuple extends any[], i, output = never> = tuple extends readonly [infer p, ...infer tail] ? ReduceUnionForExclude<tail, i, output | InvertPatternForExclude<p, i, never>> : output; | ||
| declare type ExcludeIfExists<a, b> = [b] extends [never] ? never : DeepExclude<a, b> extends infer excluded ? Equal<a, excluded> extends true ? unknown : excluded : never; | ||
| export declare type ReduceIntersectionForExclude<tuple extends any[], i, output = unknown> = tuple extends readonly [infer p, ...infer tail] ? ReduceIntersectionForExclude<tail, i, output & InvertPatternForExcludeInternal<p, i, unknown>> : output; | ||
| export declare type ReduceUnionForExclude<tuple extends any[], i, output = never> = tuple extends readonly [infer p, ...infer tail] ? ReduceUnionForExclude<tail, i, output | InvertPatternForExcludeInternal<p, i, never>> : output; | ||
| declare type ExcludeIfExists<a, b> = [ | ||
| b | ||
| ] extends [never] ? never : unknown extends a ? never : DeepExclude<a, b>; | ||
| /** | ||
| * ### InvertPatternForExclude | ||
| */ | ||
| export declare type InvertPatternForExclude<p, i, empty = never> = p extends Matcher<infer matchableInput, infer subpattern, infer matcherType, any, infer excluded> ? { | ||
| select: InvertPatternForExclude<subpattern, i, empty>; | ||
| array: i extends readonly (infer ii)[] ? InvertPatternForExclude<subpattern, ii, empty>[] : empty; | ||
| optional: InvertPatternForExclude<subpattern, i, empty> | undefined; | ||
| export declare type InvertPatternForExclude<p, i> = Equal<p, Pattern<i>> extends true ? never : InvertPatternForExcludeInternal<p, i>; | ||
| declare type InvertPatternForExcludeInternal<p, i, empty = never> = p extends Matcher<infer matchableInput, infer subpattern, infer matcherType, any, infer excluded> ? { | ||
| select: InvertPatternForExcludeInternal<subpattern, i, empty>; | ||
| array: i extends readonly (infer ii)[] ? InvertPatternForExcludeInternal<subpattern, ii, empty>[] : empty; | ||
| optional: InvertPatternForExcludeInternal<subpattern, i, empty> | undefined; | ||
| and: ReduceIntersectionForExclude<Cast<subpattern, any[]>, i>; | ||
| or: ReduceUnionForExclude<Cast<subpattern, any[]>, i>; | ||
| not: ExcludeIfExists<unknown extends matchableInput ? i : matchableInput, InvertPatternForExclude<subpattern, i>>; | ||
| not: ExcludeIfExists<unknown extends matchableInput ? i : matchableInput, InvertPatternForExcludeInternal<subpattern, i>>; | ||
| default: excluded; | ||
| }[matcherType] : p extends Primitives ? IsLiteral<p> extends true ? p : IsLiteral<i> extends true ? p : empty : p extends readonly (infer pp)[] ? i extends readonly (infer ii)[] ? p extends readonly [infer p1, infer p2, infer p3, infer p4, infer p5] ? i extends readonly [infer i1, infer i2, infer i3, infer i4, infer i5] ? readonly [ | ||
| InvertPatternForExclude<p1, i1, empty>, | ||
| InvertPatternForExclude<p2, i2, empty>, | ||
| InvertPatternForExclude<p3, i3, empty>, | ||
| InvertPatternForExclude<p4, i4, empty>, | ||
| InvertPatternForExclude<p5, i5, empty> | ||
| InvertPatternForExcludeInternal<p1, i1, empty>, | ||
| InvertPatternForExcludeInternal<p2, i2, empty>, | ||
| InvertPatternForExcludeInternal<p3, i3, empty>, | ||
| InvertPatternForExcludeInternal<p4, i4, empty>, | ||
| InvertPatternForExcludeInternal<p5, i5, empty> | ||
| ] : empty : p extends readonly [infer p1, infer p2, infer p3, infer p4] ? i extends readonly [infer i1, infer i2, infer i3, infer i4] ? readonly [ | ||
| InvertPatternForExclude<p1, i1, empty>, | ||
| InvertPatternForExclude<p2, i2, empty>, | ||
| InvertPatternForExclude<p3, i3, empty>, | ||
| InvertPatternForExclude<p4, i4, empty> | ||
| InvertPatternForExcludeInternal<p1, i1, empty>, | ||
| InvertPatternForExcludeInternal<p2, i2, empty>, | ||
| InvertPatternForExcludeInternal<p3, i3, empty>, | ||
| InvertPatternForExcludeInternal<p4, i4, empty> | ||
| ] : empty : p extends readonly [infer p1, infer p2, infer p3] ? i extends readonly [infer i1, infer i2, infer i3] ? readonly [ | ||
| InvertPatternForExclude<p1, i1, empty>, | ||
| InvertPatternForExclude<p2, i2, empty>, | ||
| InvertPatternForExclude<p3, i3, empty> | ||
| InvertPatternForExcludeInternal<p1, i1, empty>, | ||
| InvertPatternForExcludeInternal<p2, i2, empty>, | ||
| InvertPatternForExcludeInternal<p3, i3, empty> | ||
| ] : empty : p extends readonly [infer p1, infer p2] ? i extends readonly [infer i1, infer i2] ? readonly [ | ||
| InvertPatternForExclude<p1, i1, empty>, | ||
| InvertPatternForExclude<p2, i2, empty> | ||
| ] : empty : p extends readonly [infer p1] ? i extends readonly [infer i1] ? readonly [InvertPatternForExclude<p1, i1, empty>] : empty : p extends readonly [] ? [] : InvertPatternForExclude<pp, ii, empty>[] : empty : p extends Map<infer pk, infer pv> ? i extends Map<any, infer iv> ? Map<pk, InvertPatternForExclude<pv, iv, empty>> : empty : p extends Set<infer pv> ? i extends Set<infer iv> ? Set<InvertPatternForExclude<pv, iv, empty>> : empty : IsPlainObject<p> extends true ? i extends object ? [keyof p & keyof i] extends [never] ? empty : OptionalKeys<p> extends infer optKeys ? [optKeys] extends [never] ? { | ||
| readonly [k in keyof p]: k extends keyof i ? InvertPatternForExclude<p[k], i[k], empty> : InvertPattern<p[k]>; | ||
| InvertPatternForExcludeInternal<p1, i1, empty>, | ||
| InvertPatternForExcludeInternal<p2, i2, empty> | ||
| ] : empty : p extends readonly [infer p1] ? i extends readonly [infer i1] ? readonly [InvertPatternForExcludeInternal<p1, i1, empty>] : empty : p extends readonly [] ? [] : InvertPatternForExcludeInternal<pp, ii, empty>[] : empty : p extends Map<infer pk, infer pv> ? i extends Map<any, infer iv> ? Map<pk, InvertPatternForExcludeInternal<pv, iv, empty>> : empty : p extends Set<infer pv> ? i extends Set<infer iv> ? Set<InvertPatternForExcludeInternal<pv, iv, empty>> : empty : IsPlainObject<p> extends true ? i extends object ? [keyof p & keyof i] extends [never] ? empty : OptionalKeys<p> extends infer optKeys ? [optKeys] extends [never] ? { | ||
| readonly [k in keyof p]: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPattern<p[k]>; | ||
| } : Compute<{ | ||
| readonly [k in Exclude<keyof p, optKeys>]: k extends keyof i ? InvertPatternForExclude<p[k], i[k], empty> : InvertPattern<p[k]>; | ||
| readonly [k in Exclude<keyof p, optKeys>]: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPattern<p[k]>; | ||
| } & { | ||
| readonly [k in Cast<optKeys, keyof p>]?: k extends keyof i ? InvertPatternForExclude<p[k], i[k], empty> : InvertPattern<p[k]>; | ||
| readonly [k in Cast<optKeys, keyof p>]?: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPattern<p[k]>; | ||
| }> : empty : empty : empty; | ||
| export {}; |
+39
-32
| import type * as symbols from '../internals/symbols'; | ||
| import type { Pattern, Matcher } from './Pattern'; | ||
| import type { Pattern } from './Pattern'; | ||
| import type { ExtractPreciseValue } from './ExtractPreciseValue'; | ||
@@ -17,3 +17,3 @@ import type { InvertPatternForExclude, InvertPattern } from './InvertPattern'; | ||
| */ | ||
| export declare type Match<i, o, patternValueTuples extends [any, any][] = [], inferredOutput = never> = { | ||
| export declare type Match<i, o, patternValueTuples extends any[] = [], inferredOutput = never> = { | ||
| /** | ||
@@ -25,8 +25,14 @@ * `.with(pattern, handler)` Registers a pattern and an handler function which | ||
| **/ | ||
| with<p extends Pattern<i>, c, value extends MatchedValue<i, InvertPattern<p>>>(pattern: p, handler: (selections: FindSelected<value, p>, value: value) => PickReturnValue<o, c>): Match<i, o, [...patternValueTuples, [p, value]], Union<inferredOutput, c>>; | ||
| with<p1 extends Pattern<i>, p2 extends Pattern<i>, c, p extends p1 | p2, value extends p extends any ? MatchedValue<i, InvertPattern<p>> : never>(p1: p1, p2: p2, handler: (value: value) => PickReturnValue<o, c>): Match<i, o, [ | ||
| with<p extends Pattern<i>, c, value extends MatchedValue<i, InvertPattern<p>>, x = InvertPatternForExclude<p, value>>(pattern: p, handler: (selections: FindSelected<value, p>, value: value) => PickReturnValue<o, c>): [InvertPatternForExclude<p, value>] extends [infer excluded] ? Match<Exclude<i, excluded>, o, [ | ||
| ...patternValueTuples, | ||
| [p1, value], | ||
| [p2, value] | ||
| ], Union<inferredOutput, c>>; | ||
| excluded | ||
| ], Union<inferredOutput, c>> : never; | ||
| with<p1 extends Pattern<i>, p2 extends Pattern<i>, c, p extends p1 | p2, value extends p extends any ? MatchedValue<i, InvertPattern<p>> : never>(p1: p1, p2: p2, handler: (value: value) => PickReturnValue<o, c>): [ | ||
| InvertPatternForExclude<p1, value>, | ||
| InvertPatternForExclude<p2, value> | ||
| ] extends [infer excluded1, infer excluded2] ? Match<Exclude<i, excluded1 | excluded2>, o, [ | ||
| ...patternValueTuples, | ||
| excluded1, | ||
| excluded2 | ||
| ], Union<inferredOutput, c>> : never; | ||
| with<p1 extends Pattern<i>, p2 extends Pattern<i>, p3 extends Pattern<i>, ps extends Pattern<i>[], c, p extends p1 | p2 | p3 | ps[number], value extends p extends any ? MatchedValue<i, InvertPattern<p>> : never>(...args: [ | ||
@@ -38,19 +44,23 @@ p1: p1, | ||
| handler: (value: value) => PickReturnValue<o, c> | ||
| ]): Match<i, o, [ | ||
| ]): [ | ||
| InvertPatternForExclude<p1, value>, | ||
| InvertPatternForExclude<p2, value>, | ||
| InvertPatternForExclude<p3, value>, | ||
| MakeTuples<ps, value> | ||
| ] extends [ | ||
| infer excluded1, | ||
| infer excluded2, | ||
| infer excluded3, | ||
| infer excludedRest extends any[] | ||
| ] ? Match<Exclude<i, excluded1 | excluded2 | excluded3 | excludedRest[number]>, o, [ | ||
| ...patternValueTuples, | ||
| [ | ||
| p1, | ||
| value | ||
| ], | ||
| [ | ||
| p2, | ||
| value | ||
| ], | ||
| [ | ||
| p3, | ||
| value | ||
| ], | ||
| ...MakeTuples<ps, value> | ||
| ], Union<inferredOutput, c>>; | ||
| with<pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat>>) => unknown, c, value extends GuardValue<pred>>(pattern: pat, predicate: pred, handler: (selections: FindSelected<value, pat>, value: value) => PickReturnValue<o, c>): Match<i, o, pred extends (value: any) => value is infer narrowed ? [...patternValueTuples, [Matcher<unknown, narrowed>, value]] : patternValueTuples, Union<inferredOutput, c>>; | ||
| excluded1, | ||
| excluded2, | ||
| excluded3, | ||
| ...excludedRest | ||
| ], Union<inferredOutput, c>> : never; | ||
| with<pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat>>) => unknown, c, value extends GuardValue<pred>>(pattern: pat, predicate: pred, handler: (selections: FindSelected<value, pat>, value: value) => PickReturnValue<o, c>): pred extends (value: any) => value is infer narrowed ? Match<Exclude<i, narrowed>, o, [ | ||
| ...patternValueTuples, | ||
| narrowed | ||
| ], Union<inferredOutput, c>> : Match<i, o, patternValueTuples, Union<inferredOutput, c>>; | ||
| /** | ||
@@ -62,3 +72,6 @@ * `.when(predicate, handler)` Registers a predicate function and an handler function. | ||
| **/ | ||
| when<pred extends (value: i) => unknown, c, value extends GuardValue<pred>>(predicate: pred, handler: (value: value) => PickReturnValue<o, c>): Match<i, o, pred extends (value: any) => value is infer narrowed ? [...patternValueTuples, [Matcher<unknown, narrowed>, value]] : patternValueTuples, Union<inferredOutput, c>>; | ||
| when<pred extends (value: i) => unknown, c, value extends GuardValue<pred>>(predicate: pred, handler: (value: value) => PickReturnValue<o, c>): pred extends (value: any) => value is infer narrowed ? Match<Exclude<i, narrowed>, o, [ | ||
| ...patternValueTuples, | ||
| narrowed | ||
| ], Union<inferredOutput, c>> : Match<i, o, patternValueTuples, Union<inferredOutput, c>>; | ||
| /** | ||
@@ -107,12 +120,6 @@ * `.otherwise()` takes a function returning the **default value**, and | ||
| */ | ||
| declare type DeepExcludeAll<a, tupleList extends any[]> = tupleList extends [ | ||
| [ | ||
| infer p, | ||
| infer v | ||
| ], | ||
| ...infer tail | ||
| ] ? DeepExcludeAll<DeepExclude<a, InvertPatternForExclude<p, v>>, tail> : a; | ||
| declare type DeepExcludeAll<a, tupleList extends any[]> = [a] extends [never] ? never : tupleList extends [infer matched, ...infer tail] ? DeepExcludeAll<DeepExclude<a, matched>, tail> : a; | ||
| declare type MakeTuples<ps extends any[], value> = { | ||
| -readonly [index in keyof ps]: [ps[index], value]; | ||
| -readonly [index in keyof ps]: InvertPatternForExclude<ps[index], value>; | ||
| }; | ||
| export {}; |
+2
-1
| { | ||
| "name": "ts-pattern", | ||
| "version": "4.0.6", | ||
| "version": "4.1.0", | ||
| "description": " The exhaustive Pattern Matching library for TypeScript.", | ||
@@ -27,2 +27,3 @@ "type": "module", | ||
| "dev": "microbundle watch", | ||
| "prepublishOnly": "npm run test && npm run build", | ||
| "test": "jest", | ||
@@ -29,0 +30,0 @@ "clear-test": "jest --clearCache", |
+0
-2
@@ -93,4 +93,2 @@ <h1 align="center">TS-Pattern</h1> | ||
| #### ⚠️ This is the docs for **TS-Pattern v4**. Find the docs for [**TS-Pattern v3 here**](https://github.com/gvergnaud/ts-pattern/tree/v3). | ||
| - [Code Sandbox Examples](#code-sandbox-examples) | ||
@@ -97,0 +95,0 @@ - [Getting Started](#getting-started) |
New alerts
Long strings
Supply chain riskContains long string literals, which may be a sign of obfuscated or packed code.
Found 1 instance in 1 package
URL strings
Supply chain riskPackage contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.
Found 1 instance in 1 package
Fixed alerts
Long strings
Supply chain riskContains long string literals, which may be a sign of obfuscated or packed code.
Found 1 instance in 1 package
URL strings
Supply chain riskPackage contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
287193
16.63%- Number of package files
29
7.41%- Lines of code
1289
34.55%Worsened metrics
- Number of lines in readme file
1390
-0.14%No dependency changes