pythonlib 1.0.2 → 2.0.1

package/dist/chunk-IANXD4D4.js

@@ -0,0 +1,250 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/urllib.ts
+var urllib_exports = {};
+__export(urllib_exports, {
+  parse: () => parse,
+  parseQs: () => parseQs,
+  parseQsl: () => parseQsl,
+  quote: () => quote,
+  quotePlus: () => quotePlus,
+  splithost: () => splithost,
+  splitpasswd: () => splitpasswd,
+  splitport: () => splitport,
+  splittype: () => splittype,
+  splituser: () => splituser,
+  unquote: () => unquote,
+  unquotePlus: () => unquotePlus,
+  urlencode: () => urlencode,
+  urljoin: () => urljoin,
+  urlparse: () => urlparse,
+  urlunparse: () => urlunparse
+});
+function urlparse(urlstring, scheme = "", allowFragments = true) {
+  try {
+    let url;
+    if (!urlstring.includes("://")) {
+      url = new URL((scheme || "http") + "://" + urlstring);
+    } else {
+      url = new URL(urlstring);
+    }
+    let fragment = "";
+    if (allowFragments && url.hash) {
+      fragment = url.hash.slice(1);
+    }
+    let netloc = url.host;
+    if (url.username) {
+      const userinfo = url.password ? `${url.username}:${url.password}` : url.username;
+      netloc = `${userinfo}@${url.host}`;
+    }
+    return {
+      scheme: url.protocol.slice(0, -1),
+      netloc,
+      path: url.pathname,
+      params: "",
+      query: url.search ? url.search.slice(1) : "",
+      fragment,
+      username: url.username || null,
+      password: url.password || null,
+      hostname: url.hostname || null,
+      port: url.port ? parseInt(url.port, 10) : null
+    };
+  } catch {
+    return {
+      scheme,
+      netloc: "",
+      path: urlstring,
+      params: "",
+      query: "",
+      fragment: "",
+      username: null,
+      password: null,
+      hostname: null,
+      port: null
+    };
+  }
+}
+function urlunparse(components) {
+  let scheme, netloc, path, params, query, fragment;
+  if (Array.isArray(components)) {
+    ;
+    [scheme, netloc, path, params, query, fragment] = components;
+  } else {
+    ;
+    ({ scheme, netloc, path, params, query, fragment } = components);
+  }
+  let url = "";
+  if (scheme) {
+    url += scheme + "://";
+  }
+  if (netloc) {
+    url += netloc;
+  }
+  url += path;
+  if (params) {
+    url += ";" + params;
+  }
+  if (query) {
+    url += "?" + query;
+  }
+  if (fragment) {
+    url += "#" + fragment;
+  }
+  return url;
+}
+function urljoin(base, url, allowFragments = true) {
+  if (!base) return url;
+  if (!url) return base;
+  try {
+    const result = new URL(url, base);
+    if (!allowFragments) {
+      result.hash = "";
+    }
+    return result.href;
+  } catch {
+    return url;
+  }
+}
+function urlencode(query, doseq = false) {
+  const params = new URLSearchParams();
+  if (Array.isArray(query)) {
+    for (const [key, value] of query) {
+      params.append(key, value);
+    }
+  } else {
+    for (const [key, value] of Object.entries(query)) {
+      if (Array.isArray(value) && doseq) {
+        for (const v of value) {
+          params.append(key, v);
+        }
+      } else if (Array.isArray(value)) {
+        params.append(key, value.join(","));
+      } else {
+        params.append(key, value);
+      }
+    }
+  }
+  return params.toString();
+}
+function parseQs(qs, keepBlankValues = false) {
+  const result = {};
+  const params = new URLSearchParams(qs);
+  for (const [key, value] of params) {
+    if (!keepBlankValues && value === "") {
+      continue;
+    }
+    if (!(key in result)) {
+      result[key] = [];
+    }
+    result[key]?.push(value);
+  }
+  return result;
+}
+function parseQsl(qs, keepBlankValues = false) {
+  const result = [];
+  const params = new URLSearchParams(qs);
+  for (const [key, value] of params) {
+    if (!keepBlankValues && value === "") {
+      continue;
+    }
+    result.push([key, value]);
+  }
+  return result;
+}
+function quote(s, safe = "") {
+  let result = encodeURIComponent(s);
+  for (const char of safe) {
+    result = result.replace(new RegExp(encodeURIComponent(char), "g"), char);
+  }
+  return result;
+}
+function quotePlus(s, safe = "") {
+  return quote(s, safe).replace(/%20/g, "+");
+}
+function unquote(s) {
+  return decodeURIComponent(s);
+}
+function unquotePlus(s) {
+  return decodeURIComponent(s.replace(/\+/g, " "));
+}
+function splittype(url) {
+  const match = /^([a-zA-Z][a-zA-Z0-9+.-]*):(.*)$/.exec(url);
+  if (match) {
+    return [match[1] ?? "", match[2] ?? ""];
+  }
+  return ["", url];
+}
+function splithost(url) {
+  const match = /^\/\/([^/?#]*)(.*)$/.exec(url);
+  if (match) {
+    return [match[1] ?? null, match[2] ?? ""];
+  }
+  return [null, url];
+}
+function splituser(host) {
+  const match = /^([^@]*)@(.*)$/.exec(host);
+  if (match) {
+    return [match[1] ?? null, match[2] ?? ""];
+  }
+  return [null, host];
+}
+function splitpasswd(user) {
+  const match = /^([^:]*):(.*)$/.exec(user);
+  if (match) {
+    return [match[1] ?? "", match[2] ?? null];
+  }
+  return [user, null];
+}
+function splitport(host) {
+  if (host.startsWith("[")) {
+    const match2 = /^\[([^\]]+)\]:?(\d*)$/.exec(host);
+    if (match2) {
+      return [match2[1] ?? "", match2[2] ?? null];
+    }
+    return [host, null];
+  }
+  const match = /^(.*):(\d+)$/.exec(host);
+  if (match) {
+    return [match[1] ?? "", match[2] ?? null];
+  }
+  return [host, null];
+}
+var parse = {
+  urlparse,
+  urlunparse,
+  urljoin,
+  urlencode,
+  parseQs,
+  parseQsl,
+  quote,
+  quotePlus,
+  unquote,
+  unquotePlus,
+  splittype,
+  splithost,
+  splituser,
+  splitpasswd,
+  splitport
+};
+
+export {
+  urlparse,
+  urlunparse,
+  urljoin,
+  urlencode,
+  parseQs,
+  parseQsl,
+  quote,
+  quotePlus,
+  unquote,
+  unquotePlus,
+  splittype,
+  splithost,
+  splituser,
+  splitpasswd,
+  splitport,
+  parse,
+  urllib_exports
+};

package/dist/{chunk-G6PUQTVZ.js → chunk-JAUU3HMH.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/json.ts
 var json_exports = {};
@@ -106,4 +106,3 @@ export {
 };
 /* v8 ignore start -- error handling for invalid JSON @preserve */
 /* v8 ignore start -- advanced custom parser hooks @preserve */
-//# sourceMappingURL=chunk-G6PUQTVZ.js.map

package/dist/chunk-JVTQM7CI.js

@@ -0,0 +1,195 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/shutil.node.ts
+var shutil_node_exports = {};
+__export(shutil_node_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
+});
+import { constants } from "fs";
+import {
+  access,
+  chmod,
+  copyFile,
+  lstat,
+  mkdir,
+  readdir,
+  readlink,
+  rename as fsRename,
+  rm,
+  stat,
+  statfs,
+  symlink,
+  unlink,
+  utimes
+} from "fs/promises";
+import { basename, delimiter, join } from "path";
+async function copy(src, dst) {
+  let finalDst = dst;
+  try {
+    if ((await stat(dst)).isDirectory()) {
+      finalDst = join(dst, basename(src));
+    }
+  } catch {
+  }
+  await copyFile(src, finalDst);
+  return finalDst;
+}
+async function copy2(src, dst) {
+  const finalDst = await copy(src, dst);
+  const srcStat = await stat(src);
+  await utimes(finalDst, srcStat.atime, srcStat.mtime);
+  return finalDst;
+}
+async function copytree(src, dst, options) {
+  const copyFunc = options?.copyFunction ?? (async (s, d) => {
+    await copy2(s, d);
+  });
+  const ignoreFunc = options?.ignore;
+  await mkdir(dst, { recursive: options?.dirsExistOk });
+  const entries = await readdir(src);
+  const ignoredNames = ignoreFunc ? ignoreFunc(src, entries) : [];
+  for (const entry of entries) {
+    if (ignoredNames.includes(entry)) {
+      continue;
+    }
+    const srcPath = join(src, entry);
+    const dstPath = join(dst, entry);
+    const entryStat = await lstat(srcPath);
+    if (entryStat.isDirectory()) {
+      await copytree(srcPath, dstPath, options);
+    } else if (entryStat.isSymbolicLink() && options?.symlinkss) {
+      const target = await readlink(srcPath);
+      await symlink(target, dstPath);
+    } else {
+      await copyFunc(srcPath, dstPath);
+    }
+  }
+  return dst;
+}
+async function move(src, dst) {
+  let finalDst = dst;
+  try {
+    if ((await stat(dst)).isDirectory()) {
+      finalDst = join(dst, basename(src));
+    }
+  } catch {
+  }
+  try {
+    await fsRename(src, finalDst);
+  } catch {
+    const srcStat = await stat(src);
+    if (srcStat.isDirectory()) {
+      await copytree(src, finalDst);
+      await rmtree(src);
+    } else {
+      await copy2(src, finalDst);
+      await unlink(src);
+    }
+  }
+  return finalDst;
+}
+async function rmtree(path, options) {
+  try {
+    await rm(path, { recursive: true, force: options?.ignoreErrors ?? false });
+  } catch (err) {
+    if (!options?.ignoreErrors) {
+      throw err;
+    }
+  }
+}
+async function which(cmd, path) {
+  const pathDirs = (path ?? process.env.PATH ?? "").split(delimiter);
+  const extensions = process.platform === "win32" ? [".exe", ".cmd", ".bat", ".com", ""] : [""];
+  for (const dir of pathDirs) {
+    for (const ext of extensions) {
+      const fullPath = join(dir, cmd + ext);
+      try {
+        await access(fullPath, constants.X_OK);
+        return fullPath;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+async function diskUsage(path) {
+  if (process.platform === "win32") {
+    throw new Error("diskUsage is not implemented on Windows");
+  }
+  const fsStat = await statfs(path);
+  const total = fsStat.blocks * fsStat.bsize;
+  const free = fsStat.bavail * fsStat.bsize;
+  return { total, used: total - free, free };
+}
+function getTerminalSize() {
+  const columns = process.stdout.columns ?? 80;
+  const lines = process.stdout.rows ?? 24;
+  return { columns, lines };
+}
+async function copymode(src, dst) {
+  const srcStat = await stat(src);
+  await chmod(dst, srcStat.mode);
+}
+async function copystat(src, dst) {
+  const srcStat = await stat(src);
+  await chmod(dst, srcStat.mode);
+  await utimes(dst, srcStat.atime, srcStat.mtime);
+}
+async function copyfile(src, dst) {
+  await copyFile(src, dst);
+}
+function copyfileobj(fsrc, fdst, length) {
+  if (length === void 0) {
+    ;
+    fsrc.pipe(fdst);
+  } else {
+    let remaining = length;
+    fsrc.on("data", (chunk) => {
+      if (remaining <= 0) return;
+      const toWrite = chunk.subarray(0, Math.min(chunk.length, remaining));
+      fdst.write(toWrite);
+      remaining -= toWrite.length;
+    });
+  }
+}
+function makeArchive(_baseName, _format, _rootDir) {
+  throw new Error("makeArchive is not implemented (requires external tools)");
+}
+function unpackArchive(_filename, _extractDir) {
+  throw new Error("unpackArchive is not implemented (requires external tools)");
+}
+
+export {
+  copy,
+  copy2,
+  copytree,
+  move,
+  rmtree,
+  which,
+  diskUsage,
+  getTerminalSize,
+  copymode,
+  copystat,
+  copyfile,
+  copyfileobj,
+  makeArchive,
+  unpackArchive,
+  shutil_node_exports
+};
+/* v8 ignore next 3 -- Windows-specific check @preserve */
+/* v8 ignore start -- stream operations are tested via integration @preserve */