pythonlib 1.0.2 → 2.0.1

package/dist/chunk-YONWJHJU.js

@@ -0,0 +1,265 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/hashlib.ts
+var hashlib_exports = {};
+__export(hashlib_exports, {
+  algorithmsAvailable: () => algorithmsAvailable,
+  algorithmsGuaranteed: () => algorithmsGuaranteed,
+  blake2b: () => blake2b,
+  blake2s: () => blake2s,
+  compareDigest: () => compareDigest,
+  fileDigest: () => fileDigest,
+  md5: () => md5,
+  newHash: () => newHash,
+  pbkdf2Hmac: () => pbkdf2Hmac,
+  scrypt: () => scrypt,
+  sha1: () => sha1,
+  sha224: () => sha224,
+  sha256: () => sha256,
+  sha384: () => sha384,
+  sha3_256: () => sha3_256,
+  sha3_512: () => sha3_512,
+  sha512: () => sha512
+});
+var ALGORITHM_INFO = {
+  md5: { digestSize: 16, blockSize: 64 },
+  // Not in Web Crypto
+  sha1: { digestSize: 20, blockSize: 64, webCryptoName: "SHA-1" },
+  sha224: { digestSize: 28, blockSize: 64 },
+  // Not in Web Crypto
+  sha256: { digestSize: 32, blockSize: 64, webCryptoName: "SHA-256" },
+  sha384: { digestSize: 48, blockSize: 128, webCryptoName: "SHA-384" },
+  sha512: { digestSize: 64, blockSize: 128, webCryptoName: "SHA-512" },
+  "sha3-256": { digestSize: 32, blockSize: 136 },
+  // Not in Web Crypto
+  "sha3-512": { digestSize: 64, blockSize: 72 },
+  // Not in Web Crypto
+  blake2b512: { digestSize: 64, blockSize: 128 },
+  // Not in Web Crypto
+  blake2s256: { digestSize: 32, blockSize: 64 }
+  // Not in Web Crypto
+};
+var isNode = typeof process !== "undefined" && typeof process.versions?.node === "string";
+var nodeCrypto;
+async function getNodeCrypto() {
+  nodeCrypto ??= await import("crypto");
+  return nodeCrypto;
+}
+function stringToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function createHashObject(algorithm, initialData) {
+  const normalizedAlgorithm = algorithm.toLowerCase();
+  const info = ALGORITHM_INFO[normalizedAlgorithm] ?? { digestSize: 32, blockSize: 64 };
+  const dataChunks = [];
+  if (initialData) {
+    dataChunks.push(initialData);
+  }
+  const hashObject = {
+    name: normalizedAlgorithm,
+    digestSize: info.digestSize,
+    blockSize: info.blockSize,
+    update(data) {
+      const bytes = typeof data === "string" ? stringToBytes(data) : data;
+      dataChunks.push(bytes);
+    },
+    async digest() {
+      const totalLength = dataChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+      const allData = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of dataChunks) {
+        allData.set(chunk, offset);
+        offset += chunk.length;
+      }
+      if (isNode) {
+        const crypto2 = await getNodeCrypto();
+        const hash = crypto2.createHash(normalizedAlgorithm);
+        hash.update(allData);
+        return new Uint8Array(hash.digest());
+      } else {
+        const webCryptoName = info.webCryptoName;
+        if (!webCryptoName) {
+          throw new Error(
+            `Algorithm "${normalizedAlgorithm}" is not available in Web Crypto API. Available algorithms: SHA-1, SHA-256, SHA-384, SHA-512`
+          );
+        }
+        const hashBuffer = await crypto.subtle.digest(webCryptoName, allData);
+        return new Uint8Array(hashBuffer);
+      }
+    },
+    async hexdigest() {
+      const digestBytes = await this.digest();
+      return bytesToHex(digestBytes);
+    },
+    copy() {
+      const totalLength = dataChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+      const allData = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of dataChunks) {
+        allData.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return createHashObject(algorithm, allData);
+    }
+  };
+  return hashObject;
+}
+function newHash(name, data) {
+  const hash = createHashObject(name);
+  if (data !== void 0) {
+    hash.update(data);
+  }
+  return hash;
+}
+function md5(data) {
+  return newHash("md5", data);
+}
+function sha1(data) {
+  return newHash("sha1", data);
+}
+function sha224(data) {
+  return newHash("sha224", data);
+}
+function sha256(data) {
+  return newHash("sha256", data);
+}
+function sha384(data) {
+  return newHash("sha384", data);
+}
+function sha512(data) {
+  return newHash("sha512", data);
+}
+function sha3_256(data) {
+  return newHash("sha3-256", data);
+}
+function sha3_512(data) {
+  return newHash("sha3-512", data);
+}
+function blake2b(data) {
+  return newHash("blake2b512", data);
+}
+function blake2s(data) {
+  return newHash("blake2s256", data);
+}
+var algorithmsAvailable = /* @__PURE__ */ new Set([
+  "md5",
+  "sha1",
+  "sha224",
+  "sha256",
+  "sha384",
+  "sha512",
+  "sha3-256",
+  "sha3-512",
+  "blake2b512",
+  "blake2s256"
+]);
+var algorithmsGuaranteed = /* @__PURE__ */ new Set(["sha1", "sha256", "sha384", "sha512"]);
+async function pbkdf2Hmac(hashName, password, salt, iterations, dklen) {
+  const passwordBytes = typeof password === "string" ? stringToBytes(password) : password;
+  const saltBytes = typeof salt === "string" ? stringToBytes(salt) : salt;
+  if (isNode) {
+    const crypto2 = await getNodeCrypto();
+    return new Uint8Array(crypto2.pbkdf2Sync(passwordBytes, saltBytes, iterations, dklen, hashName));
+  } else {
+    const info = ALGORITHM_INFO[hashName.toLowerCase()];
+    const webCryptoName = info?.webCryptoName;
+    if (!webCryptoName) {
+      throw new Error(`Algorithm "${hashName}" is not available in Web Crypto API`);
+    }
+    const keyMaterial = await crypto.subtle.importKey("raw", passwordBytes, "PBKDF2", false, [
+      "deriveBits"
+    ]);
+    const derivedBits = await crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        salt: saltBytes,
+        iterations,
+        hash: webCryptoName
+      },
+      keyMaterial,
+      dklen * 8
+    );
+    return new Uint8Array(derivedBits);
+  }
+}
+async function scrypt(password, salt, n, r, p, dklen) {
+  if (!isNode) {
+    throw new Error("scrypt is only available in Node.js, not in browser environments");
+  }
+  const crypto2 = await getNodeCrypto();
+  const passwordBytes = typeof password === "string" ? stringToBytes(password) : password;
+  const saltBytes = typeof salt === "string" ? stringToBytes(salt) : salt;
+  return new Uint8Array(
+    crypto2.scryptSync(passwordBytes, saltBytes, dklen, {
+      N: n,
+      r,
+      p
+    })
+  );
+}
+async function compareDigest(a, b) {
+  const aBytes = typeof a === "string" ? stringToBytes(a) : a;
+  const bBytes = typeof b === "string" ? stringToBytes(b) : b;
+  if (aBytes.length !== bBytes.length) {
+    return false;
+  }
+  if (isNode) {
+    const crypto2 = await getNodeCrypto();
+    return crypto2.timingSafeEqual(aBytes, bBytes);
+  } else {
+    let result = 0;
+    for (let i = 0; i < aBytes.length; i++) {
+      const aByte = aBytes[i] ?? 0;
+      const bByte = bBytes[i] ?? 0;
+      result |= aByte ^ bByte;
+    }
+    return result === 0;
+  }
+}
+async function fileDigest(path, algorithm = "sha256") {
+  if (!isNode) {
+    throw new Error("fileDigest is only available in Node.js");
+  }
+  const crypto2 = await getNodeCrypto();
+  const fs = await import("fs");
+  return new Promise((resolve, reject) => {
+    const hash = crypto2.createHash(algorithm);
+    const stream = fs.createReadStream(path);
+    stream.on("data", (data) => {
+      hash.update(data);
+    });
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+    stream.on("error", reject);
+  });
+}
+
+export {
+  newHash,
+  md5,
+  sha1,
+  sha224,
+  sha256,
+  sha384,
+  sha512,
+  sha3_256,
+  sha3_512,
+  blake2b,
+  blake2s,
+  algorithmsAvailable,
+  algorithmsGuaranteed,
+  pbkdf2Hmac,
+  scrypt,
+  compareDigest,
+  fileDigest,
+  hashlib_exports
+};
+/* v8 ignore start -- browser Web Crypto API path @preserve */
+/* v8 ignore next 3 -- browser error path @preserve */
+/* v8 ignore start -- browser fallback path @preserve */

