modern-ts 0.8.0

package/dist/subpath/Maps.mjs

@@ -0,0 +1,123 @@
+function u(e, n) {
+  const o = /* @__PURE__ */ new Map();
+  for (const [t, r] of e)
+    n(r, t) && o.set(t, r);
+  return o;
+}
+const l = (e, n) => {
+  const o = /* @__PURE__ */ new Map();
+  for (const [t, r] of e)
+    o.set(t, n(r, t));
+  return o;
+}, f = (e, n) => {
+  const o = /* @__PURE__ */ new Map();
+  for (const [t, r] of e)
+    o.set(n(r, t), r);
+  return o;
+}, a = (e, n) => {
+  for (const [o, t] of e)
+    if (n(t, o)) return o;
+}, i = (e, n, o = (t, r) => t === r) => {
+  for (const t of e.values())
+    if (o(t, n)) return !0;
+  return !1;
+}, v = (e, n, o) => {
+  let t = o;
+  for (const [r, s] of e)
+    t = n(t, s, r);
+  return t;
+}, y = (e, n) => {
+  const o = {};
+  for (const [t, r] of e) {
+    const s = n(r, t);
+    o[s] = (o[s] || 0) + 1;
+  }
+  return o;
+}, _ = (e, n) => {
+  const o = /* @__PURE__ */ new Map();
+  for (const [t, r] of e) {
+    const s = n(r, t);
+    let c = o.get(s);
+    c || (c = [], o.set(s, c)), c.push([t, r]);
+  }
+  return o;
+}, k = (e, n) => {
+  const o = /* @__PURE__ */ new Map();
+  for (const t of n)
+    e.has(t) && o.set(t, e.get(t));
+  return o;
+}, d = (e, n) => {
+  const o = new Map(e), t = n instanceof Set ? n : new Set(n);
+  for (const r of t)
+    o.delete(r);
+  return o;
+}, p = (e, n) => {
+  for (const [o, t] of e)
+    n(t, o) || e.delete(o);
+  return e;
+}, g = (e, n) => {
+  for (const [o, t] of e)
+    e.set(o, n(t, o));
+  return e;
+}, w = (e, n) => {
+  for (const o of n)
+    e.delete(o);
+  return e;
+}, M = (e, n) => {
+  const o = n instanceof Set ? n : new Set(n);
+  for (const t of e.keys())
+    o.has(t) || e.delete(t);
+  return e;
+}, P = (e, n, o = (t, r) => r) => {
+  for (const [t, r] of n)
+    e.has(t) ? e.set(t, o(e.get(t), r, t)) : e.set(t, r);
+  return e;
+}, I = (e, n, o) => {
+  if (e.has(n))
+    return e.get(n);
+  const t = o(n);
+  return e.set(n, t), t;
+}, S = (e, n, o) => {
+  const t = e.get(n), r = o(t, n);
+  return e.set(n, r), e;
+}, h = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  countBy: y,
+  filter: u,
+  filterInPlace: p,
+  findKey: a,
+  getOrSetInPlace: I,
+  groupBy: _,
+  hasValue: i,
+  mapKeys: f,
+  mapValues: l,
+  mapValuesInPlace: g,
+  mergeInPlace: P,
+  omit: d,
+  omitInPlace: w,
+  pick: k,
+  pickInPlace: M,
+  reduce: v,
+  updateInPlace: S
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  h as M,
+  y as countBy,
+  u as filter,
+  p as filterInPlace,
+  a as findKey,
+  I as getOrSetInPlace,
+  _ as groupBy,
+  i as hasValue,
+  f as mapKeys,
+  l as mapValues,
+  g as mapValuesInPlace,
+  P as mergeInPlace,
+  d as omit,
+  w as omitInPlace,
+  k as pick,
+  M as pickInPlace,
+  v as reduce,
+  S as updateInPlace
+};
+//# sourceMappingURL=Maps.mjs.map

