pythonlib 1.0.2 → 2.0.1

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-HTCQ4OO5.js

@@ -0,0 +1,238 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/base64.ts
+var base64_exports = {};
+__export(base64_exports, {
+  a85decode: () => a85decode,
+  a85encode: () => a85encode,
+  b16decode: () => b16decode,
+  b16encode: () => b16encode,
+  b32decode: () => b32decode,
+  b32encode: () => b32encode,
+  b64decode: () => b64decode,
+  b64encode: () => b64encode,
+  b85decode: () => b85decode,
+  b85encode: () => b85encode,
+  decodeString: () => decodeString,
+  encodeString: () => encodeString,
+  standardB64decode: () => standardB64decode,
+  standardB64encode: () => standardB64encode,
+  urlsafeB64decode: () => urlsafeB64decode,
+  urlsafeB64encode: () => urlsafeB64encode
+});
+function uint8ArrayToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function b64encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  const base64String = uint8ArrayToBase64(bytes);
+  return new TextEncoder().encode(base64String);
+}
+function b64decode(s) {
+  const base64String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = base64String.replace(/\s/g, "");
+  return base64ToUint8Array(cleaned);
+}
+function standardB64encode(s) {
+  return b64encode(s);
+}
+function standardB64decode(s) {
+  return b64decode(s);
+}
+function urlsafeB64encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  const base64String = uint8ArrayToBase64(bytes);
+  const urlSafe = base64String.replace(/\+/g, "-").replace(/\//g, "_");
+  return new TextEncoder().encode(urlSafe);
+}
+function urlsafeB64decode(s) {
+  const base64String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = base64String.replace(/\s/g, "").replace(/-/g, "+").replace(/_/g, "/");
+  const padding = (4 - cleaned.length % 4) % 4;
+  const padded = cleaned + "=".repeat(padding);
+  return base64ToUint8Array(padded);
+}
+function b16encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0").toUpperCase();
+  }
+  return new TextEncoder().encode(hex);
+}
+function b16decode(s) {
+  const hexString = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = hexString.replace(/\s/g, "");
+  if (cleaned.length % 2 !== 0) {
+    throw new Error("Non-hexadecimal digit found");
+  }
+  const bytes = new Uint8Array(cleaned.length / 2);
+  for (let i = 0; i < cleaned.length; i += 2) {
+    const byte = parseInt(cleaned.substring(i, i + 2), 16);
+    if (isNaN(byte)) {
+      throw new Error("Non-hexadecimal digit found");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+function b32encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  let result = "";
+  let bits = 0;
+  let value = 0;
+  for (const byte of bytes) {
+    value = value << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      const idx = value >> bits & 31;
+      result += alphabet[idx] ?? "";
+    }
+  }
+  if (bits > 0) {
+    const idx = value << 5 - bits & 31;
+    result += alphabet[idx] ?? "";
+  }
+  while (result.length % 8 !== 0) {
+    result += "=";
+  }
+  return new TextEncoder().encode(result);
+}
+function b32decode(s) {
+  const base32String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  const cleaned = base32String.replace(/=+$/, "").replace(/\s/g, "").toUpperCase();
+  let bits = 0;
+  let value = 0;
+  const result = [];
+  for (const char of cleaned) {
+    const idx = alphabet.indexOf(char);
+    if (idx === -1) {
+      throw new Error("Invalid Base32 character");
+    }
+    value = value << 5 | idx;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      result.push(value >> bits & 255);
+    }
+  }
+  return new Uint8Array(result);
+}
+function a85encode(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  let result = "";
+  for (let i = 0; i < bytes.length; i += 4) {
+    const chunk = bytes.slice(i, i + 4);
+    let value = 0;
+    for (const byte of chunk) {
+      value = value * 256 + byte;
+    }
+    for (let j = chunk.length; j < 4; j++) {
+      value = value * 256;
+    }
+    if (value === 0 && chunk.length === 4) {
+      result += "z";
+    } else {
+      const chars = [];
+      for (let j = 0; j < 5; j++) {
+        chars.unshift(String.fromCharCode(value % 85 + 33));
+        value = Math.floor(value / 85);
+      }
+      const outputLen = chunk.length + 1;
+      result += chars.slice(0, outputLen).join("");
+    }
+  }
+  return new TextEncoder().encode(result);
+}
+function a85decode(s) {
+  const ascii85String = typeof s === "string" ? s : new TextDecoder().decode(s);
+  const cleaned = ascii85String.replace(/\s/g, "");
+  const result = [];
+  let i = 0;
+  while (i < cleaned.length) {
+    if (cleaned[i] === "z") {
+      result.push(0, 0, 0, 0);
+      i++;
+    } else {
+      let chunk = cleaned.slice(i, i + 5);
+      const chunkLen = chunk.length;
+      while (chunk.length < 5) {
+        chunk += "u";
+      }
+      let value = 0;
+      for (let j = 0; j < 5; j++) {
+        const charCode = chunk.charCodeAt(j) - 33;
+        if (charCode < 0 || charCode > 84) {
+          throw new Error("Invalid Ascii85 character");
+        }
+        value = value * 85 + charCode;
+      }
+      const bytes = [];
+      for (let j = 0; j < 4; j++) {
+        bytes.unshift(value & 255);
+        value = Math.floor(value / 256);
+      }
+      const outputLen = chunkLen - 1;
+      result.push(...bytes.slice(0, outputLen));
+      i += chunkLen;
+    }
+  }
+  return new Uint8Array(result);
+}
+function b85encode(s) {
+  return a85encode(s);
+}
+function b85decode(s) {
+  return a85decode(s);
+}
+function encodeString(s) {
+  const bytes = typeof s === "string" ? new TextEncoder().encode(s) : s;
+  return uint8ArrayToBase64(bytes);
+}
+function decodeString(s) {
+  return base64ToUint8Array(s);
+}
+
+export {
+  b64encode,
+  b64decode,
+  standardB64encode,
+  standardB64decode,
+  urlsafeB64encode,
+  urlsafeB64decode,
+  b16encode,
+  b16decode,
+  b32encode,
+  b32decode,
+  a85encode,
+  a85decode,
+  b85encode,
+  b85decode,
+  encodeString,
+  decodeString,
+  base64_exports
+};
+/* v8 ignore start -- browser fallback @preserve */