pythonlib 1.0.2 → 2.0.0

package/dist/chunk-LHPQS75Z.js

@@ -0,0 +1,192 @@
+// src/os.shared.ts
+var environ = typeof process !== "undefined" ? process.env : {};
+function getenv(key, defaultValue) {
+  return environ[key] ?? defaultValue;
+}
+var sep = typeof process !== "undefined" && process.platform === "win32" ? "\\" : "/";
+var altSep = typeof process !== "undefined" && process.platform === "win32" ? "/" : null;
+var pathSep = typeof process !== "undefined" && process.platform === "win32" ? ";" : ":";
+var lineSep = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
+var curDir = ".";
+var parDir = "..";
+var extSep = ".";
+var name = typeof process !== "undefined" && process.platform === "win32" ? "nt" : "posix";
+function pathJoin(...paths) {
+  if (paths.length === 0) return "";
+  if (paths.length === 1) return paths[0] ?? "";
+  let result = paths[0] ?? "";
+  for (let i = 1; i < paths.length; i++) {
+    const p = paths[i] ?? "";
+    if (p.startsWith("/") || p.length > 1 && p[1] === ":") {
+      result = p;
+    } else if (result === "" || result.endsWith("/") || result.endsWith("\\")) {
+      result += p;
+    } else {
+      result += sep + p;
+    }
+  }
+  return result;
+}
+function pathBasename(p, suffix) {
+  let s = p.replace(/[/\\]+$/, "");
+  const idx = Math.max(s.lastIndexOf("/"), s.lastIndexOf("\\"));
+  s = idx >= 0 ? s.slice(idx + 1) : s;
+  if (suffix && s.endsWith(suffix)) {
+    s = s.slice(0, -suffix.length);
+  }
+  return s;
+}
+function pathDirname(p) {
+  const s = p.replace(/[/\\]+$/, "");
+  const idx = Math.max(s.lastIndexOf("/"), s.lastIndexOf("\\"));
+  if (idx < 0) return "";
+  if (idx === 0) return s[0] ?? "";
+  return s.slice(0, idx);
+}
+function pathSplitFn(p) {
+  return [pathDirname(p), pathBasename(p)];
+}
+function pathSplitExt(p) {
+  const base = pathBasename(p);
+  const dotIdx = base.lastIndexOf(".");
+  if (dotIdx <= 0) {
+    return [p, ""];
+  }
+  const dir = pathDirname(p);
+  const root = base.slice(0, dotIdx);
+  const ext = base.slice(dotIdx);
+  return [dir ? pathJoin(dir, root) : root, ext];
+}
+function pathExtName(p) {
+  return pathSplitExt(p)[1];
+}
+function pathIsAbs(p) {
+  if (p.startsWith("/")) return true;
+  if (p.length >= 3 && p[1] === ":" && (p[2] === "/" || p[2] === "\\")) return true;
+  if (p.startsWith("\\\\")) return true;
+  return false;
+}
+function pathNormPath(p) {
+  if (!p) return ".";
+  let prefix = "";
+  if (p.length >= 2 && p[1] === ":") {
+    prefix = p.slice(0, 2);
+    p = p.slice(2);
+  }
+  const isWin = p.includes("\\");
+  p = p.replace(/\\/g, "/");
+  const isAbsolute = p.startsWith("/");
+  const parts = p.split("/").filter((part) => part && part !== ".");
+  const result = [];
+  for (const part of parts) {
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        result.pop();
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let normalized = result.join(isWin ? "\\" : "/");
+  if (isAbsolute) {
+    normalized = (isWin ? "\\" : "/") + normalized;
+  }
+  normalized = prefix + normalized;
+  return normalized || ".";
+}
+function pathRelPath(p, start = ".") {
+  const pParts = pathNormPath(p).split(/[/\\]/).filter(Boolean);
+  const startParts = pathNormPath(start).split(/[/\\]/).filter(Boolean);
+  let commonLen = 0;
+  const minLen = Math.min(pParts.length, startParts.length);
+  for (let i = 0; i < minLen; i++) {
+    if (pParts[i] === startParts[i]) {
+      commonLen++;
+    } else {
+      break;
+    }
+  }
+  const upCount = startParts.length - commonLen;
+  const result = [...Array(upCount).fill(".."), ...pParts.slice(commonLen)];
+  return result.join(sep) || ".";
+}
+function pathCommonPath(paths) {
+  if (paths.length === 0) {
+    throw new Error("commonPath() arg is an empty sequence");
+  }
+  const splitPaths = paths.map((p) => pathNormPath(p).split(/[/\\]/));
+  const first = splitPaths[0];
+  if (!first) {
+    throw new Error("commonPath() arg is an empty sequence");
+  }
+  let commonLen = first.length;
+  for (const parts of splitPaths.slice(1)) {
+    commonLen = Math.min(commonLen, parts.length);
+    for (let j = 0; j < commonLen; j++) {
+      if (parts[j] !== first[j]) {
+        commonLen = j;
+        break;
+      }
+    }
+  }
+  return first.slice(0, commonLen).join(sep) || sep;
+}
+function pathExpandUser(p) {
+  if (!p.startsWith("~")) return p;
+  const home = typeof process !== "undefined" ? process.env.HOME ?? process.env.USERPROFILE : void 0;
+  if (!home) return p;
+  if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
+    return home + p.slice(1);
+  }
+  return p;
+}
+function pathExpandVars(p) {
+  return p.replace(/\$(\w+)|\$\{(\w+)\}/g, (_, v1, v2) => {
+    const key = v1 || v2;
+    return environ[key] ?? "";
+  });
+}
+function getCwd() {
+  if (typeof process !== "undefined") {
+    return process.cwd();
+  }
+  return "/";
+}
+function getCwdb() {
+  return getCwd();
+}
+function chdir(p) {
+  if (typeof process !== "undefined") {
+    process.chdir(p);
+  }
+}
+
+export {
+  environ,
+  getenv,
+  sep,
+  altSep,
+  pathSep,
+  lineSep,
+  curDir,
+  parDir,
+  extSep,
+  name,
+  pathJoin,
+  pathBasename,
+  pathDirname,
+  pathSplitFn,
+  pathSplitExt,
+  pathExtName,
+  pathIsAbs,
+  pathNormPath,
+  pathRelPath,
+  pathCommonPath,
+  pathExpandUser,
+  pathExpandVars,
+  getCwd,
+  getCwdb,
+  chdir
+};

