pythonlib 0.1.0

package/dist/math.js

@@ -0,0 +1,96 @@
+import {
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  cbrt,
+  ceil,
+  copysign,
+  cos,
+  cosh,
+  degrees,
+  e,
+  exp,
+  expm1,
+  fabs,
+  factorial,
+  floor,
+  fsum,
+  gcd,
+  hypot,
+  inf,
+  isclose,
+  isfinite,
+  isinf,
+  isnan,
+  lcm,
+  log,
+  log10,
+  log1p,
+  log2,
+  modf,
+  nan,
+  pi,
+  pow,
+  prod,
+  radians,
+  sin,
+  sinh,
+  sqrt,
+  tan,
+  tanh,
+  tau,
+  trunc
+} from "./chunk-IVYYI2VR.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  cbrt,
+  ceil,
+  copysign,
+  cos,
+  cosh,
+  degrees,
+  e,
+  exp,
+  expm1,
+  fabs,
+  factorial,
+  floor,
+  fsum,
+  gcd,
+  hypot,
+  inf,
+  isclose,
+  isfinite,
+  isinf,
+  isnan,
+  lcm,
+  log,
+  log10,
+  log1p,
+  log2,
+  modf,
+  nan,
+  pi,
+  pow,
+  prod,
+  radians,
+  sin,
+  sinh,
+  sqrt,
+  tan,
+  tanh,
+  tau,
+  trunc
+};
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

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

