pythonlib 0.1.0 → 0.2.1

package/dist/chunk-TOI6IG3T.js.map

@@ -1 +0,0 @@
-{"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 * 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 * zip_longest([1, 2, 3], ['a', 'b'], { fillvalue: '-' }) -> [[1, 'a'], [2, 'b'], [3, '-']]\n */\nexport function zip_longest<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 * combinations_with_replacement([1, 2, 3], 2) -> [[1, 1], [1, 2], [1, 3], [2, 2], [2, 3], [3, 3]]\n */\nexport function combinations_with_replacement<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"],"mappings":"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","names":["repeat"]}

package/dist/chunk-UFMTN4T4.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/collections.ts"],"sourcesContent":["/**\n * Python collections module for TypeScript\n *\n * Provides specialized container datatypes.\n */\n\n/**\n * Counter: a dict subclass for counting hashable objects\n *\n * Elements are stored as keys and their counts are stored as values.\n */\nexport class Counter<T> extends Map<T, number> {\n  constructor(iterable?: Iterable<T>) {\n    super()\n    if (iterable) {\n      for (const item of iterable) {\n        this.increment(item)\n      }\n    }\n  }\n\n  /**\n   * Increment the count for a key\n   */\n  increment(key: T, n: number = 1): void {\n    this.set(key, (super.get(key) ?? 0) + n)\n  }\n\n  /**\n   * Get the count for a key (returns 0 for missing keys)\n   */\n  get(key: T): number {\n    return super.get(key) ?? 0\n  }\n\n  /**\n   * List the n most common elements and their counts\n   * If n is undefined, list all elements from most common to least\n   */\n  mostCommon(n?: number): [T, number][] {\n    const sorted = [...this.entries()].sort((a, b) => b[1] - a[1])\n    return n !== undefined ? sorted.slice(0, n) : sorted\n  }\n\n  /**\n   * Iterate over elements, repeating each as many times as its count\n   */\n  *elements(): Generator<T> {\n    for (const [key, count] of this) {\n      for (let i = 0; i < count; i++) {\n        yield key\n      }\n    }\n  }\n\n  /**\n   * Subtract counts from another iterable or Counter\n   */\n  subtract(iterable: Iterable<T> | Counter<T>): void {\n    if (iterable instanceof Counter) {\n      for (const [key, count] of iterable) {\n        this.set(key, (super.get(key) ?? 0) - count)\n      }\n    } else {\n      for (const item of iterable) {\n        this.set(item, (super.get(item) ?? 0) - 1)\n      }\n    }\n  }\n\n  /**\n   * Add counts from another iterable or Counter\n   */\n  update(iterable: Iterable<T> | Counter<T>): void {\n    if (iterable instanceof Counter) {\n      for (const [key, count] of iterable) {\n        this.increment(key, count)\n      }\n    } else {\n      for (const item of iterable) {\n        this.increment(item)\n      }\n    }\n  }\n\n  /**\n   * Return total count of all elements\n   */\n  total(): number {\n    let sum = 0\n    for (const count of this.values()) {\n      sum += count\n    }\n    return sum\n  }\n}\n\n/**\n * defaultdict: a dict that provides default values for missing keys\n *\n * Uses a Proxy to automatically call the factory function for missing keys.\n */\nexport function defaultdict<K, V>(factory: () => V): Map<K, V> & { get(key: K): V } {\n  const map = new Map<K, V>()\n  return new Proxy(map, {\n    get(target, prop, receiver): unknown {\n      if (prop === \"get\") {\n        return (key: K): V => {\n          if (!target.has(key)) {\n            const defaultValue = factory()\n            target.set(key, defaultValue)\n            return defaultValue\n          }\n          return target.get(key) as V\n        }\n      }\n      const val: unknown = Reflect.get(target, prop, receiver)\n      if (typeof val === \"function\") {\n        return (val as (...args: unknown[]) => unknown).bind(target)\n      }\n      return val\n    }\n  }) as Map<K, V> & { get(key: K): V }\n}\n\n/**\n * deque: double-ended queue with O(1) append and pop from both ends\n */\nexport class deque<T> {\n  private items: T[]\n  private maxlen: number | null\n\n  constructor(iterable?: Iterable<T>, maxlen?: number) {\n    this.items = iterable ? [...iterable] : []\n    this.maxlen = maxlen ?? null\n    if (this.maxlen !== null && this.items.length > this.maxlen) {\n      this.items = this.items.slice(-this.maxlen)\n    }\n  }\n\n  /**\n   * Add element to the right end\n   */\n  append(x: T): void {\n    this.items.push(x)\n    if (this.maxlen !== null && this.items.length > this.maxlen) {\n      this.items.shift()\n    }\n  }\n\n  /**\n   * Add element to the left end\n   */\n  appendleft(x: T): void {\n    this.items.unshift(x)\n    if (this.maxlen !== null && this.items.length > this.maxlen) {\n      this.items.pop()\n    }\n  }\n\n  /**\n   * Remove and return element from the right end\n   */\n  pop(): T | undefined {\n    return this.items.pop()\n  }\n\n  /**\n   * Remove and return element from the left end\n   */\n  popleft(): T | undefined {\n    return this.items.shift()\n  }\n\n  /**\n   * Extend the right side with elements from iterable\n   */\n  extend(iterable: Iterable<T>): void {\n    for (const x of iterable) {\n      this.append(x)\n    }\n  }\n\n  /**\n   * Extend the left side with elements from iterable\n   */\n  extendleft(iterable: Iterable<T>): void {\n    for (const x of iterable) {\n      this.appendleft(x)\n    }\n  }\n\n  /**\n   * Rotate the deque n steps to the right (negative n rotates left)\n   */\n  rotate(n: number = 1): void {\n    const len = this.items.length\n    if (len === 0) return\n    n = n % len\n    if (n > 0) {\n      // Move last n elements to the front\n      const tail = this.items.splice(-n, n)\n      this.items.unshift(...tail)\n    } else if (n < 0) {\n      // Move first -n elements to the end\n      const head = this.items.splice(0, -n)\n      this.items.push(...head)\n    }\n  }\n\n  /**\n   * Remove all elements\n   */\n  clear(): void {\n    this.items = []\n  }\n\n  /**\n   * Number of elements\n   */\n  get length(): number {\n    return this.items.length\n  }\n\n  /**\n   * Make iterable\n   */\n  *[Symbol.iterator](): Generator<T> {\n    yield* this.items\n  }\n\n  /**\n   * Convert to array\n   */\n  toArray(): T[] {\n    return [...this.items]\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-V63LKSA3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/re.ts"],"sourcesContent":["/**\n * Python re module for TypeScript\n *\n * Provides regular expression matching operations matching Python's re module.\n * Uses JavaScript's RegExp as the underlying engine.\n *\n * Note: Some Python regex features are not supported in JavaScript:\n * - Lookbehind assertions (limited support in modern JS)\n * - Named groups use different syntax (?P<name>...) vs (?<name>...)\n * - Verbose mode (x flag) is not supported\n */\n\n// ============================================================================\n// Flags\n// ============================================================================\n\n/** Ignore case */\nexport const IGNORECASE = 2\nexport const I = IGNORECASE\n\n/** Multi-line mode */\nexport const MULTILINE = 8\nexport const M = MULTILINE\n\n/** Dot matches all (including newline) */\nexport const DOTALL = 16\nexport const S = DOTALL\n\n/** Unicode matching (always on in JS) */\nexport const UNICODE = 32\nexport const U = UNICODE\n\n/** ASCII-only matching */\nexport const ASCII = 256\nexport const A = ASCII\n\n// ============================================================================\n// Match object\n// ============================================================================\n\nexport class Match {\n  private _match: RegExpExecArray\n  private _string: string\n  private _pattern: Pattern\n  private _pos: number\n  private _endpos: number\n\n  constructor(\n    match: RegExpExecArray,\n    string: string,\n    pattern: Pattern,\n    pos: number = 0,\n    endpos?: number\n  ) {\n    this._match = match\n    this._string = string\n    this._pattern = pattern\n    this._pos = pos\n    this._endpos = endpos ?? string.length\n  }\n\n  /** Return the string matched by the RE */\n  group(groupNum: number | string = 0): string | undefined {\n    if (typeof groupNum === \"number\") {\n      return this._match[groupNum]\n    }\n    // Named group\n    return this._match.groups?.[groupNum]\n  }\n\n  /** Return a tuple containing all subgroups */\n  groups(defaultValue?: string): (string | undefined)[] {\n    const result: (string | undefined)[] = []\n    for (let i = 1; i < this._match.length; i++) {\n      result.push(this._match[i] ?? defaultValue)\n    }\n    return result\n  }\n\n  /** Return a dictionary of named groups */\n  groupdict(defaultValue?: string): Record<string, string | undefined> {\n    const groups = this._match.groups ?? {}\n    const result: Record<string, string | undefined> = {}\n    for (const [key, value] of Object.entries(groups)) {\n      // Groups can have undefined values for non-participating groups\n      result[key] = (value as string | undefined) ?? defaultValue\n    }\n    return result\n  }\n\n  /** Return the start index of the match */\n  start(groupNum: number = 0): number {\n    if (groupNum === 0) {\n      return this._match.index\n    }\n    // For subgroups, we need to find the position\n    const fullMatch = this._match[0]\n    const subMatch = this._match[groupNum]\n    if (!fullMatch || !subMatch) return -1\n    const offset = fullMatch.indexOf(subMatch)\n    return offset >= 0 ? this._match.index + offset : -1\n  }\n\n  /** Return the end index of the match */\n  end(groupNum: number = 0): number {\n    const s = this.start(groupNum)\n    const g = this.group(groupNum)\n    if (s < 0 || g === undefined) return -1\n    return s + g.length\n  }\n\n  /** Return a tuple (start, end) */\n  span(groupNum: number = 0): [number, number] {\n    return [this.start(groupNum), this.end(groupNum)]\n  }\n\n  /** Return start position of search */\n  get pos(): number {\n    return this._pos\n  }\n\n  /** Return end position of search */\n  get endpos(): number {\n    return this._endpos\n  }\n\n  /** Return the last matched group index */\n  get lastindex(): number | undefined {\n    for (let i = this._match.length - 1; i > 0; i--) {\n      if (this._match[i] !== undefined) return i\n    }\n    return undefined\n  }\n\n  /** Return the name of the last matched group */\n  get lastgroup(): string | undefined {\n    if (!this._match.groups) return undefined\n    const lastIdx = this.lastindex\n    if (lastIdx === undefined) return undefined\n    // Find the name for this index\n    let idx = 1\n    for (const name of Object.keys(this._match.groups)) {\n      if (idx === lastIdx) return name\n      idx++\n    }\n    return undefined\n  }\n\n  /** Return the pattern object */\n  get re(): Pattern {\n    return this._pattern\n  }\n\n  /** Return the input string */\n  get string(): string {\n    return this._string\n  }\n\n  /** Expand template with groups */\n  expand(template: string): string {\n    return template.replace(/\\\\(\\d+)|\\\\g<(\\w+)>/g, (_, num: string | undefined, name: string) => {\n      if (num) {\n        return this.group(parseInt(num)) ?? \"\"\n      }\n      return this.group(name) ?? \"\"\n    })\n  }\n\n  /** Return iterator of all groups */\n  *[Symbol.iterator](): Generator<string | undefined> {\n    for (let i = 0; i < this._match.length; i++) {\n      yield this._match[i]\n    }\n  }\n\n  toString(): string {\n    return `<re.Match object; span=(${String(this.start())}, ${String(this.end())}), match='${this.group() ?? \"\"}'>`\n  }\n}\n\n// ============================================================================\n// Pattern object\n// ============================================================================\n\nexport class Pattern {\n  private _regex: RegExp\n  private _pattern: string\n  private _flags: number\n\n  constructor(pattern: string, flags: number = 0) {\n    this._pattern = pattern\n    this._flags = flags\n    this._regex = this._compileRegex(pattern, flags)\n  }\n\n  private _compileRegex(pattern: string, flags: number): RegExp {\n    // Convert Python regex syntax to JavaScript\n    const jsPattern = pattern\n      // Convert Python named groups (?P<name>...) to JS (?<name>...)\n      .replace(/\\(\\?P<(\\w+)>/g, \"(?<$1>\")\n      // Convert Python named backreferences (?P=name) to JS \\k<name>\n      .replace(/\\(\\?P=(\\w+)\\)/g, \"\\\\k<$1>\")\n\n    let jsFlags = \"\"\n    if (flags & IGNORECASE) jsFlags += \"i\"\n    if (flags & MULTILINE) jsFlags += \"m\"\n    if (flags & DOTALL) jsFlags += \"s\"\n    jsFlags += \"u\" // Always use unicode\n\n    return new RegExp(jsPattern, jsFlags)\n  }\n\n  /** Search for pattern in string */\n  search(string: string, pos: number = 0, endpos?: number): Match | null {\n    const searchStr = endpos !== undefined ? string.slice(0, endpos) : string\n    const searchFrom = searchStr.slice(pos)\n\n    const regex = new RegExp(this._regex.source, this._regex.flags)\n    const match = regex.exec(searchFrom)\n\n    if (match) {\n      match.index += pos\n      return new Match(match, string, this, pos, endpos)\n    }\n    return null\n  }\n\n  /** Match pattern at start of string */\n  match(string: string, pos: number = 0, endpos?: number): Match | null {\n    const searchStr = endpos !== undefined ? string.slice(0, endpos) : string\n    const searchFrom = searchStr.slice(pos)\n\n    // Force match at start\n    const regex = new RegExp(\"^(?:\" + this._regex.source + \")\", this._regex.flags)\n    const match = regex.exec(searchFrom)\n\n    if (match) {\n      match.index += pos\n      return new Match(match, string, this, pos, endpos)\n    }\n    return null\n  }\n\n  /** Match pattern against entire string */\n  fullmatch(string: string, pos: number = 0, endpos?: number): Match | null {\n    const searchStr = endpos !== undefined ? string.slice(0, endpos) : string\n    const searchFrom = searchStr.slice(pos)\n\n    // Force match entire string\n    const regex = new RegExp(\"^(?:\" + this._regex.source + \")$\", this._regex.flags)\n    const match = regex.exec(searchFrom)\n\n    if (match) {\n      match.index += pos\n      return new Match(match, string, this, pos, endpos)\n    }\n    return null\n  }\n\n  /** Split string by pattern */\n  split(string: string, maxsplit: number = 0): string[] {\n    if (maxsplit === 0) {\n      return string.split(this._regex)\n    }\n\n    const result: string[] = []\n    let lastIndex = 0\n    let count = 0\n    const regex = new RegExp(this._regex.source, this._regex.flags + \"g\")\n\n    let match: RegExpExecArray | null\n    while ((match = regex.exec(string)) !== null && (maxsplit === 0 || count < maxsplit)) {\n      result.push(string.slice(lastIndex, match.index))\n      // Add captured groups\n      for (let i = 1; i < match.length; i++) {\n        const group = match[i]\n        if (group !== undefined) {\n          result.push(group)\n        }\n      }\n      lastIndex = regex.lastIndex\n      count++\n    }\n    result.push(string.slice(lastIndex))\n    return result\n  }\n\n  /** Find all matches */\n  findall(string: string, pos: number = 0, endpos?: number): (string | string[])[] {\n    const searchStr = endpos !== undefined ? string.slice(0, endpos) : string\n    const searchFrom = searchStr.slice(pos)\n\n    const regex = new RegExp(this._regex.source, this._regex.flags + \"g\")\n    const results: (string | string[])[] = []\n\n    let match: RegExpExecArray | null\n    while ((match = regex.exec(searchFrom)) !== null) {\n      if (match.length === 1) {\n        results.push(match[0])\n      } else if (match.length === 2 && match[1] !== undefined) {\n        results.push(match[1])\n      } else {\n        results.push(match.slice(1))\n      }\n    }\n    return results\n  }\n\n  /** Find all matches as iterator */\n  *finditer(string: string, pos: number = 0, endpos?: number): Generator<Match> {\n    const searchStr = endpos !== undefined ? string.slice(0, endpos) : string\n    const searchFrom = searchStr.slice(pos)\n\n    const regex = new RegExp(this._regex.source, this._regex.flags + \"g\")\n\n    let match: RegExpExecArray | null\n    while ((match = regex.exec(searchFrom)) !== null) {\n      match.index += pos\n      yield new Match(match, string, this, pos, endpos)\n    }\n  }\n\n  /** Replace pattern in string */\n  sub(repl: string | ((match: Match) => string), string: string, count: number = 0): string {\n    if (typeof repl === \"function\") {\n      let n = 0\n      const regex = new RegExp(this._regex.source, this._regex.flags + \"g\")\n      return string.replace(regex, (...args) => {\n        if (count > 0 && n >= count) {\n          return args[0]\n        }\n        n++\n        const match = regex.exec(string)\n        if (!match) return args[0]\n        return repl(new Match(match, string, this))\n      })\n    }\n\n    // Convert Python replacement syntax\n    const jsRepl = repl.replace(/\\\\g<(\\w+)>/g, \"$<$1>\").replace(/\\\\(\\d+)/g, \"$$$1\")\n\n    if (count === 0) {\n      const regex = new RegExp(this._regex.source, this._regex.flags + \"g\")\n      return string.replace(regex, jsRepl)\n    }\n\n    let result = string\n    let n = 0\n    const regex = new RegExp(this._regex.source, this._regex.flags)\n    while (n < count) {\n      const newResult = result.replace(regex, jsRepl)\n      if (newResult === result) break\n      result = newResult\n      n++\n    }\n    return result\n  }\n\n  /** Replace pattern and return (newstring, count) */\n  subn(\n    repl: string | ((match: Match) => string),\n    string: string,\n    count: number = 0\n  ): [string, number] {\n    let n = 0\n    const result = this.sub(\n      typeof repl === \"function\"\n        ? (m) => {\n            n++\n            return repl(m)\n          }\n        : repl,\n      string,\n      count\n    )\n    if (typeof repl === \"string\") {\n      // Count replacements\n      const regex = new RegExp(this._regex.source, this._regex.flags + \"g\")\n      const matches = string.match(regex)\n      n = matches ? (count > 0 ? Math.min(matches.length, count) : matches.length) : 0\n    }\n    return [result, n]\n  }\n\n  /** Return the pattern string */\n  get pattern(): string {\n    return this._pattern\n  }\n\n  /** Return the flags */\n  get flags(): number {\n    return this._flags\n  }\n\n  /** Return number of groups */\n  get groups(): number {\n    // Count groups in pattern\n    let count = 0\n    for (let i = 0; i < this._pattern.length; i++) {\n      if (this._pattern[i] === \"\\\\\") {\n        i++\n        continue\n      }\n      if (this._pattern[i] === \"(\") {\n        if (this._pattern[i + 1] !== \"?\") {\n          count++\n        } else if (\n          this._pattern.slice(i + 1, i + 4) === \"?P<\" ||\n          this._pattern.slice(i + 1, i + 3) === \"?<\"\n        ) {\n          count++\n        }\n      }\n    }\n    return count\n  }\n\n  /** Return named groups mapping */\n  get groupindex(): Record<string, number> {\n    const result: Record<string, number> = {}\n    let groupNum = 0\n    const regex = /\\(\\?P?<(\\w+)>/g\n    let match: RegExpExecArray | null\n    while ((match = regex.exec(this._pattern)) !== null) {\n      groupNum++\n      const name = match[1]\n      if (name) {\n        result[name] = groupNum\n      }\n    }\n    return result\n  }\n\n  toString(): string {\n    return `re.compile('${this._pattern}')`\n  }\n}\n\n// ============================================================================\n// Module functions\n// ============================================================================\n\n/** Compile a regular expression pattern */\nexport function compile(pattern: string, flags: number = 0): Pattern {\n  return new Pattern(pattern, flags)\n}\n\n/** Search for pattern in string */\nexport function search(pattern: string | Pattern, string: string, flags: number = 0): Match | null {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.search(string)\n}\n\n/** Match pattern at start of string */\nexport function match(pattern: string | Pattern, string: string, flags: number = 0): Match | null {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.match(string)\n}\n\n/** Match pattern against entire string */\nexport function fullmatch(\n  pattern: string | Pattern,\n  string: string,\n  flags: number = 0\n): Match | null {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.fullmatch(string)\n}\n\n/** Split string by pattern */\nexport function split(\n  pattern: string | Pattern,\n  string: string,\n  maxsplit: number = 0,\n  flags: number = 0\n): string[] {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.split(string, maxsplit)\n}\n\n/** Find all matches */\nexport function findall(\n  pattern: string | Pattern,\n  string: string,\n  flags: number = 0\n): (string | string[])[] {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.findall(string)\n}\n\n/** Find all matches as iterator */\nexport function finditer(\n  pattern: string | Pattern,\n  string: string,\n  flags: number = 0\n): Generator<Match> {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.finditer(string)\n}\n\n/** Replace pattern in string */\nexport function sub(\n  pattern: string | Pattern,\n  repl: string | ((match: Match) => string),\n  string: string,\n  count: number = 0,\n  flags: number = 0\n): string {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.sub(repl, string, count)\n}\n\n/** Replace pattern and return (newstring, count) */\nexport function subn(\n  pattern: string | Pattern,\n  repl: string | ((match: Match) => string),\n  string: string,\n  count: number = 0,\n  flags: number = 0\n): [string, number] {\n  const p = pattern instanceof Pattern ? pattern : compile(pattern, flags)\n  return p.subn(repl, string, count)\n}\n\n/** Escape special characters in pattern */\nexport function escape(pattern: string): string {\n  return pattern.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")\n}\n\n/** Purge the regex cache (no-op in this implementation) */\nexport function purge(): void {\n  // No cache to purge\n}\n"],"mappings":"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","names":["match","n","regex"]}

package/dist/chunk-WAONBJE5.js.map

@@ -1 +0,0 @@
-{"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\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"]}