pythonlib 0.1.0 → 0.2.1

package/dist/{chunk-OMQNGE6T.js → chunk-EE7SK2GV.js}

@@ -5,18 +5,19 @@ import {
 // src/functools.ts
 var functools_exports = {};
 __export(functools_exports, {
-  attrgetter: () => attrgetter,
+  attrGetter: () => attrGetter,
   cache: () => cache,
-  cmp_to_key: () => cmp_to_key,
+  cmpToKey: () => cmpToKey,
   identity: () => identity,
-  itemgetter: () => itemgetter,
-  lru_cache: () => lru_cache,
-  methodcaller: () => methodcaller,
+  itemGetter: () => itemGetter,
+  lruCache: () => lruCache,
+  methodCaller: () => methodCaller,
   partial: () => partial,
-  partialmethod: () => partialmethod,
+  partialMethod: () => partialMethod,
+  pipe: () => pipe,
   reduce: () => reduce,
-  singledispatch: () => singledispatch,
-  total_ordering: () => total_ordering,
+  singleDispatch: () => singleDispatch,
+  totalOrdering: () => totalOrdering,
   wraps: () => wraps
 });
 function partial(func, ...partialArgs) {
@@ -46,7 +47,7 @@ function reduce(func, iterable, initializer) {
   }
   return acc;
 }
-function lru_cache(func, maxsize = 128) {
+function lruCache(func, maxsize = 128) {
   const cache2 = /* @__PURE__ */ new Map();
   const order = [];
   let hits = 0;
@@ -74,13 +75,13 @@ function lru_cache(func, maxsize = 128) {
     order.push(key);
     return result;
   });
-  cached.cache_info = () => ({
+  cached.cacheInfo = () => ({
     hits,
     misses,
     maxsize,
     currsize: cache2.size
   });
-  cached.cache_clear = () => {
+  cached.cacheClear = () => {
     cache2.clear();
     order.length = 0;
     hits = 0;
@@ -100,10 +101,10 @@ function cache(func) {
     return result;
   });
 }
-function partialmethod(func, ...partialArgs) {
+function partialMethod(func, ...partialArgs) {
   return partial(func, ...partialArgs);
 }
-function singledispatch(func) {
+function singleDispatch(func) {
   const registry = /* @__PURE__ */ new Map();
   registry.set("object", func);
   const dispatcher = ((...args) => {
@@ -133,7 +134,7 @@ function wraps(wrapped) {
     return wrapper;
   };
 }
-function attrgetter(...attrs) {
+function attrGetter(...attrs) {
   if (attrs.length === 1) {
     const attr = attrs[0];
     const parts = attr.split(".");
@@ -156,7 +157,7 @@ function attrgetter(...attrs) {
     });
   };
 }
-function itemgetter(...items) {
+function itemGetter(...items) {
   if (items.length === 1) {
     const item = items[0];
     return (obj) => {
@@ -175,7 +176,7 @@ function itemgetter(...items) {
     });
   };
 }
-function methodcaller(name, ...args) {
+function methodCaller(name, ...args) {
   return (obj) => {
     const method = obj[name];
     if (typeof method !== "function") {
@@ -187,7 +188,7 @@ function methodcaller(name, ...args) {
 function identity(x) {
   return x;
 }
-function cmp_to_key(mycmp) {
+function cmpToKey(mycmp) {
   return (x) => ({
     value: x,
     __lt__(other) {
@@ -195,7 +196,7 @@ function cmp_to_key(mycmp) {
     }
   });
 }
-function total_ordering(obj) {
+function totalOrdering(obj) {
   const lt = obj.__lt__?.bind(obj);
   const le = obj.__le__?.bind(obj);
   const gt = obj.__gt__?.bind(obj);
@@ -225,21 +226,26 @@ function total_ordering(obj) {
   }
   return result;
 }
+function pipe(value, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), value);
+}
 
 export {
   partial,
   reduce,
-  lru_cache,
+  lruCache,
   cache,
-  partialmethod,
-  singledispatch,
+  partialMethod,
+  singleDispatch,
   wraps,
-  attrgetter,
-  itemgetter,
-  methodcaller,
+  attrGetter,
+  itemGetter,
+  methodCaller,
   identity,
-  cmp_to_key,
-  total_ordering,
+  cmpToKey,
+  totalOrdering,
+  pipe,
   functools_exports
 };
-//# sourceMappingURL=chunk-OMQNGE6T.js.map
+/* v8 ignore start -- complex utility rarely used directly @preserve */
+//# sourceMappingURL=chunk-EE7SK2GV.js.map

package/dist/chunk-EE7SK2GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/functools.ts"],"sourcesContent":["/**\n * Python functools module for TypeScript\n *\n * Provides higher-order functions and operations on callable objects.\n *\n * @see {@link https://docs.python.org/3/library/functools.html | Python functools documentation}\n */\n\n/**\n * Create a partial function application\n * partial(func, arg1, arg2) returns a function that calls func with arg1, arg2 prepended\n *\n * Example:\n *   const add = (a: number, b: number) => a + b\n *   const add5 = partial(add, 5)\n *   add5(3) // returns 8\n */\nexport function partial<T extends (...args: unknown[]) => unknown>(\n  func: T,\n  ...partialArgs: unknown[]\n): (...args: unknown[]) => ReturnType<T> {\n  return (...args: unknown[]): ReturnType<T> => {\n    return func(...partialArgs, ...args) as ReturnType<T>\n  }\n}\n\n/**\n * Apply a function of two arguments cumulatively to the items of an iterable\n * reduce((x, y) => x + y, [1, 2, 3, 4, 5]) returns 15\n * reduce((x, y) => x + y, [1, 2, 3, 4, 5], 10) returns 25\n */\nexport function reduce<T, U = T>(\n  func: (acc: U, val: T) => U,\n  iterable: Iterable<T>,\n  initializer?: U\n): U {\n  const arr = [...iterable]\n\n  if (arr.length === 0) {\n    if (initializer === undefined) {\n      throw new TypeError(\"reduce() of empty sequence with no initial value\")\n    }\n    return initializer\n  }\n\n  let acc: U\n  let startIdx: number\n\n  if (initializer !== undefined) {\n    acc = initializer\n    startIdx = 0\n  } else {\n    acc = arr[0] as unknown as U\n    startIdx = 1\n  }\n\n  for (let i = startIdx; i < arr.length; i++) {\n    acc = func(acc, arr[i] as T)\n  }\n\n  return acc\n}\n\n/**\n * Simple LRU cache decorator (returns a memoized version of the function)\n * Note: This is a simplified implementation that caches based on JSON-stringified arguments\n *\n * Example:\n *   const fib = lruCache((n: number): number => n <= 1 ? n : fib(n - 1) + fib(n - 2))\n */\nexport function lruCache<T extends (...args: unknown[]) => unknown>(\n  func: T,\n  maxsize: number = 128\n): T & {\n  cacheInfo: () => { hits: number; misses: number; maxsize: number; currsize: number }\n  cacheClear: () => void\n} {\n  const cache = new Map<string, ReturnType<T>>()\n  const order: string[] = []\n  let hits = 0\n  let misses = 0\n\n  const cached = ((...args: unknown[]): ReturnType<T> => {\n    const key = JSON.stringify(args)\n\n    if (cache.has(key)) {\n      hits++\n      // Move to end (most recently used)\n      const idx = order.indexOf(key)\n      if (idx > -1) {\n        order.splice(idx, 1)\n        order.push(key)\n      }\n      return cache.get(key) as ReturnType<T>\n    }\n\n    misses++\n    const result = func(...args) as ReturnType<T>\n\n    // Evict oldest if at max size\n    if (maxsize > 0 && cache.size >= maxsize) {\n      const oldest = order.shift()\n      if (oldest !== undefined) {\n        cache.delete(oldest)\n      }\n    }\n\n    cache.set(key, result)\n    order.push(key)\n\n    return result\n  }) as T & {\n    cacheInfo: () => { hits: number; misses: number; maxsize: number; currsize: number }\n    cacheClear: () => void\n  }\n\n  cached.cacheInfo = () => ({\n    hits,\n    misses,\n    maxsize,\n    currsize: cache.size\n  })\n\n  cached.cacheClear = () => {\n    cache.clear()\n    order.length = 0\n    hits = 0\n    misses = 0\n  }\n\n  return cached\n}\n\n/**\n * Cache decorator that caches all calls (no size limit)\n * Equivalent to lru_cache(maxsize=None)\n */\nexport function cache<T extends (...args: unknown[]) => unknown>(func: T): T {\n  const cacheMap = new Map<string, ReturnType<T>>()\n\n  return ((...args: unknown[]): ReturnType<T> => {\n    const key = JSON.stringify(args)\n    if (cacheMap.has(key)) {\n      return cacheMap.get(key) as ReturnType<T>\n    }\n    const result = func(...args) as ReturnType<T>\n    cacheMap.set(key, result)\n    return result\n  }) as T\n}\n\n/**\n * Return a new partial object which behaves like func called with keyword arguments\n * In TypeScript, we simulate this with an options object as the last argument\n */\nexport function partialMethod<T extends (...args: unknown[]) => unknown>(\n  func: T,\n  ...partialArgs: unknown[]\n): (...args: unknown[]) => ReturnType<T> {\n  return partial(func, ...partialArgs)\n}\n\n/**\n * Transform a function into a single-dispatch generic function\n * This is a simplified version - full singleDispatch would require runtime type checking\n */\nexport function singleDispatch<T extends (...args: unknown[]) => unknown>(\n  func: T\n): T & { register: (type: string, impl: T) => void } {\n  const registry = new Map<string, T>()\n  registry.set(\"object\", func)\n\n  const dispatcher = ((...args: unknown[]): ReturnType<T> => {\n    if (args.length === 0) {\n      return func(...args) as ReturnType<T>\n    }\n\n    const firstArg = args[0]\n    let typeName: string\n\n    if (firstArg === null) {\n      typeName = \"null\"\n    } else if (Array.isArray(firstArg)) {\n      typeName = \"array\"\n    } else {\n      typeName = typeof firstArg\n    }\n\n    const impl = registry.get(typeName) ?? func\n    return impl(...args) as ReturnType<T>\n  }) as T & { register: (type: string, impl: T) => void }\n\n  dispatcher.register = (type: string, impl: T) => {\n    registry.set(type, impl)\n  }\n\n  return dispatcher\n}\n\n/**\n * Decorator to update a wrapper function to look like the wrapped function\n * In TypeScript, this just returns the wrapper as-is (metadata is handled differently)\n */\nexport function wraps<T extends (...args: unknown[]) => unknown>(\n  wrapped: T\n): (wrapper: (...args: unknown[]) => unknown) => T {\n  return (wrapper: (...args: unknown[]) => unknown): T => {\n    // Copy function name if possible\n    Object.defineProperty(wrapper, \"name\", { value: wrapped.name, writable: false })\n    return wrapper as T\n  }\n}\n\n/**\n * Return a callable object that fetches attr from its operand\n * attrGetter('name') returns a function that gets the 'name' attribute\n */\nexport function attrGetter<T>(...attrs: string[]): (obj: unknown) => T | T[] {\n  if (attrs.length === 1) {\n    const attr = attrs[0] as string\n    const parts = attr.split(\".\")\n    return (obj: unknown): T => {\n      let result: unknown = obj\n      for (const part of parts) {\n        result = (result as Record<string, unknown>)[part]\n      }\n      return result as T\n    }\n  }\n\n  return (obj: unknown): T[] => {\n    return attrs.map((attr) => {\n      const parts = attr.split(\".\")\n      let result: unknown = obj\n      for (const part of parts) {\n        result = (result as Record<string, unknown>)[part]\n      }\n      return result as T\n    })\n  }\n}\n\n/**\n * Return a callable object that fetches item from its operand\n * itemGetter(1) returns a function that gets index 1\n * itemGetter('key') returns a function that gets the 'key' property\n */\nexport function itemGetter<T>(...items: (string | number)[]): (obj: unknown) => T | T[] {\n  if (items.length === 1) {\n    const item = items[0] as string | number\n    return (obj: unknown): T => {\n      if (Array.isArray(obj) && typeof item === \"number\") {\n        return obj[item] as T\n      }\n      return (obj as Record<string | number, T>)[item] as T\n    }\n  }\n\n  return (obj: unknown): T[] => {\n    return items.map((item): T => {\n      if (Array.isArray(obj) && typeof item === \"number\") {\n        return obj[item] as T\n      }\n      return (obj as Record<string | number, T>)[item] as T\n    })\n  }\n}\n\n/**\n * Return a callable object that calls the method name on its operand\n * methodCaller('split', ' ') returns a function that calls .split(' ')\n */\nexport function methodCaller(name: string, ...args: unknown[]): (obj: unknown) => unknown {\n  return (obj: unknown): unknown => {\n    const method = (obj as Record<string, (...a: unknown[]) => unknown>)[name]\n    if (typeof method !== \"function\") {\n      throw new TypeError(`'${typeof obj}' object has no method '${name}'`)\n    }\n    return method.apply(obj, args)\n  }\n}\n\n/**\n * Return the same object passed in (identity function)\n */\nexport function identity<T>(x: T): T {\n  return x\n}\n\n/**\n * Compare two objects for ordering (returns -1, 0, or 1)\n * Used for sorting with a key function\n */\nexport function cmpToKey<T>(\n  mycmp: (a: T, b: T) => number\n): (x: T) => { value: T; __lt__: (other: { value: T }) => boolean } {\n  return (x: T) => ({\n    value: x,\n    __lt__(other: { value: T }): boolean {\n      return mycmp(x, other.value) < 0\n    }\n  })\n}\n\n/**\n * Return total ordering for a class that has __lt__, __le__, __gt__, or __ge__\n * This is typically used as a class decorator in Python\n * In TypeScript, we provide helper comparisons\n */\n/* v8 ignore start -- complex utility rarely used directly @preserve */\nexport function totalOrdering<\n  T extends {\n    __lt__?: (other: T) => boolean\n    __le__?: (other: T) => boolean\n    __gt__?: (other: T) => boolean\n    __ge__?: (other: T) => boolean\n    __eq__?: (other: T) => boolean\n  }\n>(\n  obj: T\n): T & {\n  __lt__: (other: T) => boolean\n  __le__: (other: T) => boolean\n  __gt__: (other: T) => boolean\n  __ge__: (other: T) => boolean\n} {\n  const lt = obj.__lt__?.bind(obj)\n  const le = obj.__le__?.bind(obj)\n  const gt = obj.__gt__?.bind(obj)\n  const ge = obj.__ge__?.bind(obj)\n  const eq = obj.__eq__?.bind(obj) ?? ((other: T) => obj === other)\n\n  const result = obj as T & {\n    __lt__: (other: T) => boolean\n    __le__: (other: T) => boolean\n    __gt__: (other: T) => boolean\n    __ge__: (other: T) => boolean\n  }\n\n  if (lt) {\n    result.__lt__ = lt\n    result.__le__ = (other: T) => lt(other) || eq(other)\n    result.__gt__ = (other: T) => !lt(other) && !eq(other)\n    result.__ge__ = (other: T) => !lt(other)\n  } else if (le) {\n    result.__le__ = le\n    result.__lt__ = (other: T) => le(other) && !eq(other)\n    result.__gt__ = (other: T) => !le(other)\n    result.__ge__ = (other: T) => !le(other) || eq(other)\n  } else if (gt) {\n    result.__gt__ = gt\n    result.__ge__ = (other: T) => gt(other) || eq(other)\n    result.__lt__ = (other: T) => !gt(other) && !eq(other)\n    result.__le__ = (other: T) => !gt(other)\n  } else if (ge) {\n    result.__ge__ = ge\n    result.__gt__ = (other: T) => ge(other) && !eq(other)\n    result.__le__ = (other: T) => !ge(other) || eq(other)\n    result.__lt__ = (other: T) => !ge(other)\n  }\n\n  return result\n}\n/* v8 ignore stop */\n\n/**\n * Pipe a value through a series of functions.\n * @inspired Remeda, Ramda\n *\n * Example:\n *   pipe(5, x => x * 2, x => x + 1) // returns 11\n */\nexport function pipe<T>(value: T): T\nexport function pipe<T, A>(value: T, fn1: (x: T) => A): A\nexport function pipe<T, A, B>(value: T, fn1: (x: T) => A, fn2: (x: A) => B): B\nexport function pipe<T, A, B, C>(value: T, fn1: (x: T) => A, fn2: (x: A) => B, fn3: (x: B) => C): C\nexport function pipe<T, A, B, C, D>(\n  value: T,\n  fn1: (x: T) => A,\n  fn2: (x: A) => B,\n  fn3: (x: B) => C,\n  fn4: (x: C) => D\n): D\nexport function pipe<T, A, B, C, D, E>(\n  value: T,\n  fn1: (x: T) => A,\n  fn2: (x: A) => B,\n  fn3: (x: B) => C,\n  fn4: (x: C) => D,\n  fn5: (x: D) => E\n): E\nexport function pipe(value: unknown, ...fns: ((x: unknown) => unknown)[]): unknown {\n  return fns.reduce((acc, fn) => fn(acc), value)\n}\n"],"mappings":"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","names":["cache"]}

package/dist/{chunk-WAONBJE5.js → chunk-H76SKASU.js}

@@ -5,24 +5,24 @@ import {
 // src/random.ts
 var random_exports = {};
 __export(random_exports, {
-  betavariate: () => betavariate,
+  betaVariate: () => betaVariate,
   choice: () => choice,
   choices: () => choices,
-  expovariate: () => expovariate,
-  gammavariate: () => gammavariate,
+  expoVariate: () => expoVariate,
+  gammaVariate: () => gammaVariate,
   gauss: () => gauss,
-  lognormvariate: () => lognormvariate,
-  normalvariate: () => normalvariate,
-  paretovariate: () => paretovariate,
-  randint: () => randint,
+  logNormVariate: () => logNormVariate,
+  normalVariate: () => normalVariate,
+  paretoVariate: () => paretoVariate,
+  randInt: () => randInt,
+  randRange: () => randRange,
   random: () => random,
-  randrange: () => randrange,
   sample: () => sample,
   shuffle: () => shuffle,
   triangular: () => triangular,
   uniform: () => uniform,
-  vonmisesvariate: () => vonmisesvariate,
-  weibullvariate: () => weibullvariate
+  vonMisesVariate: () => vonMisesVariate,
+  weibullVariate: () => weibullVariate
 });
 function random() {
   return Math.random();
@@ -30,12 +30,12 @@ function random() {
 function uniform(a, b) {
   return a + Math.random() * (b - a);
 }
-function randint(a, b) {
+function randInt(a, b) {
   a = Math.floor(a);
   b = Math.floor(b);
   return Math.floor(Math.random() * (b - a + 1)) + a;
 }
-function randrange(start, stop, step = 1) {
+function randRange(start, stop, step = 1) {
   if (stop === void 0) {
     stop = start;
     start = 0;
@@ -45,7 +45,7 @@ function randrange(start, stop, step = 1) {
   }
   const numSteps = Math.ceil((stop - start) / step);
   if (numSteps <= 0) {
-    throw new Error("empty range for randrange()");
+    throw new Error("empty range for randRange()");
   }
   const randomStep = Math.floor(Math.random() * numSteps);
   return start + randomStep * step;
@@ -130,7 +130,7 @@ function gauss(mu = 0, sigma = 1) {
   const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
   return mu + z * sigma;
 }
-var normalvariate = gauss;
+var normalVariate = gauss;
 function triangular(low = 0, high = 1, mode) {
   if (mode === void 0) {
     mode = (low + high) / 2;
@@ -142,17 +142,17 @@ function triangular(low = 0, high = 1, mode) {
   }
   return high - Math.sqrt((1 - u) * (high - low) * (high - mode));
 }
-function betavariate(alpha, beta) {
-  const y = gammavariate(alpha, 1);
+function betaVariate(alpha, beta) {
+  const y = gammaVariate(alpha, 1);
   if (y === 0) return 0;
-  return y / (y + gammavariate(beta, 1));
+  return y / (y + gammaVariate(beta, 1));
 }
-function expovariate(lambd) {
+function expoVariate(lambd) {
   return -Math.log(1 - Math.random()) / lambd;
 }
-function gammavariate(alpha, beta) {
+function gammaVariate(alpha, beta) {
   if (alpha <= 0 || beta <= 0) {
-    throw new Error("gammavariate: alpha and beta must be > 0");
+    throw new Error("gammaVariate: alpha and beta must be > 0");
   }
   if (alpha > 1) {
     const d = alpha - 1 / 3;
@@ -175,13 +175,13 @@ function gammavariate(alpha, beta) {
     }
   } else {
     const u = Math.random();
-    return gammavariate(1 + alpha, beta) * Math.pow(u, 1 / alpha);
+    return gammaVariate(1 + alpha, beta) * Math.pow(u, 1 / alpha);
   }
 }
-function lognormvariate(mu, sigma) {
+function logNormVariate(mu, sigma) {
   return Math.exp(gauss(mu, sigma));
 }
-function vonmisesvariate(mu, kappa) {
+function vonMisesVariate(mu, kappa) {
   if (kappa <= 1e-6) {
     return 2 * Math.PI * Math.random();
   }
@@ -203,11 +203,11 @@ function vonmisesvariate(mu, kappa) {
     }
   }
 }
-function paretovariate(alpha) {
+function paretoVariate(alpha) {
   const u = 1 - Math.random();
   return 1 / Math.pow(u, 1 / alpha);
 }
-function weibullvariate(alpha, beta) {
+function weibullVariate(alpha, beta) {
   const u = 1 - Math.random();
   return alpha * Math.pow(-Math.log(u), 1 / beta);
 }
@@ -215,22 +215,22 @@ function weibullvariate(alpha, beta) {
 export {
   random,
   uniform,
-  randint,
-  randrange,
+  randInt,
+  randRange,
   choice,
   choices,
   sample,
   shuffle,
   gauss,
-  normalvariate,
+  normalVariate,
   triangular,
-  betavariate,
-  expovariate,
-  gammavariate,
-  lognormvariate,
-  vonmisesvariate,
-  paretovariate,
-  weibullvariate,
+  betaVariate,
+  expoVariate,
+  gammaVariate,
+  logNormVariate,
+  vonMisesVariate,
+  paretoVariate,
+  weibullVariate,
   random_exports
 };
-//# sourceMappingURL=chunk-WAONBJE5.js.map
+//# sourceMappingURL=chunk-H76SKASU.js.map

package/dist/chunk-H76SKASU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/random.ts"],"sourcesContent":["/**\n * Python random module for TypeScript\n *\n * Provides random number generation functions matching Python's random module.\n * Uses JavaScript's Math.random() as the underlying generator.\n *\n * Note: This is NOT cryptographically secure. For security-sensitive\n * applications, use the Web Crypto API instead.\n *\n * @see {@link https://docs.python.org/3/library/random.html | Python random documentation}\n */\n\n// ============================================================================\n// Basic random functions\n// ============================================================================\n\n/** Return a random floating point number in the range [0.0, 1.0) */\nexport function random(): number {\n  return Math.random()\n}\n\n/** Return a random floating point number N such that a <= N <= b */\nexport function uniform(a: number, b: number): number {\n  return a + Math.random() * (b - a)\n}\n\n/** Return a random integer N such that a <= N <= b (inclusive) */\nexport function randInt(a: number, b: number): number {\n  a = Math.floor(a)\n  b = Math.floor(b)\n  return Math.floor(Math.random() * (b - a + 1)) + a\n}\n\n/** Return a randomly selected element from range(start, stop, step) */\nexport function randRange(start: number, stop?: number, step: number = 1): number {\n  if (stop === undefined) {\n    stop = start\n    start = 0\n  }\n  if (step === 0) {\n    throw new Error(\"step cannot be zero\")\n  }\n\n  const numSteps = Math.ceil((stop - start) / step)\n  if (numSteps <= 0) {\n    throw new Error(\"empty range for randRange()\")\n  }\n\n  const randomStep = Math.floor(Math.random() * numSteps)\n  return start + randomStep * step\n}\n\n// ============================================================================\n// Sequence functions\n// ============================================================================\n\n/** Return a random element from the non-empty sequence */\nexport function choice<T>(seq: T[] | string): T | string {\n  if (seq.length === 0) {\n    throw new Error(\"Cannot choose from an empty sequence\")\n  }\n  const index = Math.floor(Math.random() * seq.length)\n  return seq[index] as T | string\n}\n\n/** Return a k-length list of elements chosen from the population with replacement */\nexport function choices<T>(population: T[], options?: { weights?: number[]; k?: number }): T[] {\n  const k = options?.k ?? 1\n  const weights = options?.weights\n\n  if (population.length === 0) {\n    throw new Error(\"Cannot choose from an empty population\")\n  }\n\n  if (weights) {\n    if (weights.length !== population.length) {\n      throw new Error(\"weights and population must have the same length\")\n    }\n\n    // Compute cumulative weights\n    const cumWeights: number[] = []\n    let total = 0\n    for (const w of weights) {\n      total += w\n      cumWeights.push(total)\n    }\n\n    const result: T[] = []\n    for (let i = 0; i < k; i++) {\n      const r = Math.random() * total\n      // Binary search for the index\n      let lo = 0\n      let hi = cumWeights.length\n      while (lo < hi) {\n        const mid = Math.floor((lo + hi) / 2)\n        if (r > (cumWeights[mid] as number)) {\n          lo = mid + 1\n        } else {\n          hi = mid\n        }\n      }\n      result.push(population[lo] as T)\n    }\n    return result\n  }\n\n  const result: T[] = []\n  for (let i = 0; i < k; i++) {\n    result.push(population[Math.floor(Math.random() * population.length)] as T)\n  }\n  return result\n}\n\n/** Return a k-length list of unique elements chosen from the population (without replacement) */\nexport function sample<T>(population: T[], k: number): T[] {\n  if (k > population.length) {\n    throw new Error(\"Sample larger than population\")\n  }\n  if (k < 0) {\n    throw new Error(\"Sample size cannot be negative\")\n  }\n\n  // Fisher-Yates shuffle on a copy, take first k elements\n  const pool = [...population]\n  for (let i = 0; i < k; i++) {\n    const j = i + Math.floor(Math.random() * (pool.length - i))\n    const temp = pool[i] as T\n    pool[i] = pool[j] as T\n    pool[j] = temp\n  }\n  return pool.slice(0, k)\n}\n\n/** Shuffle the sequence in place */\nexport function shuffle(x: unknown[]): void {\n  // Fisher-Yates shuffle\n  for (let i = x.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1))\n    const temp = x[i]\n    x[i] = x[j]\n    x[j] = temp\n  }\n}\n\n// ============================================================================\n// Real-valued distributions\n// ============================================================================\n\n/** Gaussian distribution with mean mu and standard deviation sigma */\nexport function gauss(mu: number = 0, sigma: number = 1): number {\n  // Box-Muller transform\n  let u1: number\n  let u2: number\n  do {\n    u1 = Math.random()\n    u2 = Math.random()\n  } while (u1 === 0)\n\n  const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2)\n  return mu + z * sigma\n}\n\n/** Normal distribution (alias for gauss) */\nexport const normalVariate = gauss\n\n/** Triangular distribution with low, high, and mode */\nexport function triangular(low: number = 0, high: number = 1, mode?: number): number {\n  if (mode === undefined) {\n    mode = (low + high) / 2\n  }\n\n  const u = Math.random()\n  const c = (mode - low) / (high - low)\n\n  if (u < c) {\n    return low + Math.sqrt(u * (high - low) * (mode - low))\n  }\n  return high - Math.sqrt((1 - u) * (high - low) * (high - mode))\n}\n\n/** Beta distribution with alpha and beta parameters */\nexport function betaVariate(alpha: number, beta: number): number {\n  // Use the gamma method\n  const y = gammaVariate(alpha, 1)\n  if (y === 0) return 0\n  return y / (y + gammaVariate(beta, 1))\n}\n\n/** Exponential distribution with mean 1/lambd */\nexport function expoVariate(lambd: number): number {\n  // lambd is 1.0 divided by the desired mean\n  return -Math.log(1 - Math.random()) / lambd\n}\n\n/** Gamma distribution with shape alpha and scale beta */\nexport function gammaVariate(alpha: number, beta: number): number {\n  // Marsaglia and Tsang's method\n  if (alpha <= 0 || beta <= 0) {\n    throw new Error(\"gammaVariate: alpha and beta must be > 0\")\n  }\n\n  if (alpha > 1) {\n    const d = alpha - 1 / 3\n    const c = 1 / Math.sqrt(9 * d)\n    for (;;) {\n      let x: number\n      let v: number\n      do {\n        x = gauss()\n        v = 1 + c * x\n      } while (v <= 0)\n      v = v * v * v\n      const u = Math.random()\n      if (u < 1 - 0.0331 * (x * x) * (x * x)) {\n        return d * v * beta\n      }\n      if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {\n        return d * v * beta\n      }\n    }\n  } else {\n    // alpha <= 1\n    const u = Math.random()\n    return gammaVariate(1 + alpha, beta) * Math.pow(u, 1 / alpha)\n  }\n}\n\n/** Log normal distribution */\nexport function logNormVariate(mu: number, sigma: number): number {\n  return Math.exp(gauss(mu, sigma))\n}\n\n/** Von Mises distribution (circular data) */\nexport function vonMisesVariate(mu: number, kappa: number): number {\n  if (kappa <= 1e-6) {\n    return 2 * Math.PI * Math.random()\n  }\n\n  const s = 0.5 / kappa\n  const r = s + Math.sqrt(1 + s * s)\n\n  for (;;) {\n    const u1 = Math.random()\n    const z = Math.cos(Math.PI * u1)\n    const d = z / (r + z)\n    const u2 = Math.random()\n    if (u2 < 1 - d * d || u2 <= (1 - d) * Math.exp(d)) {\n      const q = 1 / r\n      const f = (q + z) / (1 + q * z)\n      const u3 = Math.random()\n      if (u3 > 0.5) {\n        return (mu + Math.acos(f)) % (2 * Math.PI)\n      }\n      return (mu - Math.acos(f)) % (2 * Math.PI)\n    }\n  }\n}\n\n/** Pareto distribution */\nexport function paretoVariate(alpha: number): number {\n  const u = 1 - Math.random()\n  return 1 / Math.pow(u, 1 / alpha)\n}\n\n/** Weibull distribution */\nexport function weibullVariate(alpha: number, beta: number): number {\n  const u = 1 - Math.random()\n  return alpha * Math.pow(-Math.log(u), 1 / beta)\n}\n"],"mappings":"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","names":["result"]}

package/dist/{chunk-TOI6IG3T.js → chunk-HQ42WNKZ.js}

@@ -7,23 +7,25 @@ var itertools_exports = {};
 __export(itertools_exports, {
   accumulate: () => accumulate,
   chain: () => chain,
+  chunk: () => chunk,
   combinations: () => combinations,
-  combinations_with_replacement: () => combinations_with_replacement,
+  combinationsWithReplacement: () => combinationsWithReplacement,
   compress: () => compress,
   count: () => count,
   cycle: () => cycle,
-  dropwhile: () => dropwhile,
-  filterfalse: () => filterfalse,
+  dropWhile: () => dropWhile,
+  filterFalse: () => filterFalse,
   groupby: () => groupby,
   islice: () => islice,
   pairwise: () => pairwise,
+  partition: () => partition,
   permutations: () => permutations,
   product: () => product,
   productRepeat: () => productRepeat,
   repeat: () => repeat,
-  takewhile: () => takewhile,
+  takeWhile: () => takeWhile,
   tee: () => tee,
-  zip_longest: () => zip_longest
+  zipLongest: () => zipLongest
 });
 function chain(...iterables) {
   return iterables.flatMap((it) => [...it]);
@@ -148,7 +150,7 @@ function islice(iterable, start, stop, step = 1) {
   }
   return result;
 }
-function takewhile(predicate, iterable) {
+function takeWhile(predicate, iterable) {
   const result = [];
   for (const element of iterable) {
     if (predicate(element)) {
@@ -159,7 +161,7 @@ function takewhile(predicate, iterable) {
   }
   return result;
 }
-function dropwhile(predicate, iterable) {
+function dropWhile(predicate, iterable) {
   const result = [];
   let dropping = true;
   for (const element of iterable) {
@@ -171,7 +173,7 @@ function dropwhile(predicate, iterable) {
   }
   return result;
 }
-function zip_longest(...args) {
+function zipLongest(...args) {
   let fillvalue;
   let iterables;
   const lastArg = args[args.length - 1];
@@ -206,7 +208,7 @@ function compress(data, selectors) {
   }
   return result;
 }
-function filterfalse(predicate, iterable) {
+function filterFalse(predicate, iterable) {
   const result = [];
   for (const element of iterable) {
     if (!predicate(element)) {
@@ -292,7 +294,7 @@ function productRepeat(iterable, repeat2 = 1) {
   const pools = Array.from({ length: repeat2 }, () => pool);
   return product(...pools);
 }
-function combinations_with_replacement(iterable, r) {
+function combinationsWithReplacement(iterable, r) {
   const pool = [...iterable];
   const n = pool.length;
   if (r < 0 || n === 0) return r === 0 ? [[]] : [];
@@ -311,6 +313,29 @@ function combinations_with_replacement(iterable, r) {
   }
   return result;
 }
+function chunk(iterable, size) {
+  if (size < 1) {
+    throw new Error("chunk size must be at least 1");
+  }
+  const arr = [...iterable];
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+function partition(iterable, predicate) {
+  const truthy = [];
+  const falsy = [];
+  for (const item of iterable) {
+    if (predicate(item)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
+    }
+  }
+  return [truthy, falsy];
+}
 
 export {
   chain,
@@ -320,18 +345,20 @@ export {
   cycle,
   repeat,
   islice,
-  takewhile,
-  dropwhile,
-  zip_longest,
+  takeWhile,
+  dropWhile,
+  zipLongest,
   compress,
-  filterfalse,
+  filterFalse,
   accumulate,
   groupby,
   count,
   tee,
   pairwise,
   productRepeat,
-  combinations_with_replacement,
+  combinationsWithReplacement,
+  chunk,
+  partition,
   itertools_exports
 };
-//# sourceMappingURL=chunk-TOI6IG3T.js.map
+//# sourceMappingURL=chunk-HQ42WNKZ.js.map

package/dist/chunk-HQ42WNKZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/itertools.ts"],"sourcesContent":["/**\n * Python itertools module for TypeScript\n *\n * Provides iterator building blocks inspired by Python's itertools module.\n *\n * @see {@link https://docs.python.org/3/library/itertools.html | Python itertools documentation}\n *\n * Design Decision (ADR-0008):\n * - Most functions return eager arrays for better debugging and familiarity\n * - Only infinite sequences (cycle, repeat without count) use generators\n */\n\n/**\n * Chain multiple iterables together into a single array\n * chain([1, 2], [3, 4]) -> [1, 2, 3, 4]\n */\nexport function chain<T>(...iterables: Iterable<T>[]): T[] {\n  return iterables.flatMap((it) => [...it])\n}\n\n/**\n * Return successive r-length combinations of elements\n * combinations([1, 2, 3], 2) -> [[1, 2], [1, 3], [2, 3]]\n */\nexport function combinations<T>(iterable: Iterable<T>, r: number): T[][] {\n  const pool = [...iterable]\n  const n = pool.length\n  if (r > n || r < 0) return []\n\n  const result: T[][] = []\n  const indices: number[] = Array.from({ length: r }, (_, i) => i)\n  result.push(indices.map((i) => pool[i] as T))\n\n  for (;;) {\n    let i = r - 1\n    while (i >= 0 && indices[i] === i + n - r) i--\n    if (i < 0) break\n    ;(indices[i] as number)++\n    for (let j = i + 1; j < r; j++) {\n      indices[j] = (indices[j - 1] as number) + 1\n    }\n    result.push(indices.map((idx) => pool[idx] as T))\n  }\n\n  return result\n}\n\n/**\n * Return successive r-length permutations of elements\n * permutations([1, 2, 3], 2) -> [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]\n */\nexport function permutations<T>(iterable: Iterable<T>, r?: number): T[][] {\n  const pool = [...iterable]\n  const n = pool.length\n  const rLen = r === undefined ? n : r\n  if (rLen > n || rLen < 0) return []\n\n  const result: T[][] = []\n  const indices: number[] = Array.from({ length: n }, (_, i) => i)\n  const cycles: number[] = Array.from({ length: rLen }, (_, i) => n - i)\n\n  result.push(indices.slice(0, rLen).map((i) => pool[i] as T))\n\n  outer: for (;;) {\n    for (let i = rLen - 1; i >= 0; i--) {\n      ;(cycles[i] as number)--\n      if (cycles[i] === 0) {\n        // Rotate indices[i:] left by one\n        const temp = indices[i] as number\n        for (let j = i; j < n - 1; j++) {\n          indices[j] = indices[j + 1] as number\n        }\n        indices[n - 1] = temp\n        cycles[i] = n - i\n      } else {\n        const j = n - (cycles[i] as number)\n        const swap = indices[j] as number\n        indices[j] = indices[i] as number\n        indices[i] = swap\n        result.push(indices.slice(0, rLen).map((idx) => pool[idx] as T))\n        continue outer\n      }\n    }\n    break\n  }\n\n  return result\n}\n\n/**\n * Cartesian product of input iterables\n * product([1, 2], ['a', 'b']) -> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n */\nexport function product<T>(...iterables: Iterable<T>[]): T[][] {\n  if (iterables.length === 0) return [[]]\n\n  const pools = iterables.map((it) => [...it])\n\n  // Check if any pool is empty\n  if (pools.some((p) => p.length === 0)) return []\n\n  const result: T[][] = []\n  const indices: number[] = new Array<number>(pools.length).fill(0)\n  result.push(pools.map((p, i) => p[indices[i] as number] as T))\n\n  for (;;) {\n    let i = pools.length - 1\n    while (i >= 0) {\n      ;(indices[i] as number)++\n      const currentPool = pools[i] as T[]\n      if ((indices[i] as number) < currentPool.length) {\n        result.push(pools.map((p, j) => p[indices[j] as number] as T))\n        break\n      }\n      indices[i] = 0\n      i--\n    }\n    if (i < 0) break\n  }\n\n  return result\n}\n\n/**\n * Cycle through an iterable indefinitely (INFINITE - returns Generator)\n * cycle([1, 2, 3]) -> 1, 2, 3, 1, 2, 3, 1, 2, 3, ...\n *\n * WARNING: This is infinite! Use with for...of and break, or islice.\n */\nexport function* cycle<T>(iterable: Iterable<T>): Generator<T> {\n  const saved: T[] = []\n  for (const element of iterable) {\n    yield element\n    saved.push(element)\n  }\n  if (saved.length === 0) return\n  for (;;) {\n    yield* saved\n  }\n}\n\n/**\n * Repeat an object. If times is specified, returns an array. Otherwise returns\n * an infinite generator.\n *\n * repeat('x', 3) -> ['x', 'x', 'x']\n * repeat('x') -> Generator that yields 'x' forever (INFINITE)\n */\nexport function repeat<T>(obj: T, times?: number): T[] | Generator<T> {\n  if (times !== undefined) {\n    // Finite: return array\n    return Array.from({ length: times }, () => obj)\n  }\n  // Infinite: return generator\n  return (function* () {\n    for (;;) {\n      yield obj\n    }\n  })()\n}\n\n/**\n * Slice an iterable from start to stop with step\n * islice([1, 2, 3, 4, 5], 1, 4) -> [2, 3, 4]\n * islice([1, 2, 3, 4, 5], 3) -> [1, 2, 3]\n */\nexport function islice<T>(\n  iterable: Iterable<T>,\n  start: number,\n  stop?: number,\n  step: number = 1\n): T[] {\n  // Handle single argument (stop only): islice(it, 5) means islice(it, 0, 5, 1)\n  let actualStart = start\n  let actualStop = stop\n  if (actualStop === undefined) {\n    actualStop = start\n    actualStart = 0\n  }\n\n  if (step < 1) {\n    throw new Error(\"step must be >= 1\")\n  }\n\n  const result: T[] = []\n  let index = 0\n  let nextIndex = actualStart\n\n  for (const element of iterable) {\n    if (index >= actualStop) break\n    if (index === nextIndex) {\n      result.push(element)\n      nextIndex += step\n    }\n    index++\n  }\n\n  return result\n}\n\n/**\n * Take elements while predicate is true\n * takeWhile(x => x < 5, [1, 4, 6, 4, 1]) -> [1, 4]\n */\nexport function takeWhile<T>(predicate: (x: T) => boolean, iterable: Iterable<T>): T[] {\n  const result: T[] = []\n  for (const element of iterable) {\n    if (predicate(element)) {\n      result.push(element)\n    } else {\n      break\n    }\n  }\n  return result\n}\n\n/**\n * Skip elements while predicate is true, then return the rest\n * dropWhile(x => x < 5, [1, 4, 6, 4, 1]) -> [6, 4, 1]\n */\nexport function dropWhile<T>(predicate: (x: T) => boolean, iterable: Iterable<T>): T[] {\n  const result: T[] = []\n  let dropping = true\n  for (const element of iterable) {\n    if (dropping && predicate(element)) {\n      continue\n    }\n    dropping = false\n    result.push(element)\n  }\n  return result\n}\n\n/**\n * Zip iterables together, filling missing values with fillvalue\n * zipLongest([1, 2, 3], ['a', 'b'], { fillvalue: '-' }) -> [[1, 'a'], [2, 'b'], [3, '-']]\n */\nexport function zipLongest<T>(\n  ...args: [...Iterable<T>[], { fillvalue?: T }] | Iterable<T>[]\n): T[][] {\n  let fillvalue: T | undefined\n  let iterables: Iterable<T>[]\n\n  // Check if last argument is options object\n  const lastArg = args[args.length - 1]\n  if (\n    lastArg &&\n    typeof lastArg === \"object\" &&\n    !Array.isArray(lastArg) &&\n    !(Symbol.iterator in lastArg)\n  ) {\n    fillvalue = (lastArg as { fillvalue?: T }).fillvalue\n    iterables = args.slice(0, -1) as Iterable<T>[]\n  } else {\n    iterables = args as Iterable<T>[]\n  }\n\n  if (iterables.length === 0) return []\n\n  const arrays = iterables.map((it) => [...it])\n  const maxLen = Math.max(...arrays.map((a) => a.length))\n  const result: T[][] = []\n\n  for (let i = 0; i < maxLen; i++) {\n    const tuple: T[] = []\n    for (const arr of arrays) {\n      tuple.push(i < arr.length ? (arr[i] as T) : (fillvalue as T))\n    }\n    result.push(tuple)\n  }\n\n  return result\n}\n\n/**\n * Return elements from iterable where the corresponding selector is true\n * compress([1, 2, 3, 4, 5], [1, 0, 1, 0, 1]) -> [1, 3, 5]\n */\nexport function compress<T>(data: Iterable<T>, selectors: Iterable<unknown>): T[] {\n  const result: T[] = []\n  const dataArr = [...data]\n  const selectorsArr = [...selectors]\n  const len = Math.min(dataArr.length, selectorsArr.length)\n\n  for (let i = 0; i < len; i++) {\n    if (selectorsArr[i]) {\n      result.push(dataArr[i] as T)\n    }\n  }\n  return result\n}\n\n/**\n * Return elements for which predicate is false\n * filterFalse(x => x % 2, [1, 2, 3, 4, 5]) -> [2, 4]\n */\nexport function filterFalse<T>(predicate: (x: T) => unknown, iterable: Iterable<T>): T[] {\n  const result: T[] = []\n  for (const element of iterable) {\n    if (!predicate(element)) {\n      result.push(element)\n    }\n  }\n  return result\n}\n\n/**\n * Make an iterator that returns accumulated sums or accumulated results\n * accumulate([1, 2, 3, 4, 5]) -> [1, 3, 6, 10, 15]\n * accumulate([1, 2, 3, 4, 5], (x, y) => x * y) -> [1, 2, 6, 24, 120]\n */\nexport function accumulate<T>(\n  iterable: Iterable<T>,\n  func?: (acc: T, val: T) => T,\n  initial?: T\n): T[] {\n  const result: T[] = []\n  const arr = [...iterable]\n\n  if (arr.length === 0) {\n    if (initial !== undefined) {\n      return [initial]\n    }\n    return []\n  }\n\n  const operation = func ?? ((a: T, b: T): T => ((a as number) + (b as number)) as unknown as T)\n\n  let acc: T\n  let startIdx: number\n\n  if (initial !== undefined) {\n    acc = initial\n    startIdx = 0\n    result.push(acc)\n  } else {\n    acc = arr[0] as T\n    startIdx = 1\n    result.push(acc)\n  }\n\n  for (let i = startIdx; i < arr.length; i++) {\n    acc = operation(acc, arr[i] as T)\n    result.push(acc)\n  }\n\n  return result\n}\n\n/**\n * Return consecutive keys and groups from the iterable\n * groupby([1, 1, 2, 2, 2, 3, 1, 1]) -> [[1, [1, 1]], [2, [2, 2, 2]], [3, [3]], [1, [1, 1]]]\n */\nexport function groupby<T, K = T>(iterable: Iterable<T>, key?: (x: T) => K): [K, T[]][] {\n  const result: [K, T[]][] = []\n  const keyFunc = key ?? ((x: T) => x as unknown as K)\n\n  let currentKey: K | undefined\n  let currentGroup: T[] = []\n  let first = true\n\n  for (const element of iterable) {\n    const k = keyFunc(element)\n    if (first) {\n      currentKey = k\n      currentGroup = [element]\n      first = false\n    } else if (k === currentKey) {\n      currentGroup.push(element)\n    } else {\n      result.push([currentKey as K, currentGroup])\n      currentKey = k\n      currentGroup = [element]\n    }\n  }\n\n  if (!first) {\n    result.push([currentKey as K, currentGroup])\n  }\n\n  return result\n}\n\n/**\n * Make an iterator that returns evenly spaced values starting with n\n * count(10, 2) -> 10, 12, 14, 16, 18, ...  (INFINITE Generator)\n */\nexport function* count(start: number = 0, step: number = 1): Generator<number> {\n  let n = start\n  for (;;) {\n    yield n\n    n += step\n  }\n}\n\n/**\n * Return n independent iterators from a single iterable\n * tee([1, 2, 3], 2) -> [[1, 2, 3], [1, 2, 3]]\n */\nexport function tee<T>(iterable: Iterable<T>, n: number = 2): T[][] {\n  const arr = [...iterable]\n  return Array.from({ length: n }, () => [...arr])\n}\n\n/**\n * Return successive overlapping pairs from the iterable\n * pairwise([1, 2, 3, 4, 5]) -> [[1, 2], [2, 3], [3, 4], [4, 5]]\n */\nexport function pairwise<T>(iterable: Iterable<T>): [T, T][] {\n  const arr = [...iterable]\n  const result: [T, T][] = []\n  for (let i = 0; i < arr.length - 1; i++) {\n    result.push([arr[i] as T, arr[i + 1] as T])\n  }\n  return result\n}\n\n/**\n * Cartesian product with repeat (product(range(3), repeat=2) like nested loops)\n * productRepeat([0, 1], 2) -> [[0, 0], [0, 1], [1, 0], [1, 1]]\n */\nexport function productRepeat<T>(iterable: Iterable<T>, repeat: number = 1): T[][] {\n  const pool = [...iterable]\n  if (repeat < 1 || pool.length === 0) return repeat === 0 ? [[]] : []\n\n  const pools = Array.from({ length: repeat }, () => pool)\n  return product(...pools)\n}\n\n/**\n * Return r-length combinations with replacement\n * combinationsWithReplacement([1, 2, 3], 2) -> [[1, 1], [1, 2], [1, 3], [2, 2], [2, 3], [3, 3]]\n */\nexport function combinationsWithReplacement<T>(iterable: Iterable<T>, r: number): T[][] {\n  const pool = [...iterable]\n  const n = pool.length\n  if (r < 0 || n === 0) return r === 0 ? [[]] : []\n\n  const result: T[][] = []\n  const indices: number[] = new Array<number>(r).fill(0)\n  result.push(indices.map((i) => pool[i] as T))\n\n  for (;;) {\n    let i = r - 1\n    while (i >= 0 && indices[i] === n - 1) i--\n    if (i < 0) break\n    const newVal = (indices[i] as number) + 1\n    for (let j = i; j < r; j++) {\n      indices[j] = newVal\n    }\n    result.push(indices.map((idx) => pool[idx] as T))\n  }\n\n  return result\n}\n\n/**\n * Split an iterable into chunks of specified size.\n * @inspired Remeda, Lodash\n *\n * chunk([1, 2, 3, 4, 5], 2) -> [[1, 2], [3, 4], [5]]\n */\nexport function chunk<T>(iterable: Iterable<T>, size: number): T[][] {\n  if (size < 1) {\n    throw new Error(\"chunk size must be at least 1\")\n  }\n  const arr = [...iterable]\n  const result: T[][] = []\n  for (let i = 0; i < arr.length; i += size) {\n    result.push(arr.slice(i, i + size))\n  }\n  return result\n}\n\n/**\n * Partition an iterable into two arrays based on a predicate.\n * @inspired Remeda, Lodash\n *\n * partition([1, 2, 3, 4], x => x % 2 === 0) -> [[2, 4], [1, 3]]\n */\nexport function partition<T>(iterable: Iterable<T>, predicate: (x: T) => boolean): [T[], T[]] {\n  const truthy: T[] = []\n  const falsy: T[] = []\n  for (const item of iterable) {\n    if (predicate(item)) {\n      truthy.push(item)\n    } else {\n      falsy.push(item)\n    }\n  }\n  return [truthy, falsy]\n}\n"],"mappings":"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","names":["repeat"]}