package/dist/os-FRSJbEUH.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Python os module for TypeScript
+ *
+ * Provides operating system interface functions matching Python's os module.
+ * Note: This is a browser-compatible subset. Some functions are stubs.
+ */
+/** Environment variables (browser-safe empty object or Node's process.env) */
+declare const environ: Record<string, string | undefined>;
+/** Get an environment variable */
+declare function getenv(key: string, defaultValue?: string): string | undefined;
+/** Path separator for the current platform */
+declare const sep: string;
+/** Alternative path separator (Windows has both / and \) */
+declare const altsep: string | null;
+/** Path list separator (: on Unix, ; on Windows) */
+declare const pathsep: string;
+/** Line separator */
+declare const linesep: string;
+/** Current directory string */
+declare const curdir = ".";
+/** Parent directory string */
+declare const pardir = "..";
+/** Extension separator */
+declare const extsep = ".";
+declare const path: {
+    /** Join path components intelligently */
+    join(...paths: string[]): string;
+    /** Return the base name of pathname */
+    basename(p: string, suffix?: string): string;
+    /** Return the directory name of pathname */
+    dirname(p: string): string;
+    /** Split pathname into (head, tail) */
+    split(p: string): [string, string];
+    /** Split pathname into root and extension */
+    splitext(p: string): [string, string];
+    /** Return the extension of pathname */
+    extname(p: string): string;
+    /** Test whether a path is absolute */
+    isabs(p: string): boolean;
+    /** Normalize a pathname */
+    normpath(p: string): string;
+    /** Return normalized absolutized version of pathname */
+    abspath(p: string): string;
+    /** Return canonical path, eliminating symlinks (stub - just normalizes) */
+    realpath(p: string): string;
+    /** Return relative path from start to path */
+    relpath(p: string, start?: string): string;
+    /** Return common path prefix */
+    commonpath(paths: string[]): string;
+    /** Expand ~ and ~user (stub - returns unchanged in browser) */
+    expanduser(p: string): string;
+    /** Expand shell variables (stub - returns unchanged) */
+    expandvars(p: string): string;
+    /** Test if path exists (stub - always returns false in browser) */
+    exists(_p: string): boolean;
+    /** Test if path is a file (stub - always returns false in browser) */
+    isfile(_p: string): boolean;
+    /** Test if path is a directory (stub - always returns false in browser) */
+    isdir(_p: string): boolean;
+    /** Test if path is a symbolic link (stub - always returns false in browser) */
+    islink(_p: string): boolean;
+    /** Return size of file (stub - returns 0 in browser) */
+    getsize(_p: string): number;
+    /** Return modification time (stub - returns 0 in browser) */
+    getmtime(_p: string): number;
+    /** Return access time (stub - returns 0 in browser) */
+    getatime(_p: string): number;
+    /** Return creation time (stub - returns 0 in browser) */
+    getctime(_p: string): number;
+};
+/** Get current working directory */
+declare function getcwd(): string;
+/** Get current working directory as bytes (same as getcwd in TS) */
+declare function getcwdb(): string;
+/** Change current working directory (stub in browser) */
+declare function chdir(p: string): void;
+/** List directory contents (stub - returns empty array in browser) */
+declare function listdir(_p?: string): string[];
+/** Create a directory (stub in browser) */
+declare function mkdir(_p: string, _mode?: number): void;
+/** Create a directory and parents (stub in browser) */
+declare function makedirs(_p: string, _mode?: number, _existOk?: boolean): void;
+/** Remove a file (stub in browser) */
+declare function remove(_p: string): void;
+/** Remove a file (alias for remove) */
+declare const unlink: typeof remove;
+/** Remove a directory (stub in browser) */
+declare function rmdir(_p: string): void;
+/** Remove directory tree (stub in browser) */
+declare function removedirs(_p: string): void;
+/** Rename a file or directory (stub in browser) */
+declare function rename(_src: string, _dst: string): void;
+/** Rename with automatic directory creation (stub in browser) */
+declare function renames(_src: string, _dst: string): void;
+/** Replace file (stub in browser) */
+declare function replace(_src: string, _dst: string): void;
+/** Walk directory tree (stub - yields nothing in browser) */
+declare function walk(_top: string, _options?: {
+    topdown?: boolean;
+    followlinks?: boolean;
+}): Generator<[string, string[], string[]]>;
+/** Get file stat (stub in browser) */
+declare function stat(_p: string): {
+    st_mode: number;
+    st_size: number;
+    st_mtime: number;
+    st_atime: number;
+    st_ctime: number;
+};
+/** Operating system name */
+declare const name: string;
+
+declare const osModule_altsep: typeof altsep;
+declare const osModule_chdir: typeof chdir;
+declare const osModule_curdir: typeof curdir;
+declare const osModule_environ: typeof environ;
+declare const osModule_extsep: typeof extsep;
+declare const osModule_getcwd: typeof getcwd;
+declare const osModule_getcwdb: typeof getcwdb;
+declare const osModule_getenv: typeof getenv;
+declare const osModule_linesep: typeof linesep;
+declare const osModule_listdir: typeof listdir;
+declare const osModule_makedirs: typeof makedirs;
+declare const osModule_mkdir: typeof mkdir;
+declare const osModule_name: typeof name;
+declare const osModule_pardir: typeof pardir;
+declare const osModule_path: typeof path;
+declare const osModule_pathsep: typeof pathsep;
+declare const osModule_remove: typeof remove;
+declare const osModule_removedirs: typeof removedirs;
+declare const osModule_rename: typeof rename;
+declare const osModule_renames: typeof renames;
+declare const osModule_replace: typeof replace;
+declare const osModule_rmdir: typeof rmdir;
+declare const osModule_sep: typeof sep;
+declare const osModule_stat: typeof stat;
+declare const osModule_unlink: typeof unlink;
+declare const osModule_walk: typeof walk;
+declare namespace osModule {
+  export { osModule_altsep as altsep, osModule_chdir as chdir, osModule_curdir as curdir, osModule_environ as environ, osModule_extsep as extsep, osModule_getcwd as getcwd, osModule_getcwdb as getcwdb, osModule_getenv as getenv, osModule_linesep as linesep, osModule_listdir as listdir, osModule_makedirs as makedirs, osModule_mkdir as mkdir, osModule_name as name, osModule_pardir as pardir, osModule_path as path, osModule_pathsep as pathsep, osModule_remove as remove, osModule_removedirs as removedirs, osModule_rename as rename, osModule_renames as renames, osModule_replace as replace, osModule_rmdir as rmdir, osModule_sep as sep, osModule_stat as stat, osModule_unlink as unlink, osModule_walk as walk };
+}
+
+export { name as A, altsep as a, pardir as b, curdir as c, extsep as d, environ as e, path as f, getenv as g, getcwd as h, getcwdb as i, chdir as j, listdir as k, linesep as l, mkdir as m, makedirs as n, osModule as o, pathsep as p, rmdir as q, remove as r, sep as s, removedirs as t, unlink as u, rename as v, renames as w, replace as x, walk as y, stat as z };

