pythonlib 0.1.0

package/dist/chunk-WAONBJE5.js

@@ -0,0 +1,236 @@
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/random.ts
+var random_exports = {};
+__export(random_exports, {
+  betavariate: () => betavariate,
+  choice: () => choice,
+  choices: () => choices,
+  expovariate: () => expovariate,
+  gammavariate: () => gammavariate,
+  gauss: () => gauss,
+  lognormvariate: () => lognormvariate,
+  normalvariate: () => normalvariate,
+  paretovariate: () => paretovariate,
+  randint: () => randint,
+  random: () => random,
+  randrange: () => randrange,
+  sample: () => sample,
+  shuffle: () => shuffle,
+  triangular: () => triangular,
+  uniform: () => uniform,
+  vonmisesvariate: () => vonmisesvariate,
+  weibullvariate: () => weibullvariate
+});
+function random() {
+  return Math.random();
+}
+function uniform(a, b) {
+  return a + Math.random() * (b - a);
+}
+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) {
+  if (stop === void 0) {
+    stop = start;
+    start = 0;
+  }
+  if (step === 0) {
+    throw new Error("step cannot be zero");
+  }
+  const numSteps = Math.ceil((stop - start) / step);
+  if (numSteps <= 0) {
+    throw new Error("empty range for randrange()");
+  }
+  const randomStep = Math.floor(Math.random() * numSteps);
+  return start + randomStep * step;
+}
+function choice(seq) {
+  if (seq.length === 0) {
+    throw new Error("Cannot choose from an empty sequence");
+  }
+  const index = Math.floor(Math.random() * seq.length);
+  return seq[index];
+}
+function choices(population, options) {
+  const k = options?.k ?? 1;
+  const weights = options?.weights;
+  if (population.length === 0) {
+    throw new Error("Cannot choose from an empty population");
+  }
+  if (weights) {
+    if (weights.length !== population.length) {
+      throw new Error("weights and population must have the same length");
+    }
+    const cumWeights = [];
+    let total = 0;
+    for (const w of weights) {
+      total += w;
+      cumWeights.push(total);
+    }
+    const result2 = [];
+    for (let i = 0; i < k; i++) {
+      const r = Math.random() * total;
+      let lo = 0;
+      let hi = cumWeights.length;
+      while (lo < hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        if (r > cumWeights[mid]) {
+          lo = mid + 1;
+        } else {
+          hi = mid;
+        }
+      }
+      result2.push(population[lo]);
+    }
+    return result2;
+  }
+  const result = [];
+  for (let i = 0; i < k; i++) {
+    result.push(population[Math.floor(Math.random() * population.length)]);
+  }
+  return result;
+}
+function sample(population, k) {
+  if (k > population.length) {
+    throw new Error("Sample larger than population");
+  }
+  if (k < 0) {
+    throw new Error("Sample size cannot be negative");
+  }
+  const pool = [...population];
+  for (let i = 0; i < k; i++) {
+    const j = i + Math.floor(Math.random() * (pool.length - i));
+    const temp = pool[i];
+    pool[i] = pool[j];
+    pool[j] = temp;
+  }
+  return pool.slice(0, k);
+}
+function shuffle(x) {
+  for (let i = x.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = x[i];
+    x[i] = x[j];
+    x[j] = temp;
+  }
+}
+function gauss(mu = 0, sigma = 1) {
+  let u1;
+  let u2;
+  do {
+    u1 = Math.random();
+    u2 = Math.random();
+  } while (u1 === 0);
+  const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+  return mu + z * sigma;
+}
+var normalvariate = gauss;
+function triangular(low = 0, high = 1, mode) {
+  if (mode === void 0) {
+    mode = (low + high) / 2;
+  }
+  const u = Math.random();
+  const c = (mode - low) / (high - low);
+  if (u < c) {
+    return low + Math.sqrt(u * (high - low) * (mode - low));
+  }
+  return high - Math.sqrt((1 - u) * (high - low) * (high - mode));
+}
+function betavariate(alpha, beta) {
+  const y = gammavariate(alpha, 1);
+  if (y === 0) return 0;
+  return y / (y + gammavariate(beta, 1));
+}
+function expovariate(lambd) {
+  return -Math.log(1 - Math.random()) / lambd;
+}
+function gammavariate(alpha, beta) {
+  if (alpha <= 0 || beta <= 0) {
+    throw new Error("gammavariate: alpha and beta must be > 0");
+  }
+  if (alpha > 1) {
+    const d = alpha - 1 / 3;
+    const c = 1 / Math.sqrt(9 * d);
+    for (; ; ) {
+      let x;
+      let v;
+      do {
+        x = gauss();
+        v = 1 + c * x;
+      } while (v <= 0);
+      v = v * v * v;
+      const u = Math.random();
+      if (u < 1 - 0.0331 * (x * x) * (x * x)) {
+        return d * v * beta;
+      }
+      if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {
+        return d * v * beta;
+      }
+    }
+  } else {
+    const u = Math.random();
+    return gammavariate(1 + alpha, beta) * Math.pow(u, 1 / alpha);
+  }
+}
+function lognormvariate(mu, sigma) {
+  return Math.exp(gauss(mu, sigma));
+}
+function vonmisesvariate(mu, kappa) {
+  if (kappa <= 1e-6) {
+    return 2 * Math.PI * Math.random();
+  }
+  const s = 0.5 / kappa;
+  const r = s + Math.sqrt(1 + s * s);
+  for (; ; ) {
+    const u1 = Math.random();
+    const z = Math.cos(Math.PI * u1);
+    const d = z / (r + z);
+    const u2 = Math.random();
+    if (u2 < 1 - d * d || u2 <= (1 - d) * Math.exp(d)) {
+      const q = 1 / r;
+      const f = (q + z) / (1 + q * z);
+      const u3 = Math.random();
+      if (u3 > 0.5) {
+        return (mu + Math.acos(f)) % (2 * Math.PI);
+      }
+      return (mu - Math.acos(f)) % (2 * Math.PI);
+    }
+  }
+}
+function paretovariate(alpha) {
+  const u = 1 - Math.random();
+  return 1 / Math.pow(u, 1 / alpha);
+}
+function weibullvariate(alpha, beta) {
+  const u = 1 - Math.random();
+  return alpha * Math.pow(-Math.log(u), 1 / beta);
+}
+
+export {
+  random,
+  uniform,
+  randint,
+  randrange,
+  choice,
+  choices,
+  sample,
+  shuffle,
+  gauss,
+  normalvariate,
+  triangular,
+  betavariate,
+  expovariate,
+  gammavariate,
+  lognormvariate,
+  vonmisesvariate,
+  paretovariate,
+  weibullvariate,
+  random_exports
+};
+//# sourceMappingURL=chunk-WAONBJE5.js.map

