pythonlib 1.0.1 → 2.0.0

package/dist/chunk-RB6BYCIQ.js

@@ -0,0 +1,141 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/glob.node.ts
+var glob_node_exports = {};
+__export(glob_node_exports, {
+  escape: () => escape,
+  glob: () => glob,
+  hasMagic: () => hasMagic,
+  iglob: () => iglob,
+  rglob: () => rglob
+});
+import { readdir, stat } from "fs/promises";
+import { isAbsolute, join, relative } from "path";
+async function glob(pattern, options) {
+  const rootDir = options?.rootDir ?? ".";
+  const recursive = options?.recursive ?? pattern.includes("**");
+  const includeHidden = options?.includeHidden ?? false;
+  const results = [];
+  const regex = patternToRegex(pattern);
+  const isAbsolutePath = isAbsolute(pattern);
+  const baseDir = isAbsolutePath ? "/" : rootDir;
+  const parts = pattern.split(/[\\/]/);
+  let fixedPrefix = "";
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i] ?? "";
+    if (part.includes("*") || part.includes("?") || part.includes("[")) {
+      break;
+    }
+    if (fixedPrefix) {
+      fixedPrefix = join(fixedPrefix, part);
+    } else if (part === "" && i === 0 && isAbsolutePath) {
+      fixedPrefix = "/";
+    } else {
+      fixedPrefix = part;
+    }
+  }
+  const searchDir = fixedPrefix ? isAbsolutePath ? fixedPrefix : join(rootDir, fixedPrefix) : baseDir;
+  const walk = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!includeHidden && entry.startsWith(".")) {
+        continue;
+      }
+      const fullPath = join(dir, entry);
+      const relativePath = isAbsolutePath ? fullPath : relative(rootDir, fullPath);
+      if (regex.test(relativePath)) {
+        results.push(relativePath);
+      }
+      if (recursive) {
+        try {
+          if ((await stat(fullPath)).isDirectory()) {
+            await walk(fullPath, depth + 1);
+          }
+        } catch {
+        }
+      }
+    }
+  };
+  await walk(searchDir, 0);
+  return results.sort();
+}
+async function* iglob(pattern, options) {
+  const results = await glob(pattern, options);
+  for (const result of results) {
+    yield result;
+  }
+}
+function escape(pathname) {
+  return pathname.replace(/([*?[])/g, "[$1]");
+}
+function hasMagic(pattern) {
+  return /[*?[\]]/.test(pattern);
+}
+function patternToRegex(pattern) {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const char = pattern[i];
+    if (char === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/" || pattern[i + 2] === "\\") {
+          regex += "(?:.*/)?";
+          i += 3;
+        } else {
+          regex += ".*";
+          i += 2;
+        }
+      } else {
+        regex += "[^/\\\\]*";
+        i++;
+      }
+    } else if (char === "?") {
+      regex += "[^/\\\\]";
+      i++;
+    } else if (char === "[") {
+      let j = i + 1;
+      let charClass = "[";
+      if (pattern[j] === "!" || pattern[j] === "^") {
+        charClass += "^";
+        j++;
+      }
+      while (j < pattern.length && pattern[j] !== "]") {
+        charClass += pattern[j] ?? "";
+        j++;
+      }
+      charClass += "]";
+      regex += charClass;
+      i = j + 1;
+    } else if (char === "/" || char === "\\") {
+      regex += "[/\\\\]";
+      i++;
+    } else if (".+^${}()|\\".includes(char ?? "")) {
+      regex += "\\" + (char ?? "");
+      i++;
+    } else {
+      regex += char ?? "";
+      i++;
+    }
+  }
+  return new RegExp("^" + regex + "$");
+}
+async function rglob(pattern, rootDir = ".") {
+  const fullPattern = pattern.startsWith("**") ? pattern : "**/" + pattern;
+  return glob(fullPattern, { recursive: true, rootDir });
+}
+
+export {
+  glob,
+  iglob,
+  escape,
+  hasMagic,
+  rglob,
+  glob_node_exports
+};

package/dist/chunk-U4X5DEIP.js