package/dist/os.d.ts

@@ -0,0 +1 @@
+export { a as altsep, j as chdir, c as curdir, e as environ, d as extsep, h as getcwd, i as getcwdb, g as getenv, l as linesep, k as listdir, n as makedirs, m as mkdir, A as name, b as pardir, f as path, p as pathsep, r as remove, t as removedirs, v as rename, w as renames, x as replace, q as rmdir, s as sep, z as stat, u as unlink, y as walk } from './os-FRSJbEUH.js';

package/dist/os.js

@@ -0,0 +1,58 @@
+import {
+  altsep,
+  chdir,
+  curdir,
+  environ,
+  extsep,
+  getcwd,
+  getcwdb,
+  getenv,
+  linesep,
+  listdir,
+  makedirs,
+  mkdir,
+  name,
+  pardir,
+  path,
+  pathsep,
+  remove,
+  removedirs,
+  rename,
+  renames,
+  replace,
+  rmdir,
+  sep,
+  stat,
+  unlink,
+  walk
+} from "./chunk-TJFGYXBJ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  altsep,
+  chdir,
+  curdir,
+  environ,
+  extsep,
+  getcwd,
+  getcwdb,
+  getenv,
+  linesep,
+  listdir,
+  makedirs,
+  mkdir,
+  name,
+  pardir,
+  path,
+  pathsep,
+  remove,
+  removedirs,
+  rename,
+  renames,
+  replace,
+  rmdir,
+  sep,
+  stat,
+  unlink,
+  walk
+};
+//# sourceMappingURL=os.js.map

package/dist/os.js.map

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