package/dist/subpath/Maps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Maps.mjs","sources":["../../src/Utils/Map.ts"],"sourcesContent":["// ============================================\r\n// ./src/Utils/Map.ts\r\n// ============================================\r\n\r\n/**\r\n * Filters a Map, keeping only entries that satisfy the predicate\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @template S - Narrowed value type (when using type guard predicate)\r\n * @param map - Map to filter\r\n * @param predicate - Function that returns true to keep entry, false to remove\r\n * @returns New Map with filtered entries\r\n * @remarks If the predicate is a type guard, returns Map<K, S>, otherwise Map<K, V>\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * filter(m, (v) => v > 1); // Map([['b', 2], ['c', 3]])\r\n * ```\r\n */\r\nexport function filter<K, V, S extends V>(\r\n  map: Map<K, V>,\r\n  predicate: (value: V, key: K) => value is S,\r\n): Map<K, S>;\r\nexport function filter<K, V>(\r\n  map: Map<K, V>,\r\n  predicate: (value: V, key: K) => boolean,\r\n): Map<K, V>;\r\nexport function filter<K, V>(\r\n  map: Map<K, V>,\r\n  predicate: (value: V, key: K) => boolean,\r\n): Map<K, V> {\r\n  const result = new Map<K, V>();\r\n  for (const [key, value] of map) {\r\n    if (predicate(value, key)) {\r\n      result.set(key, value);\r\n    }\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Creates a new Map with same keys but values transformed by iteratee\r\n *\r\n * @template K - Key type\r\n * @template V - Original value type\r\n * @template T - Transformed value type\r\n * @param map - Map to transform values of\r\n * @param iteratee - Function that transforms each value\r\n * @returns New Map with transformed values\r\n * @remarks Original Map is not modified\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2]]);\r\n * mapValues(m, v => v * 2); // Map([['a', 2], ['b', 4]])\r\n * ```\r\n */\r\nexport const mapValues = <K, V, T>(\r\n  map: Map<K, V>,\r\n  iteratee: (value: V, key: K) => T,\r\n): Map<K, T> => {\r\n  const result = new Map<K, T>();\r\n  for (const [key, value] of map) {\r\n    result.set(key, iteratee(value, key));\r\n  }\r\n  return result;\r\n};\r\n\r\n/**\r\n * Creates a new Map with same values but keys transformed by iteratee\r\n *\r\n * @template K - Original key type\r\n * @template V - Value type\r\n * @template T - Transformed key type\r\n * @param map - Map to transform keys of\r\n * @param iteratee - Function that transforms each key\r\n * @returns New Map with transformed keys\r\n * @remarks Duplicate transformed keys will overwrite previous entries\r\n * @example\r\n * ```typescript\r\n * const m = new Map([[1, 'a'], [2, 'b']]);\r\n * mapKeys(m, (v, k) => `key-${k}`); // Map([['key-1', 'a'], ['key-2', 'b']])\r\n * ```\r\n */\r\nexport const mapKeys = <K, V, T>(\r\n  map: Map<K, V>,\r\n  iteratee: (value: V, key: K) => T,\r\n): Map<T, V> => {\r\n  const result = new Map<T, V>();\r\n  for (const [key, value] of map) {\r\n    result.set(iteratee(value, key), value);\r\n  }\r\n  return result;\r\n};\r\n\r\n/**\r\n * Finds the first key that satisfies the predicate\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to search\r\n * @param predicate - Function that returns true for matching entry\r\n * @returns First matching key or undefined if none found\r\n * @remarks Iterates in insertion order, stops at first match\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * findKey(m, v => v > 1); // 'b'\r\n * ```\r\n */\r\nexport const findKey = <K, V>(\r\n  map: Map<K, V>,\r\n  predicate: (value: V, key: K) => boolean,\r\n): K | undefined => {\r\n  for (const [key, value] of map) {\r\n    if (predicate(value, key)) return key;\r\n  }\r\n  return undefined;\r\n};\r\n\r\n/**\r\n * Checks if Map contains a value matching target_value using comparator\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to search\r\n * @param target_value - Value to search for\r\n * @param comparator - Optional comparison function (defaults to ===)\r\n * @returns True if matching value found, false otherwise\r\n * @remarks Uses linear search, O(n) time\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', {id: 1}], ['b', {id: 2}]]);\r\n * hasValue(m, {id: 1}, (a, b) => a.id === b.id); // true\r\n * ```\r\n */\r\nexport const hasValue = <K, V>(\r\n  map: Map<K, V>,\r\n  target_value: V,\r\n  comparator: (a: V, b: V) => boolean = (a, b) => a === b,\r\n): boolean => {\r\n  for (const value of map.values()) {\r\n    if (comparator(value, target_value)) return true;\r\n  }\r\n  return false;\r\n};\r\n\r\n/**\r\n * Reduces Map to a single value using iteratee function\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @template T - Accumulator type\r\n * @param map - Map to reduce\r\n * @param iteratee - Function that updates accumulator with each entry\r\n * @param initial_value - Starting accumulator value\r\n * @returns Final accumulator value\r\n * @remarks Iterates in insertion order\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * reduce(m, (sum, v) => sum + v, 0); // 6\r\n * ```\r\n */\r\nexport const reduce = <K, V, T>(\r\n  map: Map<K, V>,\r\n  iteratee: (accumulator: T, value: V, key: K) => T,\r\n  initial_value: T,\r\n): T => {\r\n  let accumulator = initial_value;\r\n  for (const [key, value] of map) {\r\n    accumulator = iteratee(accumulator, value, key);\r\n  }\r\n  return accumulator;\r\n};\r\n\r\n/**\r\n * Groups Map entries by key derived from iteratee and counts occurrences\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to analyze\r\n * @param iteratee - Function that returns grouping key (string or number)\r\n * @returns Object with grouping keys as properties and counts as values\r\n * @remarks Keys are coerced to string for object property access\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 1]]);\r\n * countBy(m, v => v); // {1: 2, 2: 1}\r\n * ```\r\n */\r\nexport const countBy = <K, V>(\r\n  map: Map<K, V>,\r\n  iteratee: (value: V, key: K) => string | number,\r\n): Record<string | number, number> => {\r\n  const result: Record<string | number, number> = {};\r\n  for (const [key, value] of map) {\r\n    const group_key = iteratee(value, key);\r\n    result[group_key] = (result[group_key] || 0) + 1;\r\n  }\r\n  return result;\r\n};\r\n\r\n/**\r\n * Groups Map entries by key derived from iteratee\r\n *\r\n * @template K - Original key type\r\n * @template V - Value type\r\n * @template T - Grouping key type\r\n * @param map - Map to group\r\n * @param iteratee - Function that returns grouping key\r\n * @returns New Map with grouping keys and arrays of [K, V] entries\r\n * @remarks Each group contains original key-value pairs as arrays\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 1]]);\r\n * groupBy(m, v => v); // Map([[1, [['a', 1], ['c', 1]]], [2, [['b', 2]]]])\r\n * ```\r\n */\r\nexport const groupBy = <K, V, T>(\r\n  map: Map<K, V>,\r\n  iteratee: (value: V, key: K) => T,\r\n): Map<T, Array<[K, V]>> => {\r\n  const result = new Map<T, Array<[K, V]>>();\r\n  for (const [key, value] of map) {\r\n    const group_key = iteratee(value, key);\r\n    let group = result.get(group_key);\r\n    if (!group) {\r\n      group = [];\r\n      result.set(group_key, group);\r\n    }\r\n    group.push([key, value]);\r\n  }\r\n  return result;\r\n};\r\n\r\n/**\r\n * Creates new Map with only specified keys\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to pick from\r\n * @param keys - Iterable of keys to include\r\n * @returns New Map with selected keys\r\n * @remarks Keys not present in original Map are silently ignored\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * pick(m, ['a', 'c']); // Map([['a', 1], ['c', 3]])\r\n * ```\r\n */\r\nexport const pick = <K, V>(map: Map<K, V>, keys: Iterable<K>): Map<K, V> => {\r\n  const result = new Map<K, V>();\r\n  for (const key of keys) {\r\n    if (map.has(key)) {\r\n      result.set(key, map.get(key)!);\r\n    }\r\n  }\r\n  return result;\r\n};\r\n\r\n/**\r\n * Creates new Map without specified keys\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to omit from\r\n * @param keys - Iterable of keys to exclude\r\n * @returns New Map without specified keys\r\n * @remarks Keys not present in original Map are silently ignored\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * omit(m, ['b']); // Map([['a', 1], ['c', 3]])\r\n * ```\r\n */\r\nexport const omit = <K, V>(map: Map<K, V>, keys: Iterable<K>): Map<K, V> => {\r\n  const result = new Map(map);\r\n  const keys_to_delete = keys instanceof Set ? keys : new Set(keys);\r\n  for (const key of keys_to_delete) {\r\n    result.delete(key as K);\r\n  }\r\n  return result;\r\n};\r\n\r\n/**\r\n * Filters Map in-place, removing entries that don't satisfy predicate\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to filter (modified in-place)\r\n * @param predicate - Function that returns true to keep entry\r\n * @returns Same Map instance (mutated)\r\n * @remarks Modifies original Map, use filter() for immutable operation\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * filterInPlace(m, v => v > 1); // m is now Map([['b', 2], ['c', 3]])\r\n * ```\r\n */\r\nexport const filterInPlace = <K, V>(\r\n  map: Map<K, V>,\r\n  predicate: (value: V, key: K) => boolean,\r\n): Map<K, V> => {\r\n  for (const [key, value] of map) {\r\n    if (!predicate(value, key)) {\r\n      map.delete(key);\r\n    }\r\n  }\r\n  return map;\r\n};\r\n\r\n/**\r\n * Transforms Map values in-place\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to transform (modified in-place)\r\n * @param iteratee - Function that transforms each value\r\n * @returns Same Map instance (mutated)\r\n * @remarks Modifies original Map, use mapValues() for immutable operation\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2]]);\r\n * mapValuesInPlace(m, v => v * 2); // m is now Map([['a', 2], ['b', 4]])\r\n * ```\r\n */\r\nexport const mapValuesInPlace = <K, V>(\r\n  map: Map<K, V>,\r\n  iteratee: (value: V, key: K) => V,\r\n): Map<K, V> => {\r\n  for (const [key, value] of map) {\r\n    map.set(key, iteratee(value, key));\r\n  }\r\n  return map;\r\n};\r\n\r\n/**\r\n * Removes specified keys from Map in-place\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to modify (modified in-place)\r\n * @param keys - Iterable of keys to remove\r\n * @returns Same Map instance (mutated)\r\n * @remarks Modifies original Map, use omit() for immutable operation\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * omitInPlace(m, ['b']); // m is now Map([['a', 1], ['c', 3]])\r\n * ```\r\n */\r\nexport const omitInPlace = <K, V>(\r\n  map: Map<K, V>,\r\n  keys: Iterable<K>,\r\n): Map<K, V> => {\r\n  for (const key of keys) {\r\n    map.delete(key);\r\n  }\r\n  return map;\r\n};\r\n\r\n/**\r\n * Keeps only specified keys in Map in-place\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to modify (modified in-place)\r\n * @param keys - Iterable of keys to keep\r\n * @returns Same Map instance (mutated)\r\n * @remarks Modifies original Map, use pick() for immutable operation\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1], ['b', 2], ['c', 3]]);\r\n * pickInPlace(m, ['a', 'c']); // m is now Map([['a', 1], ['c', 3]])\r\n * ```\r\n */\r\nexport const pickInPlace = <K, V>(\r\n  map: Map<K, V>,\r\n  keys: Iterable<K>,\r\n): Map<K, V> => {\r\n  const keep_set = keys instanceof Set ? keys : new Set(keys);\r\n  for (const key of map.keys()) {\r\n    if (!keep_set.has(key)) {\r\n      map.delete(key);\r\n    }\r\n  }\r\n  return map;\r\n};\r\n\r\n/**\r\n * Merges source Map into target Map in-place\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param target - Map to merge into (modified in-place)\r\n * @param source - Map to merge from\r\n * @param resolve_conflict - Function to resolve key conflicts (default: source wins)\r\n * @returns Same target Map instance (mutated)\r\n * @remarks Modifies target Map, source Map is not modified\r\n * @example\r\n * ```typescript\r\n * const t = new Map([['a', 1], ['b', 2]]);\r\n * const s = new Map([['b', 20], ['c', 3]]);\r\n * mergeInPlace(t, s); // t is now Map([['a', 1], ['b', 20], ['c', 3]])\r\n * ```\r\n */\r\nexport const mergeInPlace = <K, V>(\r\n  target: Map<K, V>,\r\n  source: Map<K, V>,\r\n  resolve_conflict: (target_val: V, source_val: V, key: K) => V = (_t, s) => s,\r\n): Map<K, V> => {\r\n  for (const [key, value] of source) {\r\n    if (target.has(key)) {\r\n      target.set(key, resolve_conflict(target.get(key)!, value, key));\r\n    } else {\r\n      target.set(key, value);\r\n    }\r\n  }\r\n  return target;\r\n};\r\n\r\n/**\r\n * Gets value for key, setting it with default_factory if not present\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to access (modified in-place if key missing)\r\n * @param key - Key to get/set\r\n * @param default_factory - Function that creates default value when key missing\r\n * @returns Existing value or newly created default value\r\n * @remarks Modifies Map if key was not present (lazy initialization)\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1]]);\r\n * getOrSetInPlace(m, 'b', () => 100); // Returns 100, m now has 'b': 100\r\n * ```\r\n */\r\nexport const getOrSetInPlace = <K, V>(\r\n  map: Map<K, V>,\r\n  key: K,\r\n  default_factory: (key: K) => V,\r\n): V => {\r\n  if (map.has(key)) {\r\n    return map.get(key)!;\r\n  }\r\n  const new_value = default_factory(key);\r\n  map.set(key, new_value);\r\n  return new_value;\r\n};\r\n\r\n/**\r\n * Updates value for key using updater function\r\n *\r\n * @template K - Key type\r\n * @template V - Value type\r\n * @param map - Map to update (modified in-place)\r\n * @param key - Key to update\r\n * @param updater - Function that receives current value (or undefined) and returns new value\r\n * @returns Same Map instance (mutated)\r\n * @remarks Always sets the key, even if updater returns undefined (as value)\r\n * @example\r\n * ```typescript\r\n * const m = new Map([['a', 1]]);\r\n * updateInPlace(m, 'a', v => v ? v + 1 : 0); // m is now Map([['a', 2]])\r\n * ```\r\n */\r\nexport const updateInPlace = <K, V>(\r\n  map: Map<K, V>,\r\n  key: K,\r\n  updater: (value: V | undefined, key: K) => V,\r\n): Map<K, V> => {\r\n  const current_value = map.get(key);\r\n  const next_value = updater(current_value, key);\r\n  map.set(key, next_value);\r\n  return map;\r\n};\r\n"],"names":["filter","map","predicate","result","key","value","mapValues","iteratee","mapKeys","findKey","hasValue","target_value","comparator","a","b","reduce","initial_value","accumulator","countBy","group_key","groupBy","group","pick","keys","omit","keys_to_delete","filterInPlace","mapValuesInPlace","omitInPlace","pickInPlace","keep_set","mergeInPlace","target","source","resolve_conflict","_t","s","getOrSetInPlace","default_factory","new_value","updateInPlace","updater","current_value","next_value"],"mappings":"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"}