@@ -0,0 +1,188 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/sys.ts
+var sys_exports = {};
+__export(sys_exports, {
+  apiVersion: () => apiVersion,
+  argv: () => argv,
+  byteorder: () => byteorder,
+  executable: () => executable,
+  exit: () => exit,
+  floatInfo: () => floatInfo,
+  getDefaultEncoding: () => getDefaultEncoding,
+  getFilesystemEncoding: () => getFilesystemEncoding,
+  getRecursionLimit: () => getRecursionLimit,
+  getRefCount: () => getRefCount,
+  getSizeOf: () => getSizeOf,
+  hashInfo: () => hashInfo,
+  intInfo: () => intInfo,
+  maxsize: () => maxsize,
+  path: () => path,
+  platform: () => platform,
+  prefix: () => prefix,
+  setRecursionLimit: () => setRecursionLimit,
+  stderr: () => stderr,
+  stdin: () => stdin,
+  stdout: () => stdout,
+  version: () => version,
+  versionInfo: () => versionInfo
+});
+var argv = typeof process !== "undefined" ? process.argv.slice(2) : [];
+var platform = typeof process !== "undefined" ? process.platform : "unknown";
+var version = "3.11.0 (pythonlib TypeScript implementation)";
+var versionInfo = {
+  major: 3,
+  minor: 11,
+  micro: 0,
+  releaselevel: "final",
+  serial: 0,
+  // Make it tuple-like (indexable)
+  0: 3,
+  1: 11,
+  2: 0,
+  3: "final",
+  4: 0,
+  length: 5,
+  [Symbol.iterator]: function* () {
+    yield this.major;
+    yield this.minor;
+    yield this.micro;
+    yield this.releaselevel;
+    yield this.serial;
+  }
+};
+var executable = typeof process !== "undefined" ? process.execPath : "";
+var path = (() => {
+  if (typeof process === "undefined") return [];
+  return [];
+})();
+var maxsize = Number.MAX_SAFE_INTEGER;
+var stdin = typeof process !== "undefined" ? process.stdin : null;
+var stdout = typeof process !== "undefined" ? process.stdout : null;
+var stderr = typeof process !== "undefined" ? process.stderr : null;
+function exit(code) {
+  if (typeof process !== "undefined") {
+    process.exit(code ?? 0);
+  }
+  throw new Error(`SystemExit: ${String(code ?? 0)}`);
+}
+function getRecursionLimit() {
+  return 1e3;
+}
+function setRecursionLimit(limit) {
+  void limit;
+}
+function getSizeOf(obj) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function estimate(value) {
+    if (value === null || value === void 0) return 0;
+    const type = typeof value;
+    if (type === "boolean") return 4;
+    if (type === "number") return 8;
+    if (type === "string") return value.length * 2;
+    if (type === "bigint") return value.toString().length * 8 / 10;
+    if (type === "object" || type === "function") {
+      if (seen.has(value)) return 0;
+      seen.add(value);
+      if (Array.isArray(value)) {
+        return value.reduce((sum, item) => sum + estimate(item), 64);
+      }
+      if (value instanceof Map) {
+        let size2 = 64;
+        for (const [k, v] of value) {
+          size2 += estimate(k) + estimate(v);
+        }
+        return size2;
+      }
+      if (value instanceof Set) {
+        let size2 = 64;
+        for (const item of value) {
+          size2 += estimate(item);
+        }
+        return size2;
+      }
+      let size = 64;
+      for (const key in value) {
+        size += key.length * 2 + estimate(value[key]);
+      }
+      return size;
+    }
+    return 0;
+  }
+  return estimate(obj);
+}
+function getRefCount(obj) {
+  void obj;
+  return 1;
+}
+function getDefaultEncoding() {
+  return "utf-8";
+}
+function getFilesystemEncoding() {
+  return "utf-8";
+}
+var apiVersion = 0;
+var prefix = typeof process !== "undefined" ? process.execPath.replace(/\/bin\/node$/, "") : "";
+var byteorder = (() => {
+  const buffer = new ArrayBuffer(2);
+  new DataView(buffer).setInt16(0, 256, true);
+  return new Int16Array(buffer)[0] === 256 ? "little" : "big";
+})();
+var floatInfo = {
+  max: Number.MAX_VALUE,
+  maxExp: 1024,
+  max10Exp: 308,
+  min: Number.MIN_VALUE,
+  minExp: -1021,
+  min10Exp: -307,
+  dig: 15,
+  mant_dig: 53,
+  epsilon: Number.EPSILON,
+  radix: 2,
+  rounds: 1
+};
+var intInfo = {
+  bitsPerDigit: 30,
+  sizeofDigit: 4,
+  defaultMaxStrDigits: 4300,
+  strDigitsCheckThreshold: 640
+};
+var hashInfo = {
+  width: 64,
+  modulus: 2n ** 61n - 1n,
+  inf: 314159,
+  nan: 0,
+  imag: 1000003,
+  algorithm: "siphash24",
+  hashBits: 64,
+  seedBits: 128
+};
+
+export {
+  argv,
+  platform,
+  version,
+  versionInfo,
+  executable,
+  path,
+  maxsize,
+  stdin,
+  stdout,
+  stderr,
+  exit,
+  getRecursionLimit,
+  setRecursionLimit,
+  getSizeOf,
+  getRefCount,
+  getDefaultEncoding,
+  getFilesystemEncoding,
+  apiVersion,
+  prefix,
+  byteorder,
+  floatInfo,
+  intInfo,
+  hashInfo,
+  sys_exports
+};

