pythonlib 1.0.2 → 2.0.0

package/dist/chunk-BCVIH2BN.js

@@ -0,0 +1,175 @@
+import {
+  altSep,
+  chdir,
+  curDir,
+  environ,
+  extSep,
+  getCwd,
+  getCwdb,
+  getenv,
+  lineSep,
+  name,
+  parDir,
+  pathBasename,
+  pathCommonPath,
+  pathDirname,
+  pathExpandUser,
+  pathExpandVars,
+  pathExtName,
+  pathIsAbs,
+  pathJoin,
+  pathNormPath,
+  pathRelPath,
+  pathSep,
+  pathSplitExt,
+  pathSplitFn,
+  sep
+} from "./chunk-LHPQS75Z.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/os.browser.ts
+var os_browser_exports = {};
+__export(os_browser_exports, {
+  altSep: () => altSep,
+  chdir: () => chdir,
+  curDir: () => curDir,
+  environ: () => environ,
+  extSep: () => extSep,
+  getCwd: () => getCwd,
+  getCwdb: () => getCwdb,
+  getenv: () => getenv,
+  lineSep: () => lineSep,
+  listDir: () => listDir,
+  makeDirs: () => makeDirs,
+  mkdir: () => mkdir,
+  name: () => name,
+  parDir: () => parDir,
+  path: () => path,
+  pathBasename: () => pathBasename,
+  pathCommonPath: () => pathCommonPath,
+  pathDirname: () => pathDirname,
+  pathExpandUser: () => pathExpandUser,
+  pathExpandVars: () => pathExpandVars,
+  pathExtName: () => pathExtName,
+  pathIsAbs: () => pathIsAbs,
+  pathJoin: () => pathJoin,
+  pathNormPath: () => pathNormPath,
+  pathRelPath: () => pathRelPath,
+  pathSep: () => pathSep,
+  pathSplitExt: () => pathSplitExt,
+  pathSplitFn: () => pathSplitFn,
+  remove: () => remove,
+  removeDirs: () => removeDirs,
+  rename: () => rename,
+  renames: () => renames,
+  replace: () => replace,
+  rmdir: () => rmdir,
+  sep: () => sep,
+  stat: () => stat,
+  unlink: () => unlink,
+  walk: () => walk
+});
+var path = {
+  join: pathJoin,
+  basename: pathBasename,
+  dirname: pathDirname,
+  split: pathSplitFn,
+  splitExt: pathSplitExt,
+  extName: pathExtName,
+  isAbs: pathIsAbs,
+  normPath: pathNormPath,
+  relPath: pathRelPath,
+  commonPath: pathCommonPath,
+  expandUser: pathExpandUser,
+  expandVars: pathExpandVars,
+  /** Return normalized absolutized version of pathname */
+  absPath(p) {
+    if (pathIsAbs(p)) {
+      return pathNormPath(p);
+    }
+    return pathNormPath(p);
+  },
+  /** Return canonical path, eliminating symlinks (stub - just normalizes) */
+  realPath(p) {
+    return path.absPath(p);
+  },
+  /* v8 ignore start -- browser stubs @preserve */
+  /** Test if path exists (stub - always returns false in browser) */
+  exists(_p) {
+    return false;
+  },
+  /** Test if path is a file (stub - always returns false in browser) */
+  isFile(_p) {
+    return false;
+  },
+  /** Test if path is a directory (stub - always returns false in browser) */
+  isDir(_p) {
+    return false;
+  },
+  /** Test if path is a symbolic link (stub - always returns false in browser) */
+  isLink(_p) {
+    return false;
+  },
+  /** Return size of file (stub - returns 0 in browser) */
+  getSize(_p) {
+    return 0;
+  },
+  /** Return modification time (stub - returns 0 in browser) */
+  getMtime(_p) {
+    return 0;
+  },
+  /** Return access time (stub - returns 0 in browser) */
+  getAtime(_p) {
+    return 0;
+  },
+  /** Return creation time (stub - returns 0 in browser) */
+  getCtime(_p) {
+    return 0;
+  }
+  /* v8 ignore stop */
+};
+function listDir(_p = ".") {
+  return [];
+}
+function mkdir(_p, _mode = 511) {
+}
+function makeDirs(_p, _mode = 511, _existOk = false) {
+}
+function remove(_p) {
+}
+var unlink = remove;
+function rmdir(_p) {
+}
+function removeDirs(_p) {
+}
+function rename(_src, _dst) {
+}
+function renames(_src, _dst) {
+}
+function replace(_src, _dst) {
+}
+function* walk(_top, _options) {
+}
+function stat(_p) {
+  return { st_mode: 0, st_size: 0, st_mtime: 0, st_atime: 0, st_ctime: 0 };
+}
+
+export {
+  path,
+  listDir,
+  mkdir,
+  makeDirs,
+  remove,
+  unlink,
+  rmdir,
+  removeDirs,
+  rename,
+  renames,
+  replace,
+  walk,
+  stat,
+  os_browser_exports
+};
+/* v8 ignore start -- browser stubs for filesystem operations @preserve */

