modern-ts 0.8.0

package/dist/chunks/Errors-DwUAvFIF.mjs

@@ -0,0 +1,63 @@
+class e extends Error {
+  /**
+   * Creates an instance of UseAfterFreeError.
+   * @param message - The error message. Defaults to 'Cannot access resource after it has been disposed.'
+   */
+  constructor(r) {
+    super(r), this.name = "UseAfterFreeError", typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, e);
+  }
+}
+class t extends Error {
+  /**
+   * Creates an instance of LockError.
+   * @param message - The error message describing the lock failure.
+   */
+  constructor(r) {
+    super(r), this.name = "LockError", typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, t);
+  }
+}
+class c extends t {
+  /**
+   * Creates an instance of MutexError.
+   * @param message - The error message describing the mutex failure.
+   */
+  constructor(r) {
+    super(r), this.name = "MutexError", typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, c);
+  }
+}
+class a extends t {
+  /**
+   * Creates an instance of RWLockError.
+   * @param message - The error message describing the read-write lock failure.
+   */
+  constructor(r) {
+    super(r), this.name = "RWLockError", typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, a);
+  }
+}
+class o extends Error {
+  /**
+   * Creates an instance of ParameterError.
+   * @param message - The error message describing the parameter validation failure.
+   */
+  constructor(r) {
+    super(r), this.name = "ParameterError", typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, o);
+  }
+}
+class s extends Error {
+  /**
+   * Creates an instance of FlowCompletionError.
+   * @param message - The error message. Defaults to 'Flow completed before run could finish'.
+   */
+  constructor(r = "Flow completed before run could finish") {
+    super(r), this.name = "FlowCompletionError", typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, s);
+  }
+}
+export {
+  s as F,
+  t as L,
+  c as M,
+  o as P,
+  a as R,
+  e as U
+};
+//# sourceMappingURL=Errors-DwUAvFIF.mjs.map

package/dist/chunks/Errors-DwUAvFIF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors-DwUAvFIF.mjs","sources":["../../src/Errors.ts"],"sourcesContent":["// ========================================\r\n// ./src/Errors.ts\r\n// ========================================\r\n/* v8 ignore file -- @preserve */\r\n\r\n/**\r\n * Error thrown when a resource is accessed after it has been disposed (Use After Free).\r\n */\r\nexport class UseAfterFreeError extends Error {\r\n  /**\r\n   * Creates an instance of UseAfterFreeError.\r\n   * @param message - The error message. Defaults to 'Cannot access resource after it has been disposed.'\r\n   */\r\n  constructor(message: string) {\r\n    super(message);\r\n    this.name = 'UseAfterFreeError';\r\n    if (typeof Error.captureStackTrace === 'function')\r\n      Error.captureStackTrace(this, UseAfterFreeError);\r\n  }\r\n}\r\n\r\n/**\r\n * Error thrown when a lock operation fails.\r\n * Base class for all lock-related errors.\r\n */\r\nexport class LockError extends Error {\r\n  /**\r\n   * Creates an instance of LockError.\r\n   * @param message - The error message describing the lock failure.\r\n   */\r\n  constructor(message: string) {\r\n    super(message);\r\n    this.name = 'LockError';\r\n    if (typeof Error.captureStackTrace === 'function')\r\n      Error.captureStackTrace(this, LockError);\r\n  }\r\n}\r\n\r\n/**\r\n * Error thrown when a mutex operation fails.\r\n * Used for mutual exclusion lock violations and failures.\r\n */\r\nexport class MutexError extends LockError {\r\n  /**\r\n   * Creates an instance of MutexError.\r\n   * @param message - The error message describing the mutex failure.\r\n   */\r\n  constructor(message: string) {\r\n    super(message);\r\n    this.name = 'MutexError';\r\n    if (typeof Error.captureStackTrace === 'function')\r\n      Error.captureStackTrace(this, MutexError);\r\n  }\r\n}\r\n\r\n/**\r\n * Error thrown when a read-write lock operation fails.\r\n * Used for reader-writer lock violations and failures.\r\n */\r\nexport class RWLockError extends LockError {\r\n  /**\r\n   * Creates an instance of RWLockError.\r\n   * @param message - The error message describing the read-write lock failure.\r\n   */\r\n  constructor(message: string) {\r\n    super(message);\r\n    this.name = 'RWLockError';\r\n    if (typeof Error.captureStackTrace === 'function')\r\n      Error.captureStackTrace(this, RWLockError);\r\n  }\r\n}\r\n\r\n/**\r\n * Error thrown when a function parameter is invalid.\r\n * Used for parameter validation failures.\r\n */\r\nexport class ParameterError extends Error {\r\n  /**\r\n   * Creates an instance of ParameterError.\r\n   * @param message - The error message describing the parameter validation failure.\r\n   */\r\n  constructor(message: string) {\r\n    super(message);\r\n    this.name = 'ParameterError';\r\n    if (typeof Error.captureStackTrace === 'function')\r\n      Error.captureStackTrace(this, ParameterError);\r\n  }\r\n}\r\n\r\n/**\r\n * Error thrown when a Flow completes before a run operation could finish.\r\n * This indicates that the Flow was completed or stopped while there were\r\n * still pending operations waiting for values.\r\n */\r\nexport class FlowCompletionError extends Error {\r\n  /**\r\n   * Creates an instance of FlowCompletionError.\r\n   * @param message - The error message. Defaults to 'Flow completed before run could finish'.\r\n   */\r\n  constructor(message: string = 'Flow completed before run could finish') {\r\n    super(message);\r\n    this.name = 'FlowCompletionError';\r\n    if (typeof Error.captureStackTrace === 'function')\r\n      Error.captureStackTrace(this, FlowCompletionError);\r\n  }\r\n}\r\n"],"names":["UseAfterFreeError","message","LockError","MutexError","RWLockError","ParameterError","FlowCompletionError"],"mappings":"AAQO,MAAMA,UAA0B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,EAK3C,YAAYC,GAAiB;AAC3B,UAAMA,CAAO,GACb,KAAK,OAAO,qBACR,OAAO,MAAM,qBAAsB,cACrC,MAAM,kBAAkB,MAAMD,CAAiB;AAAA,EACnD;AACF;AAMO,MAAME,UAAkB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,EAKnC,YAAYD,GAAiB;AAC3B,UAAMA,CAAO,GACb,KAAK,OAAO,aACR,OAAO,MAAM,qBAAsB,cACrC,MAAM,kBAAkB,MAAMC,CAAS;AAAA,EAC3C;AACF;AAMO,MAAMC,UAAmBD,EAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAKxC,YAAYD,GAAiB;AAC3B,UAAMA,CAAO,GACb,KAAK,OAAO,cACR,OAAO,MAAM,qBAAsB,cACrC,MAAM,kBAAkB,MAAME,CAAU;AAAA,EAC5C;AACF;AAMO,MAAMC,UAAoBF,EAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAKzC,YAAYD,GAAiB;AAC3B,UAAMA,CAAO,GACb,KAAK,OAAO,eACR,OAAO,MAAM,qBAAsB,cACrC,MAAM,kBAAkB,MAAMG,CAAW;AAAA,EAC7C;AACF;AAMO,MAAMC,UAAuB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,EAKxC,YAAYJ,GAAiB;AAC3B,UAAMA,CAAO,GACb,KAAK,OAAO,kBACR,OAAO,MAAM,qBAAsB,cACrC,MAAM,kBAAkB,MAAMI,CAAc;AAAA,EAChD;AACF;AAOO,MAAMC,UAA4B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,EAK7C,YAAYL,IAAkB,0CAA0C;AACtE,UAAMA,CAAO,GACb,KAAK,OAAO,uBACR,OAAO,MAAM,qBAAsB,cACrC,MAAM,kBAAkB,MAAMK,CAAmB;AAAA,EACrD;AACF;"}

package/dist/chunks/Math-CGEH1ClN.mjs

@@ -0,0 +1,68 @@
+const g = (t, n, e) => Math.min(Math.max(t, n), e), l = (t, n = 0) => +(Math.round(+(t + "e" + n)) + "e-" + n), u = (t, n, e) => n === e ? 0 : (t - n) / (e - n), c = (t, n) => {
+  for (t = Math.abs(t), n = Math.abs(n); n !== 0; ) {
+    const e = n;
+    n = t % n, t = e;
+  }
+  return t;
+}, m = (t, n) => t === 0 || n === 0 ? 0 : Math.abs(t / c(t, n) * n), d = (t, n, e) => Number.isFinite(t) && t >= n && t < e, M = (t, n, e = 1) => {
+  if (e === 0 || !Number.isFinite(t) || !Number.isFinite(n)) return [];
+  const s = Math.max(Math.ceil((n - t) / e), 0);
+  return Array.from({ length: s }, (a, r) => t + r * e);
+}, f = (t, n, e = 1) => {
+  if (e === 0 || !Number.isFinite(t) || !Number.isFinite(n)) return [];
+  const s = Math.max(Math.ceil((n - t) / e), 0);
+  return Array.from({ length: s }, (a, r) => t + (s - 1 - r) * e);
+}, y = (t, n, e, s, a) => !Number.isFinite(t) || n === e ? s : (t - n) * (a - s) / (e - n) + s, x = (t, n) => Math.random() * (n - t) + t, N = (t, n) => Math.floor(Math.random() * (n - t + 1)) + t, h = (t) => t.reduce((n, e) => n + e, 0), o = (t, n) => t.reduce((e, s) => e + n(s), 0), i = (t) => t.length === 0 ? 0 : h(t) / t.length, b = (t, n) => t.length ? o(t, n) / t.length : 0, v = (t) => {
+  const n = [...t].sort((s, a) => s - a), e = n.length >> 1;
+  return n.length % 2 ? n[e] : (n[e - 1] + n[e]) / 2;
+}, F = (t, n) => {
+  if (t.length === 0)
+    return 0;
+  const e = t.map(n).sort((a, r) => a - r), s = e.length >> 1;
+  return e.length % 2 ? e[s] : (e[s - 1] + e[s]) / 2;
+}, D = (t, n = !1) => {
+  if (t.length === 0 || n && t.length === 1) return 0;
+  const e = i(t), s = o(t, (a) => (a - e) ** 2) / (t.length - (n ? 1 : 0));
+  return Math.sqrt(s);
+}, q = (t, n, e = 1e-10) => Math.abs(t - n) < e, A = (t) => (t & 1) === 0, B = (t) => (t & 1) !== 0, R = (t) => t * Math.PI / 180, w = (t) => t * 180 / Math.PI, z = (t) => (t % 360 + 360) % 360, I = (t, n) => {
+  const e = (n - t + 180) % 360;
+  return (e < 0 ? e + 360 : e) - 180;
+}, p = (t, n, e, s) => Math.hypot(e - t, s - n), E = (t, n, e, s) => (e - t) ** 2 + (s - n) ** 2, P = (t, n, e) => t + e * (n - t), _ = (t, n, e, s) => {
+  const a = 1 - s;
+  return {
+    x: a * a * t.x + 2 * a * s * n.x + s * s * e.x,
+    y: a * a * t.y + 2 * a * s * n.y + s * s * e.y
+  };
+};
+export {
+  E as A,
+  P as B,
+  _ as C,
+  M as a,
+  f as b,
+  g as c,
+  x as d,
+  N as e,
+  o as f,
+  c as g,
+  i as h,
+  d as i,
+  b as j,
+  v as k,
+  m as l,
+  y as m,
+  u as n,
+  F as o,
+  D as p,
+  q,
+  l as r,
+  h as s,
+  A as t,
+  B as u,
+  R as v,
+  w,
+  z as x,
+  I as y,
+  p as z
+};
+//# sourceMappingURL=Math-CGEH1ClN.mjs.map