package/dist/chunk-WAONBJE5.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\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/collections-xN9Gi0TA.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Python collections module for TypeScript
+ *
+ * Provides specialized container datatypes.
+ */
+/**
+ * Counter: a dict subclass for counting hashable objects
+ *
+ * Elements are stored as keys and their counts are stored as values.
+ */
+declare class Counter<T> extends Map<T, number> {
+    constructor(iterable?: Iterable<T>);
+    /**
+     * Increment the count for a key
+     */
+    increment(key: T, n?: number): void;
+    /**
+     * Get the count for a key (returns 0 for missing keys)
+     */
+    get(key: T): number;
+    /**
+     * List the n most common elements and their counts
+     * If n is undefined, list all elements from most common to least
+     */
+    mostCommon(n?: number): [T, number][];
+    /**
+     * Iterate over elements, repeating each as many times as its count
+     */
+    elements(): Generator<T>;
+    /**
+     * Subtract counts from another iterable or Counter
+     */
+    subtract(iterable: Iterable<T> | Counter<T>): void;
+    /**
+     * Add counts from another iterable or Counter
+     */
+    update(iterable: Iterable<T> | Counter<T>): void;
+    /**
+     * Return total count of all elements
+     */
+    total(): number;
+}
+/**
+ * defaultdict: a dict that provides default values for missing keys
+ *
+ * Uses a Proxy to automatically call the factory function for missing keys.
+ */
+declare function defaultdict<K, V>(factory: () => V): Map<K, V> & {
+    get(key: K): V;
+};
+/**
+ * deque: double-ended queue with O(1) append and pop from both ends
+ */
+declare class deque<T> {
+    private items;
+    private maxlen;
+    constructor(iterable?: Iterable<T>, maxlen?: number);
+    /**
+     * Add element to the right end
+     */
+    append(x: T): void;
+    /**
+     * Add element to the left end
+     */
+    appendleft(x: T): void;
+    /**
+     * Remove and return element from the right end
+     */
+    pop(): T | undefined;
+    /**
+     * Remove and return element from the left end
+     */
+    popleft(): T | undefined;
+    /**
+     * Extend the right side with elements from iterable
+     */
+    extend(iterable: Iterable<T>): void;
+    /**
+     * Extend the left side with elements from iterable
+     */
+    extendleft(iterable: Iterable<T>): void;
+    /**
+     * Rotate the deque n steps to the right (negative n rotates left)
+     */
+    rotate(n?: number): void;
+    /**
+     * Remove all elements
+     */
+    clear(): void;
+    /**
+     * Number of elements
+     */
+    get length(): number;
+    /**
+     * Make iterable
+     */
+    [Symbol.iterator](): Generator<T>;
+    /**
+     * Convert to array
+     */
+    toArray(): T[];
+}
+
+type collectionsModule_Counter<T> = Counter<T>;
+declare const collectionsModule_Counter: typeof Counter;
+declare const collectionsModule_defaultdict: typeof defaultdict;
+type collectionsModule_deque<T> = deque<T>;
+declare const collectionsModule_deque: typeof deque;
+declare namespace collectionsModule {
+  export { collectionsModule_Counter as Counter, collectionsModule_defaultdict as defaultdict, collectionsModule_deque as deque };
+}
+
+export { Counter as C, deque as a, collectionsModule as c, defaultdict as d };

