pythonlib 1.0.2 → 2.0.1

package/README.md

@@ -1,85 +1,159 @@
 # pythonlib
 
+<div align="center">
+
+**Python's Beloved Standard Library — Now in TypeScript**
+
 [![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,
-collections, and more.
+</div>
+
+---
 
-> Zero dependencies · Full TypeScript support · Tree-shakeable · camelCase API · Works everywhere JS
-> runs
+Miss `itertools.combinations`? Love `collections.Counter`? Wish you had `functools.lru_cache` in
+JavaScript?
 
-## Quick Start
+**pythonlib** brings Python's most powerful utilities to TypeScript — zero dependencies, full type
+safety, tree-shakeable.
+
+## Install
 
 ```bash
 npm install pythonlib
 ```
 
+## Why pythonlib?
+
+| What You Get                | Why It Matters                                    |
+| --------------------------- | ------------------------------------------------- |
+| **Zero dependencies**       | No supply chain bloat, minimal attack surface     |
+| **Full TypeScript support** | Generics, type inference, autocomplete everywhere |
+| **Tree-shakeable**          | Bundle only what you use                          |
+| **camelCase API**           | Feels native in TypeScript                        |
+| **Works everywhere**        | Browsers, Node.js, Deno, Bun, Workers             |
+
+## Quick Examples
+
+### itertools — Combinatorics Made Easy
+
 ```typescript
-import { range, enumerate, sorted } from "pythonlib"
-import { combinations } from "pythonlib/itertools"
-import { Counter } from "pythonlib/collections"
-import { lruCache } from "pythonlib/functools"
-
-// Python-style iteration
-for (const i of range(10)) {
-  console.log(i)
-}
+import { combinations, permutations, product } from "pythonlib/itertools"
 
-// Combinatorics
-for (const combo of combinations([1, 2, 3], 2)) {
-  console.log(combo) // [1,2], [1,3], [2,3]
-}
+// All 2-element combinations
+[...combinations([1, 2, 3], 2)]
+// → [[1, 2], [1, 3], [2, 3]]
+
+// Cartesian product
+[...product(["a", "b"], [1, 2])]
+// → [["a", 1], ["a", 2], ["b", 1], ["b", 2]]
+```
+
+### collections — Data Structures That Just Work
 
-// Count occurrences
-const counter = new Counter("mississippi")
-counter.mostCommon(2) // [["i", 4], ["s", 4]]
+```typescript
+import { Counter, defaultdict, deque } from "pythonlib/collections"
+
+// Count anything
+const votes = new Counter(["alice", "bob", "alice", "alice"])
+votes.mostCommon(1) // → [["alice", 3]]
 
-// Memoization
+// No more "undefined" checks
+const graph = defaultdict(() => [])
+graph.get("node1").push("node2") // Just works!
+
+// Double-ended queue with O(1) operations
+const dq = new deque([1, 2, 3])
+dq.appendLeft(0) // [0, 1, 2, 3]
+dq.pop() // [0, 1, 2]
+```
+
+### functools — Functional Programming Utilities
+
+```typescript
+import { lruCache, partial, reduce } from "pythonlib/functools"
+
+// Memoization with one line
 const fib = lruCache((n: number): number => (n <= 1 ? n : fib(n - 1) + fib(n - 2)))
+fib(100) // Instant, even for large values
+
+// Partial application
+const greet = (greeting: string, name: string) => `${greeting}, ${name}!`
+const sayHello = partial(greet, "Hello")
+sayHello("World") // → "Hello, World!"
 ```
 
-## Available Modules
+### Builtins — Python's Greatest Hits
 
-| Import Path             | Contents                                           | API Docs                                                                 |
-| ----------------------- | -------------------------------------------------- | ------------------------------------------------------------------------ |
-| `pythonlib`             | Builtins: `len`, `range`, `sorted`, `enumerate`... | [→](https://sebastian-software.github.io/python2ts/docs/api/index)       |
-| `pythonlib/itertools`   | `chain`, `combinations`, `zipLongest`, `takeWhile` | [→](https://sebastian-software.github.io/python2ts/docs/api/itertools)   |
-| `pythonlib/functools`   | `partial`, `reduce`, `lruCache`, `pipe`            | [→](https://sebastian-software.github.io/python2ts/docs/api/functools)   |
-| `pythonlib/collections` | `Counter`, `defaultdict`, `deque`                  | [→](https://sebastian-software.github.io/python2ts/docs/api/collections) |
-| `pythonlib/math`        | `sqrt`, `floor`, `ceil`, `factorial`, `pi`, `e`    | [→](https://sebastian-software.github.io/python2ts/docs/api/math)        |
-| `pythonlib/random`      | `randInt`, `choice`, `shuffle`, `sample`           | [→](https://sebastian-software.github.io/python2ts/docs/api/random)      |
-| `pythonlib/datetime`    | `datetime`, `date`, `time`, `timedelta`            | [→](https://sebastian-software.github.io/python2ts/docs/api/datetime)    |
-| `pythonlib/json`        | `loads`, `dumps`                                   | [→](https://sebastian-software.github.io/python2ts/docs/api/json)        |
-| `pythonlib/re`          | `search`, `match`, `findAll`, `sub`, `compile`     | [→](https://sebastian-software.github.io/python2ts/docs/api/re)          |
-| `pythonlib/string`      | `Template`, `capWords`, `asciiLowercase`           | [→](https://sebastian-software.github.io/python2ts/docs/api/string)      |
-
-> All function names use **camelCase** to feel native in TypeScript.
+```typescript
+import { range, enumerate, zip, sorted, reversed } from "pythonlib"
 
-## Documentation
+// Python-style range
+for (const i of range(5)) {
+} // 0, 1, 2, 3, 4
+for (const i of range(1, 10, 2)) {
+} // 1, 3, 5, 7, 9
 
-**[📚 View Full Documentation](https://sebastian-software.github.io/python2ts/)**
+// Enumerate with index
+for (const [i, item] of enumerate(["a", "b", "c"])) {
+  console.log(i, item) // 0 "a", 1 "b", 2 "c"
+}
+
+// Zip multiple iterables
+;[...zip([1, 2, 3], ["a", "b", "c"])]
+// → [[1, "a"], [2, "b"], [3, "c"]]
+```
+
+## Available Modules
 
-| Resource                                                                       | Description                                 |
-| ------------------------------------------------------------------------------ | ------------------------------------------- |
-| [Homepage](https://sebastian-software.github.io/python2ts/)                    | Project overview, features, and quick start |
-| [Runtime Guide](https://sebastian-software.github.io/python2ts/docs/runtime)   | How to use pythonlib in your projects       |
-| [API Reference](https://sebastian-software.github.io/python2ts/docs/api)       | Complete API documentation for all modules  |
-| [Syntax Reference](https://sebastian-software.github.io/python2ts/docs/syntax) | Python → TypeScript transformation rules    |
+| Module                  | Highlights                                                  | Docs                                                                     |
+| ----------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------ |
+| `pythonlib`             | `range`, `enumerate`, `zip`, `sorted`, `len`, `min`, `max`  | [→](https://sebastian-software.github.io/python2ts/docs/api/index)       |
+| `pythonlib/itertools`   | `chain`, `combinations`, `permutations`, `product`, `cycle` | [→](https://sebastian-software.github.io/python2ts/docs/api/itertools)   |
+| `pythonlib/functools`   | `lruCache`, `partial`, `reduce`, `pipe`, `compose`          | [→](https://sebastian-software.github.io/python2ts/docs/api/functools)   |
+| `pythonlib/collections` | `Counter`, `defaultdict`, `deque`, `OrderedDict`            | [→](https://sebastian-software.github.io/python2ts/docs/api/collections) |
+| `pythonlib/math`        | `sqrt`, `floor`, `ceil`, `factorial`, `gcd`, `pi`           | [→](https://sebastian-software.github.io/python2ts/docs/api/math)        |
+| `pythonlib/random`      | `randInt`, `choice`, `shuffle`, `sample`, `random`          | [→](https://sebastian-software.github.io/python2ts/docs/api/random)      |
+| `pythonlib/datetime`    | `datetime`, `date`, `time`, `timedelta`                     | [→](https://sebastian-software.github.io/python2ts/docs/api/datetime)    |
+| `pythonlib/re`          | `search`, `match`, `findAll`, `sub`, `compile`              | [→](https://sebastian-software.github.io/python2ts/docs/api/re)          |
+| `pythonlib/json`        | `loads`, `dumps` with Python semantics                      | [→](https://sebastian-software.github.io/python2ts/docs/api/json)        |
+| `pythonlib/string`      | `Template`, `capWords`, `ascii_lowercase`                   | [→](https://sebastian-software.github.io/python2ts/docs/api/string)      |
+| `pythonlib/os`          | `path.join`, `environ`, `getcwd`                            | [→](https://sebastian-software.github.io/python2ts/docs/api/os)          |
+| `pythonlib/pathlib`     | `Path` class for filesystem operations                      | [→](https://sebastian-software.github.io/python2ts/docs/api/pathlib)     |
+| `pythonlib/glob`        | File pattern matching                                       | [→](https://sebastian-software.github.io/python2ts/docs/api/glob)        |
+| `pythonlib/hashlib`     | `md5`, `sha256`, `sha512` hashing                           | [→](https://sebastian-software.github.io/python2ts/docs/api/hashlib)     |
+| `pythonlib/base64`      | Base64 encoding/decoding                                    | [→](https://sebastian-software.github.io/python2ts/docs/api/base64)      |
+| `pythonlib/uuid`        | UUID generation                                             | [→](https://sebastian-software.github.io/python2ts/docs/api/uuid)        |
 
 ## Runtime Support
 
-Tested on every commit: **Node.js** (v22, v24) · **Bun** · **Deno** · **Browsers**
+Works everywhere JavaScript runs:
+
+- **Node.js** (v22, v24)
+- **Bun**
+- **Deno**
+- **Browsers** (Chrome, Firefox, Safari)
+- **Edge** (Cloudflare Workers, Vercel, AWS Lambda)
+
+## Documentation
 
-Also works in Cloudflare Workers, AWS Lambda, and other JS environments.
+| Resource                                                                     | Description                                |
+| ---------------------------------------------------------------------------- | ------------------------------------------ |
+| [Homepage](https://sebastian-software.github.io/python2ts/)                  | Project overview and quick start           |
+| [Runtime Guide](https://sebastian-software.github.io/python2ts/docs/runtime) | Detailed usage guide                       |
+| [API Reference](https://sebastian-software.github.io/python2ts/docs/api)     | Complete API documentation for all modules |
 
 ## Related
 
 - [**python2ts**](https://www.npmjs.com/package/python2ts) — Transpile Python to TypeScript
-- [**GitHub**](https://github.com/sebastian-software/python2ts) — Source code and issue tracker
+  automatically
+- [**GitHub**](https://github.com/sebastian-software/python2ts) — Source code, issues, contributions
+  welcome
 
 ## License
 

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-HTCQ4OO5.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-2QEMKE7U.js

@@ -0,0 +1,252 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/uuid.ts
+var uuid_exports = {};
+__export(uuid_exports, {
+  NAMESPACE_DNS: () => NAMESPACE_DNS,
+  NAMESPACE_OID: () => NAMESPACE_OID,
+  NAMESPACE_URL: () => NAMESPACE_URL,
+  NAMESPACE_X500: () => NAMESPACE_X500,
+  UUID: () => UUID,
+  uuid1: () => uuid1,
+  uuid3: () => uuid3,
+  uuid4: () => uuid4,
+  uuid5: () => uuid5
+});
+var UUID = class _UUID {
+  _bytes;
+  /** Helper to safely get byte at index */
+  getByte(index) {
+    return this._bytes[index] ?? 0;
+  }
+  /**
+   * Create a UUID from various input formats.
+   *
+   * @param hex - Hexadecimal string (with or without hyphens)
+   * @param bytes - 16 bytes as Uint8Array
+   * @param int - Integer value
+   */
+  constructor(options) {
+    if (typeof options === "string") {
+      options = { hex: options };
+    }
+    if ("hex" in options) {
+      const hex = options.hex.replace(/-/g, "").replace(/[{}]/g, "");
+      if (hex.length !== 32) {
+        throw new Error("badly formed hexadecimal UUID string");
+      }
+      this._bytes = new Uint8Array(16);
+      for (let i = 0; i < 16; i++) {
+        this._bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+      }
+    } else if ("bytes" in options) {
+      if (options.bytes.length !== 16) {
+        throw new Error("bytes must be a 16-byte array");
+      }
+      this._bytes = new Uint8Array(options.bytes);
+    } else if ("int" in options) {
+      this._bytes = new Uint8Array(16);
+      let value = options.int;
+      for (let i = 15; i >= 0; i--) {
+        this._bytes[i] = Number(value & 0xffn);
+        value = value >> 8n;
+      }
+    } else {
+      throw new Error("one of hex, bytes, or int is required");
+    }
+  }
+  /**
+   * The UUID as a 32-character lowercase hexadecimal string.
+   */
+  get hex() {
+    let result = "";
+    for (const byte of this._bytes) {
+      result += byte.toString(16).padStart(2, "0");
+    }
+    return result;
+  }
+  /**
+   * The UUID as a 16-byte Uint8Array.
+   */
+  get bytes() {
+    return new Uint8Array(this._bytes);
+  }
+  /**
+   * The UUID as a 128-bit integer.
+   */
+  get int() {
+    let value = 0n;
+    for (const byte of this._bytes) {
+      value = value << 8n | BigInt(byte);
+    }
+    return value;
+  }
+  /**
+   * The version number (1 through 5, as an integer).
+   */
+  get version() {
+    return this.getByte(6) >> 4 & 15;
+  }
+  /**
+   * The variant (reserved bits).
+   */
+  get variant() {
+    const byte = this.getByte(8);
+    if ((byte & 128) === 0) {
+      return "reserved for NCS compatibility";
+    } else if ((byte & 192) === 128) {
+      return "specified in RFC 4122";
+    } else if ((byte & 224) === 192) {
+      return "reserved for Microsoft compatibility";
+    } else {
+      return "reserved for future definition";
+    }
+  }
+  /**
+   * The UUID as a hyphenated string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).
+   */
+  toString() {
+    const h = this.hex;
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+  }
+  /**
+   * The UUID as a URN (urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).
+   */
+  get urn() {
+    return `urn:uuid:${this.toString()}`;
+  }
+  /**
+   * Compare UUIDs for equality.
+   */
+  equals(other) {
+    if (!(other instanceof _UUID)) return false;
+    for (let i = 0; i < 16; i++) {
+      if (this._bytes[i] !== other._bytes[i]) return false;
+    }
+    return true;
+  }
+  /**
+   * Get the time_low field (first 32 bits).
+   */
+  get timeLow() {
+    return (this.getByte(0) << 24 | this.getByte(1) << 16 | this.getByte(2) << 8 | this.getByte(3)) >>> 0;
+  }
+  /**
+   * Get the time_mid field (next 16 bits).
+   */
+  get timeMid() {
+    return this.getByte(4) << 8 | this.getByte(5);
+  }
+  /**
+   * Get the time_hi_version field (next 16 bits).
+   */
+  get timeHiVersion() {
+    return this.getByte(6) << 8 | this.getByte(7);
+  }
+  /**
+   * Get the clock_seq_hi_variant field.
+   */
+  get clockSeqHiVariant() {
+    return this.getByte(8);
+  }
+  /**
+   * Get the clock_seq_low field.
+   */
+  get clockSeqLow() {
+    return this.getByte(9);
+  }
+  /**
+   * Get the node field (last 48 bits).
+   */
+  get node() {
+    let value = 0n;
+    for (let i = 10; i < 16; i++) {
+      value = value << 8n | BigInt(this.getByte(i));
+    }
+    return value;
+  }
+};
+function uuid4() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return new UUID({ hex: crypto.randomUUID() });
+  }
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  return new UUID({ bytes });
+}
+function uuid1(node, clockSeq) {
+  const bytes = new Uint8Array(16);
+  const now = Date.now();
+  const UUID_EPOCH_OFFSET = 122192928000000000n;
+  const timestamp = BigInt(now) * 10000n + UUID_EPOCH_OFFSET;
+  const timeLow = Number(timestamp & 0xffffffffn);
+  bytes[0] = timeLow >> 24 & 255;
+  bytes[1] = timeLow >> 16 & 255;
+  bytes[2] = timeLow >> 8 & 255;
+  bytes[3] = timeLow & 255;
+  const timeMid = Number(timestamp >> 32n & 0xffffn);
+  bytes[4] = timeMid >> 8 & 255;
+  bytes[5] = timeMid & 255;
+  const timeHi = Number(timestamp >> 48n & 0x0fffn);
+  bytes[6] = timeHi >> 8 & 15 | 16;
+  bytes[7] = timeHi & 255;
+  const seq = clockSeq ?? Math.floor(Math.random() * 16384);
+  bytes[8] = seq >> 8 & 63 | 128;
+  bytes[9] = seq & 255;
+  let nodeId = node;
+  if (nodeId === void 0) {
+    const randomNode = new Uint8Array(6);
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+      crypto.getRandomValues(randomNode);
+    } else {
+      for (let i = 0; i < 6; i++) {
+        randomNode[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    randomNode[0] = (randomNode[0] ?? 0) | 1;
+    nodeId = 0n;
+    for (const byte of randomNode) {
+      nodeId = nodeId << 8n | BigInt(byte);
+    }
+  }
+  for (let i = 15; i >= 10; i--) {
+    bytes[i] = Number(nodeId & 0xffn);
+    nodeId = nodeId >> 8n;
+  }
+  return new UUID({ bytes });
+}
+function uuid3(_namespace, _name) {
+  throw new Error("uuid3 requires hashlib.md5 - import from 'pythonlib/hashlib'");
+}
+function uuid5(_namespace, _name) {
+  throw new Error("uuid5 requires hashlib.sha1 - import from 'pythonlib/hashlib'");
+}
+var NAMESPACE_DNS = new UUID({ hex: "6ba7b810-9dad-11d1-80b4-00c04fd430c8" });
+var NAMESPACE_URL = new UUID({ hex: "6ba7b811-9dad-11d1-80b4-00c04fd430c8" });
+var NAMESPACE_OID = new UUID({ hex: "6ba7b812-9dad-11d1-80b4-00c04fd430c8" });
+var NAMESPACE_X500 = new UUID({ hex: "6ba7b814-9dad-11d1-80b4-00c04fd430c8" });
+
+export {
+  UUID,
+  uuid4,
+  uuid1,
+  uuid3,
+  uuid5,
+  NAMESPACE_DNS,
+  NAMESPACE_URL,
+  NAMESPACE_OID,
+  NAMESPACE_X500,
+  uuid_exports
+};
+/* v8 ignore start -- fallback for environments without crypto.randomUUID @preserve */
+/* v8 ignore start -- fallback for environments without crypto @preserve */