package/dist/chunks/Math-CGEH1ClN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Math-CGEH1ClN.mjs","sources":["../../src/Utils/Math.ts"],"sourcesContent":["// ========================================\r\n// ./src/Utils/Math.ts\r\n// ========================================\r\n\r\n// 1. Basic numeric utilities\r\n\r\n/**\r\n * Clamps a number between a minimum and maximum value.\r\n * @param n The number to clamp.\r\n * @param min The minimum allowed value.\r\n * @param max The maximum allowed value.\r\n * @returns The clamped number.\r\n */\r\nexport const clamp = (n: number, min: number, max: number): number =>\r\n  Math.min(Math.max(n, min), max);\r\n\r\n/**\r\n * Rounds a number to a specified number of decimal places.\r\n * @param n The number to round.\r\n * @param precision The number of decimal places (default: 0).\r\n * @returns The rounded number.\r\n */\r\nexport const round = (n: number, precision = 0): number => {\r\n  // 利用指数移动小数点，避免直接乘法带来的精度偏移\r\n  return Number(Math.round(Number(n + 'e' + precision)) + 'e-' + precision);\r\n};\r\n/**\r\n * Normalizes a value from a given range to [0, 1].\r\n * @param n The value to normalize.\r\n * @param min The minimum of the original range.\r\n * @param max The maximum of the original range.\r\n * @returns The normalized value in [0, 1].\r\n */\r\nexport const normalize = (n: number, min: number, max: number): number =>\r\n  min === max ? 0 : (n - min) / (max - min);\r\n\r\n/**\r\n * Computes the greatest common divisor (GCD) of two numbers.\r\n * @param a First number\r\n * @param b Second number\r\n * @returns The GCD (always non-negative)\r\n */\r\nexport const gcd = (a: number, b: number): number => {\r\n  a = Math.abs(a);\r\n  b = Math.abs(b);\r\n  while (b !== 0) {\r\n    const temp = b;\r\n    b = a % b;\r\n    a = temp;\r\n  }\r\n  return a;\r\n};\r\n\r\n/**\r\n * Computes the least common multiple (LCM) of two numbers.\r\n * Uses safe calculation to prevent integer overflow.\r\n * @param a First number\r\n * @param b Second number\r\n * @returns The LCM (always non-negative), 0 if either input is 0\r\n */\r\nexport const lcm = (a: number, b: number): number => {\r\n  if (a === 0 || b === 0) return 0;\r\n\r\n  // 先除后乘，避免 (a * b) 溢出\r\n  return Math.abs((a / gcd(a, b)) * b);\r\n};\r\n\r\n// 2. Range and interval utilities\r\n\r\n/**\r\n * Checks if a number is within a specified range [min, max).\r\n * @param n The number to check.\r\n * @param min The inclusive lower bound.\r\n * @param max The exclusive upper bound.\r\n * @returns `true` if the number is in range.\r\n */\r\nexport const inRange = (n: number, min: number, max: number): boolean =>\r\n  Number.isFinite(n) && n >= min && n < max;\r\n\r\n/**\r\n * Generates an array of numbers from `start` to `end` (exclusive), incremented by `step`.\r\n * @param start The start of the range.\r\n * @param end The end of the range (exclusive).\r\n * @param step The increment between numbers (default: 1).\r\n * @returns An array of numbers.\r\n */\r\nexport const range = (start: number, end: number, step = 1): number[] => {\r\n  if (step === 0 || !Number.isFinite(start) || !Number.isFinite(end)) return [];\r\n  const length = Math.max(Math.ceil((end - start) / step), 0);\r\n  return Array.from({length}, (_, i) => start + i * step);\r\n};\r\n\r\n/**\r\n * Like `range`, but returns numbers in reverse order.\r\n * @param start The start of the range.\r\n * @param end The end of the range (exclusive).\r\n * @param step The increment between numbers (default: 1).\r\n * @returns A reversed array of numbers.\r\n */\r\nexport const rangeRight = (start: number, end: number, step = 1): number[] => {\r\n  if (step === 0 || !Number.isFinite(start) || !Number.isFinite(end)) return [];\r\n  const len = Math.max(Math.ceil((end - start) / step), 0);\r\n  return Array.from({length: len}, (_, i) => start + (len - 1 - i) * step);\r\n};\r\n\r\n/**\r\n * Maps a number from one range to another linearly.\r\n * @param n The input value.\r\n * @param inMin Minimum of the input range.\r\n * @param inMax Maximum of the input range.\r\n * @param outMin Minimum of the output range.\r\n * @param outMax Maximum of the output range.\r\n * @returns The mapped value.\r\n */\r\nexport const mapRange = (\r\n  n: number,\r\n  inMin: number,\r\n  inMax: number,\r\n  outMin: number,\r\n  outMax: number,\r\n): number => {\r\n  if (!Number.isFinite(n) || inMin === inMax) return outMin;\r\n  return ((n - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;\r\n};\r\n\r\n// Random number generation\r\n\r\n/**\r\n * Generates a random floating-point number between `min` (inclusive) and `max` (exclusive).\r\n * @param min The minimum value (inclusive).\r\n * @param max The maximum value (exclusive).\r\n * @returns A random number in [min, max).\r\n */\r\nexport const random = (min: number, max: number): number =>\r\n  Math.random() * (max - min) + min;\r\n\r\n/**\r\n * Generates a random integer between `min` and `max` (both inclusive).\r\n * @param min The minimum integer (inclusive).\r\n * @param max The maximum integer (inclusive).\r\n * @returns A random integer in [min, max].\r\n */\r\nexport const randomInt = (min: number, max: number): number =>\r\n  Math.floor(Math.random() * (max - min + 1)) + min;\r\n\r\n// Aggregation & statistics\r\n\r\n/**\r\n * Computes the sum of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @returns The sum.\r\n */\r\nexport const sum = (nums: number[]): number => nums.reduce((a, b) => a + b, 0);\r\n\r\n/**\r\n * Computes the sum of values extracted from an array using a selector function.\r\n * @param arr The input array.\r\n * @param getValue A function to extract numeric values from items.\r\n * @returns The sum of extracted values.\r\n */\r\nexport const sumBy = <T>(arr: T[], getValue: (item: T) => number): number =>\r\n  arr.reduce((sum, item) => sum + getValue(item), 0);\r\n\r\n/**\r\n * Computes the arithmetic mean (average) of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @returns The mean, or 0 if the array is empty.\r\n */\r\nexport const mean = (nums: number[]): number =>\r\n  nums.length === 0 ? 0 : sum(nums) / nums.length;\r\n\r\n/**\r\n * Computes the arithmetic mean of values extracted from an array.\r\n * @param arr The input array.\r\n * @param getValue A function to extract numeric values from items.\r\n * @returns The mean of extracted values, or 0 if empty.\r\n */\r\nexport const meanBy = <T>(arr: T[], getValue: (item: T) => number): number =>\r\n  arr.length ? sumBy(arr, getValue) / arr.length : 0;\r\n\r\n/**\r\n * Computes the median of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @returns The median value.\r\n */\r\nexport const median = (nums: number[]): number => {\r\n  const s = [...nums].sort((a, b) => a - b),\r\n    m = s.length >> 1;\r\n  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;\r\n};\r\n\r\n/**\r\n * Computes the median of values extracted from an array.\r\n * @param arr The input array.\r\n * @param getValue A function to extract numeric values from items.\r\n * @returns The median of extracted values.\r\n */\r\nexport const medianBy = <T>(\r\n  arr: T[],\r\n  getValue: (item: T) => number,\r\n): number => {\r\n  if (arr.length === 0) {\r\n    return 0;\r\n  }\r\n  const v = arr.map(getValue).sort((a, b) => a - b),\r\n    m = v.length >> 1;\r\n  return v.length % 2 ? v[m] : (v[m - 1] + v[m]) / 2;\r\n};\r\n\r\n/**\r\n * Computes the standard deviation of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @param isSample If `true`, computes sample standard deviation (Bessel's correction).\r\n * @returns The standard deviation.\r\n */\r\nexport const stdDev = (nums: number[], isSample = false): number => {\r\n  if (nums.length === 0) return 0;\r\n  if (isSample && nums.length === 1) return 0;\r\n  const avg = mean(nums);\r\n  const variance =\r\n    sumBy(nums, (n) => (n - avg) ** 2) / (nums.length - (isSample ? 1 : 0));\r\n  return Math.sqrt(variance);\r\n};\r\n\r\n// Comparison & approximation\r\n\r\n/**\r\n * Checks if two numbers are approximately equal within a tolerance.\r\n * @param n1 First number.\r\n * @param n2 Second number.\r\n * @param epsilon Tolerance (default: 1e-10).\r\n * @returns `true` if |n1 - n2| < epsilon.\r\n */\r\nexport const approxEqual = (n1: number, n2: number, epsilon = 1e-10): boolean =>\r\n  Math.abs(n1 - n2) < epsilon;\r\n\r\n/**\r\n * Checks if a number is even.\r\n * @param n The number to check.\r\n * @returns `true` if even.\r\n */\r\nexport const isEven = (n: number): boolean => (n & 1) === 0;\r\n\r\n/**\r\n * Checks if a number is odd.\r\n * @param n The number to check.\r\n * @returns `true` if odd.\r\n */\r\nexport const isOdd = (n: number): boolean => (n & 1) !== 0;\r\n\r\n// Angle utilities\r\n\r\n/**\r\n * Converts degrees to radians.\r\n * @param deg Angle in degrees.\r\n * @returns Angle in radians.\r\n */\r\nexport const toRadians = (deg: number): number => (deg * Math.PI) / 180;\r\n\r\n/**\r\n * Converts radians to degrees.\r\n * @param rad Angle in radians.\r\n * @returns Angle in degrees.\r\n */\r\nexport const toDegrees = (rad: number): number => (rad * 180) / Math.PI;\r\n\r\n/**\r\n * Wraps an angle in degrees to [0, 360).\r\n * @param deg Input angle in degrees.\r\n * @returns Wrapped angle in [0, 360).\r\n */\r\nexport const wrapAngle = (deg: number): number => ((deg % 360) + 360) % 360;\r\n\r\n/**\r\n * Computes the smallest signed difference between two angles (in degrees).\r\n * Result is in [-180, 180].\r\n * @param a First angle in degrees.\r\n * @param b Second angle in degrees.\r\n * @returns The angular difference.\r\n */\r\nexport const angleDist = (a: number, b: number): number => {\r\n  const d = (b - a + 180) % 360;\r\n  return (d < 0 ? d + 360 : d) - 180;\r\n};\r\n\r\n// Geometric distance\r\n\r\n/**\r\n * Computes the Euclidean distance between two 2D points.\r\n * @param x1 X-coordinate of the first point.\r\n * @param y1 Y-coordinate of the first point.\r\n * @param x2 X-coordinate of the second point.\r\n * @param y2 Y-coordinate of the second point.\r\n * @returns The distance.\r\n */\r\nexport const getDistance = (\r\n  x1: number,\r\n  y1: number,\r\n  x2: number,\r\n  y2: number,\r\n): number => Math.hypot(x2 - x1, y2 - y1);\r\n\r\n/**\r\n * Computes the squared Euclidean distance between two 2D points (faster, no sqrt).\r\n * @param x1 X-coordinate of the first point.\r\n * @param y1 Y-coordinate of the first point.\r\n * @param x2 X-coordinate of the second point.\r\n * @param y2 Y-coordinate of the second point.\r\n * @returns The squared distance.\r\n */\r\nexport const getDistanceSq = (\r\n  x1: number,\r\n  y1: number,\r\n  x2: number,\r\n  y2: number,\r\n): number => (x2 - x1) ** 2 + (y2 - y1) ** 2;\r\n\r\n// Linear interpolation\r\n\r\n/**\r\n * Linearly interpolates between `start` and `end` by factor `t`.\r\n * @param start Start value.\r\n * @param end End value.\r\n * @param t Interpolation factor (0 = start, 1 = end).\r\n * @returns The interpolated value.\r\n */\r\nexport const lerp = (start: number, end: number, t: number): number =>\r\n  start + t * (end - start);\r\n\r\n/**\r\n * Computes a point on a quadratic Bezier curve.\r\n * @param p0 Start point {x, y}\r\n * @param p1 Control point {x, y}\r\n * @param p2 End point {x, y}\r\n * @param t Interpolation factor [0, 1]\r\n * @returns The interpolated point {x, y}\r\n */\r\nexport const bezier2 = (\r\n  p0: {x: number; y: number},\r\n  p1: {x: number; y: number},\r\n  p2: {x: number; y: number},\r\n  t: number,\r\n) => {\r\n  const mt = 1 - t;\r\n  return {\r\n    x: mt * mt * p0.x + 2 * mt * t * p1.x + t * t * p2.x,\r\n    y: mt * mt * p0.y + 2 * mt * t * p1.y + t * t * p2.y,\r\n  };\r\n};\r\n"],"names":["clamp","n","min","max","round","precision","normalize","gcd","a","b","temp","lcm","inRange","range","start","end","step","length","_","i","rangeRight","len","mapRange","inMin","inMax","outMin","outMax","random","randomInt","sum","nums","sumBy","arr","getValue","item","mean","meanBy","median","s","m","medianBy","v","stdDev","isSample","avg","variance","approxEqual","n1","n2","epsilon","isEven","isOdd","toRadians","deg","toDegrees","rad","wrapAngle","angleDist","d","getDistance","x1","y1","x2","y2","getDistanceSq","lerp","t","bezier2","p0","p1","p2","mt"],"mappings":"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"}

package/dist/chunks/Math-CWZVxSF-.cjs

@@ -0,0 +1,2 @@
+"use strict";const h=(t,e,n)=>Math.min(Math.max(t,e),n),l=(t,e=0)=>+(Math.round(+(t+"e"+e))+"e-"+e),m=(t,e,n)=>e===n?0:(t-e)/(n-e),c=(t,e)=>{for(t=Math.abs(t),e=Math.abs(e);e!==0;){const n=e;e=t%e,t=n}return t},u=(t,e)=>t===0||e===0?0:Math.abs(t/c(t,e)*e),d=(t,e,n)=>Number.isFinite(t)&&t>=e&&t<n,y=(t,e,n=1)=>{if(n===0||!Number.isFinite(t)||!Number.isFinite(e))return[];const r=Math.max(Math.ceil((e-t)/n),0);return Array.from({length:r},(a,o)=>t+o*n)},M=(t,e,n=1)=>{if(n===0||!Number.isFinite(t)||!Number.isFinite(e))return[];const r=Math.max(Math.ceil((e-t)/n),0);return Array.from({length:r},(a,o)=>t+(r-1-o)*n)},f=(t,e,n,r,a)=>!Number.isFinite(t)||e===n?r:(t-e)*(a-r)/(n-e)+r,D=(t,e)=>Math.random()*(e-t)+t,N=(t,e)=>Math.floor(Math.random()*(e-t+1))+t,i=t=>t.reduce((e,n)=>e+n,0),s=(t,e)=>t.reduce((n,r)=>n+e(r),0),g=t=>t.length===0?0:i(t)/t.length,R=(t,e)=>t.length?s(t,e)/t.length:0,b=t=>{const e=[...t].sort((r,a)=>r-a),n=e.length>>1;return e.length%2?e[n]:(e[n-1]+e[n])/2},v=(t,e)=>{if(t.length===0)return 0;const n=t.map(e).sort((a,o)=>a-o),r=n.length>>1;return n.length%2?n[r]:(n[r-1]+n[r])/2},x=(t,e=!1)=>{if(t.length===0||e&&t.length===1)return 0;const n=g(t),r=s(t,a=>(a-n)**2)/(t.length-(e?1:0));return Math.sqrt(r)},p=(t,e,n=1e-10)=>Math.abs(t-e)<n,B=t=>(t&1)===0,F=t=>(t&1)!==0,q=t=>t*Math.PI/180,z=t=>t*180/Math.PI,A=t=>(t%360+360)%360,E=(t,e)=>{const n=(e-t+180)%360;return(n<0?n+360:n)-180},I=(t,e,n,r)=>Math.hypot(n-t,r-e),w=(t,e,n,r)=>(n-t)**2+(r-e)**2,O=(t,e,n)=>t+n*(e-t),P=(t,e,n,r)=>{const a=1-r;return{x:a*a*t.x+2*a*r*e.x+r*r*n.x,y:a*a*t.y+2*a*r*e.y+r*r*n.y}};exports.angleDist=E;exports.approxEqual=p;exports.bezier2=P;exports.clamp=h;exports.gcd=c;exports.getDistance=I;exports.getDistanceSq=w;exports.inRange=d;exports.isEven=B;exports.isOdd=F;exports.lcm=u;exports.lerp=O;exports.mapRange=f;exports.mean=g;exports.meanBy=R;exports.median=b;exports.medianBy=v;exports.normalize=m;exports.random=D;exports.randomInt=N;exports.range=y;exports.rangeRight=M;exports.round=l;exports.stdDev=x;exports.sum=i;exports.sumBy=s;exports.toDegrees=z;exports.toRadians=q;exports.wrapAngle=A;
+//# sourceMappingURL=Math-CWZVxSF-.cjs.map