package/dist/collections.d.ts

@@ -0,0 +1 @@
+export { C as Counter, d as defaultdict, a as deque } from './collections-xN9Gi0TA.js';

package/dist/collections.js

@@ -0,0 +1,12 @@
+import {
+  Counter,
+  defaultdict,
+  deque
+} from "./chunk-UFMTN4T4.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  Counter,
+  defaultdict,
+  deque
+};
+//# sourceMappingURL=collections.js.map

package/dist/collections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/datetime-DRwFAiGV.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Python datetime module for TypeScript
+ *
+ * Provides date and time handling matching Python's datetime module.
+ */
+declare class timedelta {
+    readonly days: number;
+    readonly seconds: number;
+    readonly microseconds: number;
+    constructor(options?: {
+        days?: number;
+        seconds?: number;
+        microseconds?: number;
+        milliseconds?: number;
+        minutes?: number;
+        hours?: number;
+        weeks?: number;
+    });
+    total_seconds(): number;
+    toString(): string;
+    add(other: timedelta): timedelta;
+    subtract(other: timedelta): timedelta;
+    multiply(n: number): timedelta;
+    static min: timedelta;
+    static max: timedelta;
+    static resolution: timedelta;
+}
+declare class date {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    constructor(year: number, month: number, day: number);
+    static today(): date;
+    static fromtimestamp(timestamp: number): date;
+    static fromisoformat(dateString: string): date;
+    static fromordinal(ordinal: number): date;
+    replace(options?: {
+        year?: number;
+        month?: number;
+        day?: number;
+    }): date;
+    toordinal(): number;
+    weekday(): number;
+    isoweekday(): number;
+    isocalendar(): [number, number, number];
+    isoformat(): string;
+    strftime(format: string): string;
+    toString(): string;
+    __add__(delta: timedelta): date;
+    __sub__(other: date | timedelta): date | timedelta;
+    __lt__(other: date): boolean;
+    __le__(other: date): boolean;
+    __gt__(other: date): boolean;
+    __ge__(other: date): boolean;
+    __eq__(other: date): boolean;
+    static min: date;
+    static max: date;
+    static resolution: timedelta;
+}
+declare class time {
+    readonly hour: number;
+    readonly minute: number;
+    readonly second: number;
+    readonly microsecond: number;
+    readonly tzinfo: null;
+    constructor(hour?: number, minute?: number, second?: number, microsecond?: number);
+    static fromisoformat(timeString: string): time;
+    replace(options?: {
+        hour?: number;
+        minute?: number;
+        second?: number;
+        microsecond?: number;
+    }): time;
+    isoformat(timespec?: "auto" | "hours" | "minutes" | "seconds" | "milliseconds" | "microseconds"): string;
+    strftime(format: string): string;
+    toString(): string;
+    static min: time;
+    static max: time;
+    static resolution: timedelta;
+}
+declare class datetime extends date {
+    readonly hour: number;
+    readonly minute: number;
+    readonly second: number;
+    readonly microsecond: number;
+    readonly tzinfo: null;
+    constructor(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, microsecond?: number);
+    static today(): datetime;
+    static now(): datetime;
+    static utcnow(): datetime;
+    static fromtimestamp(timestamp: number): datetime;
+    static utcfromtimestamp(timestamp: number): datetime;
+    static fromisoformat(s: string): datetime;
+    static combine(d: date, t: time): datetime;
+    static strptime(dateString: string, format: string): datetime;
+    replace(options?: {
+        year?: number;
+        month?: number;
+        day?: number;
+        hour?: number;
+        minute?: number;
+        second?: number;
+        microsecond?: number;
+    }): datetime;
+    date(): date;
+    time(): time;
+    timestamp(): number;
+    isoformat(sep?: string, timespec?: "auto" | "hours" | "minutes" | "seconds" | "milliseconds" | "microseconds"): string;
+    ctime(): string;
+    strftime(format: string): string;
+    toString(): string;
+    __add__(delta: timedelta): datetime;
+    __sub__(other: datetime | date | timedelta): datetime | timedelta;
+    static min: datetime;
+    static max: datetime;
+    static resolution: timedelta;
+}
+declare function strftime(format: string, dt: datetime): string;
+declare function strptime(dateString: string, format: string): datetime;
+declare const MINYEAR = 1;
+declare const MAXYEAR = 9999;
+
+declare const datetimeModule_MAXYEAR: typeof MAXYEAR;
+declare const datetimeModule_MINYEAR: typeof MINYEAR;
+type datetimeModule_date = date;
+declare const datetimeModule_date: typeof date;
+type datetimeModule_datetime = datetime;
+declare const datetimeModule_datetime: typeof datetime;
+declare const datetimeModule_strftime: typeof strftime;
+declare const datetimeModule_strptime: typeof strptime;
+type datetimeModule_time = time;
+declare const datetimeModule_time: typeof time;
+type datetimeModule_timedelta = timedelta;
+declare const datetimeModule_timedelta: typeof timedelta;
+declare namespace datetimeModule {
+  export { datetimeModule_MAXYEAR as MAXYEAR, datetimeModule_MINYEAR as MINYEAR, datetimeModule_date as date, datetimeModule_datetime as datetime, datetimeModule_strftime as strftime, datetimeModule_strptime as strptime, datetimeModule_time as time, datetimeModule_timedelta as timedelta };
+}
+
+export { MINYEAR as M, date as a, time as b, datetime as c, datetimeModule as d, strptime as e, MAXYEAR as f, strftime as s, timedelta as t };