package/dist/random-D5S5iSV3.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Python random module for TypeScript
+ *
+ * Provides random number generation functions matching Python's random module.
+ * Uses JavaScript's Math.random() as the underlying generator.
+ *
+ * Note: This is NOT cryptographically secure. For security-sensitive
+ * applications, use the Web Crypto API instead.
+ */
+/** Return a random floating point number in the range [0.0, 1.0) */
+declare function random(): number;
+/** Return a random floating point number N such that a <= N <= b */
+declare function uniform(a: number, b: number): number;
+/** Return a random integer N such that a <= N <= b (inclusive) */
+declare function randint(a: number, b: number): number;
+/** Return a randomly selected element from range(start, stop, step) */
+declare function randrange(start: number, stop?: number, step?: number): number;
+/** Return a random element from the non-empty sequence */
+declare function choice<T>(seq: T[] | string): T | string;
+/** Return a k-length list of elements chosen from the population with replacement */
+declare function choices<T>(population: T[], options?: {
+    weights?: number[];
+    k?: number;
+}): T[];
+/** Return a k-length list of unique elements chosen from the population (without replacement) */
+declare function sample<T>(population: T[], k: number): T[];
+/** Shuffle the sequence in place */
+declare function shuffle(x: unknown[]): void;
+/** Gaussian distribution with mean mu and standard deviation sigma */
+declare function gauss(mu?: number, sigma?: number): number;
+/** Normal distribution (alias for gauss) */
+declare const normalvariate: typeof gauss;
+/** Triangular distribution with low, high, and mode */
+declare function triangular(low?: number, high?: number, mode?: number): number;
+/** Beta distribution with alpha and beta parameters */
+declare function betavariate(alpha: number, beta: number): number;
+/** Exponential distribution with mean 1/lambd */
+declare function expovariate(lambd: number): number;
+/** Gamma distribution with shape alpha and scale beta */
+declare function gammavariate(alpha: number, beta: number): number;
+/** Log normal distribution */
+declare function lognormvariate(mu: number, sigma: number): number;
+/** Von Mises distribution (circular data) */
+declare function vonmisesvariate(mu: number, kappa: number): number;
+/** Pareto distribution */
+declare function paretovariate(alpha: number): number;
+/** Weibull distribution */
+declare function weibullvariate(alpha: number, beta: number): number;
+
+declare const randomModule_betavariate: typeof betavariate;
+declare const randomModule_choice: typeof choice;
+declare const randomModule_choices: typeof choices;
+declare const randomModule_expovariate: typeof expovariate;
+declare const randomModule_gammavariate: typeof gammavariate;
+declare const randomModule_gauss: typeof gauss;
+declare const randomModule_lognormvariate: typeof lognormvariate;
+declare const randomModule_normalvariate: typeof normalvariate;
+declare const randomModule_paretovariate: typeof paretovariate;
+declare const randomModule_randint: typeof randint;
+declare const randomModule_random: typeof random;
+declare const randomModule_randrange: typeof randrange;
+declare const randomModule_sample: typeof sample;
+declare const randomModule_shuffle: typeof shuffle;
+declare const randomModule_triangular: typeof triangular;
+declare const randomModule_uniform: typeof uniform;
+declare const randomModule_vonmisesvariate: typeof vonmisesvariate;
+declare const randomModule_weibullvariate: typeof weibullvariate;
+declare namespace randomModule {
+  export { randomModule_betavariate as betavariate, randomModule_choice as choice, randomModule_choices as choices, randomModule_expovariate as expovariate, randomModule_gammavariate as gammavariate, randomModule_gauss as gauss, randomModule_lognormvariate as lognormvariate, randomModule_normalvariate as normalvariate, randomModule_paretovariate as paretovariate, randomModule_randint as randint, randomModule_random as random, randomModule_randrange as randrange, randomModule_sample as sample, randomModule_shuffle as shuffle, randomModule_triangular as triangular, randomModule_uniform as uniform, randomModule_vonmisesvariate as vonmisesvariate, randomModule_weibullvariate as weibullvariate };
+}
+
+export { random as a, randint as b, randrange as c, choice as d, choices as e, shuffle as f, gauss as g, betavariate as h, expovariate as i, gammavariate as j, lognormvariate as l, normalvariate as n, paretovariate as p, randomModule as r, sample as s, triangular as t, uniform as u, vonmisesvariate as v, weibullvariate as w };

package/dist/random.d.ts

@@ -0,0 +1 @@
+export { h as betavariate, d as choice, e as choices, i as expovariate, j as gammavariate, g as gauss, l as lognormvariate, n as normalvariate, p as paretovariate, b as randint, a as random, c as randrange, s as sample, f as shuffle, t as triangular, u as uniform, v as vonmisesvariate, w as weibullvariate } from './random-D5S5iSV3.js';

package/dist/random.js

@@ -0,0 +1,42 @@
+import {
+  betavariate,
+  choice,
+  choices,
+  expovariate,
+  gammavariate,
+  gauss,
+  lognormvariate,
+  normalvariate,
+  paretovariate,
+  randint,
+  random,
+  randrange,
+  sample,
+  shuffle,
+  triangular,
+  uniform,
+  vonmisesvariate,
+  weibullvariate
+} from "./chunk-WAONBJE5.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  betavariate,
+  choice,
+  choices,
+  expovariate,
+  gammavariate,
+  gauss,
+  lognormvariate,
+  normalvariate,
+  paretovariate,
+  randint,
+  random,
+  randrange,
+  sample,
+  shuffle,
+  triangular,
+  uniform,
+  vonmisesvariate,
+  weibullvariate
+};
+//# sourceMappingURL=random.js.map

package/dist/random.js.map

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

