pythonlib 1.0.1 → 2.0.0

package/dist/datetime.js

@@ -7,8 +7,8 @@ import {
   strptime,
   time,
   timedelta
-} from "./chunk-LWO6BIAD.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-LK2L2TFG.js";
+import "./chunk-MLKGABMK.js";
 export {
   MAXYEAR,
   MINYEAR,
@@ -19,4 +19,3 @@ export {
   time,
   timedelta
 };
-//# sourceMappingURL=datetime.js.map

package/dist/{functools-NrsZAqJk.d.ts → functools-uIa5g75p.d.ts}

@@ -1,9 +1,11 @@
 /**
  * Python functools module for TypeScript
  *
- * Provides higher-order functions and operations on callable objects.
+ * Provides higher-order functions and operations on callable objects,
+ * including partial application, function caching (lru_cache), and reduce.
  *
  * @see {@link https://docs.python.org/3/library/functools.html | Python functools documentation}
+ * @module
  */
 /**
  * Create a partial function application

package/dist/functools.d.ts

@@ -1 +1 @@
-export { b as attrGetter, c as cache, e as cmpToKey, d as identity, i as itemGetter, l as lruCache, m as methodCaller, p as partial, a as partialMethod, g as pipe, r as reduce, s as singleDispatch, t as totalOrdering, w as wraps } from './functools-NrsZAqJk.js';
+export { b as attrGetter, c as cache, e as cmpToKey, d as identity, i as itemGetter, l as lruCache, m as methodCaller, p as partial, a as partialMethod, g as pipe, r as reduce, s as singleDispatch, t as totalOrdering, w as wraps } from './functools-uIa5g75p.js';

package/dist/functools.js

@@ -13,8 +13,8 @@ import {
   singleDispatch,
   totalOrdering,
   wraps
-} from "./chunk-EE7SK2GV.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-D35YI363.js";
+import "./chunk-MLKGABMK.js";
 export {
   attrGetter,
   cache,
@@ -31,4 +31,3 @@ export {
   totalOrdering,
   wraps
 };
-//# sourceMappingURL=functools.js.map

package/dist/glob.browser-B6d_YdV5.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Python glob module for TypeScript - Browser version
+ *
+ * Browser stub - filesystem operations are not available.
+ *
+ * @see {@link https://docs.python.org/3/library/glob.html | Python glob documentation}
+ * @module
+ */
+/**
+ * Return a list of paths matching a pathname pattern.
+ * Browser stub - always returns empty array.
+ */
+declare function glob(_pattern: string, _options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): Promise<string[]>;
+/**
+ * Return an async iterator of paths matching a pathname pattern.
+ * Browser stub - yields nothing.
+ */
+declare function iglob(_pattern: string, _options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): AsyncGenerator<string>;
+/**
+ * Escape all special characters in a pathname.
+ */
+declare function escape(pathname: string): string;
+/**
+ * Return true if the pattern contains any magic glob characters.
+ */
+declare function hasMagic(pattern: string): boolean;
+/**
+ * Return a list of all files matching pattern recursively.
+ * Browser stub - always returns empty array.
+ */
+declare function rglob(_pattern: string, _rootDir?: string): Promise<string[]>;
+
+declare const globModule_escape: typeof escape;
+declare const globModule_glob: typeof glob;
+declare const globModule_hasMagic: typeof hasMagic;
+declare const globModule_iglob: typeof iglob;
+declare const globModule_rglob: typeof rglob;
+declare namespace globModule {
+  export { globModule_escape as escape, globModule_glob as glob, globModule_hasMagic as hasMagic, globModule_iglob as iglob, globModule_rglob as rglob };
+}
+
+export { glob as a, escape as e, globModule as g, hasMagic as h, iglob as i, rglob as r };

package/dist/glob.browser.d.ts

@@ -0,0 +1 @@
+export { e as escape, a as glob, h as hasMagic, i as iglob, r as rglob } from './glob.browser-B6d_YdV5.js';

package/dist/glob.browser.js

@@ -0,0 +1,15 @@
+import {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+} from "./chunk-B5LQJODJ.js";
+import "./chunk-MLKGABMK.js";
+export {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+};

package/dist/glob.node-wn5ehtyM.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Python glob module for TypeScript
+ *
+ * Provides Unix shell-style pathname pattern matching with async operations.
+ *
+ * @see {@link https://docs.python.org/3/library/glob.html | Python glob documentation}
+ * @module
+ */
+/**
+ * Return a list of paths matching a pathname pattern.
+ *
+ * The pattern may contain shell-style wildcards:
+ * - `*` matches any number of characters
+ * - `?` matches a single character
+ * - `[seq]` matches any character in seq
+ * - `[!seq]` matches any character not in seq
+ * - `**` matches everything, including any subdirectories
+ *
+ * @param pattern - The glob pattern
+ * @param options - Options object
+ * @returns Promise of array of matching paths
+ *
+ * @example
+ * ```typescript
+ * await glob("*.txt")              // All .txt files in current directory
+ * await glob("**\/*.py")           // All .py files recursively
+ * await glob("/path/to/*.js")      // All .js files in /path/to
+ * ```
+ */
+declare function glob(pattern: string, options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): Promise<string[]>;
+/**
+ * Return an async iterator of paths matching a pathname pattern.
+ *
+ * @param pattern - The glob pattern
+ * @param options - Options object
+ * @returns AsyncGenerator of matching paths
+ */
+declare function iglob(pattern: string, options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): AsyncGenerator<string>;
+/**
+ * Escape all special characters in a pathname.
+ *
+ * @param pathname - The path to escape
+ * @returns Escaped path safe for use in glob patterns
+ */
+declare function escape(pathname: string): string;
+/**
+ * Return true if the pattern contains any magic glob characters.
+ *
+ * @param pattern - The pattern to check
+ * @returns True if pattern contains wildcards
+ */
+declare function hasMagic(pattern: string): boolean;
+/**
+ * Return a list of all files matching pattern in directory and subdirectories.
+ * This is an alias for glob with recursive=true.
+ *
+ * @param pattern - The glob pattern (without **)
+ * @param rootDir - Root directory to search from
+ * @returns Promise of array of matching paths
+ */
+declare function rglob(pattern: string, rootDir?: string): Promise<string[]>;
+
+declare const globModule_escape: typeof escape;
+declare const globModule_glob: typeof glob;
+declare const globModule_hasMagic: typeof hasMagic;
+declare const globModule_iglob: typeof iglob;
+declare const globModule_rglob: typeof rglob;
+declare namespace globModule {
+  export { globModule_escape as escape, globModule_glob as glob, globModule_hasMagic as hasMagic, globModule_iglob as iglob, globModule_rglob as rglob };
+}
+
+export { glob as a, escape as e, globModule as g, hasMagic as h, iglob as i, rglob as r };

package/dist/glob.node.d.ts

@@ -0,0 +1 @@
+export { e as escape, a as glob, h as hasMagic, i as iglob, r as rglob } from './glob.node-wn5ehtyM.js';

package/dist/glob.node.js

@@ -0,0 +1,15 @@
+import {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+} from "./chunk-RB6BYCIQ.js";
+import "./chunk-MLKGABMK.js";
+export {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+};

package/dist/hashlib-vKP511NY.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Python hashlib module for TypeScript
+ *
+ * Provides secure hash and message digest algorithms.
+ * Uses Node.js crypto module for server-side and Web Crypto API for browser.
+ *
+ * Note: Unlike Python's sync API, digest() and hexdigest() are async
+ * to support the Web Crypto API which only provides async operations.
+ *
+ * @see {@link https://docs.python.org/3/library/hashlib.html | Python hashlib documentation}
+ * @module
+ */
+/**
+ * Hash object interface mimicking Python's hash object.
+ * Note: digest() and hexdigest() are async to support Web Crypto API.
+ */
+interface HashObject {
+    /** Name of the hash algorithm */
+    readonly name: string;
+    /** Digest size in bytes */
+    readonly digestSize: number;
+    /** Internal block size in bytes */
+    readonly blockSize: number;
+    /** Update the hash with data (sync - buffers data) */
+    update(data: Uint8Array | string): void;
+    /** Return the digest as bytes (async) */
+    digest(): Promise<Uint8Array>;
+    /** Return the digest as a hexadecimal string (async) */
+    hexdigest(): Promise<string>;
+    /** Return a copy of the hash object */
+    copy(): HashObject;
+}
+/**
+ * Create a new hash object for the given algorithm.
+ *
+ * @param name - Name of the hash algorithm (e.g., "sha256", "md5")
+ * @param data - Optional initial data to hash
+ * @returns A hash object
+ *
+ * @example
+ * ```typescript
+ * const h = newHash("sha256")
+ * h.update("hello")
+ * console.log(await h.hexdigest())
+ * ```
+ */
+declare function newHash(name: string, data?: Uint8Array | string): HashObject;
+/**
+ * Create a new MD5 hash object.
+ * Note: MD5 is not available in Web Crypto API (browser).
+ *
+ * @param data - Optional initial data to hash
+ * @returns An MD5 hash object
+ *
+ * @example
+ * ```typescript
+ * const h = md5("hello")
+ * console.log(await h.hexdigest()) // "5d41402abc4b2a76b9719d911017c592"
+ * ```
+ */
+declare function md5(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new SHA-1 hash object.
+ *
+ * @param data - Optional initial data to hash
+ * @returns A SHA-1 hash object
+ */
+declare function sha1(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new SHA-224 hash object.
+ * Note: SHA-224 is not available in Web Crypto API (browser).
+ *
+ * @param data - Optional initial data to hash
+ * @returns A SHA-224 hash object
+ */
+declare function sha224(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new SHA-256 hash object.
+ *
+ * @param data - Optional initial data to hash
+ * @returns A SHA-256 hash object
+ */
+declare function sha256(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new SHA-384 hash object.
+ *
+ * @param data - Optional initial data to hash
+ * @returns A SHA-384 hash object
+ */
+declare function sha384(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new SHA-512 hash object.
+ *
+ * @param data - Optional initial data to hash
+ * @returns A SHA-512 hash object
+ */
+declare function sha512(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new SHA3-256 hash object.
+ * Note: SHA3 is not available in Web Crypto API (browser).
+ *
+ * @param data - Optional initial data to hash
+ * @returns A SHA3-256 hash object
+ */
+declare function sha3_256(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new SHA3-512 hash object.
+ * Note: SHA3 is not available in Web Crypto API (browser).
+ *
+ * @param data - Optional initial data to hash
+ * @returns A SHA3-512 hash object
+ */
+declare function sha3_512(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new BLAKE2b hash object.
+ * Note: BLAKE2 is not available in Web Crypto API (browser).
+ *
+ * @param data - Optional initial data to hash
+ * @returns A BLAKE2b hash object
+ */
+declare function blake2b(data?: Uint8Array | string): HashObject;
+/**
+ * Create a new BLAKE2s hash object.
+ * Note: BLAKE2 is not available in Web Crypto API (browser).
+ *
+ * @param data - Optional initial data to hash
+ * @returns A BLAKE2s hash object
+ */
+declare function blake2s(data?: Uint8Array | string): HashObject;
+/**
+ * Set of available hash algorithm names.
+ * Note: In browser, only SHA-1, SHA-256, SHA-384, SHA-512 are available.
+ */
+declare const algorithmsAvailable: Set<string>;
+/**
+ * Set of hash algorithm names guaranteed to be available in all environments.
+ * These are the algorithms supported by Web Crypto API.
+ */
+declare const algorithmsGuaranteed: Set<string>;
+/**
+ * Compute PBKDF2 key derivation.
+ * Note: This is async to support Web Crypto API.
+ *
+ * @param hashName - Name of the hash algorithm
+ * @param password - Password bytes
+ * @param salt - Salt bytes
+ * @param iterations - Number of iterations
+ * @param dklen - Derived key length in bytes
+ * @returns Derived key as Uint8Array
+ */
+declare function pbkdf2Hmac(hashName: string, password: Uint8Array | string, salt: Uint8Array | string, iterations: number, dklen: number): Promise<Uint8Array>;
+/**
+ * Compute scrypt key derivation.
+ * Note: scrypt is only available in Node.js, not in Web Crypto API.
+ *
+ * @param password - Password bytes
+ * @param salt - Salt bytes
+ * @param n - CPU/memory cost parameter
+ * @param r - Block size parameter
+ * @param p - Parallelization parameter
+ * @param dklen - Derived key length in bytes
+ * @returns Derived key as Uint8Array
+ */
+declare function scrypt(password: Uint8Array | string, salt: Uint8Array | string, n: number, r: number, p: number, dklen: number): Promise<Uint8Array>;
+/**
+ * Compare two byte sequences in constant time.
+ *
+ * @param a - First sequence
+ * @param b - Second sequence
+ * @returns True if sequences are equal
+ */
+declare function compareDigest(a: Uint8Array | string, b: Uint8Array | string): Promise<boolean>;
+/**
+ * Generate a file hash.
+ * Note: Only available in Node.js.
+ *
+ * @param path - File path
+ * @param algorithm - Hash algorithm name
+ * @returns Hash as hex string
+ */
+declare function fileDigest(path: string, algorithm?: string): Promise<string>;
+
+type hashlibModule_HashObject = HashObject;
+declare const hashlibModule_algorithmsAvailable: typeof algorithmsAvailable;
+declare const hashlibModule_algorithmsGuaranteed: typeof algorithmsGuaranteed;
+declare const hashlibModule_blake2b: typeof blake2b;
+declare const hashlibModule_blake2s: typeof blake2s;
+declare const hashlibModule_compareDigest: typeof compareDigest;
+declare const hashlibModule_fileDigest: typeof fileDigest;
+declare const hashlibModule_md5: typeof md5;
+declare const hashlibModule_newHash: typeof newHash;
+declare const hashlibModule_pbkdf2Hmac: typeof pbkdf2Hmac;
+declare const hashlibModule_scrypt: typeof scrypt;
+declare const hashlibModule_sha1: typeof sha1;
+declare const hashlibModule_sha224: typeof sha224;
+declare const hashlibModule_sha256: typeof sha256;
+declare const hashlibModule_sha384: typeof sha384;
+declare const hashlibModule_sha3_256: typeof sha3_256;
+declare const hashlibModule_sha3_512: typeof sha3_512;
+declare const hashlibModule_sha512: typeof sha512;
+declare namespace hashlibModule {
+  export { type hashlibModule_HashObject as HashObject, hashlibModule_algorithmsAvailable as algorithmsAvailable, hashlibModule_algorithmsGuaranteed as algorithmsGuaranteed, hashlibModule_blake2b as blake2b, hashlibModule_blake2s as blake2s, hashlibModule_compareDigest as compareDigest, hashlibModule_fileDigest as fileDigest, hashlibModule_md5 as md5, hashlibModule_newHash as newHash, hashlibModule_pbkdf2Hmac as pbkdf2Hmac, hashlibModule_scrypt as scrypt, hashlibModule_sha1 as sha1, hashlibModule_sha224 as sha224, hashlibModule_sha256 as sha256, hashlibModule_sha384 as sha384, hashlibModule_sha3_256 as sha3_256, hashlibModule_sha3_512 as sha3_512, hashlibModule_sha512 as sha512 };
+}
+
+export { type HashObject as H, sha224 as a, sha256 as b, sha384 as c, sha512 as d, sha3_256 as e, sha3_512 as f, blake2b as g, hashlibModule as h, blake2s as i, algorithmsAvailable as j, algorithmsGuaranteed as k, scrypt as l, md5 as m, newHash as n, compareDigest as o, pbkdf2Hmac as p, fileDigest as q, sha1 as s };

package/dist/hashlib.d.ts

@@ -0,0 +1 @@
+export { H as HashObject, j as algorithmsAvailable, k as algorithmsGuaranteed, g as blake2b, i as blake2s, o as compareDigest, q as fileDigest, m as md5, n as newHash, p as pbkdf2Hmac, l as scrypt, s as sha1, a as sha224, b as sha256, c as sha384, e as sha3_256, f as sha3_512, d as sha512 } from './hashlib-vKP511NY.js';

package/dist/hashlib.js

@@ -0,0 +1,39 @@
+import {
+  algorithmsAvailable,
+  algorithmsGuaranteed,
+  blake2b,
+  blake2s,
+  compareDigest,
+  fileDigest,
+  md5,
+  newHash,
+  pbkdf2Hmac,
+  scrypt,
+  sha1,
+  sha224,
+  sha256,
+  sha384,
+  sha3_256,
+  sha3_512,
+  sha512
+} from "./chunk-JJKTRIVO.js";
+import "./chunk-MLKGABMK.js";
+export {
+  algorithmsAvailable,
+  algorithmsGuaranteed,
+  blake2b,
+  blake2s,
+  compareDigest,
+  fileDigest,
+  md5,
+  newHash,
+  pbkdf2Hmac,
+  scrypt,
+  sha1,
+  sha224,
+  sha256,
+  sha384,
+  sha3_256,
+  sha3_512,
+  sha512
+};

package/dist/index.browser.d.ts

@@ -0,0 +1,172 @@
+import { i as itertoolsModule } from './itertools-T0rwOk2j.js';
+import { f as functoolsModule } from './functools-uIa5g75p.js';
+import { c as collectionsModule } from './collections-BthXtkEp.js';
+import { m as mathModule } from './math-D2NPMc-x.js';
+import { r as randomModule } from './random-DcS5jtEs.js';
+import { j as jsonModule } from './json-DoWhX04T.js';
+import { o as osModule } from './os.browser-krjSx5kF.js';
+import { d as datetimeModule } from './datetime-BM_IjhTq.js';
+import { r as reModule } from './re-Bo-IOqov.js';
+import { capWords, Template } from './string.js';
+import { s as sysModule } from './sys-IL8LgI_W.js';
+import { t as timeModule } from './time-CcYhdiSu.js';
+import { c as copyModule } from './copy-6ZaZ__ge.js';
+import { b as base64Module } from './base64-C_am75Sv.js';
+import { u as uuidModule } from './uuid-C0ypmn56.js';
+import { h as hashlibModule } from './hashlib-vKP511NY.js';
+import { p as pathlibModule } from './pathlib.browser-NC7kKQYe.js';
+import { g as globModule } from './glob.browser-B6d_YdV5.js';
+import { s as shutilModule } from './shutil.browser-Ck5oWhnP.js';
+import { t as tempfileModule } from './tempfile.browser-DciOKfNm.js';
+import { s as subprocessModule } from './subprocess-CZVYzQ3V.js';
+import { u as urllibModule } from './urllib-DJtkj-0f.js';
+import { l as loggingModule } from './logging.browser-Dux4L5kz.js';
+import { l as list$1, d as dict$1, s as set$1, f as floorDiv$1, m as mod$1, a as divMod$1, b as sprintf$1, c as strFormat$1, e as slice$1, g as at$1, h as contains$1, i as is$1, r as range$1, j as enumerate$1, z as zip$1, k as iter$1, n as reversed$1, o as sorted$1, p as map$1, q as filter$1, t as tuple$1, u as len$1, v as abs$1, w as min$1, x as max$1, y as sum$1, A as all$1, B as any$1, C as round$1, D as ord$1, E as chr$1, F as hex$1, G as oct$1, H as bin$1, I as int$1, J as float$1, K as str$1, L as repr$1, M as bool$1, N as ascii$1, O as isinstance$1, P as type$1, Q as input$1, R as format$1, S as getattr$1, T as hasattr$1, U as setattr$1 } from './set-JQbLAq8B.js';
+export { W as pow, V as repeatValue } from './set-JQbLAq8B.js';
+import './os.shared-C3x70nhO.js';
+
+/**
+ * Python Built-in Functions for TypeScript - Browser version
+ *
+ * This module provides Python's built-in functions that are always available
+ * without imports. These are the fundamental operations for working with data
+ * in Python, including iteration (range, enumerate, zip), aggregation (len,
+ * sum, min, max), type conversion (int, str, bool), and more.
+ *
+ * @example
+ * ```typescript
+ * // Direct imports
+ * import { len, range, sorted, min, max } from "pythonlib"
+ *
+ * // Module imports (like Python)
+ * import { chain, combinations } from "pythonlib/itertools"
+ * import { Counter, defaultdict } from "pythonlib/collections"
+ *
+ * // Module namespaces
+ * import { json, re, itertools } from "pythonlib"
+ * ```
+ *
+ * @see {@link https://docs.python.org/3/library/functions.html | Python Built-in Functions}
+ * @module
+ */
+
+declare const itertools: typeof itertoolsModule;
+declare const functools: typeof functoolsModule;
+declare const collections: typeof collectionsModule;
+declare const math: typeof mathModule;
+declare const random: typeof randomModule;
+declare const json: typeof jsonModule;
+declare const os: typeof osModule;
+declare const datetime: typeof datetimeModule;
+declare const re: typeof reModule;
+declare const string: {
+    asciiLowercase: string;
+    asciiUppercase: string;
+    asciiLetters: string;
+    digits: string;
+    hexDigits: string;
+    octDigits: string;
+    punctuation: string;
+    whitespace: string;
+    printable: string;
+    capWords: typeof capWords;
+    Template: typeof Template;
+    join(sep: string, iterable: Iterable<string>): string;
+    split(s: string, sep?: string, maxsplit?: number): string[];
+    rSplit(s: string, sep?: string, maxsplit?: number): string[];
+    strip(s: string, chars?: string): string;
+    lStrip(s: string, chars?: string): string;
+    rStrip(s: string, chars?: string): string;
+    upper(s: string): string;
+    lower(s: string): string;
+    capitalize(s: string): string;
+    title(s: string): string;
+    swapCase(s: string): string;
+    startsWith(s: string, prefix: string, start?: number, end?: number): boolean;
+    endsWith(s: string, suffix: string, start?: number, end?: number): boolean;
+    find(s: string, sub: string, start?: number, end?: number): number;
+    rFind(s: string, sub: string, start?: number, end?: number): number;
+    index(s: string, sub: string, start?: number, end?: number): number;
+    rIndex(s: string, sub: string, start?: number, end?: number): number;
+    count(s: string, sub: string, start?: number, end?: number): number;
+    replace(s: string, old: string, newStr: string, count?: number): string;
+    zFill(s: string, width: number): string;
+    center(s: string, width: number, fillchar?: string): string;
+    lJust(s: string, width: number, fillchar?: string): string;
+    rJust(s: string, width: number, fillchar?: string): string;
+    partition(s: string, sep: string): [string, string, string];
+    rPartition(s: string, sep: string): [string, string, string];
+    isAlpha(s: string): boolean;
+    isDigit(s: string): boolean;
+    isAlnum(s: string): boolean;
+    isSpace(s: string): boolean;
+    isUpper(s: string): boolean;
+    isLower(s: string): boolean;
+    format(s: string, ...args: unknown[]): string;
+};
+declare const sys: typeof sysModule;
+declare const time: typeof timeModule;
+declare const copy: typeof copyModule;
+declare const base64: typeof base64Module;
+declare const uuid: typeof uuidModule;
+declare const hashlib: typeof hashlibModule;
+declare const pathlib: typeof pathlibModule;
+declare const glob: typeof globModule;
+declare const shutil: typeof shutilModule;
+declare const tempfile: typeof tempfileModule;
+declare const subprocess: typeof subprocessModule;
+declare const urllib: typeof urllibModule;
+declare const logging: typeof loggingModule;
+type ListConstructor = (<T>(iterable?: Iterable<T>) => T[]) & typeof list$1;
+type DictConstructor = (<K, V>(entries?: Iterable<[K, V]>) => Map<K, V>) & typeof dict$1;
+type SetConstructor = (<T>(iterable?: Iterable<T>) => Set<T>) & typeof set$1;
+declare const list: ListConstructor;
+declare const dict: DictConstructor;
+declare const set: SetConstructor;
+declare const floorDiv: typeof floorDiv$1;
+declare const mod: typeof mod$1;
+declare const divMod: typeof divMod$1;
+declare const sprintf: typeof sprintf$1;
+declare const strFormat: typeof strFormat$1;
+declare const slice: typeof slice$1;
+declare const at: typeof at$1;
+declare const contains: typeof contains$1;
+declare const is: typeof is$1;
+
+declare const range: typeof range$1;
+declare const enumerate: typeof enumerate$1;
+declare const zip: typeof zip$1;
+declare const iter: typeof iter$1;
+declare const reversed: typeof reversed$1;
+declare const sorted: typeof sorted$1;
+declare const map: typeof map$1;
+declare const filter: typeof filter$1;
+declare const tuple: typeof tuple$1;
+declare const len: typeof len$1;
+declare const abs: typeof abs$1;
+declare const min: typeof min$1;
+declare const max: typeof max$1;
+declare const sum: typeof sum$1;
+declare const all: typeof all$1;
+declare const any: typeof any$1;
+declare const round: typeof round$1;
+declare const ord: typeof ord$1;
+declare const chr: typeof chr$1;
+declare const hex: typeof hex$1;
+declare const oct: typeof oct$1;
+declare const bin: typeof bin$1;
+declare const int: typeof int$1;
+declare const float: typeof float$1;
+declare const str: typeof str$1;
+declare const repr: typeof repr$1;
+declare const bool: typeof bool$1;
+declare const ascii: typeof ascii$1;
+declare const isinstance: typeof isinstance$1;
+declare const type: typeof type$1;
+declare const input: typeof input$1;
+declare const format: typeof format$1;
+declare const getattr: typeof getattr$1;
+declare const hasattr: typeof hasattr$1;
+declare const setattr: typeof setattr$1;
+
+export { abs, all, any, ascii, at, base64, bin, bool, chr, collections, contains, copy, datetime, dict, divMod, enumerate, filter, float, floorDiv, format, functools, getattr, glob, hasattr, hashlib, hex, input, int, is, isinstance, iter, itertools, json, len, list, logging, map, math, max, min, mod, oct, ord, os, pathlib, random, range, re, repr, reversed, round, set, setattr, shutil, slice, sorted, sprintf, str, strFormat, string, subprocess, sum, sys, tempfile, time, tuple, type, urllib, uuid, zip };