pythonlib 1.0.2 → 2.0.1

package/dist/chunk-OZRS5PC4.js

@@ -0,0 +1,312 @@
+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.node.ts
+var os_node_exports = {};
+__export(os_node_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
+});
+import {
+  access,
+  lstat,
+  mkdir as fsMkdir,
+  readdir,
+  realpath,
+  rename as fsRename,
+  rmdir as fsRmdir,
+  stat as fsStat,
+  unlink as fsUnlink
+} from "fs/promises";
+import { join } from "path";
+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(pathJoin(getCwd(), p));
+  },
+  /** Return canonical path, eliminating symlinks */
+  async realPath(p) {
+    try {
+      return await realpath(p);
+    } catch {
+      return path.absPath(p);
+    }
+  },
+  /** Test if path exists */
+  async exists(p) {
+    try {
+      await access(p);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  /** Test if path is a file */
+  async isFile(p) {
+    try {
+      return (await fsStat(p)).isFile();
+    } catch {
+      return false;
+    }
+  },
+  /** Test if path is a directory */
+  async isDir(p) {
+    try {
+      return (await fsStat(p)).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  /** Test if path is a symbolic link */
+  async isLink(p) {
+    try {
+      return (await lstat(p)).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  },
+  /** Return size of file */
+  async getSize(p) {
+    try {
+      return (await fsStat(p)).size;
+    } catch {
+      return 0;
+    }
+  },
+  /** Return modification time as Unix timestamp */
+  async getMtime(p) {
+    try {
+      return Math.floor((await fsStat(p)).mtimeMs / 1e3);
+    } catch {
+      return 0;
+    }
+  },
+  /** Return access time as Unix timestamp */
+  async getAtime(p) {
+    try {
+      return Math.floor((await fsStat(p)).atimeMs / 1e3);
+    } catch {
+      return 0;
+    }
+  },
+  /** Return creation time as Unix timestamp */
+  async getCtime(p) {
+    try {
+      return Math.floor((await fsStat(p)).ctimeMs / 1e3);
+    } catch {
+      return 0;
+    }
+  }
+};
+async function listDir(p = ".") {
+  try {
+    return await readdir(p);
+  } catch {
+    return [];
+  }
+}
+async function mkdir(p, mode = 511) {
+  await fsMkdir(p, { mode });
+}
+async function makeDirs(p, mode = 511, existOk = false) {
+  try {
+    await fsMkdir(p, { recursive: true, mode });
+  } catch (e) {
+    if (!existOk || !(e instanceof Error && "code" in e && e.code === "EEXIST")) {
+      throw e;
+    }
+  }
+}
+async function remove(p) {
+  await fsUnlink(p);
+}
+var unlink = remove;
+async function rmdir(p) {
+  await fsRmdir(p);
+}
+async function removeDirs(p) {
+  await fsRmdir(p);
+  let parent = pathDirname(p);
+  while (parent && parent !== p) {
+    try {
+      await fsRmdir(parent);
+      p = parent;
+      parent = pathDirname(p);
+    } catch {
+      break;
+    }
+  }
+}
+async function rename(src, dst) {
+  await fsRename(src, dst);
+}
+async function renames(src, dst) {
+  const dstDir = pathDirname(dst);
+  if (dstDir) {
+    await makeDirs(dstDir, 511, true);
+  }
+  await rename(src, dst);
+  const srcDir = pathDirname(src);
+  if (srcDir) {
+    try {
+      await removeDirs(srcDir);
+    } catch {
+    }
+  }
+}
+async function replace(src, dst) {
+  await fsRename(src, dst);
+}
+async function* walk(top, options) {
+  const topdown = options?.topdown ?? true;
+  const followlinks = options?.followlinks ?? false;
+  const dirs = [];
+  const files = [];
+  try {
+    const entries = await readdir(top, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        dirs.push(entry.name);
+      } else if (entry.isFile()) {
+        files.push(entry.name);
+      } else if (entry.isSymbolicLink()) {
+        if (followlinks) {
+          try {
+            const realPath = await realpath(join(top, entry.name));
+            if ((await fsStat(realPath)).isDirectory()) {
+              dirs.push(entry.name);
+            } else {
+              files.push(entry.name);
+            }
+          } catch {
+            files.push(entry.name);
+          }
+        } else {
+          files.push(entry.name);
+        }
+      }
+    }
+  } catch {
+    return;
+  }
+  if (topdown) {
+    yield [top, dirs, files];
+  }
+  for (const dir of dirs) {
+    const dirPath = join(top, dir);
+    yield* walk(dirPath, options);
+  }
+  if (!topdown) {
+    yield [top, dirs, files];
+  }
+}
+async function stat(p) {
+  try {
+    const s = await fsStat(p);
+    return {
+      st_mode: s.mode,
+      st_size: s.size,
+      st_mtime: Math.floor(s.mtimeMs / 1e3),
+      st_atime: Math.floor(s.atimeMs / 1e3),
+      st_ctime: Math.floor(s.ctimeMs / 1e3)
+    };
+  } catch {
+    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_node_exports
+};

package/dist/chunk-PVK4F3ME.js

@@ -0,0 +1,194 @@
+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
+};
+/* v8 ignore next -- browser fallback @preserve */
+/* v8 ignore next 5 -- always returns empty array @preserve */
+/* v8 ignore next 2 -- browser fallback @preserve */
+/* v8 ignore next 3 -- always runs in Node.js @preserve */
+/* v8 ignore start -- Set branch tested via getSizeOf(new Set()) @preserve */
+/* v8 ignore next -- unreachable after typeof checks @preserve */

package/dist/{chunk-56DGFWIJ.js → chunk-QKJBQKPY.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/math.ts
 var math_exports = {};
@@ -258,4 +258,3 @@ export {
   prod,
   math_exports
 };
-//# sourceMappingURL=chunk-56DGFWIJ.js.map

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
+};