package/dist/chunks/Math-CWZVxSF-.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Math-CWZVxSF-.cjs","sources":["../../src/Utils/Math.ts"],"sourcesContent":["// ========================================\r\n// ./src/Utils/Math.ts\r\n// ========================================\r\n\r\n// 1. Basic numeric utilities\r\n\r\n/**\r\n * Clamps a number between a minimum and maximum value.\r\n * @param n The number to clamp.\r\n * @param min The minimum allowed value.\r\n * @param max The maximum allowed value.\r\n * @returns The clamped number.\r\n */\r\nexport const clamp = (n: number, min: number, max: number): number =>\r\n  Math.min(Math.max(n, min), max);\r\n\r\n/**\r\n * Rounds a number to a specified number of decimal places.\r\n * @param n The number to round.\r\n * @param precision The number of decimal places (default: 0).\r\n * @returns The rounded number.\r\n */\r\nexport const round = (n: number, precision = 0): number => {\r\n  // 利用指数移动小数点，避免直接乘法带来的精度偏移\r\n  return Number(Math.round(Number(n + 'e' + precision)) + 'e-' + precision);\r\n};\r\n/**\r\n * Normalizes a value from a given range to [0, 1].\r\n * @param n The value to normalize.\r\n * @param min The minimum of the original range.\r\n * @param max The maximum of the original range.\r\n * @returns The normalized value in [0, 1].\r\n */\r\nexport const normalize = (n: number, min: number, max: number): number =>\r\n  min === max ? 0 : (n - min) / (max - min);\r\n\r\n/**\r\n * Computes the greatest common divisor (GCD) of two numbers.\r\n * @param a First number\r\n * @param b Second number\r\n * @returns The GCD (always non-negative)\r\n */\r\nexport const gcd = (a: number, b: number): number => {\r\n  a = Math.abs(a);\r\n  b = Math.abs(b);\r\n  while (b !== 0) {\r\n    const temp = b;\r\n    b = a % b;\r\n    a = temp;\r\n  }\r\n  return a;\r\n};\r\n\r\n/**\r\n * Computes the least common multiple (LCM) of two numbers.\r\n * Uses safe calculation to prevent integer overflow.\r\n * @param a First number\r\n * @param b Second number\r\n * @returns The LCM (always non-negative), 0 if either input is 0\r\n */\r\nexport const lcm = (a: number, b: number): number => {\r\n  if (a === 0 || b === 0) return 0;\r\n\r\n  // 先除后乘，避免 (a * b) 溢出\r\n  return Math.abs((a / gcd(a, b)) * b);\r\n};\r\n\r\n// 2. Range and interval utilities\r\n\r\n/**\r\n * Checks if a number is within a specified range [min, max).\r\n * @param n The number to check.\r\n * @param min The inclusive lower bound.\r\n * @param max The exclusive upper bound.\r\n * @returns `true` if the number is in range.\r\n */\r\nexport const inRange = (n: number, min: number, max: number): boolean =>\r\n  Number.isFinite(n) && n >= min && n < max;\r\n\r\n/**\r\n * Generates an array of numbers from `start` to `end` (exclusive), incremented by `step`.\r\n * @param start The start of the range.\r\n * @param end The end of the range (exclusive).\r\n * @param step The increment between numbers (default: 1).\r\n * @returns An array of numbers.\r\n */\r\nexport const range = (start: number, end: number, step = 1): number[] => {\r\n  if (step === 0 || !Number.isFinite(start) || !Number.isFinite(end)) return [];\r\n  const length = Math.max(Math.ceil((end - start) / step), 0);\r\n  return Array.from({length}, (_, i) => start + i * step);\r\n};\r\n\r\n/**\r\n * Like `range`, but returns numbers in reverse order.\r\n * @param start The start of the range.\r\n * @param end The end of the range (exclusive).\r\n * @param step The increment between numbers (default: 1).\r\n * @returns A reversed array of numbers.\r\n */\r\nexport const rangeRight = (start: number, end: number, step = 1): number[] => {\r\n  if (step === 0 || !Number.isFinite(start) || !Number.isFinite(end)) return [];\r\n  const len = Math.max(Math.ceil((end - start) / step), 0);\r\n  return Array.from({length: len}, (_, i) => start + (len - 1 - i) * step);\r\n};\r\n\r\n/**\r\n * Maps a number from one range to another linearly.\r\n * @param n The input value.\r\n * @param inMin Minimum of the input range.\r\n * @param inMax Maximum of the input range.\r\n * @param outMin Minimum of the output range.\r\n * @param outMax Maximum of the output range.\r\n * @returns The mapped value.\r\n */\r\nexport const mapRange = (\r\n  n: number,\r\n  inMin: number,\r\n  inMax: number,\r\n  outMin: number,\r\n  outMax: number,\r\n): number => {\r\n  if (!Number.isFinite(n) || inMin === inMax) return outMin;\r\n  return ((n - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;\r\n};\r\n\r\n// Random number generation\r\n\r\n/**\r\n * Generates a random floating-point number between `min` (inclusive) and `max` (exclusive).\r\n * @param min The minimum value (inclusive).\r\n * @param max The maximum value (exclusive).\r\n * @returns A random number in [min, max).\r\n */\r\nexport const random = (min: number, max: number): number =>\r\n  Math.random() * (max - min) + min;\r\n\r\n/**\r\n * Generates a random integer between `min` and `max` (both inclusive).\r\n * @param min The minimum integer (inclusive).\r\n * @param max The maximum integer (inclusive).\r\n * @returns A random integer in [min, max].\r\n */\r\nexport const randomInt = (min: number, max: number): number =>\r\n  Math.floor(Math.random() * (max - min + 1)) + min;\r\n\r\n// Aggregation & statistics\r\n\r\n/**\r\n * Computes the sum of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @returns The sum.\r\n */\r\nexport const sum = (nums: number[]): number => nums.reduce((a, b) => a + b, 0);\r\n\r\n/**\r\n * Computes the sum of values extracted from an array using a selector function.\r\n * @param arr The input array.\r\n * @param getValue A function to extract numeric values from items.\r\n * @returns The sum of extracted values.\r\n */\r\nexport const sumBy = <T>(arr: T[], getValue: (item: T) => number): number =>\r\n  arr.reduce((sum, item) => sum + getValue(item), 0);\r\n\r\n/**\r\n * Computes the arithmetic mean (average) of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @returns The mean, or 0 if the array is empty.\r\n */\r\nexport const mean = (nums: number[]): number =>\r\n  nums.length === 0 ? 0 : sum(nums) / nums.length;\r\n\r\n/**\r\n * Computes the arithmetic mean of values extracted from an array.\r\n * @param arr The input array.\r\n * @param getValue A function to extract numeric values from items.\r\n * @returns The mean of extracted values, or 0 if empty.\r\n */\r\nexport const meanBy = <T>(arr: T[], getValue: (item: T) => number): number =>\r\n  arr.length ? sumBy(arr, getValue) / arr.length : 0;\r\n\r\n/**\r\n * Computes the median of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @returns The median value.\r\n */\r\nexport const median = (nums: number[]): number => {\r\n  const s = [...nums].sort((a, b) => a - b),\r\n    m = s.length >> 1;\r\n  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;\r\n};\r\n\r\n/**\r\n * Computes the median of values extracted from an array.\r\n * @param arr The input array.\r\n * @param getValue A function to extract numeric values from items.\r\n * @returns The median of extracted values.\r\n */\r\nexport const medianBy = <T>(\r\n  arr: T[],\r\n  getValue: (item: T) => number,\r\n): number => {\r\n  if (arr.length === 0) {\r\n    return 0;\r\n  }\r\n  const v = arr.map(getValue).sort((a, b) => a - b),\r\n    m = v.length >> 1;\r\n  return v.length % 2 ? v[m] : (v[m - 1] + v[m]) / 2;\r\n};\r\n\r\n/**\r\n * Computes the standard deviation of an array of numbers.\r\n * @param nums Array of numbers.\r\n * @param isSample If `true`, computes sample standard deviation (Bessel's correction).\r\n * @returns The standard deviation.\r\n */\r\nexport const stdDev = (nums: number[], isSample = false): number => {\r\n  if (nums.length === 0) return 0;\r\n  if (isSample && nums.length === 1) return 0;\r\n  const avg = mean(nums);\r\n  const variance =\r\n    sumBy(nums, (n) => (n - avg) ** 2) / (nums.length - (isSample ? 1 : 0));\r\n  return Math.sqrt(variance);\r\n};\r\n\r\n// Comparison & approximation\r\n\r\n/**\r\n * Checks if two numbers are approximately equal within a tolerance.\r\n * @param n1 First number.\r\n * @param n2 Second number.\r\n * @param epsilon Tolerance (default: 1e-10).\r\n * @returns `true` if |n1 - n2| < epsilon.\r\n */\r\nexport const approxEqual = (n1: number, n2: number, epsilon = 1e-10): boolean =>\r\n  Math.abs(n1 - n2) < epsilon;\r\n\r\n/**\r\n * Checks if a number is even.\r\n * @param n The number to check.\r\n * @returns `true` if even.\r\n */\r\nexport const isEven = (n: number): boolean => (n & 1) === 0;\r\n\r\n/**\r\n * Checks if a number is odd.\r\n * @param n The number to check.\r\n * @returns `true` if odd.\r\n */\r\nexport const isOdd = (n: number): boolean => (n & 1) !== 0;\r\n\r\n// Angle utilities\r\n\r\n/**\r\n * Converts degrees to radians.\r\n * @param deg Angle in degrees.\r\n * @returns Angle in radians.\r\n */\r\nexport const toRadians = (deg: number): number => (deg * Math.PI) / 180;\r\n\r\n/**\r\n * Converts radians to degrees.\r\n * @param rad Angle in radians.\r\n * @returns Angle in degrees.\r\n */\r\nexport const toDegrees = (rad: number): number => (rad * 180) / Math.PI;\r\n\r\n/**\r\n * Wraps an angle in degrees to [0, 360).\r\n * @param deg Input angle in degrees.\r\n * @returns Wrapped angle in [0, 360).\r\n */\r\nexport const wrapAngle = (deg: number): number => ((deg % 360) + 360) % 360;\r\n\r\n/**\r\n * Computes the smallest signed difference between two angles (in degrees).\r\n * Result is in [-180, 180].\r\n * @param a First angle in degrees.\r\n * @param b Second angle in degrees.\r\n * @returns The angular difference.\r\n */\r\nexport const angleDist = (a: number, b: number): number => {\r\n  const d = (b - a + 180) % 360;\r\n  return (d < 0 ? d + 360 : d) - 180;\r\n};\r\n\r\n// Geometric distance\r\n\r\n/**\r\n * Computes the Euclidean distance between two 2D points.\r\n * @param x1 X-coordinate of the first point.\r\n * @param y1 Y-coordinate of the first point.\r\n * @param x2 X-coordinate of the second point.\r\n * @param y2 Y-coordinate of the second point.\r\n * @returns The distance.\r\n */\r\nexport const getDistance = (\r\n  x1: number,\r\n  y1: number,\r\n  x2: number,\r\n  y2: number,\r\n): number => Math.hypot(x2 - x1, y2 - y1);\r\n\r\n/**\r\n * Computes the squared Euclidean distance between two 2D points (faster, no sqrt).\r\n * @param x1 X-coordinate of the first point.\r\n * @param y1 Y-coordinate of the first point.\r\n * @param x2 X-coordinate of the second point.\r\n * @param y2 Y-coordinate of the second point.\r\n * @returns The squared distance.\r\n */\r\nexport const getDistanceSq = (\r\n  x1: number,\r\n  y1: number,\r\n  x2: number,\r\n  y2: number,\r\n): number => (x2 - x1) ** 2 + (y2 - y1) ** 2;\r\n\r\n// Linear interpolation\r\n\r\n/**\r\n * Linearly interpolates between `start` and `end` by factor `t`.\r\n * @param start Start value.\r\n * @param end End value.\r\n * @param t Interpolation factor (0 = start, 1 = end).\r\n * @returns The interpolated value.\r\n */\r\nexport const lerp = (start: number, end: number, t: number): number =>\r\n  start + t * (end - start);\r\n\r\n/**\r\n * Computes a point on a quadratic Bezier curve.\r\n * @param p0 Start point {x, y}\r\n * @param p1 Control point {x, y}\r\n * @param p2 End point {x, y}\r\n * @param t Interpolation factor [0, 1]\r\n * @returns The interpolated point {x, y}\r\n */\r\nexport const bezier2 = (\r\n  p0: {x: number; y: number},\r\n  p1: {x: number; y: number},\r\n  p2: {x: number; y: number},\r\n  t: number,\r\n) => {\r\n  const mt = 1 - t;\r\n  return {\r\n    x: mt * mt * p0.x + 2 * mt * t * p1.x + t * t * p2.x,\r\n    y: mt * mt * p0.y + 2 * mt * t * p1.y + t * t * p2.y,\r\n  };\r\n};\r\n"],"names":["clamp","n","min","max","round","precision","normalize","gcd","a","b","temp","lcm","inRange","range","start","end","step","length","_","i","rangeRight","len","mapRange","inMin","inMax","outMin","outMax","random","randomInt","sum","nums","sumBy","arr","getValue","item","mean","meanBy","median","s","m","medianBy","v","stdDev","isSample","avg","variance","approxEqual","n1","n2","epsilon","isEven","isOdd","toRadians","deg","toDegrees","rad","wrapAngle","angleDist","d","getDistance","x1","y1","x2","y2","getDistanceSq","lerp","t","bezier2","p0","p1","p2","mt"],"mappings":"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"}

package/dist/chunks/base-B9k8Lqvf.mjs

@@ -0,0 +1,56 @@
+import { i as c } from "./helper-BVabbpmX.mjs";
+const u = (t) => t, i = () => {
+}, l = async () => {
+}, f = (t) => (r) => t(r), p = (t) => (...r) => !t(...r), d = (t) => {
+  let r = !1, e;
+  return (...n) => (r || (r = !0, e = t(...n)), e);
+}, h = (t, r) => (...e) => t(...e.slice(0, r)), y = (t) => (...r) => {
+  const e = t.length > 0 ? t.length - 1 : 0, n = r.slice(0, e), s = r.slice(e);
+  return t(n, s);
+}, m = (t) => (r) => t(...r), g = (t, ...r) => (...e) => t(...r, ...e), v = (t, ...r) => (...e) => t(...e, ...r), x = (t, r) => {
+  let e = 0;
+  return (...n) => {
+    if (e++, e >= t)
+      return r(...n);
+  };
+}, b = (t, r) => {
+  let e = 0, n;
+  return (...s) => (e < t && (e++, n = r(...s)), n);
+}, k = (t, r) => {
+  const e = /* @__PURE__ */ new Map();
+  return (...n) => {
+    const s = r ? r(...n) : JSON.stringify(n);
+    if (e.has(s))
+      return e.get(s);
+    const o = t(...n);
+    return e.set(s, o), o;
+  };
+}, L = (t) => function(...r) {
+  try {
+    const e = t.apply(this, r);
+    return c(e) ? e.then(
+      (n) => [void 0, n],
+      (n) => [n, void 0]
+    ) : [void 0, e];
+  } catch (e) {
+    return [e, void 0];
+  }
+};
+export {
+  l as a,
+  p as b,
+  h as c,
+  v as d,
+  x as e,
+  b as f,
+  L as g,
+  u as i,
+  k as m,
+  i as n,
+  d as o,
+  g as p,
+  y as r,
+  m as s,
+  f as u
+};
+//# sourceMappingURL=base-B9k8Lqvf.mjs.map

