pythonlib 1.0.2 → 2.0.0

package/README.md

@@ -2,8 +2,10 @@
 
 [![npm version](https://img.shields.io/npm/v/pythonlib.svg)](https://www.npmjs.com/package/pythonlib)
 [![npm downloads](https://img.shields.io/npm/dm/pythonlib.svg)](https://www.npmjs.com/package/pythonlib)
-[![Bundle Size](https://img.shields.io/bundlephobia/minzip/pythonlib)](https://bundlephobia.com/package/pythonlib)
+[![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)](https://www.npmjs.com/package/pythonlib?activeTab=dependencies)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.6-blue.svg)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-%E2%89%A522-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![Bun](https://img.shields.io/badge/Bun-compatible-f9f1e1?logo=bun&logoColor=black)](https://bun.sh/)
 [![License](https://img.shields.io/npm/l/pythonlib.svg)](https://github.com/sebastian-software/python2ts/blob/main/LICENSE)
 
 **Python's powerful standard library, TypeScript's familiar style** — itertools, functools,

package/dist/base64-C_am75Sv.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Python base64 module for TypeScript
+ *
+ * Provides encoding and decoding using Base64 and URL-safe Base64.
+ *
+ * @see {@link https://docs.python.org/3/library/base64.html | Python base64 documentation}
+ * @module
+ */
+/**
+ * Encode bytes-like object using Base64 and return bytes.
+ *
+ * @param s - Bytes to encode (Uint8Array or string)
+ * @returns Base64 encoded Uint8Array
+ *
+ * @example
+ * ```typescript
+ * const encoded = b64encode(new TextEncoder().encode("hello"))
+ * console.log(new TextDecoder().decode(encoded)) // "aGVsbG8="
+ * ```
+ */
+declare function b64encode(s: Uint8Array | string): Uint8Array;
+/**
+ * Decode Base64 encoded bytes-like object or ASCII string and return bytes.
+ *
+ * @param s - Base64 encoded data (Uint8Array or string)
+ * @returns Decoded Uint8Array
+ *
+ * @example
+ * ```typescript
+ * const decoded = b64decode("aGVsbG8=")
+ * console.log(new TextDecoder().decode(decoded)) // "hello"
+ * ```
+ */
+declare function b64decode(s: Uint8Array | string): Uint8Array;
+/**
+ * Encode bytes-like object using standard Base64 and return bytes.
+ * This is identical to b64encode().
+ *
+ * @param s - Bytes to encode
+ * @returns Base64 encoded Uint8Array
+ */
+declare function standardB64encode(s: Uint8Array | string): Uint8Array;
+/**
+ * Decode standard Base64 encoded bytes-like object and return bytes.
+ * This is identical to b64decode().
+ *
+ * @param s - Base64 encoded data
+ * @returns Decoded Uint8Array
+ */
+declare function standardB64decode(s: Uint8Array | string): Uint8Array;
+/**
+ * Encode bytes-like object using URL-safe Base64 and return bytes.
+ *
+ * URL-safe Base64 uses - instead of + and _ instead of /,
+ * and omits padding characters.
+ *
+ * @param s - Bytes to encode
+ * @returns URL-safe Base64 encoded Uint8Array
+ *
+ * @example
+ * ```typescript
+ * const encoded = urlsafeB64encode(new Uint8Array([255, 239]))
+ * // Uses - and _ instead of + and /
+ * ```
+ */
+declare function urlsafeB64encode(s: Uint8Array | string): Uint8Array;
+/**
+ * Decode URL-safe Base64 encoded bytes-like object and return bytes.
+ *
+ * @param s - URL-safe Base64 encoded data
+ * @returns Decoded Uint8Array
+ */
+declare function urlsafeB64decode(s: Uint8Array | string): Uint8Array;
+/**
+ * Encode bytes-like object using Base16 (hexadecimal) and return bytes.
+ *
+ * @param s - Bytes to encode
+ * @returns Hexadecimal encoded Uint8Array (uppercase)
+ */
+declare function b16encode(s: Uint8Array | string): Uint8Array;
+/**
+ * Decode Base16 (hexadecimal) encoded bytes-like object and return bytes.
+ *
+ * @param s - Hexadecimal encoded data
+ * @returns Decoded Uint8Array
+ */
+declare function b16decode(s: Uint8Array | string): Uint8Array;
+/**
+ * Encode bytes-like object using Base32 and return bytes.
+ *
+ * @param s - Bytes to encode
+ * @returns Base32 encoded Uint8Array
+ */
+declare function b32encode(s: Uint8Array | string): Uint8Array;
+/**
+ * Decode Base32 encoded bytes-like object and return bytes.
+ *
+ * @param s - Base32 encoded data
+ * @returns Decoded Uint8Array
+ */
+declare function b32decode(s: Uint8Array | string): Uint8Array;
+/**
+ * Encode bytes-like object using Ascii85 (also known as Base85) and return bytes.
+ *
+ * @param s - Bytes to encode
+ * @returns Ascii85 encoded Uint8Array
+ */
+declare function a85encode(s: Uint8Array | string): Uint8Array;
+/**
+ * Decode Ascii85 encoded bytes-like object and return bytes.
+ *
+ * @param s - Ascii85 encoded data
+ * @returns Decoded Uint8Array
+ */
+declare function a85decode(s: Uint8Array | string): Uint8Array;
+/**
+ * Encode bytes-like object using Base85 (same as a85encode) and return bytes.
+ *
+ * @param s - Bytes to encode
+ * @returns Base85 encoded Uint8Array
+ */
+declare function b85encode(s: Uint8Array | string): Uint8Array;
+/**
+ * Decode Base85 encoded bytes-like object and return bytes.
+ *
+ * @param s - Base85 encoded data
+ * @returns Decoded Uint8Array
+ */
+declare function b85decode(s: Uint8Array | string): Uint8Array;
+/**
+ * Encode bytes-like object using Base64 and return as ASCII string.
+ *
+ * @param s - Bytes to encode
+ * @returns Base64 encoded string
+ */
+declare function encodeString(s: Uint8Array | string): string;
+/**
+ * Decode Base64 ASCII string and return bytes.
+ *
+ * @param s - Base64 encoded string
+ * @returns Decoded Uint8Array
+ */
+declare function decodeString(s: string): Uint8Array;
+
+declare const base64Module_a85decode: typeof a85decode;
+declare const base64Module_a85encode: typeof a85encode;
+declare const base64Module_b16decode: typeof b16decode;
+declare const base64Module_b16encode: typeof b16encode;
+declare const base64Module_b32decode: typeof b32decode;
+declare const base64Module_b32encode: typeof b32encode;
+declare const base64Module_b64decode: typeof b64decode;
+declare const base64Module_b64encode: typeof b64encode;
+declare const base64Module_b85decode: typeof b85decode;
+declare const base64Module_b85encode: typeof b85encode;
+declare const base64Module_decodeString: typeof decodeString;
+declare const base64Module_encodeString: typeof encodeString;
+declare const base64Module_standardB64decode: typeof standardB64decode;
+declare const base64Module_standardB64encode: typeof standardB64encode;
+declare const base64Module_urlsafeB64decode: typeof urlsafeB64decode;
+declare const base64Module_urlsafeB64encode: typeof urlsafeB64encode;
+declare namespace base64Module {
+  export { base64Module_a85decode as a85decode, base64Module_a85encode as a85encode, base64Module_b16decode as b16decode, base64Module_b16encode as b16encode, base64Module_b32decode as b32decode, base64Module_b32encode as b32encode, base64Module_b64decode as b64decode, base64Module_b64encode as b64encode, base64Module_b85decode as b85decode, base64Module_b85encode as b85encode, base64Module_decodeString as decodeString, base64Module_encodeString as encodeString, base64Module_standardB64decode as standardB64decode, base64Module_standardB64encode as standardB64encode, base64Module_urlsafeB64decode as urlsafeB64decode, base64Module_urlsafeB64encode as urlsafeB64encode };
+}
+
+export { b64encode as a, base64Module as b, b64decode as c, standardB64decode as d, urlsafeB64decode as e, b16encode as f, b16decode as g, b32encode as h, b32decode as i, a85encode as j, a85decode as k, b85encode as l, b85decode as m, encodeString as n, decodeString as o, standardB64encode as s, urlsafeB64encode as u };

package/dist/base64.d.ts

@@ -0,0 +1 @@
+export { k as a85decode, j as a85encode, g as b16decode, f as b16encode, i as b32decode, h as b32encode, c as b64decode, a as b64encode, m as b85decode, l as b85encode, o as decodeString, n as encodeString, d as standardB64decode, s as standardB64encode, e as urlsafeB64decode, u as urlsafeB64encode } from './base64-C_am75Sv.js';

package/dist/base64.js

@@ -0,0 +1,37 @@
+import {
+  a85decode,
+  a85encode,
+  b16decode,
+  b16encode,
+  b32decode,
+  b32encode,
+  b64decode,
+  b64encode,
+  b85decode,
+  b85encode,
+  decodeString,
+  encodeString,
+  standardB64decode,
+  standardB64encode,
+  urlsafeB64decode,
+  urlsafeB64encode
+} from "./chunk-3CLXPGAB.js";
+import "./chunk-MLKGABMK.js";
+export {
+  a85decode,
+  a85encode,
+  b16decode,
+  b16encode,
+  b32decode,
+  b32encode,
+  b64decode,
+  b64encode,
+  b85decode,
+  b85encode,
+  decodeString,
+  encodeString,
+  standardB64decode,
+  standardB64encode,
+  urlsafeB64decode,
+  urlsafeB64encode
+};

package/dist/chunk-2YTO24B5.js

@@ -0,0 +1,78 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/tempfile.browser.ts
+var tempfile_browser_exports = {};
+__export(tempfile_browser_exports, {
+  NamedTemporaryFile: () => NamedTemporaryFile,
+  TemporaryDirectory: () => TemporaryDirectory,
+  getPrefix: () => getPrefix,
+  getTempDir: () => getTempDir,
+  mkdtemp: () => mkdtemp,
+  mkstemp: () => mkstemp,
+  mktemp: () => mktemp
+});
+function getTempDir() {
+  return "/tmp";
+}
+function getPrefix() {
+  return "tmp";
+}
+function mktemp(suffix = "", prefix = "tmp", dir) {
+  const tempDir = dir ?? getTempDir();
+  const randomPart = Math.random().toString(36).slice(2, 10);
+  return `${tempDir}/${prefix}${randomPart}${suffix}`;
+}
+async function mkstemp(_suffix = "", _prefix = "tmp", _dir) {
+  throw new Error("mkstemp is not supported in browser environment");
+}
+async function mkdtemp(_suffix = "", _prefix = "tmp", _dir) {
+  throw new Error("mkdtemp is not supported in browser environment");
+}
+var NamedTemporaryFile = class {
+  name = "";
+  deleteOnClose = true;
+  constructor() {
+    throw new Error("NamedTemporaryFile is not supported in browser environment");
+  }
+  static async create(_options) {
+    throw new Error("NamedTemporaryFile is not supported in browser environment");
+  }
+  async write(_data) {
+    throw new Error("Not supported in browser");
+  }
+  async read(_size) {
+    throw new Error("Not supported in browser");
+  }
+  async flush() {
+    throw new Error("Not supported in browser");
+  }
+  async close() {
+    throw new Error("Not supported in browser");
+  }
+};
+var TemporaryDirectory = class {
+  name = "";
+  constructor() {
+    throw new Error("TemporaryDirectory is not supported in browser environment");
+  }
+  static async create(_options) {
+    throw new Error("TemporaryDirectory is not supported in browser environment");
+  }
+  async cleanup() {
+    throw new Error("Not supported in browser");
+  }
+};
+
+export {
+  getTempDir,
+  getPrefix,
+  mktemp,
+  mkstemp,
+  mkdtemp,
+  NamedTemporaryFile,
+  TemporaryDirectory,
+  tempfile_browser_exports
+};
+/* v8 ignore start -- browser stubs @preserve */

package/dist/chunk-3CLXPGAB.js

@@ -0,0 +1,237 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/base64.ts
+var base64_exports = {};
+__export(base64_exports, {
+  a85decode: () => a85decode,
+  a85encode: () => a85encode,
+  b16decode: () => b16decode,
+  b16encode: () => b16encode,
+  b32decode: () => b32decode,
+  b32encode: () => b32encode,
+  b64decode: () => b64decode,
+  b64encode: () => b64encode,
+  b85decode: () => b85decode,
+  b85encode: () => b85encode,
+  decodeString: () => decodeString,
+  encodeString: () => encodeString,
+  standardB64decode: () => standardB64decode,
+  standardB64encode: () => standardB64encode,
+  urlsafeB64decode: () => urlsafeB64decode,
+  urlsafeB64encode: () => urlsafeB64encode
+});
+function uint8ArrayToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function b64encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  const base64String = uint8ArrayToBase64(bytes);
+  return new TextEncoder().encode(base64String);
+}
+function b64decode(s) {
+  const base64String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = base64String.replace(/\s/g, "");
+  return base64ToUint8Array(cleaned);
+}
+function standardB64encode(s) {
+  return b64encode(s);
+}
+function standardB64decode(s) {
+  return b64decode(s);
+}
+function urlsafeB64encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  const base64String = uint8ArrayToBase64(bytes);
+  const urlSafe = base64String.replace(/\+/g, "-").replace(/\//g, "_");
+  return new TextEncoder().encode(urlSafe);
+}
+function urlsafeB64decode(s) {
+  const base64String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = base64String.replace(/\s/g, "").replace(/-/g, "+").replace(/_/g, "/");
+  const padding = (4 - cleaned.length % 4) % 4;
+  const padded = cleaned + "=".repeat(padding);
+  return base64ToUint8Array(padded);
+}
+function b16encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0").toUpperCase();
+  }
+  return new TextEncoder().encode(hex);
+}
+function b16decode(s) {
+  const hexString = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = hexString.replace(/\s/g, "");
+  if (cleaned.length % 2 !== 0) {
+    throw new Error("Non-hexadecimal digit found");
+  }
+  const bytes = new Uint8Array(cleaned.length / 2);
+  for (let i = 0; i < cleaned.length; i += 2) {
+    const byte = parseInt(cleaned.substring(i, i + 2), 16);
+    if (isNaN(byte)) {
+      throw new Error("Non-hexadecimal digit found");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+function b32encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  let result = "";
+  let bits = 0;
+  let value = 0;
+  for (const byte of bytes) {
+    value = value << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      const idx = value >> bits & 31;
+      result += alphabet[idx] ?? "";
+    }
+  }
+  if (bits > 0) {
+    const idx = value << 5 - bits & 31;
+    result += alphabet[idx] ?? "";
+  }
+  while (result.length % 8 !== 0) {
+    result += "=";
+  }
+  return new TextEncoder().encode(result);
+}
+function b32decode(s) {
+  const base32String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  const cleaned = base32String.replace(/=+$/, "").replace(/\s/g, "").toUpperCase();
+  let bits = 0;
+  let value = 0;
+  const result = [];
+  for (const char of cleaned) {
+    const idx = alphabet.indexOf(char);
+    if (idx === -1) {
+      throw new Error("Invalid Base32 character");
+    }
+    value = value << 5 | idx;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      result.push(value >> bits & 255);
+    }
+  }
+  return new Uint8Array(result);
+}
+function a85encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  let result = "";
+  for (let i = 0; i < bytes.length; i += 4) {
+    const chunk = bytes.slice(i, i + 4);
+    let value = 0;
+    for (const byte of chunk) {
+      value = value * 256 + byte;
+    }
+    for (let j = chunk.length; j < 4; j++) {
+      value = value * 256;
+    }
+    if (value === 0 && chunk.length === 4) {
+      result += "z";
+    } else {
+      const chars = [];
+      for (let j = 0; j < 5; j++) {
+        chars.unshift(String.fromCharCode(value % 85 + 33));
+        value = Math.floor(value / 85);
+      }
+      const outputLen = chunk.length + 1;
+      result += chars.slice(0, outputLen).join("");
+    }
+  }
+  return new TextEncoder().encode(result);
+}
+function a85decode(s) {
+  const ascii85String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = ascii85String.replace(/\s/g, "");
+  const result = [];
+  let i = 0;
+  while (i < cleaned.length) {
+    if (cleaned[i] === "z") {
+      result.push(0, 0, 0, 0);
+      i++;
+    } else {
+      let chunk = cleaned.slice(i, i + 5);
+      const chunkLen = chunk.length;
+      while (chunk.length < 5) {
+        chunk += "u";
+      }
+      let value = 0;
+      for (let j = 0; j < 5; j++) {
+        const charCode = chunk.charCodeAt(j) - 33;
+        if (charCode < 0 || charCode > 84) {
+          throw new Error("Invalid Ascii85 character");
+        }
+        value = value * 85 + charCode;
+      }
+      const bytes = [];
+      for (let j = 0; j < 4; j++) {
+        bytes.unshift(value & 255);
+        value = Math.floor(value / 256);
+      }
+      const outputLen = chunkLen - 1;
+      result.push(...bytes.slice(0, outputLen));
+      i += chunkLen;
+    }
+  }
+  return new Uint8Array(result);
+}
+function b85encode(s) {
+  return a85encode(s);
+}
+function b85decode(s) {
+  return a85decode(s);
+}
+function encodeString(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  return uint8ArrayToBase64(bytes);
+}
+function decodeString(s) {
+  return base64ToUint8Array(s);
+}
+
+export {
+  b64encode,
+  b64decode,
+  standardB64encode,
+  standardB64decode,
+  urlsafeB64encode,
+  urlsafeB64decode,
+  b16encode,
+  b16decode,
+  b32encode,
+  b32decode,
+  a85encode,
+  a85decode,
+  b85encode,
+  b85decode,
+  encodeString,
+  decodeString,
+  base64_exports
+};

package/dist/{chunk-7BZB2TQF.js → chunk-3M3PB4RO.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/random.ts
 var random_exports = {};
@@ -80,7 +80,8 @@ function choices(population, options) {
       let hi = cumWeights.length;
       while (lo < hi) {
         const mid = Math.floor((lo + hi) / 2);
-        if (r > cumWeights[mid]) {
+        const midWeight = cumWeights[mid];
+        if (midWeight !== void 0 && r > midWeight) {
           lo = mid + 1;
         } else {
           hi = mid;
@@ -132,9 +133,7 @@ function gauss(mu = 0, sigma = 1) {
 }
 var normalVariate = gauss;
 function triangular(low = 0, high = 1, mode) {
-  if (mode === void 0) {
-    mode = (low + high) / 2;
-  }
+  mode ??= (low + high) / 2;
   const u = Math.random();
   const c = (mode - low) / (high - low);
   if (u < c) {
@@ -233,4 +232,3 @@ export {
   weibullVariate,
   random_exports
 };
-//# sourceMappingURL=chunk-7BZB2TQF.js.map