package/dist/chunk-UGZ5OY5Z.js

@@ -0,0 +1,165 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/tempfile.node.ts
+var tempfile_node_exports = {};
+__export(tempfile_node_exports, {
+  NamedTemporaryFile: () => NamedTemporaryFile,
+  TemporaryDirectory: () => TemporaryDirectory,
+  gettempdir: () => gettempdir,
+  gettempprefix: () => gettempprefix,
+  mkdtemp: () => mkdtemp,
+  mkstemp: () => mkstemp,
+  mktemp: () => mktemp,
+  namedTemporaryFile: () => namedTemporaryFile,
+  temporaryDirectory: () => temporaryDirectory
+});
+import { mkdir, open, rm, unlink } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+function gettempdir() {
+  return tmpdir();
+}
+function mktemp(suffix = "", prefix = "tmp", dir) {
+  const tempDir = dir ?? gettempdir();
+  const randomPart = randomBytes(8).toString("hex");
+  return join(tempDir, `${prefix}${randomPart}${suffix}`);
+}
+async function mkstemp(suffix = "", prefix = "tmp", dir, _text = false) {
+  const tempDir = dir ?? gettempdir();
+  const randomPart = randomBytes(8).toString("hex");
+  const path = join(tempDir, `${prefix}${randomPart}${suffix}`);
+  const handle = await open(path, "w+", 384);
+  return [handle, path];
+}
+async function mkdtemp(suffix = "", prefix = "tmp", dir) {
+  const tempDir = dir ?? gettempdir();
+  const randomPart = randomBytes(8).toString("hex");
+  const path = join(tempDir, `${prefix}${randomPart}${suffix}`);
+  await mkdir(path, { mode: 448 });
+  return path;
+}
+var NamedTemporaryFile = class _NamedTemporaryFile {
+  /** The file handle */
+  handle;
+  /** The file path */
+  name;
+  /** Whether to delete the file on close */
+  deleteOnClose;
+  _closed = false;
+  constructor(handle, name, deleteOnClose) {
+    this.handle = handle;
+    this.name = name;
+    this.deleteOnClose = deleteOnClose;
+  }
+  /**
+   * Create a new NamedTemporaryFile.
+   */
+  static async create(options) {
+    const suffix = options?.suffix ?? "";
+    const prefix = options?.prefix ?? "tmp";
+    const dir = options?.dir;
+    const deleteOnClose = options?.delete ?? true;
+    const [handle, path] = await mkstemp(suffix, prefix, dir);
+    return new _NamedTemporaryFile(handle, path, deleteOnClose);
+  }
+  /**
+   * Write data to the file.
+   */
+  async write(data) {
+    const result = await this.handle.write(typeof data === "string" ? Buffer.from(data) : data);
+    return result.bytesWritten;
+  }
+  /**
+   * Read data from the file.
+   */
+  async read(size) {
+    const fileSize = size ?? (await this.handle.stat()).size;
+    const buffer = Buffer.alloc(fileSize);
+    await this.handle.read(buffer, 0, buffer.length, 0);
+    return buffer;
+  }
+  /**
+   * Seek to a position in the file.
+   */
+  seek(_offset, _whence = 0) {
+  }
+  /**
+   * Flush the file buffer.
+   */
+  async flush() {
+    await this.handle.sync();
+  }
+  /**
+   * Close the file.
+   */
+  async close() {
+    if (!this._closed) {
+      await this.handle.close();
+      if (this.deleteOnClose) {
+        try {
+          await unlink(this.name);
+        } catch {
+        }
+      }
+      this._closed = true;
+    }
+  }
+  /**
+   * Check if the file is closed.
+   */
+  get closed() {
+    return this._closed;
+  }
+};
+var TemporaryDirectory = class _TemporaryDirectory {
+  /** The directory path */
+  name;
+  _cleaned = false;
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Create a new TemporaryDirectory.
+   */
+  static async create(options) {
+    const name = await mkdtemp(options?.suffix, options?.prefix, options?.dir);
+    return new _TemporaryDirectory(name);
+  }
+  /**
+   * Remove the temporary directory and its contents.
+   */
+  async cleanup() {
+    if (!this._cleaned) {
+      try {
+        await rm(this.name, { recursive: true, force: true });
+      } catch {
+      }
+      this._cleaned = true;
+    }
+  }
+};
+async function namedTemporaryFile(options) {
+  return NamedTemporaryFile.create(options);
+}
+async function temporaryDirectory(options) {
+  return TemporaryDirectory.create(options);
+}
+function gettempprefix() {
+  return "tmp";
+}
+
+export {
+  gettempdir,
+  mktemp,
+  mkstemp,
+  mkdtemp,
+  NamedTemporaryFile,
+  TemporaryDirectory,
+  namedTemporaryFile,
+  temporaryDirectory,
+  gettempprefix,
+  tempfile_node_exports
+};