package/dist/datetime.d.ts

@@ -0,0 +1 @@
+export { f as MAXYEAR, M as MINYEAR, a as date, c as datetime, s as strftime, e as strptime, b as time, t as timedelta } from './datetime-DRwFAiGV.js';

package/dist/datetime.js

@@ -0,0 +1,22 @@
+import {
+  MAXYEAR,
+  MINYEAR,
+  date,
+  datetime,
+  strftime,
+  strptime,
+  time,
+  timedelta
+} from "./chunk-HA5Y7PKO.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  MAXYEAR,
+  MINYEAR,
+  date,
+  datetime,
+  strftime,
+  strptime,
+  time,
+  timedelta
+};
+//# sourceMappingURL=datetime.js.map

package/dist/datetime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/functools-St5GqpKG.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Python functools module for TypeScript
+ *
+ * Provides higher-order functions and operations on callable objects.
+ */
+/**
+ * Create a partial function application
+ * partial(func, arg1, arg2) returns a function that calls func with arg1, arg2 prepended
+ *
+ * Example:
+ *   const add = (a: number, b: number) => a + b
+ *   const add5 = partial(add, 5)
+ *   add5(3) // returns 8
+ */
+declare function partial<T extends (...args: unknown[]) => unknown>(func: T, ...partialArgs: unknown[]): (...args: unknown[]) => ReturnType<T>;
+/**
+ * Apply a function of two arguments cumulatively to the items of an iterable
+ * reduce((x, y) => x + y, [1, 2, 3, 4, 5]) returns 15
+ * reduce((x, y) => x + y, [1, 2, 3, 4, 5], 10) returns 25
+ */
+declare function reduce<T, U = T>(func: (acc: U, val: T) => U, iterable: Iterable<T>, initializer?: U): U;
+/**
+ * Simple LRU cache decorator (returns a memoized version of the function)
+ * Note: This is a simplified implementation that caches based on JSON-stringified arguments
+ *
+ * Example:
+ *   const fib = lru_cache((n: number): number => n <= 1 ? n : fib(n - 1) + fib(n - 2))
+ */
+declare function lru_cache<T extends (...args: unknown[]) => unknown>(func: T, maxsize?: number): T & {
+    cache_info: () => {
+        hits: number;
+        misses: number;
+        maxsize: number;
+        currsize: number;
+    };
+    cache_clear: () => void;
+};
+/**
+ * Cache decorator that caches all calls (no size limit)
+ * Equivalent to lru_cache(maxsize=None)
+ */
+declare function cache<T extends (...args: unknown[]) => unknown>(func: T): T;
+/**
+ * Return a new partial object which behaves like func called with keyword arguments
+ * In TypeScript, we simulate this with an options object as the last argument
+ */
+declare function partialmethod<T extends (...args: unknown[]) => unknown>(func: T, ...partialArgs: unknown[]): (...args: unknown[]) => ReturnType<T>;
+/**
+ * Transform a function into a single-dispatch generic function
+ * This is a simplified version - full singledispatch would require runtime type checking
+ */
+declare function singledispatch<T extends (...args: unknown[]) => unknown>(func: T): T & {
+    register: (type: string, impl: T) => void;
+};
+/**
+ * Decorator to update a wrapper function to look like the wrapped function
+ * In TypeScript, this just returns the wrapper as-is (metadata is handled differently)
+ */
+declare function wraps<T extends (...args: unknown[]) => unknown>(wrapped: T): (wrapper: (...args: unknown[]) => unknown) => T;
+/**
+ * Return a callable object that fetches attr from its operand
+ * attrgetter('name') returns a function that gets the 'name' attribute
+ */
+declare function attrgetter<T>(...attrs: string[]): (obj: unknown) => T | T[];
+/**
+ * Return a callable object that fetches item from its operand
+ * itemgetter(1) returns a function that gets index 1
+ * itemgetter('key') returns a function that gets the 'key' property
+ */
+declare function itemgetter<T>(...items: (string | number)[]): (obj: unknown) => T | T[];
+/**
+ * Return a callable object that calls the method name on its operand
+ * methodcaller('split', ' ') returns a function that calls .split(' ')
+ */
+declare function methodcaller(name: string, ...args: unknown[]): (obj: unknown) => unknown;
+/**
+ * Return the same object passed in (identity function)
+ */
+declare function identity<T>(x: T): T;
+/**
+ * Compare two objects for ordering (returns -1, 0, or 1)
+ * Used for sorting with a key function
+ */
+declare function cmp_to_key<T>(mycmp: (a: T, b: T) => number): (x: T) => {
+    value: T;
+    __lt__: (other: {
+        value: T;
+    }) => boolean;
+};
+/**
+ * Return total ordering for a class that has __lt__, __le__, __gt__, or __ge__
+ * This is typically used as a class decorator in Python
+ * In TypeScript, we provide helper comparisons
+ */
+declare function total_ordering<T extends {
+    __lt__?: (other: T) => boolean;
+    __le__?: (other: T) => boolean;
+    __gt__?: (other: T) => boolean;
+    __ge__?: (other: T) => boolean;
+    __eq__?: (other: T) => boolean;
+}>(obj: T): T & {
+    __lt__: (other: T) => boolean;
+    __le__: (other: T) => boolean;
+    __gt__: (other: T) => boolean;
+    __ge__: (other: T) => boolean;
+};
+
+declare const functoolsModule_attrgetter: typeof attrgetter;
+declare const functoolsModule_cache: typeof cache;
+declare const functoolsModule_cmp_to_key: typeof cmp_to_key;
+declare const functoolsModule_identity: typeof identity;
+declare const functoolsModule_itemgetter: typeof itemgetter;
+declare const functoolsModule_lru_cache: typeof lru_cache;
+declare const functoolsModule_methodcaller: typeof methodcaller;
+declare const functoolsModule_partial: typeof partial;
+declare const functoolsModule_partialmethod: typeof partialmethod;
+declare const functoolsModule_reduce: typeof reduce;
+declare const functoolsModule_singledispatch: typeof singledispatch;
+declare const functoolsModule_total_ordering: typeof total_ordering;
+declare const functoolsModule_wraps: typeof wraps;
+declare namespace functoolsModule {
+  export { functoolsModule_attrgetter as attrgetter, functoolsModule_cache as cache, functoolsModule_cmp_to_key as cmp_to_key, functoolsModule_identity as identity, functoolsModule_itemgetter as itemgetter, functoolsModule_lru_cache as lru_cache, functoolsModule_methodcaller as methodcaller, functoolsModule_partial as partial, functoolsModule_partialmethod as partialmethod, functoolsModule_reduce as reduce, functoolsModule_singledispatch as singledispatch, functoolsModule_total_ordering as total_ordering, functoolsModule_wraps as wraps };
+}
+
+export { partialmethod as a, attrgetter as b, cache as c, identity as d, cmp_to_key as e, functoolsModule as f, itemgetter as i, lru_cache as l, methodcaller as m, partial as p, reduce as r, singledispatch as s, total_ordering as t, wraps as w };