package/dist/subpath/Maybe.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../chunks/base-BvHqpP_s.cjs"),a=require("../chunks/helper-tsqZMRHW.cjs"),m=(o,t,n)=>e.isSome(o)?t(o):n();function A(o,t,n){return e.isSome(o)?t(o):n?.()}function u(o,t,n){return e.isNone(o)?t():n?.(o)}const w=(o,t)=>(e.isSome(o)&&t(o),o),d=(o,t)=>(e.isNone(o)&&t(),o);function S(o,{fnSome:t=()=>{},fnNone:n=()=>{}}){return e.isSome(o)?t(o):n(),o}async function y(o,t,n,r){r?.throwIfAborted();const s=await o;if(e.isSome(s)){const c=await a.dynamicAwait(t(s,r));return r?.throwIfAborted(),c}else{const c=await a.dynamicAwait(n(r));return r?.throwIfAborted(),c}}async function h(o,t,n){const r=await o;return e.isSome(r)?await a.dynamicAwait(t(r)):n?await a.dynamicAwait(n()):void 0}async function p(o,t,n){const r=await o;return e.isNone(r)?await a.dynamicAwait(t()):n?await a.dynamicAwait(n(r)):void 0}async function l(o,t,n){n?.throwIfAborted();const r=await o;return n?.throwIfAborted(),e.isSome(r)&&(await a.dynamicAwait(t(r,n)),n?.throwIfAborted()),r}async function b(o,t,n){n?.throwIfAborted();const r=await o;return n?.throwIfAborted(),e.isNone(r)&&(await a.dynamicAwait(t(n)),n?.throwIfAborted()),r}async function I(o,{fnSome:t=()=>{},fnNone:n=()=>{}},r){r?.throwIfAborted();const s=await o;return r?.throwIfAborted(),e.isSome(s)?await a.dynamicAwait(t(s,r)):await a.dynamicAwait(n(r)),r?.throwIfAborted(),s}const N=(o,t)=>e.isSome(o)?e.Some(t(o)):e.None(),P=(o,t)=>e.isSome(o)?t(o):o,v=(o,t)=>e.isSome(o)&&e.isSome(t)?e.Some(o(t)):e.None(),_=(o,t)=>e.isSome(o)&&t(o)?o:e.None(),k=(o,t,n)=>e.isSome(o)&&t(o)?e.Some(n(o)):e.None(),z=(o,t)=>e.isSome(o)?t:e.None(),T=(o,t)=>e.isSome(o)?o:t,B=(o,t)=>e.isSome(o)?o:t(),F=(o,t,n)=>e.isSome(o)?n(o):t,R=(o,t)=>e.isSome(o)&&o===t,j=(o,t)=>e.isSome(o)&&e.isSome(t)?e.Some([o,t]):e.None(),M=(o,t,n)=>e.isSome(o)&&e.isSome(t)?e.Some(n(o,t)):e.None(),O=o=>o.every(e.isSome)?e.Some(o):e.None(),q=(o,t)=>{const n=[];for(let r=0;r<o.length;r++){const s=t(o[r],r);if(!e.isSome(s))return e.None();n.push(s)}return e.Some(n)},x=o=>{const t=[];let n=0;for(const r of o)e.isSome(r)?t.push(r):n++;return[t,n]},E=o=>{const t=[];for(const n of o)e.isSome(n)&&t.push(n);return t},W=o=>o.find(e.isSome)??e.None();function K(o,t,n){let r=t;for(const s of o){if(!e.isSome(s))return e.None();r=n(r,s)}return e.Some(r)}function C(o,t,n){const r=[t];let s=t;for(const c of o){if(!e.isSome(c))return e.None();s=n(s,c),r.push(s)}return e.Some(r)}const D=(o,t,n,r)=>{let s=t;for(const c of o)s=e.isSome(c)?n(s,c):r(s);return s},G=async(o,t,n)=>{n?.throwIfAborted();const[r,s]=await Promise.all([Promise.resolve(o),Promise.resolve(t)]);return n?.throwIfAborted(),e.isSome(r)&&e.isSome(s)?e.Some(await r(s)):e.None()},H=async(o,t,n)=>{n?.throwIfAborted();const r=await o;return n?.throwIfAborted(),e.isSome(r)?e.Some(await t(r)):e.None()},J=async(o,t,n,r)=>{r?.throwIfAborted();const s=await o;if(r?.throwIfAborted(),!e.isSome(s))return e.None();const c=await t(s);return r?.throwIfAborted(),c?e.Some(await n(s)):e.None()},L=async(o,t,n)=>{n?.throwIfAborted();const r=await o;return n?.throwIfAborted(),e.isSome(r)?t(r):e.None()},Q=async(o,t,n)=>{n?.throwIfAborted();const r=await o;if(n?.throwIfAborted(),!e.isSome(r))return e.None();const s=await t(r);return n?.throwIfAborted(),s?r:e.None()},U=async(o,t,n)=>{n?.throwIfAborted();const[r,s]=await Promise.all([Promise.resolve(o),Promise.resolve(t)]);return n?.throwIfAborted(),e.isSome(r)&&e.isSome(s)?e.Some([r,s]):e.None()},V=async(o,t,n,r)=>{r?.throwIfAborted();const s=await o;return r?.throwIfAborted(),e.isSome(s)?n(s):t},X=async(o,t,n)=>{n?.throwIfAborted();const r=await o;return n?.throwIfAborted(),e.isSome(r)?r:t()},Y=async(o,t,n)=>{n?.throwIfAborted();const r=await Promise.all(o.map(async(c,i)=>(n?.throwIfAborted(),await t(c,i))));n?.throwIfAborted();const s=[];for(const c of r){if(!e.isSome(c))return e.None();s.push(c)}return e.Some(s)},Z=async(o,t)=>{t?.throwIfAborted();const n=await Promise.all(o.map(r=>(t?.throwIfAborted(),Promise.resolve(r))));return t?.throwIfAborted(),n.every(e.isSome)?e.Some(n):e.None()},$=async(o,t)=>{t?.throwIfAborted();const n=await Promise.all(o.map(r=>(t?.throwIfAborted(),Promise.resolve(r))));t?.throwIfAborted();for(const r of n)if(e.isSome(r))return e.Some(r);return e.None()};async function g(o,t,n,r){r?.throwIfAborted();let s=t;const c=await Promise.all(o.map(i=>(r?.throwIfAborted(),Promise.resolve(i))));r?.throwIfAborted();for(const i of c){if(!e.isSome(i))return e.None();s=await n(s,i),r?.throwIfAborted()}return e.Some(s)}async function oo(o,t,n,r){r?.throwIfAborted();const s=await Promise.all(o.map(f=>(r?.throwIfAborted(),Promise.resolve(f))));r?.throwIfAborted();const c=[t];let i=t;for(const f of s){if(!e.isSome(f))return e.None();i=await n(i,f),r?.throwIfAborted(),c.push(i)}return e.Some(c)}const eo=async(o,t)=>{t?.throwIfAborted();const n=await Promise.all(o.map(r=>(t?.throwIfAborted(),Promise.resolve(r))));return t?.throwIfAborted(),n.filter(e.isSome)},to=async(o,t)=>{t?.throwIfAborted();const n=await Promise.all(o.map(c=>(t?.throwIfAborted(),Promise.resolve(c))));t?.throwIfAborted();const r=[];let s=0;for(const c of n)e.isSome(c)?r.push(c):s++;return[r,s]},ro=Object.freeze(Object.defineProperty({__proto__:null,None:e.None,Some:e.Some,all:O,allAsync:Z,and:z,andThen:P,andThenAsync:L,ap:v,apAsync:G,collectSomes:E,collectSomesAsync:eo,contains:R,filter:_,filterAsync:Q,firstSome:W,firstSomeAsync:$,fold:F,foldAsync:V,folds:D,fromFalsy:e.fromFalsy,fromNullable:e.fromNullable,ifNone:u,ifNoneAsync:p,ifSome:A,ifSomeAsync:h,isNone:e.isNone,isSome:e.isSome,map:N,mapAll:q,mapAllAsync:Y,mapAsync:H,mapIf:k,mapIfAsync:J,match:m,matchAsync:y,or:T,orElse:B,orElseAsync:X,partition:x,partitionAsync:to,peek:w,peekAsync:l,peekBoth:S,peekBothAsync:I,peekNone:d,peekNoneAsync:b,reduce:K,reduceAsync:g,scan:C,scanAsync:oo,toArray:e.toArray,toNullable:e.toNullable,toResult:e.toResult,transpose:e.transpose,zip:j,zipAsync:U,zipWith:M},Symbol.toStringTag,{value:"Module"}));exports.None=e.None;exports.Some=e.Some;exports.fromFalsy=e.fromFalsy;exports.fromNullable=e.fromNullable;exports.isNone=e.isNone;exports.isSome=e.isSome;exports.toArray=e.toArray;exports.toNullable=e.toNullable;exports.toResult=e.toResult;exports.transpose=e.transpose;exports.__export__=ro;exports.all=O;exports.allAsync=Z;exports.and=z;exports.andThen=P;exports.andThenAsync=L;exports.ap=v;exports.apAsync=G;exports.collectSomes=E;exports.collectSomesAsync=eo;exports.contains=R;exports.filter=_;exports.filterAsync=Q;exports.firstSome=W;exports.firstSomeAsync=$;exports.fold=F;exports.foldAsync=V;exports.folds=D;exports.ifNone=u;exports.ifNoneAsync=p;exports.ifSome=A;exports.ifSomeAsync=h;exports.map=N;exports.mapAll=q;exports.mapAllAsync=Y;exports.mapAsync=H;exports.mapIf=k;exports.mapIfAsync=J;exports.match=m;exports.matchAsync=y;exports.or=T;exports.orElse=B;exports.orElseAsync=X;exports.partition=x;exports.partitionAsync=to;exports.peek=w;exports.peekAsync=l;exports.peekBoth=S;exports.peekBothAsync=I;exports.peekNone=d;exports.peekNoneAsync=b;exports.reduce=K;exports.reduceAsync=g;exports.scan=C;exports.scanAsync=oo;exports.zip=j;exports.zipAsync=U;exports.zipWith=M;
+//# sourceMappingURL=Maybe.cjs.map