package/dist/chunks/base-B9k8Lqvf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-B9k8Lqvf.mjs","sources":["../../src/Utils/Functions/base.ts"],"sourcesContent":["// ========================================\r\n// ./src/Utils/Functions/base.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unsafe-return */\r\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\n/* eslint-disable @typescript-eslint/no-unsafe-argument */\r\n\r\nimport {isPromiseLike} from 'src/helper';\r\n\r\n/**\r\n * Generic type for an identity function.\r\n * @template T - The type of the input and output value.\r\n */\r\nexport type IdentityFn = <T>(x: T) => T;\r\n\r\n/**\r\n * A function that returns the same value passed to it.\r\n * @template T\r\n * @param x - The value to return\r\n * @returns The input value `x`\r\n * @satisfies {IdentityFn}\r\n */\r\nexport const identity: IdentityFn = (x) => x;\r\n\r\nexport const noop = (): void => {};\r\nexport const asyncNoop = async (): Promise<void> => {};\r\n\r\n/**\r\n * Creates a function that accepts up to one argument, ignoring any additional arguments.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to cap arguments for.\r\n * @returns The new function.\r\n */\r\nexport const unary = <T, Ret>(\r\n  fn: (arg: T, ...rest: unknown[]) => Ret,\r\n): ((arg: T) => Ret) => {\r\n  return (arg) => fn(arg);\r\n};\r\n\r\n/**\r\n * Creates a function that negates the result of the predicate `fn`.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @param predicate - The predicate to negate.\r\n * @returns The new negated function.\r\n */\r\nexport const negate = <Args extends unknown[]>(\r\n  predicate: (...args: Args) => boolean,\r\n): ((...args: Args) => boolean) => {\r\n  return (...args) => !predicate(...args);\r\n};\r\n\r\n/**\r\n * Creates a function that is restricted to invoking `fn` once.\r\n * Repeat calls to the function return the value of the first invocation.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to restrict.\r\n * @returns The new restricted function.\r\n */\r\nexport const once = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n): ((...args: Args) => Ret) => {\r\n  let done = false;\r\n  let result: Ret;\r\n\r\n  return (...args) => {\r\n    if (!done) {\r\n      done = true;\r\n      result = fn(...args);\r\n    }\r\n    return result;\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with only the first `n` arguments provided.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to cap arguments for.\r\n * @param n - The number of arguments to accept.\r\n * @returns The new function.\r\n */\r\nexport const ary = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n  n: number,\r\n): ((...args: Args) => Ret) => {\r\n  return (...args) => fn(...(args.slice(0, n) as Args));\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with arguments transformed.\r\n * The implementation splits arguments based on `fn.length`, expecting `fn` to take two arguments:\r\n * 1. A tuple of the first `fn.length - 1` arguments.\r\n * 2. A tuple of the remaining arguments.\r\n *\r\n * Note: Based on the implementation `fn.length - 1`, `FixedArgs` is strictly a single-element tuple.\r\n *\r\n * @template FixedArgs - The fixed arguments tuple (must be length 1).\r\n * @template RestArgs - The rest arguments tuple.\r\n * @template Ret - The return type.\r\n * @param fn - The function to transform arguments for.\r\n * @returns The new function.\r\n */\r\nexport const rest = <\r\n  FixedArgs extends [unknown],\r\n  RestArgs extends unknown[],\r\n  Ret,\r\n>(\r\n  fn: (fixed: FixedArgs, rest: RestArgs) => Ret,\r\n): ((...args: [...FixedArgs, ...RestArgs]) => Ret) => {\r\n  return (...args) => {\r\n    const fixedLength = fn.length > 0 ? fn.length - 1 : 0;\r\n    const fixed = args.slice(0, fixedLength) as FixedArgs;\r\n    const restParts = args.slice(fixedLength) as RestArgs;\r\n    return fn(fixed, restParts);\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with the `args` spread as an array.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to spread arguments for.\r\n * @returns The new function.\r\n */\r\nexport const spread = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n): ((args: Args) => Ret) => {\r\n  return (args) => fn(...args);\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with `partial` arguments prepended to those provided to the new function.\r\n *\r\n * @template Fixed - The fixed arguments type.\r\n * @template Rest - The remaining arguments type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to partially apply arguments to.\r\n * @param fixedArgs - The arguments to prepend.\r\n * @returns The new partially applied function.\r\n */\r\nexport const partial = <Fixed extends unknown[], Rest extends unknown[], Ret>(\r\n  fn: (...args: [...Fixed, ...Rest]) => Ret,\r\n  ...fixedArgs: Fixed\r\n): ((...rest: Rest) => Ret) => {\r\n  return (...restArgs) => fn(...fixedArgs, ...restArgs);\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with `partial` arguments appended to those provided to the new function.\r\n *\r\n * @template Fixed - The fixed arguments type (appended).\r\n * @template Rest - The remaining arguments type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to partially apply arguments to.\r\n * @param fixedArgs - The arguments to append.\r\n * @returns The new partially applied function.\r\n */\r\nexport const partialRight = <\r\n  T extends (...args: any[]) => any,\r\n  Fixed extends any[],\r\n>(\r\n  fn: T,\r\n  ...fixedArgs: Fixed\r\n): ((\r\n  ...rest: T extends (...args: [...infer Rest, ...Fixed]) => any ? Rest : never\r\n) => ReturnType<T>) => {\r\n  return (...restArgs: any[]) => fn(...restArgs, ...fixedArgs);\r\n};\r\n/**\r\n * Creates a function that invokes `fn` only after being called `n` times.\r\n *\r\n * @template Args - The arguments type.\r\n * @template Ret - The return type.\r\n * @param n - The number of calls before the function is invoked.\r\n * @param fn - The function to restrict.\r\n * @returns The new restricted function.\r\n */\r\nexport const after = <Args extends unknown[], Ret>(\r\n  n: number,\r\n  fn: (...args: Args) => Ret,\r\n): ((...args: Args) => Ret | undefined) => {\r\n  let count = 0;\r\n  return (...args) => {\r\n    count++;\r\n    if (count >= n) {\r\n      return fn(...args);\r\n    }\r\n    return undefined;\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` while it's called less than `n` times.\r\n *\r\n * @template Args - The arguments type.\r\n * @template Ret - The return type.\r\n * @param n - The number of calls before the function stops being invoked.\r\n * @param fn - The function to restrict.\r\n * @returns The new restricted function.\r\n */\r\nexport const before = <Args extends unknown[], Ret>(\r\n  n: number,\r\n  fn: (...args: Args) => Ret,\r\n): ((...args: Args) => Ret | undefined) => {\r\n  let count = 0;\r\n  let lastResult: Ret | undefined;\r\n  return (...args) => {\r\n    if (count < n) {\r\n      count++;\r\n      lastResult = fn(...args);\r\n    }\r\n    return lastResult;\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that memoizes the result of `fn`.\r\n * If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided.\r\n *\r\n * @template Args - The arguments type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to memoize.\r\n * @param resolver - The function to resolve the cache key.\r\n * @returns The new memoized function.\r\n */\r\nexport const memoize = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n  resolver?: (...args: Args) => unknown,\r\n): ((...args: Args) => Ret) => {\r\n  const cache = new Map<unknown, Ret>();\r\n  return (...args) => {\r\n    const key = resolver ? resolver(...args) : JSON.stringify(args);\r\n\r\n    if (cache.has(key)) {\r\n      return cache.get(key) as Ret;\r\n    }\r\n    const result = fn(...args);\r\n    cache.set(key, result);\r\n    return result;\r\n  };\r\n};\r\n\r\ntype AttemptResult<T> =\r\n  T extends PromiseLike<infer R>\r\n    ? Promise<[undefined, R] | [unknown, undefined]>\r\n    : [undefined, T] | [unknown, undefined];\r\n\r\n/**\r\n *\r\n * Wraps any function – synchronous or asynchronous – and returns a tuple `[error, result]` instead of throwing.\r\n * It catches **everything**: thrown exceptions and rejected promises alike, turning them into a consistent error-first return.\r\n * Eliminates try-catch blocks and makes error handling explicit and type‑safe.\r\n *\r\n * @template Args - The arguments tuple type of the wrapped function\r\n * @template R - The return type of the wrapped function\r\n * @param fn - The function to wrap\r\n * @returns A function that returns `[undefined, result]` on success, or `[error, undefined]` on failure\r\n *\r\n * @example\r\n * ```typescript\r\n * const [err, data] = attempt(JSON.parse)('{\"a\":1}');\r\n * if (err) console.error('Parse failed:', err);\r\n * else console.log('Parsed:', data);\r\n * ```\r\n *\r\n * @example\r\n * ```typescript\r\n * // Works seamlessly with async functions\r\n * const fetchData = async (url: string) => ({ data: 'response' });\r\n * const [err, data] = await attempt(fetchData)('https://api.example.com');\r\n * ```\r\n */\r\nexport const attempt = <Args extends unknown[], R>(\r\n  fn: (...args: Args) => R,\r\n): ((\r\n  this: ThisParameterType<typeof fn>,\r\n  ...args: Args\r\n) => AttemptResult<R>) => {\r\n  return function (\r\n    this: ThisParameterType<typeof fn>,\r\n    ...args: Args\r\n  ): AttemptResult<R> {\r\n    try {\r\n      const result = fn.apply(this, args);\r\n\r\n      // 处理异步函数\r\n      if (isPromiseLike(result))\r\n        return (result as PromiseLike<R>).then(\r\n          (value) => [undefined, value],\r\n          (err: unknown) => [err, undefined],\r\n        ) as AttemptResult<R>;\r\n\r\n      // 处理同步函数\r\n      return [undefined, result] as AttemptResult<R>;\r\n    } catch (err) {\r\n      return [err, undefined] as AttemptResult<R>;\r\n    }\r\n  };\r\n};\r\n"],"names":["identity","x","noop","asyncNoop","unary","fn","arg","negate","predicate","args","once","done","result","ary","n","rest","fixedLength","fixed","restParts","spread","partial","fixedArgs","restArgs","partialRight","after","count","before","lastResult","memoize","resolver","cache","key","attempt","isPromiseLike","value","err"],"mappings":";AAsBO,MAAMA,IAAuB,CAACC,MAAMA,GAE9BC,IAAO,MAAY;AAAC,GACpBC,IAAY,YAA2B;AAAC,GAUxCC,IAAQ,CACnBC,MAEO,CAACC,MAAQD,EAAGC,CAAG,GAUXC,IAAS,CACpBC,MAEO,IAAIC,MAAS,CAACD,EAAU,GAAGC,CAAI,GAY3BC,IAAO,CAClBL,MAC6B;AAC7B,MAAIM,IAAO,IACPC;AAEJ,SAAO,IAAIH,OACJE,MACHA,IAAO,IACPC,IAASP,EAAG,GAAGI,CAAI,IAEdG;AAEX,GAWaC,IAAM,CACjBR,GACAS,MAEO,IAAIL,MAASJ,EAAG,GAAII,EAAK,MAAM,GAAGK,CAAC,CAAU,GAiBzCC,IAAO,CAKlBV,MAEO,IAAII,MAAS;AAClB,QAAMO,IAAcX,EAAG,SAAS,IAAIA,EAAG,SAAS,IAAI,GAC9CY,IAAQR,EAAK,MAAM,GAAGO,CAAW,GACjCE,IAAYT,EAAK,MAAMO,CAAW;AACxC,SAAOX,EAAGY,GAAOC,CAAS;AAC5B,GAWWC,IAAS,CACpBd,MAEO,CAACI,MAASJ,EAAG,GAAGI,CAAI,GAahBW,IAAU,CACrBf,MACGgB,MAEI,IAAIC,MAAajB,EAAG,GAAGgB,GAAW,GAAGC,CAAQ,GAazCC,IAAe,CAI1BlB,MACGgB,MAII,IAAIC,MAAoBjB,EAAG,GAAGiB,GAAU,GAAGD,CAAS,GAWhDG,IAAQ,CACnBV,GACAT,MACyC;AACzC,MAAIoB,IAAQ;AACZ,SAAO,IAAIhB,MAAS;AAElB,QADAgB,KACIA,KAASX;AACX,aAAOT,EAAG,GAAGI,CAAI;AAAA,EAGrB;AACF,GAWaiB,IAAS,CACpBZ,GACAT,MACyC;AACzC,MAAIoB,IAAQ,GACRE;AACJ,SAAO,IAAIlB,OACLgB,IAAQX,MACVW,KACAE,IAAatB,EAAG,GAAGI,CAAI,IAElBkB;AAEX,GAYaC,IAAU,CACrBvB,GACAwB,MAC6B;AAC7B,QAAMC,wBAAY,IAAA;AAClB,SAAO,IAAIrB,MAAS;AAClB,UAAMsB,IAAMF,IAAWA,EAAS,GAAGpB,CAAI,IAAI,KAAK,UAAUA,CAAI;AAE9D,QAAIqB,EAAM,IAAIC,CAAG;AACf,aAAOD,EAAM,IAAIC,CAAG;AAEtB,UAAMnB,IAASP,EAAG,GAAGI,CAAI;AACzB,WAAAqB,EAAM,IAAIC,GAAKnB,CAAM,GACdA;AAAA,EACT;AACF,GAgCaoB,IAAU,CACrB3B,MAKO,YAEFI,GACe;AAClB,MAAI;AACF,UAAMG,IAASP,EAAG,MAAM,MAAMI,CAAI;AAGlC,WAAIwB,EAAcrB,CAAM,IACdA,EAA0B;AAAA,MAChC,CAACsB,MAAU,CAAC,QAAWA,CAAK;AAAA,MAC5B,CAACC,MAAiB,CAACA,GAAK,MAAS;AAAA,IAAA,IAI9B,CAAC,QAAWvB,CAAM;AAAA,EAC3B,SAASuB,GAAK;AACZ,WAAO,CAACA,GAAK,MAAS;AAAA,EACxB;AACF;"}

package/dist/chunks/base-BTXL1y_I.cjs