package/dist/{chunk-QURVRHY2.js → chunk-D35YI363.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/functools.ts
 var functools_exports = {};
@@ -54,14 +54,15 @@ function lruCache(func, maxsize = 128) {
   let misses = 0;
   const cached = ((...args) => {
     const key = JSON.stringify(args);
-    if (cache2.has(key)) {
+    const entry = cache2.get(key);
+    if (entry !== void 0) {
       hits++;
       const idx = order.indexOf(key);
       if (idx > -1) {
         order.splice(idx, 1);
         order.push(key);
       }
-      return cache2.get(key);
+      return entry.value;
     }
     misses++;
     const result = func(...args);
@@ -71,7 +72,7 @@ function lruCache(func, maxsize = 128) {
         cache2.delete(oldest);
       }
     }
-    cache2.set(key, result);
+    cache2.set(key, { value: result });
     order.push(key);
     return result;
   });
@@ -93,11 +94,12 @@ function cache(func) {
   const cacheMap = /* @__PURE__ */ new Map();
   return ((...args) => {
     const key = JSON.stringify(args);
-    if (cacheMap.has(key)) {
-      return cacheMap.get(key);
+    const entry = cacheMap.get(key);
+    if (entry !== void 0) {
+      return entry.value;
     }
     const result = func(...args);
-    cacheMap.set(key, result);
+    cacheMap.set(key, { value: result });
     return result;
   });
 }
@@ -135,8 +137,9 @@ function wraps(wrapped) {
   };
 }
 function attrGetter(...attrs) {
-  if (attrs.length === 1) {
-    const attr = attrs[0];
+  const [firstAttr] = attrs;
+  if (attrs.length === 1 && firstAttr !== void 0) {
+    const attr = firstAttr;
     const parts = attr.split(".");
     return (obj) => {
       let result = obj;
@@ -158,8 +161,9 @@ function attrGetter(...attrs) {
   };
 }
 function itemGetter(...items) {
-  if (items.length === 1) {
-    const item = items[0];
+  const [firstItem] = items;
+  if (items.length === 1 && firstItem !== void 0) {
+    const item = firstItem;
     return (obj) => {
       if (Array.isArray(obj) && typeof item === "number") {
         return obj[item];
@@ -248,4 +252,3 @@ export {
   functools_exports
 };
 /* v8 ignore start -- complex utility rarely used directly @preserve */
-//# sourceMappingURL=chunk-QURVRHY2.js.map

package/dist/{chunk-RSBRI27Z.js → chunk-ETBW6XNR.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/re.ts
 var re_exports = {};
@@ -144,8 +144,8 @@ var Match = class {
   }
   /** Return iterator of all groups */
   *[Symbol.iterator]() {
-    for (let i = 0; i < this._match.length; i++) {
-      yield this._match[i];
+    for (const match2 of this._match) {
+      yield match2;
     }
   }
   toString() {
@@ -420,4 +420,3 @@ export {
   purge,
   re_exports
 };
-//# sourceMappingURL=chunk-RSBRI27Z.js.map

package/dist/chunk-FCJ7E4OE.js

@@ -0,0 +1,250 @@
+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
+};