package/dist/re-DSxiURqN.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Python re module for TypeScript
+ *
+ * Provides regular expression matching operations matching Python's re module.
+ * Uses JavaScript's RegExp as the underlying engine.
+ *
+ * Note: Some Python regex features are not supported in JavaScript:
+ * - Lookbehind assertions (limited support in modern JS)
+ * - Named groups use different syntax (?P<name>...) vs (?<name>...)
+ * - Verbose mode (x flag) is not supported
+ */
+/** Ignore case */
+declare const IGNORECASE = 2;
+declare const I = 2;
+/** Multi-line mode */
+declare const MULTILINE = 8;
+declare const M = 8;
+/** Dot matches all (including newline) */
+declare const DOTALL = 16;
+declare const S = 16;
+/** Unicode matching (always on in JS) */
+declare const UNICODE = 32;
+declare const U = 32;
+/** ASCII-only matching */
+declare const ASCII = 256;
+declare const A = 256;
+declare class Match {
+    private _match;
+    private _string;
+    private _pattern;
+    private _pos;
+    private _endpos;
+    constructor(match: RegExpExecArray, string: string, pattern: Pattern, pos?: number, endpos?: number);
+    /** Return the string matched by the RE */
+    group(groupNum?: number | string): string | undefined;
+    /** Return a tuple containing all subgroups */
+    groups(defaultValue?: string): (string | undefined)[];
+    /** Return a dictionary of named groups */
+    groupdict(defaultValue?: string): Record<string, string | undefined>;
+    /** Return the start index of the match */
+    start(groupNum?: number): number;
+    /** Return the end index of the match */
+    end(groupNum?: number): number;
+    /** Return a tuple (start, end) */
+    span(groupNum?: number): [number, number];
+    /** Return start position of search */
+    get pos(): number;
+    /** Return end position of search */
+    get endpos(): number;
+    /** Return the last matched group index */
+    get lastindex(): number | undefined;
+    /** Return the name of the last matched group */
+    get lastgroup(): string | undefined;
+    /** Return the pattern object */
+    get re(): Pattern;
+    /** Return the input string */
+    get string(): string;
+    /** Expand template with groups */
+    expand(template: string): string;
+    /** Return iterator of all groups */
+    [Symbol.iterator](): Generator<string | undefined>;
+    toString(): string;
+}
+declare class Pattern {
+    private _regex;
+    private _pattern;
+    private _flags;
+    constructor(pattern: string, flags?: number);
+    private _compileRegex;
+    /** Search for pattern in string */
+    search(string: string, pos?: number, endpos?: number): Match | null;
+    /** Match pattern at start of string */
+    match(string: string, pos?: number, endpos?: number): Match | null;
+    /** Match pattern against entire string */
+    fullmatch(string: string, pos?: number, endpos?: number): Match | null;
+    /** Split string by pattern */
+    split(string: string, maxsplit?: number): string[];
+    /** Find all matches */
+    findall(string: string, pos?: number, endpos?: number): (string | string[])[];
+    /** Find all matches as iterator */
+    finditer(string: string, pos?: number, endpos?: number): Generator<Match>;
+    /** Replace pattern in string */
+    sub(repl: string | ((match: Match) => string), string: string, count?: number): string;
+    /** Replace pattern and return (newstring, count) */
+    subn(repl: string | ((match: Match) => string), string: string, count?: number): [string, number];
+    /** Return the pattern string */
+    get pattern(): string;
+    /** Return the flags */
+    get flags(): number;
+    /** Return number of groups */
+    get groups(): number;
+    /** Return named groups mapping */
+    get groupindex(): Record<string, number>;
+    toString(): string;
+}
+/** Compile a regular expression pattern */
+declare function compile(pattern: string, flags?: number): Pattern;
+/** Search for pattern in string */
+declare function search(pattern: string | Pattern, string: string, flags?: number): Match | null;
+/** Match pattern at start of string */
+declare function match(pattern: string | Pattern, string: string, flags?: number): Match | null;
+/** Match pattern against entire string */
+declare function fullmatch(pattern: string | Pattern, string: string, flags?: number): Match | null;
+/** Split string by pattern */
+declare function split(pattern: string | Pattern, string: string, maxsplit?: number, flags?: number): string[];
+/** Find all matches */
+declare function findall(pattern: string | Pattern, string: string, flags?: number): (string | string[])[];
+/** Find all matches as iterator */
+declare function finditer(pattern: string | Pattern, string: string, flags?: number): Generator<Match>;
+/** Replace pattern in string */
+declare function sub(pattern: string | Pattern, repl: string | ((match: Match) => string), string: string, count?: number, flags?: number): string;
+/** Replace pattern and return (newstring, count) */
+declare function subn(pattern: string | Pattern, repl: string | ((match: Match) => string), string: string, count?: number, flags?: number): [string, number];
+/** Escape special characters in pattern */
+declare function escape(pattern: string): string;
+/** Purge the regex cache (no-op in this implementation) */
+declare function purge(): void;
+
+declare const reModule_A: typeof A;
+declare const reModule_ASCII: typeof ASCII;
+declare const reModule_DOTALL: typeof DOTALL;
+declare const reModule_I: typeof I;
+declare const reModule_IGNORECASE: typeof IGNORECASE;
+declare const reModule_M: typeof M;
+declare const reModule_MULTILINE: typeof MULTILINE;
+type reModule_Match = Match;
+declare const reModule_Match: typeof Match;
+type reModule_Pattern = Pattern;
+declare const reModule_Pattern: typeof Pattern;
+declare const reModule_S: typeof S;
+declare const reModule_U: typeof U;
+declare const reModule_UNICODE: typeof UNICODE;
+declare const reModule_compile: typeof compile;
+declare const reModule_escape: typeof escape;
+declare const reModule_findall: typeof findall;
+declare const reModule_finditer: typeof finditer;
+declare const reModule_fullmatch: typeof fullmatch;
+declare const reModule_match: typeof match;
+declare const reModule_purge: typeof purge;
+declare const reModule_search: typeof search;
+declare const reModule_split: typeof split;
+declare const reModule_sub: typeof sub;
+declare const reModule_subn: typeof subn;
+declare namespace reModule {
+  export { reModule_A as A, reModule_ASCII as ASCII, reModule_DOTALL as DOTALL, reModule_I as I, reModule_IGNORECASE as IGNORECASE, reModule_M as M, reModule_MULTILINE as MULTILINE, reModule_Match as Match, reModule_Pattern as Pattern, reModule_S as S, reModule_U as U, reModule_UNICODE as UNICODE, reModule_compile as compile, reModule_escape as escape, reModule_findall as findall, reModule_finditer as finditer, reModule_fullmatch as fullmatch, reModule_match as match, reModule_purge as purge, reModule_search as search, reModule_split as split, reModule_sub as sub, reModule_subn as subn };
+}
+
+export { ASCII as A, DOTALL as D, IGNORECASE as I, MULTILINE as M, Pattern as P, S, UNICODE as U, I as a, M as b, U as c, A as d, Match as e, compile as f, fullmatch as g, split as h, findall as i, finditer as j, sub as k, subn as l, match as m, escape as n, purge as p, reModule as r, search as s };