@@ -0,0 +1,2 @@
+"use strict";const s=require("./helper-tsqZMRHW.cjs"),c=r=>({ok:!0,value:r}),n=r=>({ok:!1,error:r}),i=r=>r.ok,u=r=>!r.ok,a=(r,o)=>r.ok&&o(r.value),k=(r,o)=>!r.ok&&o(r.error);function f(r,o,t){try{const e=r();return c(e)}catch(e){return t&&t(e)?n(e):n(s.UnknownError.from(e,o))}}async function m(r,o,t){try{const e=await r();return c(e)}catch(e){return t&&t(e)?n(e):n(s.UnknownError.from(e,o))}}const E=r=>r.ok?Promise.resolve(r.value):Promise.reject(s.ensureError(r.error)),w=r=>r.then(c).catch(o=>n(s.UnknownError.from(o))),y=async r=>{if(!s.isPromiseLike(r))return r;try{return await r}catch(o){return n(s.wrapError(o))}};exports.Err=n;exports.Ok=c;exports.fromPromise=w;exports.isErr=u;exports.isErrAnd=k;exports.isOk=i;exports.isOkAnd=a;exports.normalizeToResult=y;exports.safeExecute=f;exports.safeExecuteAsync=m;exports.toPromise=E;
+//# sourceMappingURL=base-BTXL1y_I.cjs.map

package/dist/chunks/base-BTXL1y_I.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-BTXL1y_I.cjs","sources":["../../src/Result/base.ts"],"sourcesContent":["// ========================================\r\n// ./src/Result/base.ts\r\n// ========================================\r\nimport type {Result, Success, Failure, AsyncResult, AnyResult} from './types';\r\nimport {UnknownError, ensureError} from '../unknown-error';\r\nimport {isPromiseLike, wrapError} from '../helper';\r\n\r\n/**\r\n * Constructs a successful Result instance.\r\n * @typeParam T - The type of the successful value\r\n * @param value - The value upon success\r\n * @returns A successful Result\r\n */\r\nexport const Ok = <T, E = never>(value: T): Result<T, E> =>\r\n  ({\r\n    ok: true,\r\n    value,\r\n  }) as const;\r\n\r\n/**\r\n * Get the value of Result<T, never>\r\n * @typeParam T - The type of the error\r\n * @param error - The error upon failure\r\n * @returns A failed Result\r\n */\r\nexport const Err = <T = never, E = unknown>(error: E): Result<T, E> =>\r\n  ({\r\n    ok: false,\r\n    error,\r\n  }) as const;\r\n\r\n/**\r\n * Checks if the Result is in the Success (Ok) state.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @returns Returns true if the Result is Success\r\n */\r\nexport const isOk = <T, E>(result: Result<T, E>): result is Success<T> =>\r\n  result.ok;\r\n\r\n/**\r\n * Checks if the Result is in the Failure (Err) state.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @returns Returns true if the Result is Failure\r\n */\r\nexport const isErr = <T, E>(result: Result<T, E>): result is Failure<E> =>\r\n  !result.ok;\r\n\r\n/**\r\n * Checks if the Result is Success AND its value satisfies the given predicate.\r\n * @typeParam T - The type of the success valueexport function isPromiseLike<T>(value: unknown): value is PromiseLike<T> {\r\n   return value !== null && typeof value === 'object' && 'then' in value;\r\n }\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @param fn - The predicate function to check the success value\r\n * @returns Returns true if the Result is Success and the condition is met\r\n */\r\nexport const isOkAnd = <T, E>(\r\n  result: Result<T, E>,\r\n  fn: (value: T) => boolean,\r\n): boolean => result.ok && fn(result.value);\r\n\r\n/**\r\n * Checks if the Result is Failure AND its error satisfies the given predicate.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @param fn - The predicate function to check the error value\r\n * @returns Returns true if the Result is Failure and the condition is met\r\n */\r\nexport const isErrAnd = <T, E>(\r\n  result: Result<T, E>,\r\n  fn: (error: E) => boolean,\r\n): boolean => !result.ok && fn(result.error);\r\n\r\n// ============================================\r\n// 异常安全执行器\r\n// ============================================\r\n\r\n/**\r\n * Safely executes a synchronous function, catching any thrown exception and wrapping it as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @param fn - The synchronous function that might throw an exception\r\n * @param message - The error message to be used as the primary message for the UnknownError if an exception is thrown\r\n * @returns Returns Ok(T) on success, or Err(UnknownError) on failure\r\n */\r\nexport function safeExecute<T>(\r\n  fn: () => T,\r\n  message?: string,\r\n): Result<T, UnknownError>;\r\n\r\n/**\r\n * Safely executes a synchronous function, catching any thrown exception. If the exception is of the declared type E,\r\n * it returns Err(E); otherwise, it is wrapped as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @typeParam E - The declared expected error type\r\n * @param fn - The synchronous function that might throw an exception\r\n * @param message - The error message to be used as the primary message for the UnknownError if an unknown exception is thrown\r\n * @param isExpectedError - A type guard function to determine if the caught error is of type E\r\n * @returns Returns Ok(T) on success, or Err(E | UnknownError) on failure\r\n */\r\nexport function safeExecute<T, E>(\r\n  fn: () => T,\r\n  message: string | undefined,\r\n  isExpectedError: (error: unknown) => error is E,\r\n): Result<T, E | UnknownError>;\r\n\r\nexport function safeExecute<T, E = never>(\r\n  fn: () => T,\r\n  message?: string,\r\n  isExpectedError?: (error: unknown) => error is E,\r\n): Result<T, E | UnknownError> {\r\n  try {\r\n    const value = fn();\r\n    return Ok(value);\r\n  } catch (raw_error) {\r\n    if (isExpectedError && isExpectedError(raw_error)) {\r\n      return Err(raw_error);\r\n    }\r\n\r\n    return Err(UnknownError.from(raw_error, message));\r\n  }\r\n}\r\n\r\n/**\r\n * Safely executes an asynchronous function, catching its rejection or thrown exception and wrapping it as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @param async_fn - The asynchronous function that might throw or reject\r\n * @param message - The error message to be used as the primary message for the UnknownError\r\n * @returns Returns Promise<Ok(T)> on success, or Promise<Err(UnknownError)> on failure\r\n */\r\nexport async function safeExecuteAsync<T>(\r\n  async_fn: () => Promise<T>,\r\n  message?: string,\r\n): AsyncResult<T, UnknownError>;\r\n\r\n/**\r\n * Safely executes an asynchronous function, catching its rejection or thrown exception. If the exception is of the declared type E,\r\n * it returns Err(E); otherwise, it is wrapped as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @typeParam E - The declared expected error type\r\n * @param async_fn - The asynchronous function that might throw or reject\r\n * @param message - The error message to be used as the primary message for the UnknownError if an unknown exception is thrown\r\n * @param isExpectedError - A type guard function to determine if the caught error is of type E\r\n * @returns Returns Promise<Ok(T)> on success, or Promise<Err(E | UnknownError)> on failure\r\n */\r\nexport async function safeExecuteAsync<T, E>(\r\n  async_fn: () => Promise<T>,\r\n  message: string | undefined,\r\n  isExpectedError: (error: unknown) => error is E,\r\n): AsyncResult<T, E | UnknownError>;\r\nexport async function safeExecuteAsync<T, E = never>(\r\n  async_fn: () => Promise<T>,\r\n  message?: string,\r\n  isExpectedError?: (error: unknown) => error is E,\r\n): AsyncResult<T, E | UnknownError> {\r\n  try {\r\n    const value = await async_fn();\r\n    return Ok(value);\r\n  } catch (raw_error) {\r\n    if (isExpectedError && isExpectedError(raw_error)) {\r\n      return Err(raw_error);\r\n    }\r\n    return Err(UnknownError.from(raw_error, message));\r\n  }\r\n}\r\n\r\n// ========================================\r\n// 互相转换\r\n// ========================================\r\n\r\n/**\r\n * Converts a Result into a Promise. Success resolves, Failure rejects.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result to convert\r\n * @returns The resulting Promise\r\n * @throws If the Result is Failure, it rejects with the error wrapped by `ensureError`\r\n */\r\nexport const toPromise = <T, E>(result: Result<T, E>): Promise<T> =>\r\n  result.ok\r\n    ? Promise.resolve(result.value)\r\n    : Promise.reject(ensureError(result.error));\r\n\r\n/**\r\n * Converts a Promise into an AsyncResult. Resolution becomes Ok, and rejection becomes Err(UnknownError).\r\n * @typeParam T - The type of the success value\r\n * @param promise - The Promise to convert\r\n * @returns The resulting AsyncResult\r\n */\r\nexport const fromPromise = <T>(\r\n  promise: Promise<T>,\r\n): AsyncResult<T, UnknownError> =>\r\n  promise.then(Ok).catch((e) => Err(UnknownError.from(e)));\r\n\r\n/**\r\n * Safely normalizes an AnyResult (synchronous Result or asynchronous AsyncResult/Thenable) into a Promise<Result>.\r\n * It handles the Promise resolve/reject paths, ensuring rejection is always encapsulated as Err(UnknownError).\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param awaitable - The value to normalize, which can be a Result, Promise<Result>, or a Thenable object\r\n * @returns The normalized Promise<Result>\r\n */\r\nexport const normalizeToResult = async <T, E>(\r\n  awaitable: AnyResult<T, E>,\r\n): Promise<Result<T, E | UnknownError | DOMException>> => {\r\n  // 同步 Result 快速路径\r\n  if (!isPromiseLike(awaitable)) return awaitable;\r\n\r\n  // 统一处理所有异步情况 (Promise & Thenable)\r\n  try {\r\n    return await awaitable;\r\n  } catch (raw_error) {\r\n    return Err(wrapError(raw_error));\r\n  }\r\n};\r\n"],"names":["Ok","value","Err","error","isOk","result","isErr","isOkAnd","fn","isErrAnd","safeExecute","message","isExpectedError","raw_error","UnknownError","safeExecuteAsync","async_fn","toPromise","ensureError","fromPromise","promise","e","normalizeToResult","awaitable","isPromiseLike","wrapError"],"mappings":"sDAaaA,EAAoBC,IAC9B,CACC,GAAI,GACJ,MAAAA,CACF,GAQWC,EAA+BC,IACzC,CACC,GAAI,GACJ,MAAAA,CACF,GASWC,EAAcC,GACzBA,EAAO,GASIC,EAAeD,GAC1B,CAACA,EAAO,GAYGE,EAAU,CACrBF,EACAG,IACYH,EAAO,IAAMG,EAAGH,EAAO,KAAK,EAU7BI,EAAW,CACtBJ,EACAG,IACY,CAACH,EAAO,IAAMG,EAAGH,EAAO,KAAK,EAkCpC,SAASK,EACdF,EACAG,EACAC,EAC6B,CAC7B,GAAI,CACF,MAAMX,EAAQO,EAAA,EACd,OAAOR,EAAGC,CAAK,CACjB,OAASY,EAAW,CAClB,OAAID,GAAmBA,EAAgBC,CAAS,EACvCX,EAAIW,CAAS,EAGfX,EAAIY,EAAAA,aAAa,KAAKD,EAAWF,CAAO,CAAC,CAClD,CACF,CA6BA,eAAsBI,EACpBC,EACAL,EACAC,EACkC,CAClC,GAAI,CACF,MAAMX,EAAQ,MAAMe,EAAA,EACpB,OAAOhB,EAAGC,CAAK,CACjB,OAASY,EAAW,CAClB,OAAID,GAAmBA,EAAgBC,CAAS,EACvCX,EAAIW,CAAS,EAEfX,EAAIY,EAAAA,aAAa,KAAKD,EAAWF,CAAO,CAAC,CAClD,CACF,CAcO,MAAMM,EAAmBZ,GAC9BA,EAAO,GACH,QAAQ,QAAQA,EAAO,KAAK,EAC5B,QAAQ,OAAOa,EAAAA,YAAYb,EAAO,KAAK,CAAC,EAQjCc,EACXC,GAEAA,EAAQ,KAAKpB,CAAE,EAAE,MAAOqB,GAAMnB,EAAIY,EAAAA,aAAa,KAAKO,CAAC,CAAC,CAAC,EAU5CC,EAAoB,MAC/BC,GACwD,CAExD,GAAI,CAACC,EAAAA,cAAcD,CAAS,EAAG,OAAOA,EAGtC,GAAI,CACF,OAAO,MAAMA,CACf,OAASV,EAAW,CAClB,OAAOX,EAAIuB,YAAUZ,CAAS,CAAC,CACjC,CACF"}

package/dist/chunks/base-BpECeKwU.mjs

@@ -0,0 +1,19 @@
+import { O as c, E as r } from "./base-K-RHLZ-S.mjs";
+const n = (s) => s, t = () => {
+}, o = (s) => s != null, l = (s) => s == null, e = (s) => l(s) ? t() : n(s), u = (s) => s ? n(s) : t(), f = (s) => o(s) ? s : null, N = (s, a) => o(s) ? c(s) : r(a()), d = (s) => o(s) ? [s] : [];
+async function p(s) {
+  return o(s) ? await s : t();
+}
+export {
+  t as N,
+  n as S,
+  l as a,
+  e as b,
+  f as c,
+  N as d,
+  p as e,
+  u as f,
+  o as i,
+  d as t
+};
+//# sourceMappingURL=base-BpECeKwU.mjs.map

