pythonlib 1.0.1 → 2.0.0

package/dist/chunk-HSTC277I.js

@@ -0,0 +1,255 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/pathlib.browser.ts
+var pathlib_browser_exports = {};
+__export(pathlib_browser_exports, {
+  Path: () => Path,
+  PosixPath: () => PosixPath,
+  PurePath: () => PurePath,
+  PurePosixPath: () => PurePosixPath,
+  PureWindowsPath: () => PureWindowsPath,
+  WindowsPath: () => WindowsPath
+});
+var SEP = "/";
+function basename(p) {
+  const normalized = p.replace(/\/+$/, "");
+  const idx = normalized.lastIndexOf(SEP);
+  return idx === -1 ? normalized : normalized.slice(idx + 1);
+}
+function dirname(p) {
+  const normalized = p.replace(/\/+$/, "");
+  const idx = normalized.lastIndexOf(SEP);
+  if (idx === -1) return "";
+  if (idx === 0) return SEP;
+  return normalized.slice(0, idx);
+}
+function extname(p) {
+  const base = basename(p);
+  const dotIdx = base.lastIndexOf(".");
+  if (dotIdx <= 0) return "";
+  return base.slice(dotIdx);
+}
+function join(...parts) {
+  return parts.filter(Boolean).join(SEP).replace(/\/+/g, "/");
+}
+function isAbsolute(p) {
+  return p.startsWith(SEP);
+}
+function normalize(p) {
+  if (!p) return ".";
+  const isAbs = isAbsolute(p);
+  const parts = p.split(SEP).filter(Boolean);
+  const result = [];
+  for (const part of parts) {
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        result.pop();
+      } else if (!isAbs) {
+        result.push("..");
+      }
+    } else if (part !== ".") {
+      result.push(part);
+    }
+  }
+  const normalized = result.join(SEP);
+  if (isAbs) return SEP + normalized;
+  return normalized || ".";
+}
+var Path = class _Path {
+  _path;
+  constructor(...pathSegments) {
+    if (pathSegments.length === 0) {
+      this._path = ".";
+    } else {
+      this._path = join(...pathSegments);
+    }
+  }
+  static of(...pathSegments) {
+    return new _Path(...pathSegments);
+  }
+  get name() {
+    return basename(this._path);
+  }
+  get stem() {
+    const base = basename(this._path);
+    const ext = extname(base);
+    return ext ? base.slice(0, -ext.length) : base;
+  }
+  get suffix() {
+    return extname(this._path);
+  }
+  get suffixes() {
+    const name = this.name;
+    const suffixes = [];
+    let remaining = name;
+    let ext = extname(remaining);
+    while (ext) {
+      suffixes.unshift(ext);
+      remaining = remaining.slice(0, -ext.length);
+      ext = extname(remaining);
+    }
+    return suffixes;
+  }
+  get parent() {
+    const parentPath = dirname(this._path);
+    return new _Path(parentPath || ".");
+  }
+  get parents() {
+    const parents = [];
+    let current = this.parent;
+    while (current._path !== "." && current._path !== SEP) {
+      parents.push(current);
+      current = current.parent;
+    }
+    if (current._path === SEP) {
+      parents.push(current);
+    }
+    return parents;
+  }
+  get parts() {
+    const parts = [];
+    if (this._path.startsWith(SEP)) {
+      parts.push(SEP);
+    }
+    parts.push(...this._path.split(SEP).filter(Boolean));
+    return parts;
+  }
+  get anchor() {
+    return this._path.startsWith(SEP) ? SEP : "";
+  }
+  get root() {
+    return this.anchor;
+  }
+  isAbsolute() {
+    return isAbsolute(this._path);
+  }
+  isRelativeTo(other) {
+    const otherPath = other instanceof _Path ? other._path : other;
+    const normalizedThis = normalize(this._path);
+    const normalizedOther = normalize(otherPath);
+    return normalizedThis.startsWith(normalizedOther + SEP) || normalizedThis === normalizedOther;
+  }
+  joinpath(...pathSegments) {
+    const segments = pathSegments.map((p) => p instanceof _Path ? p._path : p);
+    return new _Path(this._path, ...segments);
+  }
+  div(other) {
+    return this.joinpath(other);
+  }
+  withName(name) {
+    return new _Path(dirname(this._path), name);
+  }
+  withStem(stem) {
+    return new _Path(dirname(this._path), stem + this.suffix);
+  }
+  withSuffix(suffix) {
+    return new _Path(dirname(this._path), this.stem + suffix);
+  }
+  toString() {
+    return this._path;
+  }
+  valueOf() {
+    return this._path;
+  }
+  [Symbol.toPrimitive](_hint) {
+    return this._path;
+  }
+  /* v8 ignore start -- browser stubs for filesystem operations @preserve */
+  /* eslint-disable @typescript-eslint/require-await */
+  async exists() {
+    return false;
+  }
+  async isFile() {
+    return false;
+  }
+  async isDir() {
+    return false;
+  }
+  async isSymlink() {
+    return false;
+  }
+  async stat() {
+    throw new Error("Path.stat is not supported in browser environment");
+  }
+  async lstat() {
+    throw new Error("Path.lstat is not supported in browser environment");
+  }
+  async readText(_encoding) {
+    throw new Error("Path.readText is not supported in browser environment");
+  }
+  async writeText(_content, _encoding) {
+    throw new Error("Path.writeText is not supported in browser environment");
+  }
+  async readBytes() {
+    throw new Error("Path.readBytes is not supported in browser environment");
+  }
+  async writeBytes(_content) {
+    throw new Error("Path.writeBytes is not supported in browser environment");
+  }
+  async mkdir(_options) {
+    throw new Error("Path.mkdir is not supported in browser environment");
+  }
+  async rmdir() {
+    throw new Error("Path.rmdir is not supported in browser environment");
+  }
+  async unlink() {
+    throw new Error("Path.unlink is not supported in browser environment");
+  }
+  async rename(_target) {
+    throw new Error("Path.rename is not supported in browser environment");
+  }
+  async replace(_target) {
+    throw new Error("Path.replace is not supported in browser environment");
+  }
+  resolve() {
+    return new _Path(normalize(this._path));
+  }
+  absolute() {
+    if (this.isAbsolute()) {
+      return this.resolve();
+    }
+    return new _Path(SEP + this._path).resolve();
+  }
+  async readlink() {
+    throw new Error("Path.readlink is not supported in browser environment");
+  }
+  async symlinkTo(_target) {
+    throw new Error("Path.symlinkTo is not supported in browser environment");
+  }
+  async linkTo(_target) {
+    throw new Error("Path.linkTo is not supported in browser environment");
+  }
+  async chmod(_mode) {
+    throw new Error("Path.chmod is not supported in browser environment");
+  }
+  async touch(_options) {
+    throw new Error("Path.touch is not supported in browser environment");
+  }
+  async iterdir() {
+    throw new Error("Path.iterdir is not supported in browser environment");
+  }
+  async glob(_pattern) {
+    return [];
+  }
+  async rglob(_pattern) {
+    return [];
+  }
+  /* v8 ignore stop */
+};
+var PurePath = Path;
+var PurePosixPath = Path;
+var PureWindowsPath = Path;
+var PosixPath = Path;
+var WindowsPath = Path;
+
+export {
+  Path,
+  PurePath,
+  PurePosixPath,
+  PureWindowsPath,
+  PosixPath,
+  WindowsPath,
+  pathlib_browser_exports
+};

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-4KYJT3DR.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-4KYJT3DR.js.map