package/dist/{chunk-OSX7QZAW.js → chunk-LK2L2TFG.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/datetime.ts
 var datetime_exports = {};
@@ -120,7 +120,7 @@ var date = class _date {
   }
   static fromIsoFormat(dateString) {
     const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateString);
-    if (!match || !match[1] || !match[2] || !match[3]) {
+    if (!match?.[1] || !match[2] || !match[3]) {
       throw new Error(`Invalid isoFormat string: '${dateString}'`);
     }
     return new _date(parseInt(match[1]), parseInt(match[2]), parseInt(match[3]));
@@ -231,7 +231,7 @@ var time = class _time {
   }
   static fromIsoFormat(timeString) {
     const match = /^(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?$/.exec(timeString);
-    if (!match || !match[1] || !match[2] || !match[3]) {
+    if (!match?.[1] || !match[2] || !match[3]) {
       throw new Error(`Invalid isoFormat string: '${timeString}'`);
     }
     const microsecond = match[4] ? parseInt(match[4].padEnd(6, "0").slice(0, 6)) : 0;
@@ -352,9 +352,9 @@ var datetime = class _datetime extends date {
   }
   static fromIsoFormat(s) {
     const match = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?$/.exec(s);
-    if (!match || !match[1] || !match[2] || !match[3] || !match[4] || !match[5] || !match[6]) {
+    if (!match?.[1] || !match[2] || !match[3] || !match[4] || !match[5] || !match[6]) {
       const dateMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
-      if (dateMatch && dateMatch[1] && dateMatch[2] && dateMatch[3]) {
+      if (dateMatch?.[1] && dateMatch[2] && dateMatch[3]) {
         return new _datetime(parseInt(dateMatch[1]), parseInt(dateMatch[2]), parseInt(dateMatch[3]));
       }
       throw new Error(`Invalid isoFormat string: '${s}'`);
@@ -678,4 +678,3 @@ export {
   MAXYEAR,
   datetime_exports
 };
-//# sourceMappingURL=chunk-OSX7QZAW.js.map

package/dist/chunk-LLZFLQS6.js

@@ -0,0 +1,280 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/subprocess.ts
+var subprocess_exports = {};
+__export(subprocess_exports, {
+  CalledProcessError: () => CalledProcessError,
+  DEVNULL: () => DEVNULL,
+  PIPE: () => PIPE,
+  Popen: () => Popen,
+  STDOUT: () => STDOUT,
+  TimeoutExpired: () => TimeoutExpired,
+  call: () => call,
+  checkCall: () => checkCall,
+  checkOutput: () => checkOutput,
+  getoutput: () => getoutput,
+  getstatusoutput: () => getstatusoutput,
+  run: () => run
+});
+import * as childProcess from "child_process";
+var PIPE = "pipe";
+var STDOUT = "stdout";
+var DEVNULL = "devnull";
+var CalledProcessError = class extends Error {
+  returncode;
+  cmd;
+  stdout;
+  stderr;
+  constructor(returncode, cmd, stdout = null, stderr = null) {
+    super(`Command '${cmd.join(" ")}' returned non-zero exit status ${String(returncode)}`);
+    this.name = "CalledProcessError";
+    this.returncode = returncode;
+    this.cmd = cmd;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+var TimeoutExpired = class extends Error {
+  cmd;
+  timeout;
+  stdout;
+  stderr;
+  constructor(cmd, timeout, stdout = null, stderr = null) {
+    super(`Command '${cmd.join(" ")}' timed out after ${String(timeout)} milliseconds`);
+    this.name = "TimeoutExpired";
+    this.cmd = cmd;
+    this.timeout = timeout;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+function run(args, options) {
+  const encoding = options?.encoding ?? "utf-8";
+  const text = options?.text ?? true;
+  let command;
+  let cmdArgs;
+  if (typeof args === "string") {
+    command = args;
+    cmdArgs = [args];
+  } else {
+    command = args[0] ?? "";
+    cmdArgs = args.slice(1);
+  }
+  const spawnOptions = {
+    cwd: options?.cwd,
+    env: options?.env ? { ...process.env, ...options.env } : void 0,
+    input: options?.input,
+    timeout: options?.timeout,
+    shell: options?.shell,
+    encoding: text ? encoding : "buffer",
+    stdio: [
+      options?.input !== void 0 ? "pipe" : "inherit",
+      options?.stdout === PIPE ? "pipe" : options?.stdout === DEVNULL ? "ignore" : "inherit",
+      options?.stderr === PIPE ? "pipe" : options?.stderr === STDOUT ? "pipe" : options?.stderr === DEVNULL ? "ignore" : "inherit"
+    ]
+  };
+  let result;
+  if (typeof args === "string" || options?.shell) {
+    result = childProcess.spawnSync(typeof args === "string" ? args : args.join(" "), [], {
+      ...spawnOptions,
+      shell: true
+    });
+  } else {
+    result = childProcess.spawnSync(command, cmdArgs, spawnOptions);
+  }
+  if (result.error && result.error.code === "ETIMEDOUT") {
+    throw new TimeoutExpired(
+      typeof args === "string" ? [args] : args,
+      options?.timeout ?? 0,
+      result.stdout ? result.stdout.toString() : null,
+      result.stderr ? result.stderr.toString() : null
+    );
+  }
+  const stdout = result.stdout ? text ? result.stdout.toString() : result.stdout.toString() : null;
+  const stderr = result.stderr ? text ? result.stderr.toString() : result.stderr.toString() : null;
+  const returncode = result.status ?? -1;
+  if (options?.check && returncode !== 0) {
+    throw new CalledProcessError(
+      returncode,
+      typeof args === "string" ? [args] : args,
+      stdout,
+      stderr
+    );
+  }
+  return {
+    args: typeof args === "string" ? [args] : args,
+    returncode,
+    stdout,
+    stderr
+  };
+}
+function call(args, options) {
+  const result = run(args, options);
+  return result.returncode;
+}
+function checkCall(args, options) {
+  const result = run(args, { ...options, check: true });
+  return result.returncode;
+}
+function checkOutput(args, options) {
+  const result = run(args, { ...options, stdout: PIPE, check: true });
+  return result.stdout ?? "";
+}
+function getoutput(cmd) {
+  try {
+    const result = run(cmd, { shell: true, stdout: PIPE, stderr: DEVNULL });
+    return result.stdout?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+function getstatusoutput(cmd) {
+  const result = run(cmd, { shell: true, stdout: PIPE, stderr: STDOUT });
+  return [result.returncode, result.stdout?.trim() ?? ""];
+}
+var Popen = class {
+  args;
+  process;
+  _returncode = null;
+  _stdout = null;
+  _stderr = null;
+  constructor(args, options) {
+    this.args = typeof args === "string" ? [args] : args;
+    const command = typeof args === "string" ? args : args[0] ?? "";
+    const cmdArgs = typeof args === "string" ? [] : args.slice(1);
+    const spawnOptions = {
+      cwd: options?.cwd,
+      env: options?.env ? { ...process.env, ...options.env } : void 0,
+      shell: options?.shell,
+      stdio: [
+        options?.input !== void 0 ? "pipe" : "inherit",
+        options?.stdout === PIPE ? "pipe" : options?.stdout === DEVNULL ? "ignore" : "inherit",
+        options?.stderr === PIPE ? "pipe" : options?.stderr === STDOUT ? "pipe" : options?.stderr === DEVNULL ? "ignore" : "inherit"
+      ]
+    };
+    if (typeof args === "string" || options?.shell) {
+      this.process = childProcess.spawn(typeof args === "string" ? args : args.join(" "), [], {
+        ...spawnOptions,
+        shell: true
+      });
+    } else {
+      this.process = childProcess.spawn(command, cmdArgs, spawnOptions);
+    }
+    if (options?.input !== void 0 && this.process.stdin) {
+      this.process.stdin.write(options.input);
+      this.process.stdin.end();
+    }
+    if (this.process.stdout) {
+      let data = "";
+      this.process.stdout.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      this.process.stdout.on("end", () => {
+        this._stdout = data;
+      });
+    }
+    if (this.process.stderr) {
+      let data = "";
+      this.process.stderr.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      this.process.stderr.on("end", () => {
+        this._stderr = data;
+      });
+    }
+    this.process.on("exit", (code) => {
+      this._returncode = code ?? -1;
+    });
+  }
+  /**
+   * Wait for the process to complete.
+   */
+  wait() {
+    return new Promise((resolve) => {
+      if (this._returncode !== null) {
+        resolve(this._returncode);
+      } else {
+        this.process.on("exit", (code) => {
+          resolve(code ?? -1);
+        });
+      }
+    });
+  }
+  /**
+   * Get the exit code (or null if still running).
+   */
+  poll() {
+    return this._returncode;
+  }
+  /**
+   * Communicate with the process and return stdout/stderr.
+   */
+  async communicate(input) {
+    if (input !== void 0 && this.process.stdin) {
+      this.process.stdin.write(input);
+      this.process.stdin.end();
+    }
+    await this.wait();
+    return [this._stdout, this._stderr];
+  }
+  /**
+   * Send a signal to the process.
+   */
+  send_signal(signal) {
+    return this.process.kill(signal);
+  }
+  /**
+   * Terminate the process.
+   */
+  terminate() {
+    return this.process.kill("SIGTERM");
+  }
+  /**
+   * Kill the process.
+   */
+  kill() {
+    return this.process.kill("SIGKILL");
+  }
+  /**
+   * The process ID.
+   */
+  get pid() {
+    return this.process.pid;
+  }
+  /**
+   * The exit code (or null if still running).
+   */
+  get returncode() {
+    return this._returncode;
+  }
+  /**
+   * The captured stdout.
+   */
+  get stdout() {
+    return this._stdout;
+  }
+  /**
+   * The captured stderr.
+   */
+  get stderr() {
+    return this._stderr;
+  }
+};
+
+export {
+  PIPE,
+  STDOUT,
+  DEVNULL,
+  CalledProcessError,
+  TimeoutExpired,
+  run,
+  call,
+  checkCall,
+  checkOutput,
+  getoutput,
+  getstatusoutput,
+  Popen,
+  subprocess_exports
+};

package/dist/chunk-LTXTS7RP.js

@@ -0,0 +1,154 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/copy.ts
+var copy_exports = {};
+__export(copy_exports, {
+  copy: () => copy,
+  deepcopy: () => deepcopy
+});
+function copy(x) {
+  if (x === null || x === void 0) {
+    return x;
+  }
+  const type = typeof x;
+  if (type === "number" || type === "string" || type === "boolean" || type === "bigint" || type === "symbol") {
+    return x;
+  }
+  if (x instanceof Date) {
+    return new Date(x.getTime());
+  }
+  if (x instanceof RegExp) {
+    return new RegExp(x.source, x.flags);
+  }
+  if (Array.isArray(x)) {
+    return [...x];
+  }
+  if (x instanceof Map) {
+    return new Map(x);
+  }
+  if (x instanceof Set) {
+    return new Set(x);
+  }
+  if (ArrayBuffer.isView(x) && !(x instanceof DataView)) {
+    const TypedArrayConstructor = x.constructor;
+    const typedArray = x;
+    return new TypedArrayConstructor(typedArray.buffer.slice(0));
+  }
+  if (x instanceof DataView) {
+    return new DataView(x.buffer.slice(0), x.byteOffset, x.byteLength);
+  }
+  if (x instanceof ArrayBuffer) {
+    return x.slice(0);
+  }
+  if (type === "object") {
+    const proto = Object.getPrototypeOf(x);
+    if (proto === Object.prototype || proto === null) {
+      return { ...x };
+    }
+    const result = Object.create(proto);
+    Object.assign(result, x);
+    return result;
+  }
+  return x;
+}
+function deepcopy(x, memo) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(x);
+    } catch {
+    }
+  }
+  if (x === null || x === void 0) {
+    return x;
+  }
+  const type = typeof x;
+  if (type === "number" || type === "string" || type === "boolean" || type === "bigint" || type === "symbol") {
+    return x;
+  }
+  memo ??= /* @__PURE__ */ new Map();
+  if (memo.has(x)) {
+    return memo.get(x);
+  }
+  if (x instanceof Date) {
+    const result = new Date(x.getTime());
+    memo.set(x, result);
+    return result;
+  }
+  if (x instanceof RegExp) {
+    const result = new RegExp(x.source, x.flags);
+    memo.set(x, result);
+    return result;
+  }
+  if (Array.isArray(x)) {
+    const result = [];
+    memo.set(x, result);
+    for (const item of x) {
+      result.push(deepcopy(item, memo));
+    }
+    return result;
+  }
+  if (x instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    memo.set(x, result);
+    for (const [key, value] of x) {
+      result.set(deepcopy(key, memo), deepcopy(value, memo));
+    }
+    return result;
+  }
+  if (x instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    memo.set(x, result);
+    for (const item of x) {
+      result.add(deepcopy(item, memo));
+    }
+    return result;
+  }
+  if (ArrayBuffer.isView(x) && !(x instanceof DataView)) {
+    const TypedArrayConstructor = x.constructor;
+    const typedArray = x;
+    const result = new TypedArrayConstructor(typedArray.buffer.slice(0));
+    memo.set(x, result);
+    return result;
+  }
+  if (x instanceof DataView) {
+    const result = new DataView(x.buffer.slice(0), x.byteOffset, x.byteLength);
+    memo.set(x, result);
+    return result;
+  }
+  if (x instanceof ArrayBuffer) {
+    const result = x.slice(0);
+    memo.set(x, result);
+    return result;
+  }
+  if (type === "function") {
+    return x;
+  }
+  if (type === "object") {
+    const proto = Object.getPrototypeOf(x);
+    const result = Object.create(proto);
+    memo.set(x, result);
+    for (const key of Object.keys(x)) {
+      result[key] = deepcopy(x[key], memo);
+    }
+    for (const sym of Object.getOwnPropertySymbols(x)) {
+      const descriptor = Object.getOwnPropertyDescriptor(x, sym);
+      if (descriptor?.enumerable) {
+        ;
+        result[sym] = deepcopy(
+          x[sym],
+          memo
+        );
+      }
+    }
+    return result;
+  }
+  return x;
+}
+
+export {
+  copy,
+  deepcopy,
+  copy_exports
+};

package/dist/{chunk-CEZSBJJV.js → chunk-LWYBTWBZ.js}

@@ -52,7 +52,7 @@ var Template = class {
     const regex = /\$(\w+)|\$\{(\w+)\}/g;
     let match;
     while ((match = regex.exec(this.template)) !== null) {
-      const name = match[1] || match[2];
+      const name = match[1] ?? match[2];
       if (name && !identifiers.includes(name)) {
         identifiers.push(name);
       }
@@ -267,7 +267,7 @@ var string = {
    */
   zFill(s, width) {
     if (s.length >= width) return s;
-    const sign = s[0] === "-" || s[0] === "+" ? s[0] : "";
+    const sign = s.startsWith("-") || s.startsWith("+") ? s.charAt(0) : "";
     const digits2 = sign ? s.slice(1) : s;
     return sign + digits2.padStart(width - sign.length, "0");
   },
@@ -373,4 +373,3 @@ export {
   capWords,
   string
 };
-//# sourceMappingURL=chunk-CEZSBJJV.js.map

package/dist/{chunk-TAYRRHJ3.js → chunk-MFKIEN7N.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/collections.ts
 var collections_exports = {};
@@ -214,4 +214,3 @@ export {
   collections_exports
 };
 /* v8 ignore next -- getter properties on Map fail with proxy receiver @preserve */
-//# sourceMappingURL=chunk-TAYRRHJ3.js.map

package/dist/{chunk-PZ5AY32C.js → chunk-MLKGABMK.js}

@@ -7,4 +7,3 @@ var __export = (target, all) => {
 export {
   __export
 };
-//# sourceMappingURL=chunk-PZ5AY32C.js.map