package/dist/chunks/base-BpECeKwU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-BpECeKwU.mjs","sources":["../../src/Maybe/base.ts"],"sourcesContent":["// ========================================\r\n// ./src/Maybe/base.ts\r\n// ========================================\r\nimport type {Result} from 'src/Result/types';\r\nimport {type AsyncMaybe, type Maybe} from './types';\r\nimport {Err, Ok} from 'src/Result/base';\r\n\r\n/**\r\n * Constructs a `Some` value containing a non-null, non-undefined value.\r\n * @param value - The value to wrap in a Maybe.\r\n * @returns A Maybe containing the value.\r\n */\r\nexport const Some = <T>(value: T): Maybe<T> => value;\r\n\r\n/**\r\n * Constructs a `None` value representing absence of a value.\r\n * @returns An empty Maybe (undefined).\r\n */\r\nexport const None = (): Maybe<never> => undefined;\r\n\r\n/**\r\n * Type guard checking if a Maybe contains a value (`Some`).\r\n * @param m - The Maybe to inspect.\r\n * @returns True if the Maybe contains a value.\r\n */\r\nexport const isSome = <T>(m: Maybe<T>): m is T => m !== null && m !== undefined;\r\n\r\n/**\r\n * Type guard checking if a Maybe is empty (`None`).\r\n * @param m - The Maybe to inspect.\r\n * @returns True if the Maybe is null or undefined.\r\n */\r\nexport const isNone = (m: Maybe<unknown>): m is null | undefined =>\r\n  m === null || m === undefined;\r\n\r\n/**\r\n * Converts nullable value to a Maybe.\r\n * @param value - Possibly null/undefined value.\r\n * @returns Some(value) if value exists, None otherwise.\r\n */\r\nexport const fromNullable = <T>(value: T | null | undefined): Maybe<T> =>\r\n  isNone(value) ? None() : Some(value);\r\n\r\n/**\r\n * Converts falsy value to a Maybe.\r\n * @param value - Possibly falsy value.\r\n * @returns Some(value) if truthy, None otherwise.\r\n */\r\nexport const fromFalsy = <T>(\r\n  value: T | null | undefined | false | 0 | '',\r\n): Maybe<T> => (!value ? None() : Some(value as T));\r\n\r\n/**\r\n * Converts Maybe to nullable value.\r\n * @param maybe - Maybe value.\r\n * @returns The value if Some, null if None.\r\n */\r\nexport const toNullable = <T>(maybe: Maybe<T>): T | null =>\r\n  isSome(maybe) ? maybe : null;\r\n\r\n/**\r\n * Converts Maybe to Result type.\r\n * @param maybe - Maybe value.\r\n * @param errorFn - Error generator for None case.\r\n * @returns Ok(value) if Some, Err(errorFn()) if None.\r\n */\r\nexport const toResult = <T, E>(\r\n  maybe: Maybe<T>,\r\n  errorFn: () => E,\r\n): Result<T, E> => (isSome(maybe) ? Ok(maybe) : Err(errorFn()));\r\n\r\n/**\r\n * Converts Maybe to array representation.\r\n * @param val - Maybe value.\r\n * @returns Singleton array if Some, empty array if None.\r\n */\r\nexport const toArray = <T>(val: Maybe<T>): T[] => (isSome(val) ? [val] : []);\r\n\r\n/**\r\n * Transposes a Maybe containing a Promise to an AsyncMaybe.\r\n * @param val - Maybe wrapping a Promise.\r\n * @returns Promise resolving to Some(value) if input was Some, None otherwise.\r\n */\r\nexport async function transpose<T>(val: Maybe<Promise<T>>): AsyncMaybe<T> {\r\n  return isSome(val) ? await val : None();\r\n}\r\n"],"names":["Some","value","None","isSome","m","isNone","fromNullable","fromFalsy","toNullable","maybe","toResult","errorFn","Ok","Err","toArray","val","transpose"],"mappings":";AAYO,MAAMA,IAAO,CAAIC,MAAuBA,GAMlCC,IAAO,MAAA;AAAA,GAOPC,IAAS,CAAIC,MAAwBA,KAAM,MAO3CC,IAAS,CAACD,MACrBA,KAAM,MAOKE,IAAe,CAAIL,MAC9BI,EAAOJ,CAAK,IAAIC,EAAA,IAASF,EAAKC,CAAK,GAOxBM,IAAY,CACvBN,MACeA,IAAiBD,EAAKC,CAAU,IAAxBC,EAAA,GAOZM,IAAa,CAAIC,MAC5BN,EAAOM,CAAK,IAAIA,IAAQ,MAQbC,IAAW,CACtBD,GACAE,MACkBR,EAAOM,CAAK,IAAIG,EAAGH,CAAK,IAAII,EAAIF,EAAA,CAAS,GAOhDG,IAAU,CAAIC,MAAwBZ,EAAOY,CAAG,IAAI,CAACA,CAAG,IAAI,CAAA;AAOzE,eAAsBC,EAAaD,GAAuC;AACxE,SAAOZ,EAAOY,CAAG,IAAI,MAAMA,IAAMb,EAAA;AACnC;"}

package/dist/chunks/base-BvHqpP_s.cjs

@@ -0,0 +1,2 @@
+"use strict";const l=require("./base-BTXL1y_I.cjs"),n=o=>o,t=()=>{},s=o=>o!=null,e=o=>o==null,c=o=>e(o)?t():n(o),i=o=>o?n(o):t(),u=o=>s(o)?o:null,a=(o,r)=>s(o)?l.Ok(o):l.Err(r()),N=o=>s(o)?[o]:[];async function f(o){return s(o)?await o:t()}exports.None=t;exports.Some=n;exports.fromFalsy=i;exports.fromNullable=c;exports.isNone=e;exports.isSome=s;exports.toArray=N;exports.toNullable=u;exports.toResult=a;exports.transpose=f;
+//# sourceMappingURL=base-BvHqpP_s.cjs.map

package/dist/chunks/base-BvHqpP_s.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-BvHqpP_s.cjs","sources":["../../src/Maybe/base.ts"],"sourcesContent":["// ========================================\r\n// ./src/Maybe/base.ts\r\n// ========================================\r\nimport type {Result} from 'src/Result/types';\r\nimport {type AsyncMaybe, type Maybe} from './types';\r\nimport {Err, Ok} from 'src/Result/base';\r\n\r\n/**\r\n * Constructs a `Some` value containing a non-null, non-undefined value.\r\n * @param value - The value to wrap in a Maybe.\r\n * @returns A Maybe containing the value.\r\n */\r\nexport const Some = <T>(value: T): Maybe<T> => value;\r\n\r\n/**\r\n * Constructs a `None` value representing absence of a value.\r\n * @returns An empty Maybe (undefined).\r\n */\r\nexport const None = (): Maybe<never> => undefined;\r\n\r\n/**\r\n * Type guard checking if a Maybe contains a value (`Some`).\r\n * @param m - The Maybe to inspect.\r\n * @returns True if the Maybe contains a value.\r\n */\r\nexport const isSome = <T>(m: Maybe<T>): m is T => m !== null && m !== undefined;\r\n\r\n/**\r\n * Type guard checking if a Maybe is empty (`None`).\r\n * @param m - The Maybe to inspect.\r\n * @returns True if the Maybe is null or undefined.\r\n */\r\nexport const isNone = (m: Maybe<unknown>): m is null | undefined =>\r\n  m === null || m === undefined;\r\n\r\n/**\r\n * Converts nullable value to a Maybe.\r\n * @param value - Possibly null/undefined value.\r\n * @returns Some(value) if value exists, None otherwise.\r\n */\r\nexport const fromNullable = <T>(value: T | null | undefined): Maybe<T> =>\r\n  isNone(value) ? None() : Some(value);\r\n\r\n/**\r\n * Converts falsy value to a Maybe.\r\n * @param value - Possibly falsy value.\r\n * @returns Some(value) if truthy, None otherwise.\r\n */\r\nexport const fromFalsy = <T>(\r\n  value: T | null | undefined | false | 0 | '',\r\n): Maybe<T> => (!value ? None() : Some(value as T));\r\n\r\n/**\r\n * Converts Maybe to nullable value.\r\n * @param maybe - Maybe value.\r\n * @returns The value if Some, null if None.\r\n */\r\nexport const toNullable = <T>(maybe: Maybe<T>): T | null =>\r\n  isSome(maybe) ? maybe : null;\r\n\r\n/**\r\n * Converts Maybe to Result type.\r\n * @param maybe - Maybe value.\r\n * @param errorFn - Error generator for None case.\r\n * @returns Ok(value) if Some, Err(errorFn()) if None.\r\n */\r\nexport const toResult = <T, E>(\r\n  maybe: Maybe<T>,\r\n  errorFn: () => E,\r\n): Result<T, E> => (isSome(maybe) ? Ok(maybe) : Err(errorFn()));\r\n\r\n/**\r\n * Converts Maybe to array representation.\r\n * @param val - Maybe value.\r\n * @returns Singleton array if Some, empty array if None.\r\n */\r\nexport const toArray = <T>(val: Maybe<T>): T[] => (isSome(val) ? [val] : []);\r\n\r\n/**\r\n * Transposes a Maybe containing a Promise to an AsyncMaybe.\r\n * @param val - Maybe wrapping a Promise.\r\n * @returns Promise resolving to Some(value) if input was Some, None otherwise.\r\n */\r\nexport async function transpose<T>(val: Maybe<Promise<T>>): AsyncMaybe<T> {\r\n  return isSome(val) ? await val : None();\r\n}\r\n"],"names":["Some","value","None","isSome","m","isNone","fromNullable","fromFalsy","toNullable","maybe","toResult","errorFn","Ok","Err","toArray","val","transpose"],"mappings":"oDAYaA,EAAWC,GAAuBA,EAMlCC,EAAO,IAAA,GAOPC,EAAaC,GAAwBA,GAAM,KAO3CC,EAAUD,GACrBA,GAAM,KAOKE,EAAmBL,GAC9BI,EAAOJ,CAAK,EAAIC,EAAA,EAASF,EAAKC,CAAK,EAOxBM,EACXN,GACeA,EAAiBD,EAAKC,CAAU,EAAxBC,EAAA,EAOZM,EAAiBC,GAC5BN,EAAOM,CAAK,EAAIA,EAAQ,KAQbC,EAAW,CACtBD,EACAE,IACkBR,EAAOM,CAAK,EAAIG,EAAAA,GAAGH,CAAK,EAAII,EAAAA,IAAIF,EAAA,CAAS,EAOhDG,EAAcC,GAAwBZ,EAAOY,CAAG,EAAI,CAACA,CAAG,EAAI,CAAA,EAOzE,eAAsBC,EAAaD,EAAuC,CACxE,OAAOZ,EAAOY,CAAG,EAAI,MAAMA,EAAMb,EAAA,CACnC"}

package/dist/chunks/base-K-RHLZ-S.mjs

@@ -0,0 +1,46 @@
+import { U as t, e as c, i, w as u } from "./helper-BVabbpmX.mjs";
+const a = (r) => ({
+  ok: !0,
+  value: r
+}), n = (r) => ({
+  ok: !1,
+  error: r
+}), k = (r) => r.ok, m = (r) => !r.ok, w = (r, o) => r.ok && o(r.value), y = (r, o) => !r.ok && o(r.error);
+function h(r, o, e) {
+  try {
+    const s = r();
+    return a(s);
+  } catch (s) {
+    return e && e(s) ? n(s) : n(t.from(s, o));
+  }
+}
+async function v(r, o, e) {
+  try {
+    const s = await r();
+    return a(s);
+  } catch (s) {
+    return e && e(s) ? n(s) : n(t.from(s, o));
+  }
+}
+const E = (r) => r.ok ? Promise.resolve(r.value) : Promise.reject(c(r.error)), P = (r) => r.then(a).catch((o) => n(t.from(o))), O = async (r) => {
+  if (!i(r)) return r;
+  try {
+    return await r;
+  } catch (o) {
+    return n(u(o));
+  }
+};
+export {
+  n as E,
+  a as O,
+  k as a,
+  y as b,
+  w as c,
+  v as d,
+  P as f,
+  m as i,
+  O as n,
+  h as s,
+  E as t
+};
+//# sourceMappingURL=base-K-RHLZ-S.mjs.map