package/dist/subpath/Maybe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Maybe.cjs","sources":["../../src/Maybe/consumers.ts","../../src/Maybe/consumers-async.ts","../../src/Maybe/operators.ts","../../src/Maybe/operators-async.ts"],"sourcesContent":["// ========================================\r\n// ./src/Maybe/consumers.ts\r\n// ========================================\r\n\r\nimport {isNone, isSome} from './base';\r\nimport type {Maybe} from './types';\r\n\r\n// ========================================\r\n// 分支控制流\r\n// ========================================\r\n\r\n/**\r\n * Pattern matching for Maybe type\r\n * @param val - Maybe value to match\r\n * @param onSome - Callback for Some case\r\n * @param onNone - Callback for None case\r\n * @returns Result of the matched case\r\n */\r\nexport const match = <T, R>(\r\n  val: Maybe<T>,\r\n  onSome: (value: T) => R,\r\n  onNone: () => R,\r\n): R => (isSome(val) ? onSome(val) : onNone());\r\n\r\n/**\r\n * Execute callback only if Maybe is Some\r\n * @param val - Maybe value to check\r\n * @param onSome - Callback for Some case\r\n * @returns Callback result or undefined\r\n */\r\nexport function ifSome<T, R1>(\r\n  val: Maybe<T>,\r\n  onSome: (value: T) => R1,\r\n): R1 | void;\r\n\r\n/**\r\n * Execute callback for Some, fallback for None\r\n * @param val - Maybe value to check\r\n * @param onSome - Callback for Some case\r\n * @param onElse - Fallback callback\r\n * @returns Result of either callback\r\n */\r\nexport function ifSome<T, R1, R2>(\r\n  val: Maybe<T>,\r\n  onSome: (value: T) => R1,\r\n  onElse: () => R2,\r\n): R1 | R2;\r\n\r\n/**\r\n * @internal\r\n */\r\nexport function ifSome<T, R1, R2>(\r\n  val: Maybe<T>,\r\n  onSome: (value: T) => R1,\r\n  onElse?: () => R2,\r\n): R1 | R2 | void {\r\n  return isSome(val) ? onSome(val) : onElse?.();\r\n}\r\n\r\n/**\r\n * Execute callback only if Maybe is None\r\n * @param val - Maybe value to check\r\n * @param onNone - Callback for None case\r\n * @returns Callback result or undefined\r\n */\r\nexport function ifNone<T, R1>(val: Maybe<T>, onNone: () => R1): R1 | void;\r\n\r\n/**\r\n * Execute callback for None, fallback for Some\r\n * @param val - Maybe value to check\r\n * @param onNone - Callback for None case\r\n * @param onElse - Fallback callback\r\n * @returns Result of either callback\r\n */\r\nexport function ifNone<T, R1, R2>(\r\n  val: Maybe<T>,\r\n  onNone: () => R1,\r\n  onElse: (value: T) => R2,\r\n): R1 | R2;\r\n\r\n/**\r\n * @internal\r\n */\r\nexport function ifNone<T, R1, R2>(\r\n  val: Maybe<T>,\r\n  onNone: () => R1,\r\n  onElse?: (value: T) => R2,\r\n): R1 | R2 | void {\r\n  return isNone(val) ? onNone() : onElse?.(val);\r\n}\r\n\r\n// ========================================\r\n// 副作用\r\n// ========================================\r\n\r\n/**\r\n * Peek at Some value without consuming\r\n * @param val - Maybe value to inspect\r\n * @param fn - Side effect callback\r\n * @returns Original Maybe value\r\n */\r\nexport const peek = <T>(val: Maybe<T>, fn: (v: T) => void): Maybe<T> => {\r\n  if (isSome(val)) fn(val);\r\n  return val;\r\n};\r\n\r\n/**\r\n * Peek at None case without consuming\r\n * @param val - Maybe value to inspect\r\n * @param fn - Side effect callback\r\n * @returns Original Maybe value\r\n */\r\nexport const peekNone = <T>(val: Maybe<T>, fn: () => void): Maybe<T> => {\r\n  if (isNone(val)) fn();\r\n  return val;\r\n};\r\n\r\n/**\r\n * Peek at both cases with separate callbacks\r\n * @param val - Maybe value to inspect\r\n * @param callbacks - Object with Some and None handlers\r\n * @returns Original Maybe value\r\n */\r\nexport function peekBoth<T>(\r\n  val: Maybe<T>,\r\n  {\r\n    fnSome = () => {},\r\n    fnNone = () => {},\r\n  }: {\r\n    fnSome?: (v: T) => void;\r\n    fnNone?: () => void;\r\n  },\r\n): Maybe<T> {\r\n  if (isSome(val)) {\r\n    fnSome(val);\r\n  } else {\r\n    fnNone();\r\n  }\r\n\r\n  return val;\r\n}\r\n","// ========================================\n// ./src/Maybe/consumers-async.ts\n// ========================================\n\nimport {isNone, isSome} from './base';\nimport type {AnyMaybe, Maybe} from './types';\nimport type {MaybePromise} from '../Utils/type-tool';\nimport {dynamicAwait} from '../helper';\n\n// ========================================\n// 分支控制流\n// ========================================\n\n/**\n * Asynchronously pattern matches on a Maybe value, executing the appropriate callback\n * @param val - The Maybe value or Promise of Maybe to match on\n * @param onSome - Callback executed when value is Some\n * @param onNone - Callback executed when value is None\n * @param signal - Optional AbortSignal for cancellation\n * @returns Promise resolving to the result of the executed callback\n */\nexport async function matchAsync<T, R>(\n  val: AnyMaybe<T>,\n  onSome: (value: T, signal?: AbortSignal) => MaybePromise<R>,\n  onNone: (signal?: AbortSignal) => MaybePromise<R>,\n  signal?: AbortSignal,\n): Promise<R> {\n  signal?.throwIfAborted();\n  const unwrapped = await val;\n\n  if (isSome(unwrapped)) {\n    const res = await dynamicAwait(onSome(unwrapped, signal));\n    signal?.throwIfAborted();\n    return res;\n  } else {\n    const res = await dynamicAwait(onNone(signal));\n    signal?.throwIfAborted();\n    return res;\n  }\n}\n\n/**\n * Executes callback only if Maybe value is Some (single callback version)\n * @returns Promise resolving to callback result or undefined\n */\nexport async function ifSomeAsync<T, R1>(\n  val: AnyMaybe<T>,\n  onSome: (value: T) => MaybePromise<R1>,\n): Promise<R1 | void>;\n\n/**\n * Executes appropriate callback based on Maybe value (two callback version)\n * @returns Promise resolving to result of either callback\n */\nexport async function ifSomeAsync<T, R1, R2>(\n  val: AnyMaybe<T>,\n  onSome: (value: T) => MaybePromise<R1>,\n  onElse: () => MaybePromise<R2>,\n): Promise<R1 | R2>;\n\n/**\n * Conditionally executes callback based on Maybe value\n * @param val - The Maybe value or Promise of Maybe to check\n * @param onSome - Callback executed for Some values\n * @param onElse - Optional callback executed for None values\n * @returns Promise resolving to callback result or undefined\n */\nexport async function ifSomeAsync<T, R1, R2 = void>(\n  val: AnyMaybe<T>,\n  onSome: (value: T) => MaybePromise<R1>,\n  onElse?: () => MaybePromise<R2>,\n): Promise<R1 | R2 | void> {\n  const unwrapped = await val;\n\n  if (isSome(unwrapped)) {\n    return await dynamicAwait(onSome(unwrapped));\n  } else {\n    if (onElse) {\n      return await dynamicAwait(onElse());\n    }\n    return;\n  }\n}\n\n/**\n * Executes callback only if Maybe value is None (single callback version)\n * @returns Promise resolving to callback result or undefined\n */\nexport async function ifNoneAsync<T, R1>(\n  val: AnyMaybe<T>,\n  onNone: () => MaybePromise<R1>,\n): Promise<R1 | void>;\n\n/**\n * Executes appropriate callback based on Maybe value (two callback version)\n * @returns Promise resolving to result of either callback\n */\nexport async function ifNoneAsync<T, R1, R2>(\n  val: AnyMaybe<T>,\n  onNone: () => MaybePromise<R1>,\n  onElse: (value: T) => MaybePromise<R2>,\n): Promise<R1 | R2>;\n\n/**\n * Conditionally executes callback based on Maybe value\n * @param val - The Maybe value or Promise of Maybe to check\n * @param onNone - Callback executed for None values\n * @param onElse - Optional callback executed for Some values\n * @returns Promise resolving to callback result or undefined\n */\nexport async function ifNoneAsync<T, R1, R2 = void>(\n  val: AnyMaybe<T>,\n  onNone: () => MaybePromise<R1>,\n  onElse?: (value: T) => MaybePromise<R2>,\n): Promise<R1 | R2 | void> {\n  const unwrapped = await val;\n\n  if (isNone(unwrapped)) {\n    return await dynamicAwait(onNone());\n  } else {\n    if (onElse) {\n      return await dynamicAwait(onElse(unwrapped));\n    }\n    return;\n  }\n}\n\n// ========================================\n// 副作用\n// ========================================\n\n/**\n * Executes a side effect for Some values without modifying the Maybe\n * @param val - The Maybe value or Promise of Maybe to inspect\n * @param fn - Side effect function for Some values\n * @param signal - Optional AbortSignal for cancellation\n * @returns Promise resolving to the original Maybe value\n */\nexport async function peekAsync<T>(\n  val: AnyMaybe<T>,\n  fn: (v: T, signal?: AbortSignal) => MaybePromise<void>,\n  signal?: AbortSignal,\n): Promise<Maybe<T>> {\n  signal?.throwIfAborted();\n  const unwrapped = await val;\n  signal?.throwIfAborted();\n\n  if (isSome(unwrapped)) {\n    await dynamicAwait(fn(unwrapped, signal));\n    signal?.throwIfAborted();\n  }\n  return unwrapped;\n}\n\n/**\n * Executes a side effect for None values without modifying the Maybe\n * @param val - The Maybe value or Promise of Maybe to inspect\n * @param fn - Side effect function for None values\n * @param signal - Optional AbortSignal for cancellation\n * @returns Promise resolving to the original Maybe value\n */\nexport async function peekNoneAsync<T>(\n  val: AnyMaybe<T>,\n  fn: (signal?: AbortSignal) => MaybePromise<void>,\n  signal?: AbortSignal,\n): Promise<Maybe<T>> {\n  signal?.throwIfAborted();\n  const unwrapped = await val;\n  signal?.throwIfAborted();\n\n  if (isNone(unwrapped)) {\n    await dynamicAwait(fn(signal));\n    signal?.throwIfAborted();\n  }\n  return unwrapped;\n}\n\n/**\n * Executes side effects for both Some and None cases without modifying the Maybe\n * @param val - The Maybe value or Promise of Maybe to inspect\n * @param handlers - Object containing optional Some and None handlers\n * @param signal - Optional AbortSignal for cancellation\n * @returns Promise resolving to the original Maybe value\n */\nexport async function peekBothAsync<T>(\n  val: AnyMaybe<T>,\n  {\n    fnSome = () => {},\n    fnNone = () => {},\n  }: {\n    fnSome?: (v: T, signal?: AbortSignal) => MaybePromise<void>;\n    fnNone?: (signal?: AbortSignal) => MaybePromise<void>;\n  },\n  signal?: AbortSignal,\n): Promise<Maybe<T>> {\n  signal?.throwIfAborted();\n  const unwrapped = await val;\n  signal?.throwIfAborted();\n\n  if (isSome(unwrapped)) {\n    await dynamicAwait(fnSome(unwrapped, signal));\n  } else {\n    await dynamicAwait(fnNone(signal));\n  }\n  signal?.throwIfAborted();\n\n  return unwrapped;\n}\n","// ========================================\r\n// ./src/Maybe/operators.ts\r\n// ========================================\r\nimport {isSome, None, Some} from './base';\r\nimport type {Maybe} from './types';\r\n\r\n// ========================================\r\n// 基础转换\r\n// ========================================\r\n\r\n/**\r\n * Transforms the contained value if Some, returns None otherwise.\r\n * @typeparam T - Original value type\r\n * @typeparam R - Result type\r\n * @param val - Maybe value\r\n * @param fn - Transformation function\r\n * @returns Maybe<R>\r\n */\r\nexport const map = <T, R>(val: Maybe<T>, fn: (value: T) => R): Maybe<R> =>\r\n  isSome(val) ? Some(fn(val)) : None();\r\n\r\n/**\r\n * Chains computations that may fail. If Some, applies fn, otherwise returns None.\r\n * @typeparam T - Original value type\r\n * @typeparam R - Result type\r\n * @param val - Maybe value\r\n * @param fn - Function returning Maybe<R>\r\n * @returns Maybe<R>\r\n */\r\nexport const andThen = <T, R>(\r\n  val: Maybe<T>,\r\n  fn: (value: T) => Maybe<R>,\r\n): Maybe<R> => (isSome(val) ? fn(val) : val);\r\n\r\n/**\r\n * Applies a Maybe-wrapped function to a Maybe value.\r\n * @typeparam T - Input type\r\n * @typeparam R - Result type\r\n * @param fn_val - Maybe<(v: T) => R>\r\n * @param val - Maybe<T>\r\n * @returns Maybe<R>\r\n */\r\nexport const ap = <T, R>(\r\n  fn_val: Maybe<(v: T) => R>,\r\n  val: Maybe<T>,\r\n): Maybe<R> => (isSome(fn_val) && isSome(val) ? Some(fn_val(val)) : None());\r\n\r\n/**\r\n * Returns Some if value satisfies predicate, None otherwise.\r\n * @typeparam T - Value type\r\n * @param val - Maybe value\r\n * @param predicate - Filter condition\r\n * @returns Maybe<T>\r\n */\r\nexport const filter = <T>(\r\n  val: Maybe<T>,\r\n  predicate: (v: T) => boolean,\r\n): Maybe<T> => (isSome(val) && predicate(val) ? val : None());\r\n\r\n/**\r\n * Maps value if predicate passes, returns None otherwise.\r\n * @typeparam T - Original type\r\n * @typeparam R - Result type\r\n * @param val - Maybe value\r\n * @param predicate - Condition to check\r\n * @param fn - Transformation function\r\n * @returns Maybe<R>\r\n */\r\nexport const mapIf = <T, R>(\r\n  val: Maybe<T>,\r\n  predicate: (v: T) => boolean,\r\n  fn: (v: T) => R,\r\n): Maybe<R> => (isSome(val) && predicate(val) ? Some(fn(val)) : None());\r\n\r\n// ========================================\r\n// 逻辑分支与聚合\r\n// ========================================\r\n\r\n/**\r\n * Returns other if val is Some, None otherwise.\r\n * @typeparam T - First type\r\n * @typeparam U - Second type\r\n * @param val - Maybe<T>\r\n * @param other - Maybe<U>\r\n * @returns Maybe<U>\r\n */\r\nexport const and = <T, U>(val: Maybe<T>, other: Maybe<U>): Maybe<U> =>\r\n  isSome(val) ? other : None();\r\n\r\n/**\r\n * Returns first Some value, otherwise other.\r\n * @typeparam T - Value type\r\n * @param val - First Maybe\r\n * @param other - Fallback Maybe\r\n * @returns Maybe<T>\r\n */\r\nexport const or = <T>(val: Maybe<T>, other: Maybe<T>): Maybe<T> =>\r\n  isSome(val) ? val : other;\r\n\r\n/**\r\n * Returns val if Some, otherwise calls fn for fallback.\r\n * @typeparam T - Value type\r\n * @param val - Maybe value\r\n * @param fn - Fallback supplier\r\n * @returns Maybe<T>\r\n */\r\nexport const orElse = <T>(val: Maybe<T>, fn: () => Maybe<T>): Maybe<T> =>\r\n  isSome(val) ? val : fn();\r\n\r\n/**\r\n * Extracts value or returns default.\r\n * @typeparam T - Input type\r\n * @typeparam R - Output type\r\n * @param val - Maybe value\r\n * @param initial - Default value\r\n * @param onSome - Handler for Some case\r\n * @returns R\r\n */\r\nexport const fold = <T, R>(\r\n  val: Maybe<T>,\r\n  initial: R,\r\n  onSome: (v: T) => R,\r\n): R => (isSome(val) ? onSome(val) : initial);\r\n\r\n/**\r\n * Checks if Maybe contains specific value.\r\n * @typeparam T - Value type\r\n * @param val - Maybe value\r\n * @param x - Value to compare\r\n * @returns boolean\r\n */\r\nexport const contains = <T>(val: Maybe<T>, x: T): boolean =>\r\n  isSome(val) && val === x;\r\n\r\n// ========================================\r\n// 多元组合\r\n// ========================================\r\n\r\n/**\r\n * Combines two Maybes into tuple if both are Some.\r\n * @typeparam T - First type\r\n * @typeparam U - Second type\r\n * @param a - Maybe<T>\r\n * @param b - Maybe<U>\r\n * @returns Maybe<[T, U]>\r\n */\r\nexport const zip = <T, U>(a: Maybe<T>, b: Maybe<U>): Maybe<[T, U]> =>\r\n  isSome(a) && isSome(b) ? Some([a, b] as [T, U]) : None();\r\n\r\n/**\r\n * Applies function to two Maybes if both are Some.\r\n * @typeparam T - First type\r\n * @typeparam U - Second type\r\n * @typeparam R - Result type\r\n * @param ma - Maybe<T>\r\n * @param mb - Maybe<U>\r\n * @param fn - Combining function\r\n * @returns Maybe<R>\r\n */\r\nexport const zipWith = <T, U, R>(\r\n  ma: Maybe<T>,\r\n  mb: Maybe<U>,\r\n  fn: (a: T, b: U) => R,\r\n): Maybe<R> => (isSome(ma) && isSome(mb) ? Some(fn(ma, mb)) : None());\r\n\r\n// ========================================\r\n// 集合处理\r\n// ========================================\r\n\r\n/**\r\n * Returns array of all values if all are Some, None otherwise.\r\n * @typeparam T - Element type\r\n * @param vals - Array of Maybes\r\n * @returns Maybe<T[]>\r\n */\r\nexport const all = <T>(vals: readonly Maybe<T>[]): Maybe<T[]> =>\r\n  vals.every(isSome) ? Some(vals as T[]) : None();\r\n\r\n/**\r\n * Maps array to Maybes, returns Some of results if all succeed.\r\n * @typeparam T - Input type\r\n * @typeparam U - Output type\r\n * @param items - Input array\r\n * @param fn - Mapping function\r\n * @returns Maybe<U[]>\r\n */\r\nexport const mapAll = <T, U>(\r\n  items: readonly T[],\r\n  fn: (it: T, i: number) => Maybe<U>,\r\n): Maybe<U[]> => {\r\n  const results: U[] = [];\r\n  for (let i = 0; i < items.length; i++) {\r\n    const res = fn(items[i], i);\r\n    if (!isSome(res)) return None();\r\n    results.push(res);\r\n  }\r\n  return Some(results);\r\n};\r\n\r\n/**\r\n * Partitions array into Some values and None count.\r\n * @typeparam T - Element type\r\n * @param vals - Array of Maybes\r\n * @returns [T[], number] - [Some values, None count]\r\n */\r\nexport const partition = <T>(vals: readonly Maybe<T>[]): [T[], number] => {\r\n  const somes: T[] = [];\r\n  let none_count = 0;\r\n  for (const v of vals) {\r\n    if (isSome(v)) somes.push(v);\r\n    else none_count++;\r\n  }\r\n  return [somes, none_count];\r\n};\r\n\r\n/**\r\n * Collects all Some values from array.\r\n * @typeparam T - Element type\r\n * @param vals - Array of Maybes\r\n * @returns T[] - Only Some values\r\n */\r\nexport const collectSomes = <T>(vals: readonly Maybe<T>[]): T[] => {\r\n  const result: T[] = [];\r\n  for (const v of vals) if (isSome(v)) result.push(v);\r\n  return result;\r\n};\r\n\r\n/**\r\n * Returns first Some value in array, None if none found.\r\n * @typeparam T - Element type\r\n * @param vals - Array of Maybes\r\n * @returns Maybe<T>\r\n */\r\nexport const firstSome = <T>(vals: readonly Maybe<T>[]): Maybe<T> =>\r\n  vals.find(isSome) ?? None();\r\n\r\n// ========================================\r\n// 高级规约\r\n// ========================================\r\n\r\n/**\r\n * Reduces array of Maybes. Returns None if any is None.\r\n * @typeparam T - Element type\r\n * @typeparam R - Result type\r\n * @param vals - Array of Maybes\r\n * @param initial - Initial value\r\n * @param reducer - Reduction function\r\n * @returns Maybe<R>\r\n */\r\nexport function reduce<T, R>(\r\n  vals: readonly Maybe<T>[],\r\n  initial: R,\r\n  reducer: (acc: R, v: T) => R,\r\n): Maybe<R> {\r\n  let acc = initial;\r\n  for (const v of vals) {\r\n    if (!isSome(v)) return None();\r\n    acc = reducer(acc, v);\r\n  }\r\n  return Some(acc);\r\n}\r\n\r\n/**\r\n * Performs scan reduction. Returns None if any is None.\r\n * @typeparam T - Element type\r\n * @typeparam R - Result type\r\n * @param vals - Array of Maybes\r\n * @param initial - Initial value\r\n * @param scanner - Scanning function\r\n * @returns Maybe<R[]>\r\n */\r\nexport function scan<T, R>(\r\n  vals: readonly Maybe<T>[],\r\n  initial: R,\r\n  scanner: (acc: R, v: T) => R,\r\n): Maybe<R[]> {\r\n  const scanned: R[] = [initial];\r\n  let acc = initial;\r\n  for (const v of vals) {\r\n    if (!isSome(v)) return None();\r\n    acc = scanner(acc, v);\r\n    scanned.push(acc);\r\n  }\r\n  return Some(scanned);\r\n}\r\n\r\n/**\r\n * Folds with separate handlers for Some/None.\r\n * @typeparam T - Element type\r\n * @typeparam R - Result type\r\n * @param vals - Array of Maybes\r\n * @param initial - Initial value\r\n * @param onSome - Handler for Some values\r\n * @param onNone - Handler for None values\r\n * @returns R\r\n */\r\nexport const folds = <T, R>(\r\n  vals: readonly Maybe<T>[],\r\n  initial: R,\r\n  onSome: (acc: R, v: T) => R,\r\n  onNone: (acc: R) => R,\r\n): R => {\r\n  let acc = initial;\r\n  for (const v of vals) acc = isSome(v) ? onSome(acc, v) : onNone(acc);\r\n  return acc;\r\n};\r\n","// ========================================\r\n// ./src/Maybe/operators-async.ts\r\n// ========================================\r\nimport {isSome, None, Some} from './base';\r\nimport type {AnyMaybe, AsyncMaybe} from './types';\r\n\r\n// ========================================\r\n// 核心转换操作\r\n// ========================================\r\n\r\n/**\r\n * Applies async function from Maybe to async value.\r\n * @typeparam T - Input type\r\n * @typeparam R - Result type\r\n * @param fn_val - Maybe function\r\n * @param val - Maybe value\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<R>\r\n */\r\nexport const apAsync = async <T, R>(\r\n  fn_val: AnyMaybe<(v: T) => R | Promise<R>>,\r\n  val: AnyMaybe<T>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<R> => {\r\n  signal?.throwIfAborted();\r\n  const [f, v] = await Promise.all([\r\n    Promise.resolve(fn_val),\r\n    Promise.resolve(val),\r\n  ]);\r\n  signal?.throwIfAborted();\r\n  return isSome(f) && isSome(v) ? Some(await f(v)) : None();\r\n};\r\n\r\n/**\r\n * Transforms async Maybe value with async function.\r\n * @typeparam T - Input type\r\n * @typeparam R - Result type\r\n * @param val - Maybe value\r\n * @param fn - Async transformation function\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<R>\r\n */\r\nexport const mapAsync = async <T, R>(\r\n  val: AnyMaybe<T>,\r\n  fn: (v: T) => R | Promise<R>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<R> => {\r\n  signal?.throwIfAborted();\r\n  const v = await val;\r\n  signal?.throwIfAborted();\r\n  return isSome(v) ? Some(await fn(v)) : None();\r\n};\r\n\r\n/**\r\n * Maps value only if predicate passes (async).\r\n * @typeparam T - Input type\r\n * @typeparam R - Result type\r\n * @param val - Maybe value\r\n * @param predicate - Async condition check\r\n * @param fn - Async transformation function\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<R>\r\n */\r\nexport const mapIfAsync = async <T, R>(\r\n  val: AnyMaybe<T>,\r\n  predicate: (v: T) => boolean | Promise<boolean>,\r\n  fn: (v: T) => R | Promise<R>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<R> => {\r\n  signal?.throwIfAborted();\r\n  const v = await val;\r\n  signal?.throwIfAborted();\r\n  if (!isSome(v)) return None();\r\n\r\n  const shouldMap = await predicate(v);\r\n  signal?.throwIfAborted();\r\n  return shouldMap ? Some(await fn(v)) : None();\r\n};\r\n\r\n/**\r\n * Chains async computations that may fail.\r\n * @typeparam T - Input type\r\n * @typeparam R - Result type\r\n * @param val - Maybe value\r\n * @param fn - Async function returning Maybe\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<R>\r\n */\r\nexport const andThenAsync = async <T, R>(\r\n  val: AnyMaybe<T>,\r\n  fn: (v: T) => AnyMaybe<R>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<R> => {\r\n  signal?.throwIfAborted();\r\n  const v = await val;\r\n  signal?.throwIfAborted();\r\n  return isSome(v) ? fn(v) : None();\r\n};\r\n\r\n/**\r\n * Filters async Maybe value with async predicate.\r\n * @typeparam T - Value type\r\n * @param val - Maybe value\r\n * @param predicate - Async filter condition\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<T>\r\n */\r\nexport const filterAsync = async <T>(\r\n  val: AnyMaybe<T>,\r\n  predicate: (v: T) => boolean | Promise<boolean>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<T> => {\r\n  signal?.throwIfAborted();\r\n  const v = await val;\r\n  signal?.throwIfAborted();\r\n  if (!isSome(v)) return None();\r\n\r\n  const shouldKeep = await predicate(v);\r\n  signal?.throwIfAborted();\r\n  return shouldKeep ? v : None();\r\n};\r\n\r\n// ========================================\r\n// 组合操作\r\n// ========================================\r\n\r\n/**\r\n * Zips two async Maybes into tuple if both are Some.\r\n * @typeparam T - First type\r\n * @typeparam U - Second type\r\n * @param a - First Maybe\r\n * @param b - Second Maybe\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<[T, U]>\r\n */\r\nexport const zipAsync = async <T, U>(\r\n  a: AnyMaybe<T>,\r\n  b: AnyMaybe<U>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<[T, U]> => {\r\n  signal?.throwIfAborted();\r\n  const [ra, rb] = await Promise.all([Promise.resolve(a), Promise.resolve(b)]);\r\n  signal?.throwIfAborted();\r\n  return isSome(ra) && isSome(rb) ? Some([ra, rb]) : None();\r\n};\r\n\r\n// ========================================\r\n// 逻辑分支与错误处理\r\n// ========================================\r\n\r\n/**\r\n * Extracts value from async Maybe or returns default.\r\n * @typeparam T - Input type\r\n * @typeparam R - Result type\r\n * @param val - Maybe value\r\n * @param initial - Default value or Promise\r\n * @param onSome - Async handler for Some case\r\n * @param signal - Optional AbortSignal\r\n * @returns Promise<R>\r\n */\r\nexport const foldAsync = async <T, R>(\r\n  val: AnyMaybe<T>,\r\n  initial: R | Promise<R>,\r\n  onSome: (v: T) => R | Promise<R>,\r\n  signal?: AbortSignal,\r\n): Promise<R> => {\r\n  signal?.throwIfAborted();\r\n  const v = await val;\r\n  signal?.throwIfAborted();\r\n  return isSome(v) ? onSome(v) : initial;\r\n};\r\n\r\n/**\r\n * Returns value if Some, otherwise async fallback.\r\n * @typeparam T - Value type\r\n * @param val - Maybe value\r\n * @param fn - Async fallback supplier\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<T>\r\n */\r\nexport const orElseAsync = async <T>(\r\n  val: AnyMaybe<T>,\r\n  fn: () => AnyMaybe<T>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<T> => {\r\n  signal?.throwIfAborted();\r\n  const v = await val;\r\n  signal?.throwIfAborted();\r\n  return isSome(v) ? v : fn();\r\n};\r\n\r\n// ========================================\r\n// 集合操作\r\n// ========================================\r\n\r\n/**\r\n * Maps array with async function, fails if any returns None.\r\n * @typeparam T - Input type\r\n * @typeparam R - Output type\r\n * @param items - Input array\r\n * @param fn - Async mapping function\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<R[]>\r\n */\r\nexport const mapAllAsync = async <T, R>(\r\n  items: readonly T[],\r\n  fn: (it: T, i: number) => AnyMaybe<R>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<R[]> => {\r\n  signal?.throwIfAborted();\r\n  const results = await Promise.all(\r\n    items.map(async (it, i) => {\r\n      signal?.throwIfAborted();\r\n      return await fn(it, i);\r\n    }),\r\n  );\r\n  signal?.throwIfAborted();\r\n\r\n  const final: R[] = [];\r\n  for (const r of results) {\r\n    if (!isSome(r)) return None();\r\n    final.push(r);\r\n  }\r\n  return Some(final);\r\n};\r\n\r\n/**\r\n * Returns all async values if all are Some, None otherwise.\r\n * @typeparam T - Element type\r\n * @param vals - Array of async Maybes\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<T[]>\r\n */\r\nexport const allAsync = async <T>(\r\n  vals: readonly AnyMaybe<T>[],\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<T[]> => {\r\n  signal?.throwIfAborted();\r\n  const resolved = await Promise.all(\r\n    vals.map((v) => {\r\n      signal?.throwIfAborted();\r\n      return Promise.resolve(v);\r\n    }),\r\n  );\r\n  signal?.throwIfAborted();\r\n  return resolved.every(isSome) ? Some(resolved as T[]) : None();\r\n};\r\n\r\n/**\r\n * Returns first Some value from async array, None if none found.\r\n * @typeparam T - Element type\r\n * @param vals - Array of async Maybes\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<T>\r\n */\r\nexport const firstSomeAsync = async <T>(\r\n  vals: readonly AnyMaybe<T>[],\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<T> => {\r\n  signal?.throwIfAborted();\r\n  const resolved = await Promise.all(\r\n    vals.map((v) => {\r\n      signal?.throwIfAborted();\r\n      return Promise.resolve(v);\r\n    }),\r\n  );\r\n  signal?.throwIfAborted();\r\n\r\n  for (const v of resolved) {\r\n    if (isSome(v)) return Some(v);\r\n  }\r\n  return None();\r\n};\r\n\r\n// ========================================\r\n// 规约与聚合\r\n// ========================================\r\n\r\n/**\r\n * Reduces array of async Maybes with async reducer.\r\n * @typeparam T - Element type\r\n * @typeparam R - Result type\r\n * @param vals - Array of async Maybes\r\n * @param initial - Initial value\r\n * @param reducer - Async reduction function\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<R>\r\n */\r\nexport async function reduceAsync<T, R>(\r\n  vals: readonly AnyMaybe<T>[],\r\n  initial: R,\r\n  reducer: (acc: R, v: T) => R | Promise<R>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<R> {\r\n  signal?.throwIfAborted();\r\n  let acc = initial;\r\n  const resolved_vals = await Promise.all(\r\n    vals.map((v) => {\r\n      signal?.throwIfAborted();\r\n      return Promise.resolve(v);\r\n    }),\r\n  );\r\n  signal?.throwIfAborted();\r\n\r\n  for (const v of resolved_vals) {\r\n    if (!isSome(v)) return None();\r\n    acc = await reducer(acc, v);\r\n    signal?.throwIfAborted();\r\n  }\r\n  return Some(acc);\r\n}\r\n\r\n/**\r\n * Performs async scan reduction on array of async Maybes.\r\n * @typeparam T - Element type\r\n * @typeparam R - Result type\r\n * @param vals - Array of async Maybes\r\n * @param initial - Initial value\r\n * @param scanner - Async scanning function\r\n * @param signal - Optional AbortSignal\r\n * @returns AsyncMaybe<R[]>\r\n */\r\nexport async function scanAsync<T, R>(\r\n  vals: readonly AnyMaybe<T>[],\r\n  initial: R,\r\n  scanner: (acc: R, v: T) => R | Promise<R>,\r\n  signal?: AbortSignal,\r\n): AsyncMaybe<R[]> {\r\n  signal?.throwIfAborted();\r\n  const resolved = await Promise.all(\r\n    vals.map((v) => {\r\n      signal?.throwIfAborted();\r\n      return Promise.resolve(v);\r\n    }),\r\n  );\r\n  signal?.throwIfAborted();\r\n\r\n  const scanned: R[] = [initial];\r\n  let acc = initial;\r\n\r\n  for (const v of resolved) {\r\n    if (!isSome(v)) return None();\r\n    acc = await scanner(acc, v);\r\n    signal?.throwIfAborted();\r\n    scanned.push(acc);\r\n  }\r\n  return Some(scanned);\r\n}\r\n\r\n// ========================================\r\n// 集合筛选与统计\r\n// ========================================\r\n\r\n/**\r\n * Collects all Some values from async array.\r\n * @typeparam T - Element type\r\n * @param vals - Array of async Maybes\r\n * @param signal - Optional AbortSignal\r\n * @returns Promise<T[]> - Only Some values\r\n */\r\nexport const collectSomesAsync = async <T>(\r\n  vals: readonly AnyMaybe<T>[],\r\n  signal?: AbortSignal,\r\n): Promise<T[]> => {\r\n  signal?.throwIfAborted();\r\n  const resolved = await Promise.all(\r\n    vals.map((v) => {\r\n      signal?.throwIfAborted();\r\n      return Promise.resolve(v);\r\n    }),\r\n  );\r\n  signal?.throwIfAborted();\r\n  return resolved.filter(isSome) as T[];\r\n};\r\n\r\n/**\r\n * Partitions async array into Some values and None count.\r\n * @typeparam T - Element type\r\n * @param vals - Array of async Maybes\r\n * @param signal - Optional AbortSignal\r\n * @returns Promise<[T[], number]> - [Some values, None count]\r\n */\r\nexport const partitionAsync = async <T>(\r\n  vals: readonly AnyMaybe<T>[],\r\n  signal?: AbortSignal,\r\n): Promise<[T[], number]> => {\r\n  signal?.throwIfAborted();\r\n  const resolved = await Promise.all(\r\n    vals.map((v) => {\r\n      signal?.throwIfAborted();\r\n      return Promise.resolve(v);\r\n    }),\r\n  );\r\n  signal?.throwIfAborted();\r\n\r\n  const somes: T[] = [];\r\n  let none_count = 0;\r\n\r\n  for (const v of resolved) {\r\n    if (isSome(v)) somes.push(v);\r\n    else none_count++;\r\n  }\r\n\r\n  return [somes, none_count];\r\n};\r\n"],"names":["match","val","onSome","onNone","isSome","ifSome","onElse","ifNone","isNone","peek","fn","peekNone","peekBoth","fnSome","fnNone","matchAsync","signal","unwrapped","res","dynamicAwait","ifSomeAsync","ifNoneAsync","peekAsync","peekNoneAsync","peekBothAsync","map","Some","None","andThen","ap","fn_val","filter","predicate","mapIf","and","other","or","orElse","fold","initial","contains","x","zip","a","b","zipWith","ma","mb","all","vals","mapAll","items","results","i","partition","somes","none_count","v","collectSomes","result","firstSome","reduce","reducer","acc","scan","scanner","scanned","folds","apAsync","f","mapAsync","mapIfAsync","shouldMap","andThenAsync","filterAsync","shouldKeep","zipAsync","ra","rb","foldAsync","orElseAsync","mapAllAsync","it","final","r","allAsync","resolved","firstSomeAsync","reduceAsync","resolved_vals","scanAsync","collectSomesAsync","partitionAsync"],"mappings":"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"}