package/dist/chunk-WTZSAITC.js

@@ -0,0 +1,82 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/shutil.browser.ts
+var shutil_browser_exports = {};
+__export(shutil_browser_exports, {
+  copy: () => copy,
+  copy2: () => copy2,
+  copyFile: () => copyFile,
+  copyFileObj: () => copyFileObj,
+  copyMode: () => copyMode,
+  copyStat: () => copyStat,
+  copytree: () => copytree,
+  diskUsage: () => diskUsage,
+  getTerminalSize: () => getTerminalSize,
+  makeArchive: () => makeArchive,
+  move: () => move,
+  rmtree: () => rmtree,
+  unpackArchive: () => unpackArchive,
+  which: () => which
+});
+async function copy(_src, _dst) {
+  throw new Error("shutil.copy is not supported in browser environment");
+}
+async function copy2(_src, _dst) {
+  throw new Error("shutil.copy2 is not supported in browser environment");
+}
+async function copytree(_src, _dst, _options) {
+  throw new Error("shutil.copytree is not supported in browser environment");
+}
+async function move(_src, _dst) {
+  throw new Error("shutil.move is not supported in browser environment");
+}
+async function rmtree(_path, _ignoreErrors = false) {
+  throw new Error("shutil.rmtree is not supported in browser environment");
+}
+async function which(_cmd, _mode, _path) {
+  return null;
+}
+async function diskUsage(_path) {
+  throw new Error("shutil.diskUsage is not supported in browser environment");
+}
+async function copyMode(_src, _dst) {
+}
+async function copyStat(_src, _dst) {
+}
+async function copyFile(_src, _dst) {
+  throw new Error("shutil.copyFile is not supported in browser environment");
+}
+async function copyFileObj(_fsrc, _fdst, _length) {
+  throw new Error("shutil.copyFileObj is not supported in browser environment");
+}
+function getTerminalSize(fallback) {
+  const [columns, lines] = fallback ?? [80, 24];
+  return { columns, lines };
+}
+function makeArchive(_baseName, _format, _rootDir) {
+  throw new Error("makeArchive is not supported in browser environment");
+}
+function unpackArchive(_filename, _extractDir) {
+  throw new Error("unpackArchive is not supported in browser environment");
+}
+
+export {
+  copy,
+  copy2,
+  copytree,
+  move,
+  rmtree,
+  which,
+  diskUsage,
+  copyMode,
+  copyStat,
+  copyFile,
+  copyFileObj,
+  getTerminalSize,
+  makeArchive,
+  unpackArchive,
+  shutil_browser_exports
+};
+/* v8 ignore start -- browser stubs @preserve */

package/dist/{collections-CJur5Wg-.d.ts → collections-BthXtkEp.d.ts}