package/dist/chunks/base-K-RHLZ-S.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-K-RHLZ-S.mjs","sources":["../../src/Result/base.ts"],"sourcesContent":["// ========================================\r\n// ./src/Result/base.ts\r\n// ========================================\r\nimport type {Result, Success, Failure, AsyncResult, AnyResult} from './types';\r\nimport {UnknownError, ensureError} from '../unknown-error';\r\nimport {isPromiseLike, wrapError} from '../helper';\r\n\r\n/**\r\n * Constructs a successful Result instance.\r\n * @typeParam T - The type of the successful value\r\n * @param value - The value upon success\r\n * @returns A successful Result\r\n */\r\nexport const Ok = <T, E = never>(value: T): Result<T, E> =>\r\n  ({\r\n    ok: true,\r\n    value,\r\n  }) as const;\r\n\r\n/**\r\n * Get the value of Result<T, never>\r\n * @typeParam T - The type of the error\r\n * @param error - The error upon failure\r\n * @returns A failed Result\r\n */\r\nexport const Err = <T = never, E = unknown>(error: E): Result<T, E> =>\r\n  ({\r\n    ok: false,\r\n    error,\r\n  }) as const;\r\n\r\n/**\r\n * Checks if the Result is in the Success (Ok) state.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @returns Returns true if the Result is Success\r\n */\r\nexport const isOk = <T, E>(result: Result<T, E>): result is Success<T> =>\r\n  result.ok;\r\n\r\n/**\r\n * Checks if the Result is in the Failure (Err) state.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @returns Returns true if the Result is Failure\r\n */\r\nexport const isErr = <T, E>(result: Result<T, E>): result is Failure<E> =>\r\n  !result.ok;\r\n\r\n/**\r\n * Checks if the Result is Success AND its value satisfies the given predicate.\r\n * @typeParam T - The type of the success valueexport function isPromiseLike<T>(value: unknown): value is PromiseLike<T> {\r\n   return value !== null && typeof value === 'object' && 'then' in value;\r\n }\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @param fn - The predicate function to check the success value\r\n * @returns Returns true if the Result is Success and the condition is met\r\n */\r\nexport const isOkAnd = <T, E>(\r\n  result: Result<T, E>,\r\n  fn: (value: T) => boolean,\r\n): boolean => result.ok && fn(result.value);\r\n\r\n/**\r\n * Checks if the Result is Failure AND its error satisfies the given predicate.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result instance to check\r\n * @param fn - The predicate function to check the error value\r\n * @returns Returns true if the Result is Failure and the condition is met\r\n */\r\nexport const isErrAnd = <T, E>(\r\n  result: Result<T, E>,\r\n  fn: (error: E) => boolean,\r\n): boolean => !result.ok && fn(result.error);\r\n\r\n// ============================================\r\n// 异常安全执行器\r\n// ============================================\r\n\r\n/**\r\n * Safely executes a synchronous function, catching any thrown exception and wrapping it as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @param fn - The synchronous function that might throw an exception\r\n * @param message - The error message to be used as the primary message for the UnknownError if an exception is thrown\r\n * @returns Returns Ok(T) on success, or Err(UnknownError) on failure\r\n */\r\nexport function safeExecute<T>(\r\n  fn: () => T,\r\n  message?: string,\r\n): Result<T, UnknownError>;\r\n\r\n/**\r\n * Safely executes a synchronous function, catching any thrown exception. If the exception is of the declared type E,\r\n * it returns Err(E); otherwise, it is wrapped as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @typeParam E - The declared expected error type\r\n * @param fn - The synchronous function that might throw an exception\r\n * @param message - The error message to be used as the primary message for the UnknownError if an unknown exception is thrown\r\n * @param isExpectedError - A type guard function to determine if the caught error is of type E\r\n * @returns Returns Ok(T) on success, or Err(E | UnknownError) on failure\r\n */\r\nexport function safeExecute<T, E>(\r\n  fn: () => T,\r\n  message: string | undefined,\r\n  isExpectedError: (error: unknown) => error is E,\r\n): Result<T, E | UnknownError>;\r\n\r\nexport function safeExecute<T, E = never>(\r\n  fn: () => T,\r\n  message?: string,\r\n  isExpectedError?: (error: unknown) => error is E,\r\n): Result<T, E | UnknownError> {\r\n  try {\r\n    const value = fn();\r\n    return Ok(value);\r\n  } catch (raw_error) {\r\n    if (isExpectedError && isExpectedError(raw_error)) {\r\n      return Err(raw_error);\r\n    }\r\n\r\n    return Err(UnknownError.from(raw_error, message));\r\n  }\r\n}\r\n\r\n/**\r\n * Safely executes an asynchronous function, catching its rejection or thrown exception and wrapping it as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @param async_fn - The asynchronous function that might throw or reject\r\n * @param message - The error message to be used as the primary message for the UnknownError\r\n * @returns Returns Promise<Ok(T)> on success, or Promise<Err(UnknownError)> on failure\r\n */\r\nexport async function safeExecuteAsync<T>(\r\n  async_fn: () => Promise<T>,\r\n  message?: string,\r\n): AsyncResult<T, UnknownError>;\r\n\r\n/**\r\n * Safely executes an asynchronous function, catching its rejection or thrown exception. If the exception is of the declared type E,\r\n * it returns Err(E); otherwise, it is wrapped as an UnknownError.\r\n * @typeParam T - The success value type\r\n * @typeParam E - The declared expected error type\r\n * @param async_fn - The asynchronous function that might throw or reject\r\n * @param message - The error message to be used as the primary message for the UnknownError if an unknown exception is thrown\r\n * @param isExpectedError - A type guard function to determine if the caught error is of type E\r\n * @returns Returns Promise<Ok(T)> on success, or Promise<Err(E | UnknownError)> on failure\r\n */\r\nexport async function safeExecuteAsync<T, E>(\r\n  async_fn: () => Promise<T>,\r\n  message: string | undefined,\r\n  isExpectedError: (error: unknown) => error is E,\r\n): AsyncResult<T, E | UnknownError>;\r\nexport async function safeExecuteAsync<T, E = never>(\r\n  async_fn: () => Promise<T>,\r\n  message?: string,\r\n  isExpectedError?: (error: unknown) => error is E,\r\n): AsyncResult<T, E | UnknownError> {\r\n  try {\r\n    const value = await async_fn();\r\n    return Ok(value);\r\n  } catch (raw_error) {\r\n    if (isExpectedError && isExpectedError(raw_error)) {\r\n      return Err(raw_error);\r\n    }\r\n    return Err(UnknownError.from(raw_error, message));\r\n  }\r\n}\r\n\r\n// ========================================\r\n// 互相转换\r\n// ========================================\r\n\r\n/**\r\n * Converts a Result into a Promise. Success resolves, Failure rejects.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param result - The Result to convert\r\n * @returns The resulting Promise\r\n * @throws If the Result is Failure, it rejects with the error wrapped by `ensureError`\r\n */\r\nexport const toPromise = <T, E>(result: Result<T, E>): Promise<T> =>\r\n  result.ok\r\n    ? Promise.resolve(result.value)\r\n    : Promise.reject(ensureError(result.error));\r\n\r\n/**\r\n * Converts a Promise into an AsyncResult. Resolution becomes Ok, and rejection becomes Err(UnknownError).\r\n * @typeParam T - The type of the success value\r\n * @param promise - The Promise to convert\r\n * @returns The resulting AsyncResult\r\n */\r\nexport const fromPromise = <T>(\r\n  promise: Promise<T>,\r\n): AsyncResult<T, UnknownError> =>\r\n  promise.then(Ok).catch((e) => Err(UnknownError.from(e)));\r\n\r\n/**\r\n * Safely normalizes an AnyResult (synchronous Result or asynchronous AsyncResult/Thenable) into a Promise<Result>.\r\n * It handles the Promise resolve/reject paths, ensuring rejection is always encapsulated as Err(UnknownError).\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error value\r\n * @param awaitable - The value to normalize, which can be a Result, Promise<Result>, or a Thenable object\r\n * @returns The normalized Promise<Result>\r\n */\r\nexport const normalizeToResult = async <T, E>(\r\n  awaitable: AnyResult<T, E>,\r\n): Promise<Result<T, E | UnknownError | DOMException>> => {\r\n  // 同步 Result 快速路径\r\n  if (!isPromiseLike(awaitable)) return awaitable;\r\n\r\n  // 统一处理所有异步情况 (Promise & Thenable)\r\n  try {\r\n    return await awaitable;\r\n  } catch (raw_error) {\r\n    return Err(wrapError(raw_error));\r\n  }\r\n};\r\n"],"names":["Ok","value","Err","error","isOk","result","isErr","isOkAnd","fn","isErrAnd","safeExecute","message","isExpectedError","raw_error","UnknownError","safeExecuteAsync","async_fn","toPromise","ensureError","fromPromise","promise","e","normalizeToResult","awaitable","isPromiseLike","wrapError"],"mappings":";AAaO,MAAMA,IAAK,CAAeC,OAC9B;AAAA,EACC,IAAI;AAAA,EACJ,OAAAA;AACF,IAQWC,IAAM,CAAyBC,OACzC;AAAA,EACC,IAAI;AAAA,EACJ,OAAAA;AACF,IASWC,IAAO,CAAOC,MACzBA,EAAO,IASIC,IAAQ,CAAOD,MAC1B,CAACA,EAAO,IAYGE,IAAU,CACrBF,GACAG,MACYH,EAAO,MAAMG,EAAGH,EAAO,KAAK,GAU7BI,IAAW,CACtBJ,GACAG,MACY,CAACH,EAAO,MAAMG,EAAGH,EAAO,KAAK;AAkCpC,SAASK,EACdF,GACAG,GACAC,GAC6B;AAC7B,MAAI;AACF,UAAMX,IAAQO,EAAA;AACd,WAAOR,EAAGC,CAAK;AAAA,EACjB,SAASY,GAAW;AAClB,WAAID,KAAmBA,EAAgBC,CAAS,IACvCX,EAAIW,CAAS,IAGfX,EAAIY,EAAa,KAAKD,GAAWF,CAAO,CAAC;AAAA,EAClD;AACF;AA6BA,eAAsBI,EACpBC,GACAL,GACAC,GACkC;AAClC,MAAI;AACF,UAAMX,IAAQ,MAAMe,EAAA;AACpB,WAAOhB,EAAGC,CAAK;AAAA,EACjB,SAASY,GAAW;AAClB,WAAID,KAAmBA,EAAgBC,CAAS,IACvCX,EAAIW,CAAS,IAEfX,EAAIY,EAAa,KAAKD,GAAWF,CAAO,CAAC;AAAA,EAClD;AACF;AAcO,MAAMM,IAAY,CAAOZ,MAC9BA,EAAO,KACH,QAAQ,QAAQA,EAAO,KAAK,IAC5B,QAAQ,OAAOa,EAAYb,EAAO,KAAK,CAAC,GAQjCc,IAAc,CACzBC,MAEAA,EAAQ,KAAKpB,CAAE,EAAE,MAAM,CAACqB,MAAMnB,EAAIY,EAAa,KAAKO,CAAC,CAAC,CAAC,GAU5CC,IAAoB,OAC/BC,MACwD;AAExD,MAAI,CAACC,EAAcD,CAAS,EAAG,QAAOA;AAGtC,MAAI;AACF,WAAO,MAAMA;AAAA,EACf,SAASV,GAAW;AAClB,WAAOX,EAAIuB,EAAUZ,CAAS,CAAC;AAAA,EACjC;AACF;"}

package/dist/chunks/base-r6kn0B0D.cjs

@@ -0,0 +1,2 @@
+"use strict";const c=require("./helper-tsqZMRHW.cjs"),i=t=>t,u=()=>{},a=async()=>{},l=t=>r=>t(r),p=t=>(...r)=>!t(...r),y=t=>{let r=!1,e;return(...n)=>(r||(r=!0,e=t(...n)),e)},d=(t,r)=>(...e)=>t(...e.slice(0,r)),f=t=>(...r)=>{const e=t.length>0?t.length-1:0,n=r.slice(0,e),o=r.slice(e);return t(n,o)},h=t=>r=>t(...r),m=(t,...r)=>(...e)=>t(...r,...e),g=(t,...r)=>(...e)=>t(...e,...r),v=(t,r)=>{let e=0;return(...n)=>{if(e++,e>=t)return r(...n)}},N=(t,r)=>{let e=0,n;return(...o)=>(e<t&&(e++,n=r(...o)),n)},R=(t,r)=>{const e=new Map;return(...n)=>{const o=r?r(...n):JSON.stringify(n);if(e.has(o))return e.get(o);const s=t(...n);return e.set(o,s),s}},b=t=>function(...r){try{const e=t.apply(this,r);return c.isPromiseLike(e)?e.then(n=>[void 0,n],n=>[n,void 0]):[void 0,e]}catch(e){return[e,void 0]}};exports.after=v;exports.ary=d;exports.asyncNoop=a;exports.attempt=b;exports.before=N;exports.identity=i;exports.memoize=R;exports.negate=p;exports.noop=u;exports.once=y;exports.partial=m;exports.partialRight=g;exports.rest=f;exports.spread=h;exports.unary=l;
+//# sourceMappingURL=base-r6kn0B0D.cjs.map

