pythonlib 1.0.1 → 2.0.0

package/dist/time-CcYhdiSu.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Python time module for TypeScript
+ *
+ * Provides time-related functions including time access, conversions,
+ * and formatting. Note that `sleep()` uses a synchronous busy-wait
+ * which blocks the event loop.
+ *
+ * @see {@link https://docs.python.org/3/library/time.html | Python time documentation}
+ * @module
+ */
+/**
+ * Structure representing a time tuple, similar to Python's struct_time.
+ */
+interface StructTime {
+    /** Year (e.g., 2023) */
+    tm_year: number;
+    /** Month (1-12) */
+    tm_mon: number;
+    /** Day of month (1-31) */
+    tm_mday: number;
+    /** Hour (0-23) */
+    tm_hour: number;
+    /** Minute (0-59) */
+    tm_min: number;
+    /** Second (0-61, allowing for leap seconds) */
+    tm_sec: number;
+    /** Day of week (0-6, Monday is 0) */
+    tm_wday: number;
+    /** Day of year (1-366) */
+    tm_yday: number;
+    /** DST flag (-1, 0, or 1) */
+    tm_isdst: number;
+}
+/**
+ * Return the time in seconds since the epoch as a floating point number.
+ *
+ * @returns Seconds since Unix epoch (January 1, 1970)
+ *
+ * @example
+ * ```typescript
+ * console.log(time()) // 1704067200.123
+ * ```
+ */
+declare function time(): number;
+/**
+ * Return the time in nanoseconds since the epoch as a BigInt.
+ *
+ * @returns Nanoseconds since Unix epoch
+ *
+ * @example
+ * ```typescript
+ * console.log(timeNs()) // 1704067200123456789n
+ * ```
+ */
+declare function timeNs(): bigint;
+/**
+ * Suspend execution for the given number of seconds.
+ * WARNING: This uses a synchronous busy-wait that blocks the event loop.
+ *
+ * @param secs - Number of seconds to sleep (can be fractional)
+ *
+ * @example
+ * ```typescript
+ * sleep(0.5) // Sleep for 500 milliseconds
+ * ```
+ */
+declare function sleep(secs: number): void;
+/**
+ * Return the value of a performance counter (monotonic clock).
+ * Uses performance.now() for high precision.
+ *
+ * @returns Seconds as a float (relative to an undefined reference point)
+ *
+ * @example
+ * ```typescript
+ * const start = perfCounter()
+ * // ... do work ...
+ * const elapsed = perfCounter() - start
+ * ```
+ */
+declare function perfCounter(): number;
+/**
+ * Return the value of a performance counter in nanoseconds.
+ *
+ * @returns Nanoseconds as a BigInt (relative to an undefined reference point)
+ */
+declare function perfCounterNs(): bigint;
+/**
+ * Return the value of a monotonic clock.
+ * This clock cannot go backwards and is not affected by system clock updates.
+ *
+ * @returns Seconds as a float (relative to an undefined reference point)
+ */
+declare function monotonic(): number;
+/**
+ * Return the value of a monotonic clock in nanoseconds.
+ *
+ * @returns Nanoseconds as a BigInt
+ */
+declare function monotonicNs(): bigint;
+/**
+ * Convert seconds since epoch to a StructTime in local time.
+ *
+ * @param secs - Seconds since epoch (defaults to current time)
+ * @returns StructTime object representing local time
+ *
+ * @example
+ * ```typescript
+ * const t = localtime()
+ * console.log(t.tm_year, t.tm_mon, t.tm_mday)
+ * ```
+ */
+declare function localtime(secs?: number): StructTime;
+/**
+ * Convert seconds since epoch to a StructTime in UTC.
+ *
+ * @param secs - Seconds since epoch (defaults to current time)
+ * @returns StructTime object representing UTC time
+ */
+declare function gmtime(secs?: number): StructTime;
+/**
+ * Convert a StructTime to seconds since epoch (inverse of localtime).
+ *
+ * @param t - StructTime object
+ * @returns Seconds since epoch as a float
+ */
+declare function mktime(t: StructTime): number;
+/**
+ * Format a StructTime as a string using strftime-style format codes.
+ *
+ * Supported format codes:
+ * - %Y: Year with century (e.g., 2023)
+ * - %y: Year without century (00-99)
+ * - %m: Month (01-12)
+ * - %d: Day of month (01-31)
+ * - %H: Hour 24-hour (00-23)
+ * - %I: Hour 12-hour (01-12)
+ * - %M: Minute (00-59)
+ * - %S: Second (00-61)
+ * - %p: AM or PM
+ * - %A: Full weekday name
+ * - %a: Abbreviated weekday name
+ * - %B: Full month name
+ * - %b: Abbreviated month name
+ * - %w: Weekday as decimal (0-6, Sunday is 0)
+ * - %j: Day of year (001-366)
+ * - %U: Week number of year (Sunday first day)
+ * - %W: Week number of year (Monday first day)
+ * - %c: Locale's date and time representation
+ * - %x: Locale's date representation
+ * - %X: Locale's time representation
+ * - %%: Literal %
+ *
+ * @param format - Format string
+ * @param t - StructTime object (defaults to current local time)
+ * @returns Formatted time string
+ */
+declare function strftime(format: string, t?: StructTime): string;
+/**
+ * Parse a string according to a format and return a StructTime.
+ *
+ * @param timeString - String to parse
+ * @param format - Format string (same codes as strftime)
+ * @returns StructTime object
+ * @throws Error if string doesn't match format
+ */
+declare function strptime(timeString: string, format: string): StructTime;
+/**
+ * Convert a StructTime to a string in the format: "Dow Mon dd hh:mm:ss yyyy"
+ *
+ * @param t - StructTime object (defaults to current local time)
+ * @returns Formatted time string
+ */
+declare function asctime(t?: StructTime): string;
+/**
+ * Convert seconds since epoch to a string (equivalent to asctime(localtime(secs)))
+ *
+ * @param secs - Seconds since epoch (defaults to current time)
+ * @returns Formatted time string
+ */
+declare function ctime(secs?: number): string;
+/**
+ * Return the offset of the local timezone from UTC in seconds.
+ * Positive values mean west of UTC, negative mean east.
+ */
+declare const timezone: number;
+/**
+ * Return the offset of the local timezone from UTC in seconds during DST.
+ * This is the same as timezone on systems that don't have DST.
+ */
+declare const altzone: number;
+/**
+ * Return a tuple of two strings: standard timezone name and DST timezone name.
+ */
+declare const tzname: [string, string];
+/**
+ * True if DST is defined for the local timezone.
+ */
+declare const daylight = 0;
+/**
+ * Return the process time as a float (CPU time used by the process).
+ * In JavaScript, this approximates using Date.now().
+ */
+declare function processTime(): number;
+/**
+ * Return the process time in nanoseconds.
+ */
+declare function processTimeNs(): bigint;
+/**
+ * Return the current thread's CPU time (same as processTime in JavaScript).
+ */
+declare function threadTime(): number;
+/**
+ * Return the current thread's CPU time in nanoseconds.
+ */
+declare function threadTimeNs(): bigint;
+
+type timeModule_StructTime = StructTime;
+declare const timeModule_altzone: typeof altzone;
+declare const timeModule_asctime: typeof asctime;
+declare const timeModule_ctime: typeof ctime;
+declare const timeModule_daylight: typeof daylight;
+declare const timeModule_gmtime: typeof gmtime;
+declare const timeModule_localtime: typeof localtime;
+declare const timeModule_mktime: typeof mktime;
+declare const timeModule_monotonic: typeof monotonic;
+declare const timeModule_monotonicNs: typeof monotonicNs;
+declare const timeModule_perfCounter: typeof perfCounter;
+declare const timeModule_perfCounterNs: typeof perfCounterNs;
+declare const timeModule_processTime: typeof processTime;
+declare const timeModule_processTimeNs: typeof processTimeNs;
+declare const timeModule_sleep: typeof sleep;
+declare const timeModule_strftime: typeof strftime;
+declare const timeModule_strptime: typeof strptime;
+declare const timeModule_threadTime: typeof threadTime;
+declare const timeModule_threadTimeNs: typeof threadTimeNs;
+declare const timeModule_time: typeof time;
+declare const timeModule_timeNs: typeof timeNs;
+declare const timeModule_timezone: typeof timezone;
+declare const timeModule_tzname: typeof tzname;
+declare namespace timeModule {
+  export { type timeModule_StructTime as StructTime, timeModule_altzone as altzone, timeModule_asctime as asctime, timeModule_ctime as ctime, timeModule_daylight as daylight, timeModule_gmtime as gmtime, timeModule_localtime as localtime, timeModule_mktime as mktime, timeModule_monotonic as monotonic, timeModule_monotonicNs as monotonicNs, timeModule_perfCounter as perfCounter, timeModule_perfCounterNs as perfCounterNs, timeModule_processTime as processTime, timeModule_processTimeNs as processTimeNs, timeModule_sleep as sleep, timeModule_strftime as strftime, timeModule_strptime as strptime, timeModule_threadTime as threadTime, timeModule_threadTimeNs as threadTimeNs, timeModule_time as time, timeModule_timeNs as timeNs, timeModule_timezone as timezone, timeModule_tzname as tzname };
+}
+
+export { type StructTime as S, time as a, timeNs as b, perfCounterNs as c, monotonicNs as d, mktime as e, strftime as f, gmtime as g, strptime as h, asctime as i, ctime as j, timezone as k, localtime as l, monotonic as m, altzone as n, tzname as o, perfCounter as p, daylight as q, processTime as r, sleep as s, timeModule as t, processTimeNs as u, threadTime as v, threadTimeNs as w };

package/dist/time.d.ts

@@ -0,0 +1 @@
+export { S as StructTime, n as altzone, i as asctime, j as ctime, q as daylight, g as gmtime, l as localtime, e as mktime, m as monotonic, d as monotonicNs, p as perfCounter, c as perfCounterNs, r as processTime, u as processTimeNs, s as sleep, f as strftime, h as strptime, v as threadTime, w as threadTimeNs, a as time, b as timeNs, k as timezone, o as tzname } from './time-CcYhdiSu.js';

package/dist/time.js

@@ -0,0 +1,49 @@
+import {
+  altzone,
+  asctime,
+  ctime,
+  daylight,
+  gmtime,
+  localtime,
+  mktime,
+  monotonic,
+  monotonicNs,
+  perfCounter,
+  perfCounterNs,
+  processTime,
+  processTimeNs,
+  sleep,
+  strftime,
+  strptime,
+  threadTime,
+  threadTimeNs,
+  time,
+  timeNs,
+  timezone,
+  tzname
+} from "./chunk-KKHKTQNN.js";
+import "./chunk-MLKGABMK.js";
+export {
+  altzone,
+  asctime,
+  ctime,
+  daylight,
+  gmtime,
+  localtime,
+  mktime,
+  monotonic,
+  monotonicNs,
+  perfCounter,
+  perfCounterNs,
+  processTime,
+  processTimeNs,
+  sleep,
+  strftime,
+  strptime,
+  threadTime,
+  threadTimeNs,
+  time,
+  timeNs,
+  timezone,
+  tzname
+};

package/dist/urllib-DJtkj-0f.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Python urllib module for TypeScript
+ *
+ * Provides URL handling and parsing utilities.
+ *
+ * @see {@link https://docs.python.org/3/library/urllib.html | Python urllib documentation}
+ * @module
+ */
+/**
+ * Parsed URL result structure.
+ */
+interface ParseResult {
+    /** URL scheme (e.g., "http", "https") */
+    scheme: string;
+    /** Network location (e.g., "example.com:8080") */
+    netloc: string;
+    /** URL path */
+    path: string;
+    /** Query parameters (without leading ?) */
+    params: string;
+    /** Query string (without leading ?) */
+    query: string;
+    /** Fragment (without leading #) */
+    fragment: string;
+    /** Username if present */
+    username: string | null;
+    /** Password if present */
+    password: string | null;
+    /** Hostname */
+    hostname: string | null;
+    /** Port number */
+    port: number | null;
+}
+/**
+ * Parse a URL into its components.
+ *
+ * @param urlstring - The URL to parse
+ * @param scheme - Default scheme if not present in URL
+ * @param allowFragments - Whether to parse fragments (default: true)
+ * @returns Parsed URL components
+ *
+ * @example
+ * ```typescript
+ * const result = urlparse("https://user:pass@example.com:8080/path?query=1#frag")
+ * console.log(result.scheme)   // "https"
+ * console.log(result.hostname) // "example.com"
+ * console.log(result.port)     // 8080
+ * ```
+ */
+declare function urlparse(urlstring: string, scheme?: string, allowFragments?: boolean): ParseResult;
+/**
+ * Combine URL components back into a URL string.
+ *
+ * @param components - URL components tuple [scheme, netloc, path, params, query, fragment]
+ * @returns Combined URL string
+ */
+declare function urlunparse(components: [string, string, string, string, string, string] | ParseResult): string;
+/**
+ * Join a base URL with another URL.
+ *
+ * @param base - Base URL
+ * @param url - URL to join (can be relative)
+ * @param allowFragments - Whether to allow fragments
+ * @returns Combined URL
+ */
+declare function urljoin(base: string, url: string, allowFragments?: boolean): string;
+/**
+ * Encode a dictionary or sequence of tuples as a query string.
+ *
+ * @param query - Query parameters as object or array of tuples
+ * @param doseq - If true, treat sequence values as separate parameters
+ * @returns URL-encoded query string
+ */
+declare function urlencode(query: Record<string, string | string[]> | [string, string][], doseq?: boolean): string;
+/**
+ * Parse a query string into a dictionary.
+ *
+ * @param qs - Query string to parse
+ * @param keepBlankValues - Whether to keep blank values
+ * @returns Object mapping keys to arrays of values
+ */
+declare function parseQs(qs: string, keepBlankValues?: boolean): Record<string, string[]>;
+/**
+ * Parse a query string into a dictionary (single values).
+ *
+ * @param qs - Query string to parse
+ * @param keepBlankValues - Whether to keep blank values
+ * @returns Object mapping keys to single values
+ */
+declare function parseQsl(qs: string, keepBlankValues?: boolean): [string, string][];
+/**
+ * Percent-encode a string for use in a URL.
+ *
+ * @param s - String to encode
+ * @param safe - Characters that should not be encoded (default: empty)
+ * @returns Percent-encoded string
+ */
+declare function quote(s: string, safe?: string): string;
+/**
+ * Like quote() but also encodes forward slashes.
+ *
+ * @param s - String to encode
+ * @param safe - Characters that should not be encoded
+ * @returns Percent-encoded string
+ */
+declare function quotePlus(s: string, safe?: string): string;
+/**
+ * Decode a percent-encoded string.
+ *
+ * @param s - String to decode
+ * @returns Decoded string
+ */
+declare function unquote(s: string): string;
+/**
+ * Like unquote() but also decodes plus signs as spaces.
+ *
+ * @param s - String to decode
+ * @returns Decoded string
+ */
+declare function unquotePlus(s: string): string;
+/**
+ * Split a URL after the scheme into [scheme, rest].
+ *
+ * @param url - URL to split
+ * @returns Tuple of [scheme, rest]
+ */
+declare function splittype(url: string): [string, string];
+/**
+ * Split a URL after the host into [host, rest].
+ *
+ * @param url - URL to split
+ * @returns Tuple of [host, rest]
+ */
+declare function splithost(url: string): [string | null, string];
+/**
+ * Split a host into [user, host].
+ *
+ * @param host - Host string (may include user:pass@)
+ * @returns Tuple of [user, host]
+ */
+declare function splituser(host: string): [string | null, string];
+/**
+ * Split a user:pass into [user, password].
+ *
+ * @param user - User string (may include :pass)
+ * @returns Tuple of [user, password]
+ */
+declare function splitpasswd(user: string): [string, string | null];
+/**
+ * Split a host:port into [host, port].
+ *
+ * @param host - Host string (may include :port)
+ * @returns Tuple of [host, port]
+ */
+declare function splitport(host: string): [string, string | null];
+/**
+ * Namespace object for parse functions (urllib.parse compatibility).
+ */
+declare const parse: {
+    urlparse: typeof urlparse;
+    urlunparse: typeof urlunparse;
+    urljoin: typeof urljoin;
+    urlencode: typeof urlencode;
+    parseQs: typeof parseQs;
+    parseQsl: typeof parseQsl;
+    quote: typeof quote;
+    quotePlus: typeof quotePlus;
+    unquote: typeof unquote;
+    unquotePlus: typeof unquotePlus;
+    splittype: typeof splittype;
+    splithost: typeof splithost;
+    splituser: typeof splituser;
+    splitpasswd: typeof splitpasswd;
+    splitport: typeof splitport;
+};
+
+type urllibModule_ParseResult = ParseResult;
+declare const urllibModule_parse: typeof parse;
+declare const urllibModule_parseQs: typeof parseQs;
+declare const urllibModule_parseQsl: typeof parseQsl;
+declare const urllibModule_quote: typeof quote;
+declare const urllibModule_quotePlus: typeof quotePlus;
+declare const urllibModule_splithost: typeof splithost;
+declare const urllibModule_splitpasswd: typeof splitpasswd;
+declare const urllibModule_splitport: typeof splitport;
+declare const urllibModule_splittype: typeof splittype;
+declare const urllibModule_splituser: typeof splituser;
+declare const urllibModule_unquote: typeof unquote;
+declare const urllibModule_unquotePlus: typeof unquotePlus;
+declare const urllibModule_urlencode: typeof urlencode;
+declare const urllibModule_urljoin: typeof urljoin;
+declare const urllibModule_urlparse: typeof urlparse;
+declare const urllibModule_urlunparse: typeof urlunparse;
+declare namespace urllibModule {
+  export { type urllibModule_ParseResult as ParseResult, urllibModule_parse as parse, urllibModule_parseQs as parseQs, urllibModule_parseQsl as parseQsl, urllibModule_quote as quote, urllibModule_quotePlus as quotePlus, urllibModule_splithost as splithost, urllibModule_splitpasswd as splitpasswd, urllibModule_splitport as splitport, urllibModule_splittype as splittype, urllibModule_splituser as splituser, urllibModule_unquote as unquote, urllibModule_unquotePlus as unquotePlus, urllibModule_urlencode as urlencode, urllibModule_urljoin as urljoin, urllibModule_urlparse as urlparse, urllibModule_urlunparse as urlunparse };
+}
+
+export { type ParseResult as P, urlparse as a, urlunparse as b, urljoin as c, urlencode as d, parseQsl as e, quotePlus as f, unquote as g, unquotePlus as h, splithost as i, splituser as j, splitpasswd as k, splitport as l, parse as m, parseQs as p, quote as q, splittype as s, urllibModule as u };

package/dist/urllib.d.ts

@@ -0,0 +1 @@
+export { P as ParseResult, m as parse, p as parseQs, e as parseQsl, q as quote, f as quotePlus, i as splithost, k as splitpasswd, l as splitport, s as splittype, j as splituser, g as unquote, h as unquotePlus, d as urlencode, c as urljoin, a as urlparse, b as urlunparse } from './urllib-DJtkj-0f.js';

package/dist/urllib.js

@@ -0,0 +1,37 @@
+import {
+  parse,
+  parseQs,
+  parseQsl,
+  quote,
+  quotePlus,
+  splithost,
+  splitpasswd,
+  splitport,
+  splittype,
+  splituser,
+  unquote,
+  unquotePlus,
+  urlencode,
+  urljoin,
+  urlparse,
+  urlunparse
+} from "./chunk-IANXD4D4.js";
+import "./chunk-MLKGABMK.js";
+export {
+  parse,
+  parseQs,
+  parseQsl,
+  quote,
+  quotePlus,
+  splithost,
+  splitpasswd,
+  splitport,
+  splittype,
+  splituser,
+  unquote,
+  unquotePlus,
+  urlencode,
+  urljoin,
+  urlparse,
+  urlunparse
+};

package/dist/uuid-C0ypmn56.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Python uuid module for TypeScript
+ *
+ * Provides UUID objects as specified in RFC 4122.
+ *
+ * @see {@link https://docs.python.org/3/library/uuid.html | Python uuid documentation}
+ * @module
+ */
+/**
+ * UUID class representing a universally unique identifier.
+ */
+declare class UUID {
+    private readonly _bytes;
+    /** Helper to safely get byte at index */
+    private getByte;
+    /**
+     * 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: {
+        hex: string;
+    } | {
+        bytes: Uint8Array;
+    } | {
+        int: bigint;
+    } | string);
+    /**
+     * The UUID as a 32-character lowercase hexadecimal string.
+     */
+    get hex(): string;
+    /**
+     * The UUID as a 16-byte Uint8Array.
+     */
+    get bytes(): Uint8Array;
+    /**
+     * The UUID as a 128-bit integer.
+     */
+    get int(): bigint;
+    /**
+     * The version number (1 through 5, as an integer).
+     */
+    get version(): number;
+    /**
+     * The variant (reserved bits).
+     */
+    get variant(): string;
+    /**
+     * The UUID as a hyphenated string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).
+     */
+    toString(): string;
+    /**
+     * The UUID as a URN (urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).
+     */
+    get urn(): string;
+    /**
+     * Compare UUIDs for equality.
+     */
+    equals(other: UUID): boolean;
+    /**
+     * Get the time_low field (first 32 bits).
+     */
+    get timeLow(): number;
+    /**
+     * Get the time_mid field (next 16 bits).
+     */
+    get timeMid(): number;
+    /**
+     * Get the time_hi_version field (next 16 bits).
+     */
+    get timeHiVersion(): number;
+    /**
+     * Get the clock_seq_hi_variant field.
+     */
+    get clockSeqHiVariant(): number;
+    /**
+     * Get the clock_seq_low field.
+     */
+    get clockSeqLow(): number;
+    /**
+     * Get the node field (last 48 bits).
+     */
+    get node(): bigint;
+}
+/**
+ * Generate a random UUID (version 4).
+ *
+ * Uses crypto.randomUUID() when available, otherwise falls back to
+ * crypto.getRandomValues().
+ *
+ * @returns A new random UUID
+ *
+ * @example
+ * ```typescript
+ * const id = uuid4()
+ * console.log(id.toString()) // "550e8400-e29b-41d4-a716-446655440000"
+ * ```
+ */
+declare function uuid4(): UUID;
+/**
+ * Generate a UUID based on host ID and current time (version 1).
+ *
+ * Note: In browser environments, the node ID is randomly generated
+ * since MAC addresses are not accessible.
+ *
+ * @param node - Optional 48-bit node ID (defaults to random)
+ * @param clockSeq - Optional 14-bit clock sequence (defaults to random)
+ * @returns A new time-based UUID
+ */
+declare function uuid1(node?: bigint, clockSeq?: number): UUID;
+/**
+ * Generate a UUID based on the MD5 hash of a namespace identifier and a name (version 3).
+ *
+ * @param namespace - The namespace UUID
+ * @param name - The name string
+ * @returns A new name-based UUID using MD5
+ */
+declare function uuid3(_namespace: UUID, _name: string): UUID;
+/**
+ * Generate a UUID based on the SHA-1 hash of a namespace identifier and a name (version 5).
+ *
+ * @param namespace - The namespace UUID
+ * @param name - The name string
+ * @returns A new name-based UUID using SHA-1
+ */
+declare function uuid5(_namespace: UUID, _name: string): UUID;
+/**
+ * The namespace UUID for DNS domain names.
+ */
+declare const NAMESPACE_DNS: UUID;
+/**
+ * The namespace UUID for URLs.
+ */
+declare const NAMESPACE_URL: UUID;
+/**
+ * The namespace UUID for ISO OIDs.
+ */
+declare const NAMESPACE_OID: UUID;
+/**
+ * The namespace UUID for X.500 DNs.
+ */
+declare const NAMESPACE_X500: UUID;
+
+declare const uuidModule_NAMESPACE_DNS: typeof NAMESPACE_DNS;
+declare const uuidModule_NAMESPACE_OID: typeof NAMESPACE_OID;
+declare const uuidModule_NAMESPACE_URL: typeof NAMESPACE_URL;
+declare const uuidModule_NAMESPACE_X500: typeof NAMESPACE_X500;
+type uuidModule_UUID = UUID;
+declare const uuidModule_UUID: typeof UUID;
+declare const uuidModule_uuid1: typeof uuid1;
+declare const uuidModule_uuid3: typeof uuid3;
+declare const uuidModule_uuid4: typeof uuid4;
+declare const uuidModule_uuid5: typeof uuid5;
+declare namespace uuidModule {
+  export { uuidModule_NAMESPACE_DNS as NAMESPACE_DNS, uuidModule_NAMESPACE_OID as NAMESPACE_OID, uuidModule_NAMESPACE_URL as NAMESPACE_URL, uuidModule_NAMESPACE_X500 as NAMESPACE_X500, uuidModule_UUID as UUID, uuidModule_uuid1 as uuid1, uuidModule_uuid3 as uuid3, uuidModule_uuid4 as uuid4, uuidModule_uuid5 as uuid5 };
+}
+
+export { NAMESPACE_DNS as N, UUID as U, uuid4 as a, uuid1 as b, uuid3 as c, uuid5 as d, NAMESPACE_URL as e, NAMESPACE_OID as f, NAMESPACE_X500 as g, uuidModule as u };

package/dist/uuid.d.ts

@@ -0,0 +1 @@
+export { N as NAMESPACE_DNS, f as NAMESPACE_OID, e as NAMESPACE_URL, g as NAMESPACE_X500, U as UUID, b as uuid1, c as uuid3, a as uuid4, d as uuid5 } from './uuid-C0ypmn56.js';