package/dist/collections.js

@@ -2,11 +2,10 @@ import {
   Counter,
   defaultdict,
   deque
-} from "./chunk-TAYRRHJ3.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-MFKIEN7N.js";
+import "./chunk-MLKGABMK.js";
 export {
   Counter,
   defaultdict,
   deque
 };
-//# sourceMappingURL=collections.js.map

package/dist/copy-6ZaZ__ge.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Python copy module for TypeScript
+ *
+ * Provides shallow and deep copy operations.
+ *
+ * @see {@link https://docs.python.org/3/library/copy.html | Python copy documentation}
+ * @module
+ */
+/**
+ * Create a shallow copy of an object.
+ *
+ * For primitive types, returns the value as-is.
+ * For arrays, returns a new array with the same elements.
+ * For objects, returns a new object with the same properties.
+ * For Maps and Sets, returns new instances with the same entries.
+ *
+ * @param x - The object to copy
+ * @returns A shallow copy of x
+ *
+ * @example
+ * ```typescript
+ * const original = [1, [2, 3], 4]
+ * const copied = copy(original)
+ * copied[0] = 99
+ * console.log(original[0]) // 1 (unchanged)
+ * copied[1][0] = 99
+ * console.log(original[1][0]) // 99 (nested array is shared)
+ * ```
+ */
+declare function copy<T>(x: T): T;
+/**
+ * Create a deep copy of an object.
+ *
+ * Creates a complete independent copy of the object and all nested objects.
+ * Uses structuredClone when available, with a fallback for older environments.
+ *
+ * Note: Functions cannot be deep copied and will be shared between copies.
+ *
+ * @param x - The object to deep copy
+ * @param memo - Internal map for circular reference handling (optional)
+ * @returns A deep copy of x
+ *
+ * @example
+ * ```typescript
+ * const original = { a: 1, b: { c: 2 } }
+ * const copied = deepcopy(original)
+ * copied.b.c = 99
+ * console.log(original.b.c) // 2 (unchanged)
+ * ```
+ */
+declare function deepcopy<T>(x: T, memo?: Map<unknown, unknown>): T;
+
+declare const copyModule_copy: typeof copy;
+declare const copyModule_deepcopy: typeof deepcopy;
+declare namespace copyModule {
+  export { copyModule_copy as copy, copyModule_deepcopy as deepcopy };
+}
+
+export { copy as a, copyModule as c, deepcopy as d };

package/dist/copy.d.ts

@@ -0,0 +1 @@
+export { a as copy, d as deepcopy } from './copy-6ZaZ__ge.js';

package/dist/copy.js

@@ -0,0 +1,9 @@
+import {
+  copy,
+  deepcopy
+} from "./chunk-RRSOZXZE.js";
+import "./chunk-MLKGABMK.js";
+export {
+  copy,
+  deepcopy
+};

package/dist/datetime.js

@@ -7,8 +7,8 @@ import {
   strptime,
   time,
   timedelta
-} from "./chunk-OSX7QZAW.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-LK2L2TFG.js";
+import "./chunk-MLKGABMK.js";
 export {
   MAXYEAR,
   MINYEAR,
@@ -19,4 +19,3 @@ export {
   time,
   timedelta
 };
-//# sourceMappingURL=datetime.js.map

package/dist/functools.js

@@ -13,8 +13,8 @@ import {
   singleDispatch,
   totalOrdering,
   wraps
-} from "./chunk-QURVRHY2.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-D35YI363.js";
+import "./chunk-MLKGABMK.js";
 export {
   attrGetter,
   cache,
@@ -31,4 +31,3 @@ export {
   totalOrdering,
   wraps
 };
-//# sourceMappingURL=functools.js.map

package/dist/glob.browser-B6d_YdV5.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Python glob module for TypeScript - Browser version
+ *
+ * Browser stub - filesystem operations are not available.
+ *
+ * @see {@link https://docs.python.org/3/library/glob.html | Python glob documentation}
+ * @module
+ */
+/**
+ * Return a list of paths matching a pathname pattern.
+ * Browser stub - always returns empty array.
+ */
+declare function glob(_pattern: string, _options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): Promise<string[]>;
+/**
+ * Return an async iterator of paths matching a pathname pattern.
+ * Browser stub - yields nothing.
+ */
+declare function iglob(_pattern: string, _options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): AsyncGenerator<string>;
+/**
+ * Escape all special characters in a pathname.
+ */
+declare function escape(pathname: string): string;
+/**
+ * Return true if the pattern contains any magic glob characters.
+ */
+declare function hasMagic(pattern: string): boolean;
+/**
+ * Return a list of all files matching pattern recursively.
+ * Browser stub - always returns empty array.
+ */
+declare function rglob(_pattern: string, _rootDir?: string): Promise<string[]>;
+
+declare const globModule_escape: typeof escape;
+declare const globModule_glob: typeof glob;
+declare const globModule_hasMagic: typeof hasMagic;
+declare const globModule_iglob: typeof iglob;
+declare const globModule_rglob: typeof rglob;
+declare namespace globModule {
+  export { globModule_escape as escape, globModule_glob as glob, globModule_hasMagic as hasMagic, globModule_iglob as iglob, globModule_rglob as rglob };
+}
+
+export { glob as a, escape as e, globModule as g, hasMagic as h, iglob as i, rglob as r };

package/dist/glob.browser.d.ts

@@ -0,0 +1 @@
+export { e as escape, a as glob, h as hasMagic, i as iglob, r as rglob } from './glob.browser-B6d_YdV5.js';

package/dist/glob.browser.js

@@ -0,0 +1,15 @@
+import {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+} from "./chunk-B5LQJODJ.js";
+import "./chunk-MLKGABMK.js";
+export {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+};

package/dist/glob.node-wn5ehtyM.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Python glob module for TypeScript
+ *
+ * Provides Unix shell-style pathname pattern matching with async operations.
+ *
+ * @see {@link https://docs.python.org/3/library/glob.html | Python glob documentation}
+ * @module
+ */
+/**
+ * Return a list of paths matching a pathname pattern.
+ *
+ * The pattern may contain shell-style wildcards:
+ * - `*` matches any number of characters
+ * - `?` matches a single character
+ * - `[seq]` matches any character in seq
+ * - `[!seq]` matches any character not in seq
+ * - `**` matches everything, including any subdirectories
+ *
+ * @param pattern - The glob pattern
+ * @param options - Options object
+ * @returns Promise of array of matching paths
+ *
+ * @example
+ * ```typescript
+ * await glob("*.txt")              // All .txt files in current directory
+ * await glob("**\/*.py")           // All .py files recursively
+ * await glob("/path/to/*.js")      // All .js files in /path/to
+ * ```
+ */
+declare function glob(pattern: string, options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): Promise<string[]>;
+/**
+ * Return an async iterator of paths matching a pathname pattern.
+ *
+ * @param pattern - The glob pattern
+ * @param options - Options object
+ * @returns AsyncGenerator of matching paths
+ */
+declare function iglob(pattern: string, options?: {
+    recursive?: boolean;
+    rootDir?: string;
+    includeHidden?: boolean;
+}): AsyncGenerator<string>;
+/**
+ * Escape all special characters in a pathname.
+ *
+ * @param pathname - The path to escape
+ * @returns Escaped path safe for use in glob patterns
+ */
+declare function escape(pathname: string): string;
+/**
+ * Return true if the pattern contains any magic glob characters.
+ *
+ * @param pattern - The pattern to check
+ * @returns True if pattern contains wildcards
+ */
+declare function hasMagic(pattern: string): boolean;
+/**
+ * Return a list of all files matching pattern in directory and subdirectories.
+ * This is an alias for glob with recursive=true.
+ *
+ * @param pattern - The glob pattern (without **)
+ * @param rootDir - Root directory to search from
+ * @returns Promise of array of matching paths
+ */
+declare function rglob(pattern: string, rootDir?: string): Promise<string[]>;
+
+declare const globModule_escape: typeof escape;
+declare const globModule_glob: typeof glob;
+declare const globModule_hasMagic: typeof hasMagic;
+declare const globModule_iglob: typeof iglob;
+declare const globModule_rglob: typeof rglob;
+declare namespace globModule {
+  export { globModule_escape as escape, globModule_glob as glob, globModule_hasMagic as hasMagic, globModule_iglob as iglob, globModule_rglob as rglob };
+}
+
+export { glob as a, escape as e, globModule as g, hasMagic as h, iglob as i, rglob as r };

package/dist/glob.node.d.ts

@@ -0,0 +1 @@
+export { e as escape, a as glob, h as hasMagic, i as iglob, r as rglob } from './glob.node-wn5ehtyM.js';

package/dist/glob.node.js

@@ -0,0 +1,15 @@
+import {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+} from "./chunk-RB6BYCIQ.js";
+import "./chunk-MLKGABMK.js";
+export {
+  escape,
+  glob,
+  hasMagic,
+  iglob,
+  rglob
+};