package/dist/subpath/Maybe.mjs

@@ -0,0 +1,329 @@
+import { i as n, a as d, S as a, N as f, f as i, b as h, t as b, c as I, d as p, e as y } from "../chunks/base-BpECeKwU.mjs";
+import { d as u } from "../chunks/helper-BVabbpmX.mjs";
+const m = (t, o, e) => n(t) ? o(t) : e();
+function l(t, o, e) {
+  return n(t) ? o(t) : e?.();
+}
+function P(t, o, e) {
+  return d(t) ? o() : e?.(t);
+}
+const v = (t, o) => (n(t) && o(t), t), S = (t, o) => (d(t) && o(), t);
+function _(t, {
+  fnSome: o = () => {
+  },
+  fnNone: e = () => {
+  }
+}) {
+  return n(t) ? o(t) : e(), t;
+}
+async function N(t, o, e, r) {
+  r?.throwIfAborted();
+  const s = await t;
+  if (n(s)) {
+    const c = await u(o(s, r));
+    return r?.throwIfAborted(), c;
+  } else {
+    const c = await u(e(r));
+    return r?.throwIfAborted(), c;
+  }
+}
+async function k(t, o, e) {
+  const r = await t;
+  return n(r) ? await u(o(r)) : e ? await u(e()) : void 0;
+}
+async function z(t, o, e) {
+  const r = await t;
+  return d(r) ? await u(o()) : e ? await u(e(r)) : void 0;
+}
+async function T(t, o, e) {
+  e?.throwIfAborted();
+  const r = await t;
+  return e?.throwIfAborted(), n(r) && (await u(o(r, e)), e?.throwIfAborted()), r;
+}
+async function j(t, o, e) {
+  e?.throwIfAborted();
+  const r = await t;
+  return e?.throwIfAborted(), d(r) && (await u(o(e)), e?.throwIfAborted()), r;
+}
+async function x(t, {
+  fnSome: o = () => {
+  },
+  fnNone: e = () => {
+  }
+}, r) {
+  r?.throwIfAborted();
+  const s = await t;
+  return r?.throwIfAborted(), n(s) ? await u(o(s, r)) : await u(e(r)), r?.throwIfAborted(), s;
+}
+const B = (t, o) => n(t) ? a(o(t)) : f(), M = (t, o) => n(t) ? o(t) : t, O = (t, o) => n(t) && n(o) ? a(t(o)) : f(), F = (t, o) => n(t) && o(t) ? t : f(), K = (t, o, e) => n(t) && o(t) ? a(e(t)) : f(), R = (t, o) => n(t) ? o : f(), W = (t, o) => n(t) ? t : o, q = (t, o) => n(t) ? t : o(), C = (t, o, e) => n(t) ? e(t) : o, D = (t, o) => n(t) && t === o, E = (t, o) => n(t) && n(o) ? a([t, o]) : f(), G = (t, o, e) => n(t) && n(o) ? a(e(t, o)) : f(), H = (t) => t.every(n) ? a(t) : f(), J = (t, o) => {
+  const e = [];
+  for (let r = 0; r < t.length; r++) {
+    const s = o(t[r], r);
+    if (!n(s)) return f();
+    e.push(s);
+  }
+  return a(e);
+}, L = (t) => {
+  const o = [];
+  let e = 0;
+  for (const r of t)
+    n(r) ? o.push(r) : e++;
+  return [o, e];
+}, Q = (t) => {
+  const o = [];
+  for (const e of t) n(e) && o.push(e);
+  return o;
+}, U = (t) => t.find(n) ?? f();
+function V(t, o, e) {
+  let r = o;
+  for (const s of t) {
+    if (!n(s)) return f();
+    r = e(r, s);
+  }
+  return a(r);
+}
+function X(t, o, e) {
+  const r = [o];
+  let s = o;
+  for (const c of t) {
+    if (!n(c)) return f();
+    s = e(s, c), r.push(s);
+  }
+  return a(r);
+}
+const Y = (t, o, e, r) => {
+  let s = o;
+  for (const c of t) s = n(c) ? e(s, c) : r(s);
+  return s;
+}, Z = async (t, o, e) => {
+  e?.throwIfAborted();
+  const [r, s] = await Promise.all([
+    Promise.resolve(t),
+    Promise.resolve(o)
+  ]);
+  return e?.throwIfAborted(), n(r) && n(s) ? a(await r(s)) : f();
+}, $ = async (t, o, e) => {
+  e?.throwIfAborted();
+  const r = await t;
+  return e?.throwIfAborted(), n(r) ? a(await o(r)) : f();
+}, g = async (t, o, e, r) => {
+  r?.throwIfAborted();
+  const s = await t;
+  if (r?.throwIfAborted(), !n(s)) return f();
+  const c = await o(s);
+  return r?.throwIfAborted(), c ? a(await e(s)) : f();
+}, tt = async (t, o, e) => {
+  e?.throwIfAborted();
+  const r = await t;
+  return e?.throwIfAborted(), n(r) ? o(r) : f();
+}, ot = async (t, o, e) => {
+  e?.throwIfAborted();
+  const r = await t;
+  if (e?.throwIfAborted(), !n(r)) return f();
+  const s = await o(r);
+  return e?.throwIfAborted(), s ? r : f();
+}, rt = async (t, o, e) => {
+  e?.throwIfAborted();
+  const [r, s] = await Promise.all([Promise.resolve(t), Promise.resolve(o)]);
+  return e?.throwIfAborted(), n(r) && n(s) ? a([r, s]) : f();
+}, et = async (t, o, e, r) => {
+  r?.throwIfAborted();
+  const s = await t;
+  return r?.throwIfAborted(), n(s) ? e(s) : o;
+}, nt = async (t, o, e) => {
+  e?.throwIfAborted();
+  const r = await t;
+  return e?.throwIfAborted(), n(r) ? r : o();
+}, st = async (t, o, e) => {
+  e?.throwIfAborted();
+  const r = await Promise.all(
+    t.map(async (c, w) => (e?.throwIfAborted(), await o(c, w)))
+  );
+  e?.throwIfAborted();
+  const s = [];
+  for (const c of r) {
+    if (!n(c)) return f();
+    s.push(c);
+  }
+  return a(s);
+}, ct = async (t, o) => {
+  o?.throwIfAborted();
+  const e = await Promise.all(
+    t.map((r) => (o?.throwIfAborted(), Promise.resolve(r)))
+  );
+  return o?.throwIfAborted(), e.every(n) ? a(e) : f();
+}, ft = async (t, o) => {
+  o?.throwIfAborted();
+  const e = await Promise.all(
+    t.map((r) => (o?.throwIfAborted(), Promise.resolve(r)))
+  );
+  o?.throwIfAborted();
+  for (const r of e)
+    if (n(r)) return a(r);
+  return f();
+};
+async function at(t, o, e, r) {
+  r?.throwIfAborted();
+  let s = o;
+  const c = await Promise.all(
+    t.map((w) => (r?.throwIfAborted(), Promise.resolve(w)))
+  );
+  r?.throwIfAborted();
+  for (const w of c) {
+    if (!n(w)) return f();
+    s = await e(s, w), r?.throwIfAborted();
+  }
+  return a(s);
+}
+async function wt(t, o, e, r) {
+  r?.throwIfAborted();
+  const s = await Promise.all(
+    t.map((A) => (r?.throwIfAborted(), Promise.resolve(A)))
+  );
+  r?.throwIfAborted();
+  const c = [o];
+  let w = o;
+  for (const A of s) {
+    if (!n(A)) return f();
+    w = await e(w, A), r?.throwIfAborted(), c.push(w);
+  }
+  return a(c);
+}
+const ut = async (t, o) => {
+  o?.throwIfAborted();
+  const e = await Promise.all(
+    t.map((r) => (o?.throwIfAborted(), Promise.resolve(r)))
+  );
+  return o?.throwIfAborted(), e.filter(n);
+}, dt = async (t, o) => {
+  o?.throwIfAborted();
+  const e = await Promise.all(
+    t.map((c) => (o?.throwIfAborted(), Promise.resolve(c)))
+  );
+  o?.throwIfAborted();
+  const r = [];
+  let s = 0;
+  for (const c of e)
+    n(c) ? r.push(c) : s++;
+  return [r, s];
+}, ht = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  None: f,
+  Some: a,
+  all: H,
+  allAsync: ct,
+  and: R,
+  andThen: M,
+  andThenAsync: tt,
+  ap: O,
+  apAsync: Z,
+  collectSomes: Q,
+  collectSomesAsync: ut,
+  contains: D,
+  filter: F,
+  filterAsync: ot,
+  firstSome: U,
+  firstSomeAsync: ft,
+  fold: C,
+  foldAsync: et,
+  folds: Y,
+  fromFalsy: i,
+  fromNullable: h,
+  ifNone: P,
+  ifNoneAsync: z,
+  ifSome: l,
+  ifSomeAsync: k,
+  isNone: d,
+  isSome: n,
+  map: B,
+  mapAll: J,
+  mapAllAsync: st,
+  mapAsync: $,
+  mapIf: K,
+  mapIfAsync: g,
+  match: m,
+  matchAsync: N,
+  or: W,
+  orElse: q,
+  orElseAsync: nt,
+  partition: L,
+  partitionAsync: dt,
+  peek: v,
+  peekAsync: T,
+  peekBoth: _,
+  peekBothAsync: x,
+  peekNone: S,
+  peekNoneAsync: j,
+  reduce: V,
+  reduceAsync: at,
+  scan: X,
+  scanAsync: wt,
+  toArray: b,
+  toNullable: I,
+  toResult: p,
+  transpose: y,
+  zip: E,
+  zipAsync: rt,
+  zipWith: G
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  f as None,
+  a as Some,
+  ht as _,
+  H as all,
+  ct as allAsync,
+  R as and,
+  M as andThen,
+  tt as andThenAsync,
+  O as ap,
+  Z as apAsync,
+  Q as collectSomes,
+  ut as collectSomesAsync,
+  D as contains,
+  F as filter,
+  ot as filterAsync,
+  U as firstSome,
+  ft as firstSomeAsync,
+  C as fold,
+  et as foldAsync,
+  Y as folds,
+  i as fromFalsy,
+  h as fromNullable,
+  P as ifNone,
+  z as ifNoneAsync,
+  l as ifSome,
+  k as ifSomeAsync,
+  d as isNone,
+  n as isSome,
+  B as map,
+  J as mapAll,
+  st as mapAllAsync,
+  $ as mapAsync,
+  K as mapIf,
+  g as mapIfAsync,
+  m as match,
+  N as matchAsync,
+  W as or,
+  q as orElse,
+  nt as orElseAsync,
+  L as partition,
+  dt as partitionAsync,
+  v as peek,
+  T as peekAsync,
+  _ as peekBoth,
+  x as peekBothAsync,
+  S as peekNone,
+  j as peekNoneAsync,
+  V as reduce,
+  at as reduceAsync,
+  X as scan,
+  wt as scanAsync,
+  b as toArray,
+  I as toNullable,
+  p as toResult,
+  y as transpose,
+  E as zip,
+  rt as zipAsync,
+  G as zipWith
+};
+//# sourceMappingURL=Maybe.mjs.map