package/dist/re.d.ts

@@ -0,0 +1 @@
+export { d as A, A as ASCII, D as DOTALL, a as I, I as IGNORECASE, b as M, M as MULTILINE, e as Match, P as Pattern, S, c as U, U as UNICODE, f as compile, n as escape, i as findall, j as finditer, g as fullmatch, m as match, p as purge, s as search, h as split, k as sub, l as subn } from './re-DSxiURqN.js';

package/dist/re.js

@@ -0,0 +1,52 @@
+import {
+  A,
+  ASCII,
+  DOTALL,
+  I,
+  IGNORECASE,
+  M,
+  MULTILINE,
+  Match,
+  Pattern,
+  S,
+  U,
+  UNICODE,
+  compile,
+  escape,
+  findall,
+  finditer,
+  fullmatch,
+  match,
+  purge,
+  search,
+  split,
+  sub,
+  subn
+} from "./chunk-V63LKSA3.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  A,
+  ASCII,
+  DOTALL,
+  I,
+  IGNORECASE,
+  M,
+  MULTILINE,
+  Match,
+  Pattern,
+  S,
+  U,
+  UNICODE,
+  compile,
+  escape,
+  findall,
+  finditer,
+  fullmatch,
+  match,
+  purge,
+  search,
+  split,
+  sub,
+  subn
+};
+//# sourceMappingURL=re.js.map

package/dist/re.js.map

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