pythonlib 1.0.2 → 2.0.1

package/dist/chunk-B5LQJODJ.js

@@ -0,0 +1,37 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/glob.browser.ts
+var glob_browser_exports = {};
+__export(glob_browser_exports, {
+  escape: () => escape,
+  glob: () => glob,
+  hasMagic: () => hasMagic,
+  iglob: () => iglob,
+  rglob: () => rglob
+});
+async function glob(_pattern, _options) {
+  return [];
+}
+async function* iglob(_pattern, _options) {
+}
+function escape(pathname) {
+  return pathname.replace(/([*?[])/g, "[$1]");
+}
+function hasMagic(pattern) {
+  return /[*?[\]]/.test(pattern);
+}
+async function rglob(_pattern, _rootDir = ".") {
+  return [];
+}
+
+export {
+  glob,
+  iglob,
+  escape,
+  hasMagic,
+  rglob,
+  glob_browser_exports
+};
+/* v8 ignore start -- browser stubs @preserve */

package/dist/{chunk-CUP6EPDB.js → chunk-BCMGGBWG.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/itertools.ts
 var itertools_exports = {};
@@ -52,7 +52,7 @@ function combinations(iterable, r) {
 function permutations(iterable, r) {
   const pool = [...iterable];
   const n = pool.length;
-  const rLen = r === void 0 ? n : r;
+  const rLen = r ?? n;
   if (rLen > n || rLen < 0) return [];
   const result = [];
   const indices = Array.from({ length: n }, (_, i) => i);
@@ -60,7 +60,6 @@ function permutations(iterable, r) {
   result.push(indices.slice(0, rLen).map((i) => pool[i]));
   outer: for (; ; ) {
     for (let i = rLen - 1; i >= 0; i--) {
-      ;
       cycles[i]--;
       if (cycles[i] === 0) {
         const temp = indices[i];
@@ -92,7 +91,6 @@ function product(...iterables) {
   for (; ; ) {
     let i = pools.length - 1;
     while (i >= 0) {
-      ;
       indices[i]++;
       const currentPool = pools[i];
       if (indices[i] < currentPool.length) {
@@ -361,4 +359,3 @@ export {
   partition,
   itertools_exports
 };
-//# sourceMappingURL=chunk-CUP6EPDB.js.map

package/dist/chunk-BCVIH2BN.js

@@ -0,0 +1,175 @@
+import {
+  altSep,
+  chdir,
+  curDir,
+  environ,
+  extSep,
+  getCwd,
+  getCwdb,
+  getenv,
+  lineSep,
+  name,
+  parDir,
+  pathBasename,
+  pathCommonPath,
+  pathDirname,
+  pathExpandUser,
+  pathExpandVars,
+  pathExtName,
+  pathIsAbs,
+  pathJoin,
+  pathNormPath,
+  pathRelPath,
+  pathSep,
+  pathSplitExt,
+  pathSplitFn,
+  sep
+} from "./chunk-LHPQS75Z.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/os.browser.ts
+var os_browser_exports = {};
+__export(os_browser_exports, {
+  altSep: () => altSep,
+  chdir: () => chdir,
+  curDir: () => curDir,
+  environ: () => environ,
+  extSep: () => extSep,
+  getCwd: () => getCwd,
+  getCwdb: () => getCwdb,
+  getenv: () => getenv,
+  lineSep: () => lineSep,
+  listDir: () => listDir,
+  makeDirs: () => makeDirs,
+  mkdir: () => mkdir,
+  name: () => name,
+  parDir: () => parDir,
+  path: () => path,
+  pathBasename: () => pathBasename,
+  pathCommonPath: () => pathCommonPath,
+  pathDirname: () => pathDirname,
+  pathExpandUser: () => pathExpandUser,
+  pathExpandVars: () => pathExpandVars,
+  pathExtName: () => pathExtName,
+  pathIsAbs: () => pathIsAbs,
+  pathJoin: () => pathJoin,
+  pathNormPath: () => pathNormPath,
+  pathRelPath: () => pathRelPath,
+  pathSep: () => pathSep,
+  pathSplitExt: () => pathSplitExt,
+  pathSplitFn: () => pathSplitFn,
+  remove: () => remove,
+  removeDirs: () => removeDirs,
+  rename: () => rename,
+  renames: () => renames,
+  replace: () => replace,
+  rmdir: () => rmdir,
+  sep: () => sep,
+  stat: () => stat,
+  unlink: () => unlink,
+  walk: () => walk
+});
+var path = {
+  join: pathJoin,
+  basename: pathBasename,
+  dirname: pathDirname,
+  split: pathSplitFn,
+  splitExt: pathSplitExt,
+  extName: pathExtName,
+  isAbs: pathIsAbs,
+  normPath: pathNormPath,
+  relPath: pathRelPath,
+  commonPath: pathCommonPath,
+  expandUser: pathExpandUser,
+  expandVars: pathExpandVars,
+  /** Return normalized absolutized version of pathname */
+  absPath(p) {
+    if (pathIsAbs(p)) {
+      return pathNormPath(p);
+    }
+    return pathNormPath(p);
+  },
+  /** Return canonical path, eliminating symlinks (stub - just normalizes) */
+  realPath(p) {
+    return path.absPath(p);
+  },
+  /* v8 ignore start -- browser stubs @preserve */
+  /** Test if path exists (stub - always returns false in browser) */
+  exists(_p) {
+    return false;
+  },
+  /** Test if path is a file (stub - always returns false in browser) */
+  isFile(_p) {
+    return false;
+  },
+  /** Test if path is a directory (stub - always returns false in browser) */
+  isDir(_p) {
+    return false;
+  },
+  /** Test if path is a symbolic link (stub - always returns false in browser) */
+  isLink(_p) {
+    return false;
+  },
+  /** Return size of file (stub - returns 0 in browser) */
+  getSize(_p) {
+    return 0;
+  },
+  /** Return modification time (stub - returns 0 in browser) */
+  getMtime(_p) {
+    return 0;
+  },
+  /** Return access time (stub - returns 0 in browser) */
+  getAtime(_p) {
+    return 0;
+  },
+  /** Return creation time (stub - returns 0 in browser) */
+  getCtime(_p) {
+    return 0;
+  }
+  /* v8 ignore stop */
+};
+function listDir(_p = ".") {
+  return [];
+}
+function mkdir(_p, _mode = 511) {
+}
+function makeDirs(_p, _mode = 511, _existOk = false) {
+}
+function remove(_p) {
+}
+var unlink = remove;
+function rmdir(_p) {
+}
+function removeDirs(_p) {
+}
+function rename(_src, _dst) {
+}
+function renames(_src, _dst) {
+}
+function replace(_src, _dst) {
+}
+function* walk(_top, _options) {
+}
+function stat(_p) {
+  return { st_mode: 0, st_size: 0, st_mtime: 0, st_atime: 0, st_ctime: 0 };
+}
+
+export {
+  path,
+  listDir,
+  mkdir,
+  makeDirs,
+  remove,
+  unlink,
+  rmdir,
+  removeDirs,
+  rename,
+  renames,
+  replace,
+  walk,
+  stat,
+  os_browser_exports
+};
+/* v8 ignore start -- browser stubs for filesystem operations @preserve */

package/dist/chunk-CANUXHVB.js

@@ -0,0 +1,349 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/logging.browser.ts
+var logging_browser_exports = {};
+__export(logging_browser_exports, {
+  CRITICAL: () => CRITICAL,
+  DEBUG: () => DEBUG,
+  ERROR: () => ERROR,
+  FATAL: () => FATAL,
+  FileHandler: () => FileHandler,
+  Formatter: () => Formatter,
+  Handler: () => Handler,
+  INFO: () => INFO,
+  Logger: () => Logger,
+  NOTSET: () => NOTSET,
+  StreamHandler: () => StreamHandler,
+  WARN: () => WARN,
+  WARNING: () => WARNING,
+  basicConfig: () => basicConfig,
+  critical: () => critical,
+  debug: () => debug,
+  disable: () => disable,
+  error: () => error,
+  exception: () => exception,
+  fatal: () => fatal,
+  getLevelName: () => getLevelName,
+  getLogger: () => getLogger,
+  info: () => info,
+  levelNames: () => levelNames,
+  log: () => log,
+  setLevel: () => setLevel,
+  shutdown: () => shutdown,
+  warn: () => warn,
+  warning: () => warning
+});
+var CRITICAL = 50;
+var FATAL = CRITICAL;
+var ERROR = 40;
+var WARNING = 30;
+var WARN = WARNING;
+var INFO = 20;
+var DEBUG = 10;
+var NOTSET = 0;
+var levelNames = {
+  [CRITICAL]: "CRITICAL",
+  [ERROR]: "ERROR",
+  [WARNING]: "WARNING",
+  [INFO]: "INFO",
+  [DEBUG]: "DEBUG",
+  [NOTSET]: "NOTSET"
+};
+function getLevelName(level) {
+  if (typeof level === "number") {
+    return levelNames[level] ?? `Level ${String(level)}`;
+  }
+  const upper = level.toUpperCase();
+  for (const [num, name] of Object.entries(levelNames)) {
+    if (name === upper) {
+      return parseInt(num, 10);
+    }
+  }
+  return level;
+}
+var Handler = class {
+  level = NOTSET;
+  formatter = null;
+  setLevel(level) {
+    this.level = level;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  format(record) {
+    if (this.formatter) {
+      return this.formatter.format(record);
+    }
+    return record.msg;
+  }
+  handle(record) {
+    if (record.levelno >= this.level) {
+      this.emit(record);
+    }
+  }
+};
+var StreamHandler = class extends Handler {
+  emit(record) {
+    const msg = this.format(record);
+    if (record.levelno >= ERROR) {
+      console.error(msg);
+    } else if (record.levelno >= WARNING) {
+      console.warn(msg);
+    } else if (record.levelno >= INFO) {
+      console.info(msg);
+    } else {
+      console.debug(msg);
+    }
+  }
+};
+var FileHandler = class extends Handler {
+  filename;
+  mode;
+  constructor(filename, mode = "a") {
+    super();
+    this.filename = filename;
+    this.mode = mode;
+  }
+  emit(record) {
+    const msg = this.format(record);
+    console.log(`[${this.filename}]`, msg);
+  }
+};
+var Formatter = class {
+  fmt;
+  datefmt;
+  constructor(fmt, datefmt) {
+    this.fmt = fmt ?? "%(levelname)s:%(name)s:%(message)s";
+    this.datefmt = datefmt ?? "%Y-%m-%d %H:%M:%S";
+  }
+  formatTime(record) {
+    const date = new Date(record.created * 1e3);
+    return this.datefmt.replace("%Y", String(date.getFullYear())).replace("%m", String(date.getMonth() + 1).padStart(2, "0")).replace("%d", String(date.getDate()).padStart(2, "0")).replace("%H", String(date.getHours()).padStart(2, "0")).replace("%M", String(date.getMinutes()).padStart(2, "0")).replace("%S", String(date.getSeconds()).padStart(2, "0"));
+  }
+  format(record) {
+    let msg = this.fmt.replace("%(name)s", record.name).replace("%(levelno)d", String(record.levelno)).replace("%(levelname)s", record.levelname).replace("%(message)s", record.msg).replace("%(asctime)s", this.formatTime(record));
+    if (record.filename) {
+      msg = msg.replace("%(filename)s", record.filename);
+    }
+    if (record.lineno !== void 0) {
+      msg = msg.replace("%(lineno)d", String(record.lineno));
+    }
+    if (record.funcName) {
+      msg = msg.replace("%(funcName)s", record.funcName);
+    }
+    return msg;
+  }
+};
+var Logger = class {
+  name;
+  level = NOTSET;
+  handlers = [];
+  parent = null;
+  propagate = true;
+  constructor(name) {
+    this.name = name;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  addHandler(handler) {
+    if (!this.handlers.includes(handler)) {
+      this.handlers.push(handler);
+    }
+  }
+  removeHandler(handler) {
+    const index = this.handlers.indexOf(handler);
+    if (index !== -1) {
+      this.handlers.splice(index, 1);
+    }
+  }
+  getEffectiveLevel() {
+    let logger = this;
+    while (logger) {
+      if (logger.level !== NOTSET) {
+        return logger.level;
+      }
+      logger = logger.parent;
+    }
+    return NOTSET;
+  }
+  isEnabledFor(level) {
+    return level >= this.getEffectiveLevel();
+  }
+  makeRecord(level, msg, args) {
+    let formattedMsg = msg;
+    if (args.length > 0) {
+      formattedMsg = msg.replace(/%[sdfo]/g, () => {
+        const arg = args.shift();
+        return String(arg);
+      });
+    }
+    return {
+      name: this.name,
+      levelno: level,
+      levelname: levelNames[level] ?? `Level ${String(level)}`,
+      msg: formattedMsg,
+      args,
+      created: Date.now() / 1e3
+    };
+  }
+  handle(record) {
+    for (const handler of this.handlers) {
+      handler.handle(record);
+    }
+    if (this.propagate && this.parent) {
+      this.parent.handle(record);
+    }
+  }
+  log(level, msg, ...args) {
+    if (this.isEnabledFor(level)) {
+      const record = this.makeRecord(level, msg, args);
+      this.handle(record);
+    }
+  }
+  debug(msg, ...args) {
+    this.log(DEBUG, msg, ...args);
+  }
+  info(msg, ...args) {
+    this.log(INFO, msg, ...args);
+  }
+  warning(msg, ...args) {
+    this.log(WARNING, msg, ...args);
+  }
+  warn(msg, ...args) {
+    this.warning(msg, ...args);
+  }
+  error(msg, ...args) {
+    this.log(ERROR, msg, ...args);
+  }
+  critical(msg, ...args) {
+    this.log(CRITICAL, msg, ...args);
+  }
+  fatal(msg, ...args) {
+    this.critical(msg, ...args);
+  }
+  exception(msg, ...args) {
+    this.error(msg, ...args);
+  }
+};
+var loggers = /* @__PURE__ */ new Map();
+var rootLogger = new Logger("root");
+rootLogger.setLevel(WARNING);
+function getLogger(name) {
+  if (!name) {
+    return rootLogger;
+  }
+  let logger = loggers.get(name);
+  if (!logger) {
+    logger = new Logger(name);
+    const parts = name.split(".");
+    if (parts.length > 1) {
+      const parentName = parts.slice(0, -1).join(".");
+      logger.parent = getLogger(parentName);
+    } else {
+      logger.parent = rootLogger;
+    }
+    loggers.set(name, logger);
+  }
+  return logger;
+}
+function basicConfig(options) {
+  if (rootLogger.handlers.length > 0 && !options?.handlers) {
+    return;
+  }
+  rootLogger.handlers = [];
+  if (options?.level !== void 0) {
+    rootLogger.setLevel(options.level);
+  }
+  const formatter = new Formatter(options?.format, options?.datefmt);
+  if (options?.handlers) {
+    for (const handler of options.handlers) {
+      handler.setFormatter(formatter);
+      rootLogger.addHandler(handler);
+    }
+  } else if (options?.filename) {
+    const handler = new FileHandler(options.filename, options.filemode);
+    handler.setFormatter(formatter);
+    rootLogger.addHandler(handler);
+  } else {
+    const handler = new StreamHandler();
+    handler.setFormatter(formatter);
+    rootLogger.addHandler(handler);
+  }
+}
+function debug(msg, ...args) {
+  rootLogger.debug(msg, ...args);
+}
+function info(msg, ...args) {
+  rootLogger.info(msg, ...args);
+}
+function warning(msg, ...args) {
+  rootLogger.warning(msg, ...args);
+}
+function warn(msg, ...args) {
+  rootLogger.warn(msg, ...args);
+}
+function error(msg, ...args) {
+  rootLogger.error(msg, ...args);
+}
+function critical(msg, ...args) {
+  rootLogger.critical(msg, ...args);
+}
+function fatal(msg, ...args) {
+  rootLogger.fatal(msg, ...args);
+}
+function exception(msg, ...args) {
+  rootLogger.exception(msg, ...args);
+}
+function log(level, msg, ...args) {
+  rootLogger.log(level, msg, ...args);
+}
+function setLevel(level) {
+  rootLogger.setLevel(level);
+}
+function disable(level = CRITICAL) {
+  rootLogger.setLevel(level + 1);
+}
+function shutdown() {
+  rootLogger.handlers = [];
+  for (const logger of loggers.values()) {
+    logger.handlers = [];
+  }
+  loggers.clear();
+}
+
+export {
+  CRITICAL,
+  FATAL,
+  ERROR,
+  WARNING,
+  WARN,
+  INFO,
+  DEBUG,
+  NOTSET,
+  levelNames,
+  getLevelName,
+  Handler,
+  StreamHandler,
+  FileHandler,
+  Formatter,
+  Logger,
+  getLogger,
+  basicConfig,
+  debug,
+  info,
+  warning,
+  warn,
+  error,
+  critical,
+  fatal,
+  exception,
+  log,
+  setLevel,
+  disable,
+  shutdown,
+  logging_browser_exports
+};
+/* v8 ignore start -- browser version tested via browser tests @preserve */

package/dist/{chunk-QURVRHY2.js → chunk-D35YI363.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/functools.ts
 var functools_exports = {};
@@ -54,14 +54,15 @@ function lruCache(func, maxsize = 128) {
   let misses = 0;
   const cached = ((...args) => {
     const key = JSON.stringify(args);
-    if (cache2.has(key)) {
+    const entry = cache2.get(key);
+    if (entry !== void 0) {
       hits++;
       const idx = order.indexOf(key);
       if (idx > -1) {
         order.splice(idx, 1);
         order.push(key);
       }
-      return cache2.get(key);
+      return entry.value;
     }
     misses++;
     const result = func(...args);
@@ -71,7 +72,7 @@ function lruCache(func, maxsize = 128) {
         cache2.delete(oldest);
       }
     }
-    cache2.set(key, result);
+    cache2.set(key, { value: result });
     order.push(key);
     return result;
   });
@@ -93,11 +94,12 @@ function cache(func) {
   const cacheMap = /* @__PURE__ */ new Map();
   return ((...args) => {
     const key = JSON.stringify(args);
-    if (cacheMap.has(key)) {
-      return cacheMap.get(key);
+    const entry = cacheMap.get(key);
+    if (entry !== void 0) {
+      return entry.value;
     }
     const result = func(...args);
-    cacheMap.set(key, result);
+    cacheMap.set(key, { value: result });
     return result;
   });
 }
@@ -135,8 +137,9 @@ function wraps(wrapped) {
   };
 }
 function attrGetter(...attrs) {
-  if (attrs.length === 1) {
-    const attr = attrs[0];
+  const [firstAttr] = attrs;
+  if (attrs.length === 1 && firstAttr !== void 0) {
+    const attr = firstAttr;
     const parts = attr.split(".");
     return (obj) => {
       let result = obj;
@@ -158,8 +161,9 @@ function attrGetter(...attrs) {
   };
 }
 function itemGetter(...items) {
-  if (items.length === 1) {
-    const item = items[0];
+  const [firstItem] = items;
+  if (items.length === 1 && firstItem !== void 0) {
+    const item = firstItem;
     return (obj) => {
       if (Array.isArray(obj) && typeof item === "number") {
         return obj[item];
@@ -248,4 +252,3 @@ export {
   functools_exports
 };
 /* v8 ignore start -- complex utility rarely used directly @preserve */
-//# sourceMappingURL=chunk-QURVRHY2.js.map

package/dist/{chunk-RSBRI27Z.js → chunk-ETBW6XNR.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/re.ts
 var re_exports = {};
@@ -144,8 +144,8 @@ var Match = class {
   }
   /** Return iterator of all groups */
   *[Symbol.iterator]() {
-    for (let i = 0; i < this._match.length; i++) {
-      yield this._match[i];
+    for (const match2 of this._match) {
+      yield match2;
     }
   }
   toString() {
@@ -420,4 +420,3 @@ export {
   purge,
   re_exports
 };
-//# sourceMappingURL=chunk-RSBRI27Z.js.map