pythonlib 1.0.1 → 2.0.0

package/dist/chunk-JJKTRIVO.js

@@ -0,0 +1,262 @@
+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
+};

package/dist/chunk-KKHKTQNN.js

@@ -0,0 +1,361 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/time.ts
+var time_exports = {};
+__export(time_exports, {
+  altzone: () => altzone,
+  asctime: () => asctime,
+  ctime: () => ctime,
+  daylight: () => daylight,
+  gmtime: () => gmtime,
+  localtime: () => localtime,
+  mktime: () => mktime,
+  monotonic: () => monotonic,
+  monotonicNs: () => monotonicNs,
+  perfCounter: () => perfCounter,
+  perfCounterNs: () => perfCounterNs,
+  processTime: () => processTime,
+  processTimeNs: () => processTimeNs,
+  sleep: () => sleep,
+  strftime: () => strftime,
+  strptime: () => strptime,
+  threadTime: () => threadTime,
+  threadTimeNs: () => threadTimeNs,
+  time: () => time,
+  timeNs: () => timeNs,
+  timezone: () => timezone,
+  tzname: () => tzname
+});
+var startTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+function time() {
+  return Date.now() / 1e3;
+}
+function timeNs() {
+  return BigInt(Date.now()) * 1000000n;
+}
+function sleep(secs) {
+  const end = Date.now() + secs * 1e3;
+  while (Date.now() < end) {
+  }
+}
+function perfCounter() {
+  if (typeof performance !== "undefined") {
+    return performance.now() / 1e3;
+  }
+  return (Date.now() - startTime) / 1e3;
+}
+function perfCounterNs() {
+  if (typeof performance !== "undefined") {
+    return BigInt(Math.floor(performance.now() * 1e6));
+  }
+  return BigInt(Date.now() - startTime) * 1000000n;
+}
+function monotonic() {
+  return perfCounter();
+}
+function monotonicNs() {
+  return perfCounterNs();
+}
+function localtime(secs) {
+  const date = secs === void 0 ? /* @__PURE__ */ new Date() : new Date(secs * 1e3);
+  const startOfYear = new Date(date.getFullYear(), 0, 0);
+  const diff = date.getTime() - startOfYear.getTime();
+  const oneDay = 1e3 * 60 * 60 * 24;
+  const tm_yday = Math.floor(diff / oneDay);
+  const jsDay = date.getDay();
+  const tm_wday = jsDay === 0 ? 6 : jsDay - 1;
+  return {
+    tm_year: date.getFullYear(),
+    tm_mon: date.getMonth() + 1,
+    // JavaScript months are 0-indexed
+    tm_mday: date.getDate(),
+    tm_hour: date.getHours(),
+    tm_min: date.getMinutes(),
+    tm_sec: date.getSeconds(),
+    tm_wday,
+    tm_yday,
+    tm_isdst: -1
+    // Not determinable in JavaScript
+  };
+}
+function gmtime(secs) {
+  const date = secs === void 0 ? /* @__PURE__ */ new Date() : new Date(secs * 1e3);
+  const startOfYear = new Date(Date.UTC(date.getUTCFullYear(), 0, 0));
+  const diff = date.getTime() - startOfYear.getTime();
+  const oneDay = 1e3 * 60 * 60 * 24;
+  const tm_yday = Math.floor(diff / oneDay);
+  const jsDay = date.getUTCDay();
+  const tm_wday = jsDay === 0 ? 6 : jsDay - 1;
+  return {
+    tm_year: date.getUTCFullYear(),
+    tm_mon: date.getUTCMonth() + 1,
+    tm_mday: date.getUTCDate(),
+    tm_hour: date.getUTCHours(),
+    tm_min: date.getUTCMinutes(),
+    tm_sec: date.getUTCSeconds(),
+    tm_wday,
+    tm_yday,
+    tm_isdst: 0
+    // UTC never has DST
+  };
+}
+function mktime(t) {
+  const date = new Date(
+    t.tm_year,
+    t.tm_mon - 1,
+    // Convert to 0-indexed month
+    t.tm_mday,
+    t.tm_hour,
+    t.tm_min,
+    t.tm_sec
+  );
+  return date.getTime() / 1e3;
+}
+function strftime(format, t) {
+  const st = t ?? localtime();
+  const weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+  const weekdaysShort = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+  const months = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ];
+  const monthsShort = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+  const pad = (n, width = 2) => String(n).padStart(width, "0");
+  const sundayWday = (st.tm_wday + 1) % 7;
+  const hour12 = st.tm_hour % 12 || 12;
+  const date = new Date(st.tm_year, st.tm_mon - 1, st.tm_mday);
+  const startOfYear = new Date(st.tm_year, 0, 1);
+  const dayOfYear = Math.floor((date.getTime() - startOfYear.getTime()) / (24 * 60 * 60 * 1e3)) + 1;
+  const sundayWeek = Math.floor((dayOfYear + startOfYear.getDay()) / 7);
+  const mondayWeek = Math.floor((dayOfYear + (startOfYear.getDay() + 6) % 7) / 7);
+  const replacements = {
+    "%Y": String(st.tm_year),
+    "%y": pad(st.tm_year % 100),
+    "%m": pad(st.tm_mon),
+    "%d": pad(st.tm_mday),
+    "%H": pad(st.tm_hour),
+    "%I": pad(hour12),
+    "%M": pad(st.tm_min),
+    "%S": pad(st.tm_sec),
+    "%p": st.tm_hour < 12 ? "AM" : "PM",
+    "%A": weekdays[st.tm_wday] ?? "",
+    "%a": weekdaysShort[st.tm_wday] ?? "",
+    "%B": months[st.tm_mon - 1] ?? "",
+    "%b": monthsShort[st.tm_mon - 1] ?? "",
+    "%w": String(sundayWday),
+    "%j": pad(st.tm_yday, 3),
+    "%U": pad(sundayWeek),
+    "%W": pad(mondayWeek),
+    "%c": `${weekdaysShort[st.tm_wday] ?? ""} ${monthsShort[st.tm_mon - 1] ?? ""} ${pad(st.tm_mday)} ${pad(st.tm_hour)}:${pad(st.tm_min)}:${pad(st.tm_sec)} ${String(st.tm_year)}`,
+    "%x": `${pad(st.tm_mon)}/${pad(st.tm_mday)}/${pad(st.tm_year % 100)}`,
+    "%X": `${pad(st.tm_hour)}:${pad(st.tm_min)}:${pad(st.tm_sec)}`,
+    "%%": "%"
+  };
+  let result = format;
+  for (const [code, value] of Object.entries(replacements)) {
+    result = result.split(code).join(value);
+  }
+  return result;
+}
+function strptime(timeString, format) {
+  const result = {
+    tm_year: 1900,
+    tm_mon: 1,
+    tm_mday: 1,
+    tm_hour: 0,
+    tm_min: 0,
+    tm_sec: 0,
+    tm_wday: 0,
+    tm_yday: 1,
+    tm_isdst: -1
+  };
+  const monthsShort = [
+    "jan",
+    "feb",
+    "mar",
+    "apr",
+    "may",
+    "jun",
+    "jul",
+    "aug",
+    "sep",
+    "oct",
+    "nov",
+    "dec"
+  ];
+  const months = [
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december"
+  ];
+  let pattern = format;
+  pattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const formatMap = [
+    { code: "%Y", regex: "(\\d{4})", handler: (m) => result.tm_year = parseInt(m, 10) },
+    {
+      code: "%y",
+      regex: "(\\d{2})",
+      handler: (m) => {
+        const yr = parseInt(m, 10);
+        result.tm_year = yr >= 69 ? 1900 + yr : 2e3 + yr;
+      }
+    },
+    { code: "%m", regex: "(\\d{1,2})", handler: (m) => result.tm_mon = parseInt(m, 10) },
+    { code: "%d", regex: "(\\d{1,2})", handler: (m) => result.tm_mday = parseInt(m, 10) },
+    { code: "%H", regex: "(\\d{1,2})", handler: (m) => result.tm_hour = parseInt(m, 10) },
+    { code: "%I", regex: "(\\d{1,2})", handler: (m) => result.tm_hour = parseInt(m, 10) },
+    { code: "%M", regex: "(\\d{1,2})", handler: (m) => result.tm_min = parseInt(m, 10) },
+    { code: "%S", regex: "(\\d{1,2})", handler: (m) => result.tm_sec = parseInt(m, 10) },
+    {
+      code: "%p",
+      regex: "(AM|PM|am|pm)",
+      handler: (m) => {
+        if (m.toUpperCase() === "PM" && result.tm_hour !== void 0 && result.tm_hour < 12) {
+          result.tm_hour += 12;
+        } else if (m.toUpperCase() === "AM" && result.tm_hour === 12) {
+          result.tm_hour = 0;
+        }
+      }
+    },
+    {
+      code: "%b",
+      regex: "([A-Za-z]+)",
+      handler: (m) => {
+        const idx = monthsShort.indexOf(m.toLowerCase());
+        if (idx !== -1) result.tm_mon = idx + 1;
+      }
+    },
+    {
+      code: "%B",
+      regex: "([A-Za-z]+)",
+      handler: (m) => {
+        const idx = months.indexOf(m.toLowerCase());
+        if (idx !== -1) result.tm_mon = idx + 1;
+      }
+    },
+    { code: "%j", regex: "(\\d{1,3})", handler: (m) => result.tm_yday = parseInt(m, 10) },
+    { code: "%w", regex: "(\\d)", handler: (m) => result.tm_wday = (parseInt(m, 10) + 6) % 7 },
+    { code: "%%", regex: "%", handler: () => void 0 }
+  ];
+  const handlers = [];
+  for (const { code, regex, handler } of formatMap) {
+    const idx = pattern.indexOf(code.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    if (idx !== -1) {
+      pattern = pattern.replace(code.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), regex);
+      handlers.push(handler);
+    }
+  }
+  const match = new RegExp("^" + pattern + "$").exec(timeString);
+  if (!match) {
+    throw new Error(`time data '${timeString}' does not match format '${format}'`);
+  }
+  for (let i = 0; i < handlers.length; i++) {
+    if (match[i + 1] !== void 0) {
+      handlers[i]?.(match[i + 1] ?? "");
+    }
+  }
+  if (result.tm_year !== void 0 && result.tm_mon !== void 0 && result.tm_mday !== void 0) {
+    const date = new Date(result.tm_year, result.tm_mon - 1, result.tm_mday);
+    const jsDay = date.getDay();
+    result.tm_wday = jsDay === 0 ? 6 : jsDay - 1;
+  }
+  if (result.tm_year !== void 0 && result.tm_mon !== void 0 && result.tm_mday !== void 0) {
+    const date = new Date(result.tm_year, result.tm_mon - 1, result.tm_mday);
+    const startOfYear = new Date(result.tm_year, 0, 0);
+    const diff = date.getTime() - startOfYear.getTime();
+    const oneDay = 1e3 * 60 * 60 * 24;
+    result.tm_yday = Math.floor(diff / oneDay);
+  }
+  return result;
+}
+function asctime(t) {
+  return strftime("%a %b %d %H:%M:%S %Y", t);
+}
+function ctime(secs) {
+  return asctime(localtime(secs));
+}
+var timezone = (/* @__PURE__ */ new Date()).getTimezoneOffset() * 60;
+var altzone = timezone;
+var tzname = (() => {
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return [tz, tz];
+})();
+var daylight = 0;
+function processTime() {
+  if (typeof performance !== "undefined") {
+    return performance.now() / 1e3;
+  }
+  return Date.now() / 1e3;
+}
+function processTimeNs() {
+  if (typeof performance !== "undefined") {
+    return BigInt(Math.floor(performance.now() * 1e6));
+  }
+  return BigInt(Date.now()) * 1000000n;
+}
+function threadTime() {
+  return processTime();
+}
+function threadTimeNs() {
+  return processTimeNs();
+}
+
+export {
+  time,
+  timeNs,
+  sleep,
+  perfCounter,
+  perfCounterNs,
+  monotonic,
+  monotonicNs,
+  localtime,
+  gmtime,
+  mktime,
+  strftime,
+  strptime,
+  asctime,
+  ctime,
+  timezone,
+  altzone,
+  tzname,
+  daylight,
+  processTime,
+  processTimeNs,
+  threadTime,
+  threadTimeNs,
+  time_exports
+};