package/dist/chunks/base-r6kn0B0D.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-r6kn0B0D.cjs","sources":["../../src/Utils/Functions/base.ts"],"sourcesContent":["// ========================================\r\n// ./src/Utils/Functions/base.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unsafe-return */\r\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\n/* eslint-disable @typescript-eslint/no-unsafe-argument */\r\n\r\nimport {isPromiseLike} from 'src/helper';\r\n\r\n/**\r\n * Generic type for an identity function.\r\n * @template T - The type of the input and output value.\r\n */\r\nexport type IdentityFn = <T>(x: T) => T;\r\n\r\n/**\r\n * A function that returns the same value passed to it.\r\n * @template T\r\n * @param x - The value to return\r\n * @returns The input value `x`\r\n * @satisfies {IdentityFn}\r\n */\r\nexport const identity: IdentityFn = (x) => x;\r\n\r\nexport const noop = (): void => {};\r\nexport const asyncNoop = async (): Promise<void> => {};\r\n\r\n/**\r\n * Creates a function that accepts up to one argument, ignoring any additional arguments.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to cap arguments for.\r\n * @returns The new function.\r\n */\r\nexport const unary = <T, Ret>(\r\n  fn: (arg: T, ...rest: unknown[]) => Ret,\r\n): ((arg: T) => Ret) => {\r\n  return (arg) => fn(arg);\r\n};\r\n\r\n/**\r\n * Creates a function that negates the result of the predicate `fn`.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @param predicate - The predicate to negate.\r\n * @returns The new negated function.\r\n */\r\nexport const negate = <Args extends unknown[]>(\r\n  predicate: (...args: Args) => boolean,\r\n): ((...args: Args) => boolean) => {\r\n  return (...args) => !predicate(...args);\r\n};\r\n\r\n/**\r\n * Creates a function that is restricted to invoking `fn` once.\r\n * Repeat calls to the function return the value of the first invocation.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to restrict.\r\n * @returns The new restricted function.\r\n */\r\nexport const once = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n): ((...args: Args) => Ret) => {\r\n  let done = false;\r\n  let result: Ret;\r\n\r\n  return (...args) => {\r\n    if (!done) {\r\n      done = true;\r\n      result = fn(...args);\r\n    }\r\n    return result;\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with only the first `n` arguments provided.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to cap arguments for.\r\n * @param n - The number of arguments to accept.\r\n * @returns The new function.\r\n */\r\nexport const ary = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n  n: number,\r\n): ((...args: Args) => Ret) => {\r\n  return (...args) => fn(...(args.slice(0, n) as Args));\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with arguments transformed.\r\n * The implementation splits arguments based on `fn.length`, expecting `fn` to take two arguments:\r\n * 1. A tuple of the first `fn.length - 1` arguments.\r\n * 2. A tuple of the remaining arguments.\r\n *\r\n * Note: Based on the implementation `fn.length - 1`, `FixedArgs` is strictly a single-element tuple.\r\n *\r\n * @template FixedArgs - The fixed arguments tuple (must be length 1).\r\n * @template RestArgs - The rest arguments tuple.\r\n * @template Ret - The return type.\r\n * @param fn - The function to transform arguments for.\r\n * @returns The new function.\r\n */\r\nexport const rest = <\r\n  FixedArgs extends [unknown],\r\n  RestArgs extends unknown[],\r\n  Ret,\r\n>(\r\n  fn: (fixed: FixedArgs, rest: RestArgs) => Ret,\r\n): ((...args: [...FixedArgs, ...RestArgs]) => Ret) => {\r\n  return (...args) => {\r\n    const fixedLength = fn.length > 0 ? fn.length - 1 : 0;\r\n    const fixed = args.slice(0, fixedLength) as FixedArgs;\r\n    const restParts = args.slice(fixedLength) as RestArgs;\r\n    return fn(fixed, restParts);\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with the `args` spread as an array.\r\n *\r\n * @template Args - The arguments tuple type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to spread arguments for.\r\n * @returns The new function.\r\n */\r\nexport const spread = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n): ((args: Args) => Ret) => {\r\n  return (args) => fn(...args);\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with `partial` arguments prepended to those provided to the new function.\r\n *\r\n * @template Fixed - The fixed arguments type.\r\n * @template Rest - The remaining arguments type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to partially apply arguments to.\r\n * @param fixedArgs - The arguments to prepend.\r\n * @returns The new partially applied function.\r\n */\r\nexport const partial = <Fixed extends unknown[], Rest extends unknown[], Ret>(\r\n  fn: (...args: [...Fixed, ...Rest]) => Ret,\r\n  ...fixedArgs: Fixed\r\n): ((...rest: Rest) => Ret) => {\r\n  return (...restArgs) => fn(...fixedArgs, ...restArgs);\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` with `partial` arguments appended to those provided to the new function.\r\n *\r\n * @template Fixed - The fixed arguments type (appended).\r\n * @template Rest - The remaining arguments type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to partially apply arguments to.\r\n * @param fixedArgs - The arguments to append.\r\n * @returns The new partially applied function.\r\n */\r\nexport const partialRight = <\r\n  T extends (...args: any[]) => any,\r\n  Fixed extends any[],\r\n>(\r\n  fn: T,\r\n  ...fixedArgs: Fixed\r\n): ((\r\n  ...rest: T extends (...args: [...infer Rest, ...Fixed]) => any ? Rest : never\r\n) => ReturnType<T>) => {\r\n  return (...restArgs: any[]) => fn(...restArgs, ...fixedArgs);\r\n};\r\n/**\r\n * Creates a function that invokes `fn` only after being called `n` times.\r\n *\r\n * @template Args - The arguments type.\r\n * @template Ret - The return type.\r\n * @param n - The number of calls before the function is invoked.\r\n * @param fn - The function to restrict.\r\n * @returns The new restricted function.\r\n */\r\nexport const after = <Args extends unknown[], Ret>(\r\n  n: number,\r\n  fn: (...args: Args) => Ret,\r\n): ((...args: Args) => Ret | undefined) => {\r\n  let count = 0;\r\n  return (...args) => {\r\n    count++;\r\n    if (count >= n) {\r\n      return fn(...args);\r\n    }\r\n    return undefined;\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that invokes `fn` while it's called less than `n` times.\r\n *\r\n * @template Args - The arguments type.\r\n * @template Ret - The return type.\r\n * @param n - The number of calls before the function stops being invoked.\r\n * @param fn - The function to restrict.\r\n * @returns The new restricted function.\r\n */\r\nexport const before = <Args extends unknown[], Ret>(\r\n  n: number,\r\n  fn: (...args: Args) => Ret,\r\n): ((...args: Args) => Ret | undefined) => {\r\n  let count = 0;\r\n  let lastResult: Ret | undefined;\r\n  return (...args) => {\r\n    if (count < n) {\r\n      count++;\r\n      lastResult = fn(...args);\r\n    }\r\n    return lastResult;\r\n  };\r\n};\r\n\r\n/**\r\n * Creates a function that memoizes the result of `fn`.\r\n * If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided.\r\n *\r\n * @template Args - The arguments type.\r\n * @template Ret - The return type.\r\n * @param fn - The function to memoize.\r\n * @param resolver - The function to resolve the cache key.\r\n * @returns The new memoized function.\r\n */\r\nexport const memoize = <Args extends unknown[], Ret>(\r\n  fn: (...args: Args) => Ret,\r\n  resolver?: (...args: Args) => unknown,\r\n): ((...args: Args) => Ret) => {\r\n  const cache = new Map<unknown, Ret>();\r\n  return (...args) => {\r\n    const key = resolver ? resolver(...args) : JSON.stringify(args);\r\n\r\n    if (cache.has(key)) {\r\n      return cache.get(key) as Ret;\r\n    }\r\n    const result = fn(...args);\r\n    cache.set(key, result);\r\n    return result;\r\n  };\r\n};\r\n\r\ntype AttemptResult<T> =\r\n  T extends PromiseLike<infer R>\r\n    ? Promise<[undefined, R] | [unknown, undefined]>\r\n    : [undefined, T] | [unknown, undefined];\r\n\r\n/**\r\n *\r\n * Wraps any function – synchronous or asynchronous – and returns a tuple `[error, result]` instead of throwing.\r\n * It catches **everything**: thrown exceptions and rejected promises alike, turning them into a consistent error-first return.\r\n * Eliminates try-catch blocks and makes error handling explicit and type‑safe.\r\n *\r\n * @template Args - The arguments tuple type of the wrapped function\r\n * @template R - The return type of the wrapped function\r\n * @param fn - The function to wrap\r\n * @returns A function that returns `[undefined, result]` on success, or `[error, undefined]` on failure\r\n *\r\n * @example\r\n * ```typescript\r\n * const [err, data] = attempt(JSON.parse)('{\"a\":1}');\r\n * if (err) console.error('Parse failed:', err);\r\n * else console.log('Parsed:', data);\r\n * ```\r\n *\r\n * @example\r\n * ```typescript\r\n * // Works seamlessly with async functions\r\n * const fetchData = async (url: string) => ({ data: 'response' });\r\n * const [err, data] = await attempt(fetchData)('https://api.example.com');\r\n * ```\r\n */\r\nexport const attempt = <Args extends unknown[], R>(\r\n  fn: (...args: Args) => R,\r\n): ((\r\n  this: ThisParameterType<typeof fn>,\r\n  ...args: Args\r\n) => AttemptResult<R>) => {\r\n  return function (\r\n    this: ThisParameterType<typeof fn>,\r\n    ...args: Args\r\n  ): AttemptResult<R> {\r\n    try {\r\n      const result = fn.apply(this, args);\r\n\r\n      // 处理异步函数\r\n      if (isPromiseLike(result))\r\n        return (result as PromiseLike<R>).then(\r\n          (value) => [undefined, value],\r\n          (err: unknown) => [err, undefined],\r\n        ) as AttemptResult<R>;\r\n\r\n      // 处理同步函数\r\n      return [undefined, result] as AttemptResult<R>;\r\n    } catch (err) {\r\n      return [err, undefined] as AttemptResult<R>;\r\n    }\r\n  };\r\n};\r\n"],"names":["identity","x","noop","asyncNoop","unary","fn","arg","negate","predicate","args","once","done","result","ary","n","rest","fixedLength","fixed","restParts","spread","partial","fixedArgs","restArgs","partialRight","after","count","before","lastResult","memoize","resolver","cache","key","attempt","isPromiseLike","value","err"],"mappings":"sDAsBaA,EAAwBC,GAAMA,EAE9BC,EAAO,IAAY,CAAC,EACpBC,EAAY,SAA2B,CAAC,EAUxCC,EACXC,GAEQC,GAAQD,EAAGC,CAAG,EAUXC,EACXC,GAEO,IAAIC,IAAS,CAACD,EAAU,GAAGC,CAAI,EAY3BC,EACXL,GAC6B,CAC7B,IAAIM,EAAO,GACPC,EAEJ,MAAO,IAAIH,KACJE,IACHA,EAAO,GACPC,EAASP,EAAG,GAAGI,CAAI,GAEdG,EAEX,EAWaC,EAAM,CACjBR,EACAS,IAEO,IAAIL,IAASJ,EAAG,GAAII,EAAK,MAAM,EAAGK,CAAC,CAAU,EAiBzCC,EAKXV,GAEO,IAAII,IAAS,CAClB,MAAMO,EAAcX,EAAG,OAAS,EAAIA,EAAG,OAAS,EAAI,EAC9CY,EAAQR,EAAK,MAAM,EAAGO,CAAW,EACjCE,EAAYT,EAAK,MAAMO,CAAW,EACxC,OAAOX,EAAGY,EAAOC,CAAS,CAC5B,EAWWC,EACXd,GAEQI,GAASJ,EAAG,GAAGI,CAAI,EAahBW,EAAU,CACrBf,KACGgB,IAEI,IAAIC,IAAajB,EAAG,GAAGgB,EAAW,GAAGC,CAAQ,EAazCC,EAAe,CAI1BlB,KACGgB,IAII,IAAIC,IAAoBjB,EAAG,GAAGiB,EAAU,GAAGD,CAAS,EAWhDG,EAAQ,CACnBV,EACAT,IACyC,CACzC,IAAIoB,EAAQ,EACZ,MAAO,IAAIhB,IAAS,CAElB,GADAgB,IACIA,GAASX,EACX,OAAOT,EAAG,GAAGI,CAAI,CAGrB,CACF,EAWaiB,EAAS,CACpBZ,EACAT,IACyC,CACzC,IAAIoB,EAAQ,EACRE,EACJ,MAAO,IAAIlB,KACLgB,EAAQX,IACVW,IACAE,EAAatB,EAAG,GAAGI,CAAI,GAElBkB,EAEX,EAYaC,EAAU,CACrBvB,EACAwB,IAC6B,CAC7B,MAAMC,MAAY,IAClB,MAAO,IAAIrB,IAAS,CAClB,MAAMsB,EAAMF,EAAWA,EAAS,GAAGpB,CAAI,EAAI,KAAK,UAAUA,CAAI,EAE9D,GAAIqB,EAAM,IAAIC,CAAG,EACf,OAAOD,EAAM,IAAIC,CAAG,EAEtB,MAAMnB,EAASP,EAAG,GAAGI,CAAI,EACzB,OAAAqB,EAAM,IAAIC,EAAKnB,CAAM,EACdA,CACT,CACF,EAgCaoB,EACX3B,GAKO,YAEFI,EACe,CAClB,GAAI,CACF,MAAMG,EAASP,EAAG,MAAM,KAAMI,CAAI,EAGlC,OAAIwB,EAAAA,cAAcrB,CAAM,EACdA,EAA0B,KAC/BsB,GAAU,CAAC,OAAWA,CAAK,EAC3BC,GAAiB,CAACA,EAAK,MAAS,CAAA,EAI9B,CAAC,OAAWvB,CAAM,CAC3B,OAASuB,EAAK,CACZ,MAAO,CAACA,EAAK,MAAS,CACxB,CACF"}

package/dist/chunks/combine-async-DcG-3p8i.cjs

@@ -0,0 +1,2 @@
+"use strict";const r=require("./base-BTXL1y_I.cjs"),u=require("./helper-tsqZMRHW.cjs"),E=(n,o,e)=>n.ok?o(n.value):e(n.error);function m(n,o,e){return n.ok?o(n.value):e?.(n.error)}function k(n,o,e){return n.ok?e?.(n.value):o(n.error)}const O=(n,o,e)=>n.ok?e(n.value):o(n.error),w=(n,o)=>E(n,e=>r.Ok(o(e)),e=>r.Err(e)),d=(n,o)=>E(n,e=>r.Ok(e),e=>r.Err(o(e))),A=(n,o,e)=>E(n,t=>r.Ok(o(t)),t=>r.Err(e(t))),f=(n,o)=>n.ok?o(n.value):n,p=(n,o)=>n.ok?n:o(n.error),v=(n,o)=>p(n,o);function b(n,o,e){return f(n,t=>o(t)?r.Ok(t):r.Err(e(t)))}function h(n,o){if(!n.ok)return n;if(!o.ok)return o;const e=n.value,t=o.value;return r.Ok(e(t))}function l(n,o){return n.ok?o.ok?r.Ok([n.value,o.value]):o:n}function y(n){const o=[];for(const e of n){if(!e.ok)return r.Err(e.error);o.push(e.value)}return r.Ok(o)}function z(n,o){const e=[];for(let t=0;t<n.length;t++){const a=o(n[t],t);if(!a.ok)return r.Err(a.error);e.push(a.value)}return r.Ok(e)}const x=(n,o)=>n.ok?o:n,D=(n,o)=>n.ok?n:o;async function M(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const t=await r.normalizeToResult(n);if(!t.ok)return r.Err(t.error);try{const a=await u.dynamicAwait(o(t.value,e));return e?.aborted?r.Err(u.ensureDOMException(e.reason)):r.Ok(a)}catch(a){return r.Err(u.wrapError(a))}}async function T(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const t=await r.normalizeToResult(n);if(t.ok)return r.Ok(t.value);try{const a=await u.dynamicAwait(o(t.error,e));return e?.aborted?r.Err(u.ensureDOMException(e.reason)):r.Err(a)}catch(a){return r.Err(u.wrapError(a))}}async function R(n,o,e,t){if(t?.aborted)return r.Err(u.ensureDOMException(t.reason));const a=await r.normalizeToResult(n);if(a.ok)try{const c=await u.dynamicAwait(o(a.value,t));return t?.aborted?r.Err(u.ensureDOMException(t.reason)):r.Ok(c)}catch(c){return r.Err(u.wrapError(c))}try{const c=await u.dynamicAwait(e(a.error,t));return t?.aborted?r.Err(u.ensureDOMException(t.reason)):r.Err(c)}catch(c){return r.Err(u.wrapError(c))}}async function q(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const t=await r.normalizeToResult(n);if(!t.ok)return r.Err(t.error);try{const a=o(t.value,e),c=await r.normalizeToResult(a);return e?.aborted?r.Err(u.ensureDOMException(e.reason)):c}catch(a){return r.Err(u.wrapError(a))}}async function B(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const t=await r.normalizeToResult(n);if(t.ok)return r.Ok(t.value);try{const a=await r.normalizeToResult(o(t.error,e));return e?.aborted?r.Err(u.ensureDOMException(e.reason)):a}catch(a){return r.Err(u.wrapError(a))}}async function P(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const t=await r.normalizeToResult(n);if(t.ok)return r.Ok(t.value);try{const a=await r.normalizeToResult(o(t.error,e));return e?.aborted?r.Err(u.ensureDOMException(e.reason)):a}catch(a){return r.Err(u.wrapError(a))}}async function _(n,o,e,t){if(t?.aborted)return r.Err(u.ensureDOMException(t.reason));const a=await r.normalizeToResult(n);if(!a.ok)return a;const c=a.value;try{if(await u.dynamicAwait(o(c,t)))return t?.aborted?r.Err(u.ensureDOMException(t.reason)):r.Ok(c);{const s=await u.dynamicAwait(e(c,t));return t?.aborted?r.Err(u.ensureDOMException(t.reason)):r.Err(s)}}catch(i){return r.Err(u.wrapError(i))}}async function V(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const[t,a]=await Promise.all([r.normalizeToResult(n),r.normalizeToResult(o)]);if(!t.ok)return r.Err(t.error);if(!a.ok)return r.Err(a.error);const c=t.value,i=a.value;try{const s=r.Ok(await c(i,e));return e?.aborted?r.Err(u.ensureDOMException(e.reason)):s}catch(s){return r.Err(u.wrapError(s))}}async function j(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const[t,a]=await Promise.all([r.normalizeToResult(n),r.normalizeToResult(o)]);return l(t,a)}async function C(n,o){if(o?.aborted)return r.Err(u.ensureDOMException(o.reason));if(n.length===0)return r.Ok([]);const e=n.map(a=>r.normalizeToResult(a)),t=await Promise.all(e);return y(t)}async function F(n,o){if(o?.aborted)return r.Err(u.ensureDOMException(o.reason));const e=[];for(let t=0;t<n.length;t++){const a=n[t],c=await r.normalizeToResult(a);if(o?.aborted)return r.Err(u.ensureDOMException(o.reason));if(!c.ok)return r.Err(c.error);e.push(c.value)}return r.Ok(e)}async function G(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const t=await r.normalizeToResult(n);return t.ok?r.normalizeToResult(o):r.Err(t.error)}async function H(n,o,e){if(e?.aborted)return r.Err(u.ensureDOMException(e.reason));const t=await r.normalizeToResult(n);return t.ok?r.Ok(t.value):r.normalizeToResult(o)}exports.all=y;exports.allAsync=C;exports.and=x;exports.andAsync=G;exports.andThen=f;exports.andThenAsync=q;exports.ap=h;exports.apAsync=V;exports.filter=b;exports.filterAsync=_;exports.ifErr=k;exports.ifOk=m;exports.map=w;exports.mapAll=z;exports.mapAsync=M;exports.mapBoth=A;exports.mapBothAsync=R;exports.mapErr=d;exports.mapErrAsync=T;exports.mapOrElse=O;exports.match=E;exports.or=D;exports.orAsync=H;exports.orElse=v;exports.orElseAsync=P;exports.recover=p;exports.recoverAsync=B;exports.sequenceAsync=F;exports.zip=l;exports.zipAsync=j;
+//# sourceMappingURL=combine-async-DcG-3p8i.cjs.map