@@ -1,9 +1,12 @@
 /**
  * Python collections module for TypeScript
  *
- * Provides specialized container datatypes.
+ * Provides specialized container datatypes including Counter for counting
+ * hashable objects, defaultdict for dictionaries with default values, and
+ * deque for double-ended queues.
  *
  * @see {@link https://docs.python.org/3/library/collections.html | Python collections documentation}
+ * @module
  */
 /**
  * Counter: a dict subclass for counting hashable objects
@@ -23,6 +26,7 @@ declare class Counter<T> extends Map<T, number> {
     /**
      * List the n most common elements and their counts
      * If n is undefined, list all elements from most common to least
+     * Uses ES2023 Array.prototype.toSorted() for immutable sorting
      */
     mostCommon(n?: number): [T, number][];
     /**

package/dist/collections.d.ts

@@ -1 +1 @@
-export { C as Counter, d as defaultdict, a as deque } from './collections-CJur5Wg-.js';
+export { C as Counter, d as defaultdict, a as deque } from './collections-BthXtkEp.js';

package/dist/collections.js

@@ -2,11 +2,10 @@ import {
   Counter,
   defaultdict,
   deque
-} from "./chunk-6ZAJ37MR.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-MFKIEN7N.js";
+import "./chunk-MLKGABMK.js";
 export {
   Counter,
   defaultdict,
   deque
 };
-//# sourceMappingURL=collections.js.map

package/dist/copy-6ZaZ__ge.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Python copy module for TypeScript
+ *
+ * Provides shallow and deep copy operations.
+ *
+ * @see {@link https://docs.python.org/3/library/copy.html | Python copy documentation}
+ * @module
+ */
+/**
+ * Create a shallow copy of an object.
+ *
+ * For primitive types, returns the value as-is.
+ * For arrays, returns a new array with the same elements.
+ * For objects, returns a new object with the same properties.
+ * For Maps and Sets, returns new instances with the same entries.
+ *
+ * @param x - The object to copy
+ * @returns A shallow copy of x
+ *
+ * @example
+ * ```typescript
+ * const original = [1, [2, 3], 4]
+ * const copied = copy(original)
+ * copied[0] = 99
+ * console.log(original[0]) // 1 (unchanged)
+ * copied[1][0] = 99
+ * console.log(original[1][0]) // 99 (nested array is shared)
+ * ```
+ */
+declare function copy<T>(x: T): T;
+/**
+ * Create a deep copy of an object.
+ *
+ * Creates a complete independent copy of the object and all nested objects.
+ * Uses structuredClone when available, with a fallback for older environments.
+ *
+ * Note: Functions cannot be deep copied and will be shared between copies.
+ *
+ * @param x - The object to deep copy
+ * @param memo - Internal map for circular reference handling (optional)
+ * @returns A deep copy of x
+ *
+ * @example
+ * ```typescript
+ * const original = { a: 1, b: { c: 2 } }
+ * const copied = deepcopy(original)
+ * copied.b.c = 99
+ * console.log(original.b.c) // 2 (unchanged)
+ * ```
+ */
+declare function deepcopy<T>(x: T, memo?: Map<unknown, unknown>): T;
+
+declare const copyModule_copy: typeof copy;
+declare const copyModule_deepcopy: typeof deepcopy;
+declare namespace copyModule {
+  export { copyModule_copy as copy, copyModule_deepcopy as deepcopy };
+}
+
+export { copy as a, copyModule as c, deepcopy as d };

package/dist/copy.d.ts

@@ -0,0 +1 @@
+export { a as copy, d as deepcopy } from './copy-6ZaZ__ge.js';

package/dist/copy.js

@@ -0,0 +1,9 @@
+import {
+  copy,
+  deepcopy
+} from "./chunk-LTXTS7RP.js";
+import "./chunk-MLKGABMK.js";
+export {
+  copy,
+  deepcopy
+};

package/dist/{datetime-Bpce8gG2.d.ts → datetime-BM_IjhTq.d.ts}

@@ -1,9 +1,11 @@
 /**
  * Python datetime module for TypeScript
  *
- * Provides date and time handling matching Python's datetime module.
+ * Provides date and time handling matching Python's datetime module,
+ * including date, time, datetime, and timedelta classes.
  *
  * @see {@link https://docs.python.org/3/library/datetime.html | Python datetime documentation}
+ * @module
  */
 declare class timedelta {
     readonly days: number;

package/dist/datetime.d.ts

@@ -1 +1 @@
-export { f as MAXYEAR, M as MINYEAR, a as date, c as datetime, s as strftime, e as strptime, b as time, t as timedelta } from './datetime-Bpce8gG2.js';
+export { f as MAXYEAR, M as MINYEAR, a as date, c as datetime, s as strftime, e as strptime, b as time, t as timedelta } from './datetime-BM_IjhTq.js';