pythonlib 0.1.0

package/dist/index.js

@@ -0,0 +1,1332 @@
+import {
+  random_exports
+} from "./chunk-WAONBJE5.js";
+import {
+  re_exports
+} from "./chunk-V63LKSA3.js";
+import {
+  Template,
+  ascii_letters,
+  ascii_lowercase,
+  ascii_uppercase,
+  capwords,
+  digits,
+  hexdigits,
+  octdigits,
+  printable,
+  punctuation,
+  string,
+  whitespace
+} from "./chunk-3CSEXTA7.js";
+import {
+  Counter,
+  collections_exports,
+  defaultdict,
+  deque
+} from "./chunk-UFMTN4T4.js";
+import {
+  datetime_exports
+} from "./chunk-HA5Y7PKO.js";
+import {
+  functools_exports
+} from "./chunk-OMQNGE6T.js";
+import {
+  itertools_exports
+} from "./chunk-TOI6IG3T.js";
+import {
+  json_exports
+} from "./chunk-P3SGIF72.js";
+import {
+  math_exports
+} from "./chunk-IVYYI2VR.js";
+import {
+  os_exports
+} from "./chunk-TJFGYXBJ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core.ts
+function floordiv(a, b) {
+  return Math.floor(a / b);
+}
+function pow(base, exp) {
+  return Math.pow(base, exp);
+}
+function mod(a, b) {
+  return (a % b + b) % b;
+}
+function divmod(a, b) {
+  return [floordiv(a, b), mod(a, b)];
+}
+function sprintf(template, args) {
+  const values = Array.isArray(args) ? args : [args];
+  let index = 0;
+  return template.replace(
+    /%([+-]?\d*\.?\d*)([sdifxXorec%])/g,
+    (match, flags, type3) => {
+      if (type3 === "%") return "%";
+      if (index >= values.length) return match;
+      const value = values[index++];
+      switch (type3) {
+        case "s":
+          return String(value);
+        case "d":
+        case "i":
+          return String(Math.floor(Number(value)));
+        case "f":
+          if (flags && flags.includes(".")) {
+            const precision = parseInt(flags.split(".")[1] ?? "6", 10);
+            return Number(value).toFixed(precision);
+          }
+          return String(Number(value));
+        case "x":
+          return Math.floor(Number(value)).toString(16);
+        case "X":
+          return Math.floor(Number(value)).toString(16).toUpperCase();
+        case "o":
+          return Math.floor(Number(value)).toString(8);
+        case "r":
+          return JSON.stringify(value);
+        case "e":
+          return Number(value).toExponential();
+        case "c":
+          return String.fromCharCode(Number(value));
+        default:
+          return String(value);
+      }
+    }
+  );
+}
+function strFormat(template, ...args) {
+  let positionalIndex = 0;
+  const lastArg = args[args.length - 1];
+  const namedParams = lastArg && typeof lastArg === "object" && !Array.isArray(lastArg) ? lastArg : {};
+  return template.replace(/\{([^}]*)\}/g, (match, key) => {
+    if (key === "") {
+      if (positionalIndex < args.length) {
+        return String(args[positionalIndex++]);
+      }
+      return match;
+    }
+    const numIndex = parseInt(key, 10);
+    if (!isNaN(numIndex) && numIndex < args.length) {
+      return String(args[numIndex]);
+    }
+    if (key in namedParams) {
+      return String(namedParams[key]);
+    }
+    return match;
+  });
+}
+function normalizeIndex(index, length, forNegativeStep = false) {
+  if (index < 0) {
+    index = length + index;
+  }
+  if (forNegativeStep) {
+    return Math.max(-1, Math.min(length - 1, index));
+  }
+  return Math.max(0, Math.min(length, index));
+}
+function slice(obj, start, stop, step) {
+  const len3 = obj.length;
+  const actualStep = step ?? 1;
+  if (actualStep === 0) {
+    throw new Error("slice step cannot be zero");
+  }
+  let actualStart;
+  let actualStop;
+  if (actualStep > 0) {
+    actualStart = start === void 0 ? 0 : normalizeIndex(start, len3);
+    actualStop = stop === void 0 ? len3 : normalizeIndex(stop, len3);
+  } else {
+    actualStart = start === void 0 ? len3 - 1 : normalizeIndex(start, len3, true);
+    actualStop = stop === void 0 ? -1 : normalizeIndex(stop, len3, true);
+  }
+  const result = [];
+  if (actualStep > 0) {
+    for (let i = actualStart; i < actualStop; i += actualStep) {
+      if (i >= 0 && i < len3) {
+        result.push(obj[i]);
+      }
+    }
+  } else {
+    for (let i = actualStart; i > actualStop; i += actualStep) {
+      if (i >= 0 && i < len3) {
+        result.push(obj[i]);
+      }
+    }
+  }
+  if (typeof obj === "string") {
+    return result.join("");
+  }
+  return result;
+}
+function at(obj, index) {
+  const len3 = obj.length;
+  const normalizedIndex = index < 0 ? len3 + index : index;
+  if (normalizedIndex < 0 || normalizedIndex >= len3) {
+    throw new Error("IndexError: list index out of range");
+  }
+  return obj[normalizedIndex];
+}
+function repeat(obj, count) {
+  if (count <= 0) {
+    return typeof obj === "string" ? "" : [];
+  }
+  if (typeof obj === "string") {
+    return obj.repeat(count);
+  }
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(...obj);
+  }
+  return result;
+}
+function contains(item, container) {
+  if (typeof container === "string") {
+    return container.includes(item);
+  }
+  if (container instanceof Map) {
+    return container.has(item);
+  }
+  if (container instanceof Set) {
+    return container.has(item);
+  }
+  if (Array.isArray(container)) {
+    return container.includes(item);
+  }
+  for (const element of container) {
+    if (element === item) {
+      return true;
+    }
+  }
+  return false;
+}
+function is(a, b) {
+  return a === b;
+}
+
+// src/builtins.ts
+var py;
+function _setPyRef(pyRef) {
+  py = pyRef;
+}
+function range(startOrStop, stop, step) {
+  let start;
+  let end;
+  let stepVal;
+  if (stop === void 0) {
+    start = 0;
+    end = startOrStop;
+    stepVal = 1;
+  } else {
+    start = startOrStop;
+    end = stop;
+    stepVal = step ?? 1;
+  }
+  if (stepVal === 0) {
+    throw new Error("range() arg 3 must not be zero");
+  }
+  return {
+    *[Symbol.iterator]() {
+      if (stepVal > 0) {
+        for (let i = start; i < end; i += stepVal) {
+          yield i;
+        }
+      } else {
+        for (let i = start; i > end; i += stepVal) {
+          yield i;
+        }
+      }
+    }
+  };
+}
+function enumerate(iterable, start = 0) {
+  return {
+    *[Symbol.iterator]() {
+      let index = start;
+      for (const item of iterable) {
+        yield [index++, item];
+      }
+    }
+  };
+}
+function zip(...iterables) {
+  return {
+    *[Symbol.iterator]() {
+      const iterators = iterables.map((it) => it[Symbol.iterator]());
+      for (; ; ) {
+        const results = iterators.map((it) => it.next());
+        if (results.some((r) => r.done)) {
+          break;
+        }
+        yield results.map((r) => r.value);
+      }
+    }
+  };
+}
+function iter(obj) {
+  if (obj === null || obj === void 0) {
+    return [];
+  }
+  if (typeof obj[Symbol.iterator] === "function") {
+    return obj;
+  }
+  if (typeof obj === "object") {
+    return Object.keys(obj);
+  }
+  return [];
+}
+function reversed(iterable) {
+  const arr = Array.from(iterable);
+  return {
+    *[Symbol.iterator]() {
+      for (let i = arr.length - 1; i >= 0; i--) {
+        yield arr[i];
+      }
+    }
+  };
+}
+function sorted(iterable, options) {
+  const arr = Array.from(iterable);
+  const key = options?.key ?? ((x) => x);
+  const reverse = options?.reverse ?? false;
+  arr.sort((a, b) => {
+    const aKey = key(a);
+    const bKey = key(b);
+    let cmp;
+    if (typeof aKey === "string" && typeof bKey === "string") {
+      cmp = aKey.localeCompare(bKey);
+    } else {
+      cmp = aKey - bKey;
+    }
+    return reverse ? -cmp : cmp;
+  });
+  return arr;
+}
+function map(fn, iterable) {
+  return {
+    *[Symbol.iterator]() {
+      for (const item of iterable) {
+        yield fn(item);
+      }
+    }
+  };
+}
+function filter(fn, iterable) {
+  return {
+    *[Symbol.iterator]() {
+      for (const item of iterable) {
+        if (fn === null ? bool(item) : fn(item)) {
+          yield item;
+        }
+      }
+    }
+  };
+}
+function list(iterable) {
+  if (iterable === void 0) {
+    return [];
+  }
+  return Array.from(iterable);
+}
+function dict(entries) {
+  return new Map(entries);
+}
+function set(iterable) {
+  return new Set(iterable);
+}
+function tuple(...items) {
+  return Object.freeze([...items]);
+}
+function len(obj) {
+  if (typeof obj === "string" || Array.isArray(obj)) {
+    return obj.length;
+  }
+  if (obj instanceof Map || obj instanceof Set) {
+    return obj.size;
+  }
+  if (typeof obj === "object" && obj !== null && "length" in obj) {
+    return obj.length;
+  }
+  throw new TypeError("object has no len()");
+}
+function abs(x) {
+  return Math.abs(x);
+}
+function min(...args) {
+  const first = args[0];
+  if (args.length === 1 && typeof first === "object" && first !== null && Symbol.iterator in first) {
+    const arr = [...first];
+    if (arr.length === 0) {
+      throw new Error("min() arg is an empty sequence");
+    }
+    return arr.reduce((a, b) => a < b ? a : b);
+  }
+  if (args.length === 0) {
+    throw new Error("min expected at least 1 argument, got 0");
+  }
+  return args.reduce((a, b) => a < b ? a : b);
+}
+function max(...args) {
+  const first = args[0];
+  if (args.length === 1 && typeof first === "object" && first !== null && Symbol.iterator in first) {
+    const arr = [...first];
+    if (arr.length === 0) {
+      throw new Error("max() arg is an empty sequence");
+    }
+    return arr.reduce((a, b) => a > b ? a : b);
+  }
+  if (args.length === 0) {
+    throw new Error("max expected at least 1 argument, got 0");
+  }
+  return args.reduce((a, b) => a > b ? a : b);
+}
+function sum(iterable, start = 0) {
+  let total = start;
+  for (const item of iterable) {
+    total += item;
+  }
+  return total;
+}
+function all(iterable) {
+  for (const item of iterable) {
+    if (!bool(item)) return false;
+  }
+  return true;
+}
+function any(iterable) {
+  for (const item of iterable) {
+    if (bool(item)) return true;
+  }
+  return false;
+}
+function round(number, ndigits) {
+  if (ndigits === void 0 || ndigits === 0) {
+    const rounded = Math.round(number);
+    if (Math.abs(number % 1) === 0.5) {
+      return rounded % 2 === 0 ? rounded : rounded - Math.sign(number);
+    }
+    return rounded;
+  }
+  const factor = Math.pow(10, ndigits);
+  return Math.round(number * factor) / factor;
+}
+function ord(char) {
+  if (char.length !== 1) {
+    throw new Error("ord() expected a character");
+  }
+  return char.charCodeAt(0);
+}
+function chr(code) {
+  return String.fromCharCode(code);
+}
+function hex(x) {
+  const prefix = x < 0 ? "-0x" : "0x";
+  return prefix + Math.abs(Math.trunc(x)).toString(16);
+}
+function oct(x) {
+  const prefix = x < 0 ? "-0o" : "0o";
+  return prefix + Math.abs(Math.trunc(x)).toString(8);
+}
+function bin(x) {
+  const prefix = x < 0 ? "-0b" : "0b";
+  return prefix + Math.abs(Math.trunc(x)).toString(2);
+}
+function int(x, base) {
+  if (typeof x === "boolean") {
+    return x ? 1 : 0;
+  }
+  if (typeof x === "number") {
+    return Math.trunc(x);
+  }
+  const parsed = base !== void 0 ? parseInt(x, base) : parseInt(x, 10);
+  if (isNaN(parsed)) {
+    throw new Error(`invalid literal for int(): '${x}'`);
+  }
+  return parsed;
+}
+function float(x) {
+  if (typeof x === "number") {
+    return x;
+  }
+  const parsed = parseFloat(x);
+  if (isNaN(parsed)) {
+    throw new Error(`could not convert string to float: '${x}'`);
+  }
+  return parsed;
+}
+function str(x) {
+  if (x === null) {
+    return "None";
+  }
+  if (x === void 0) {
+    return "None";
+  }
+  if (typeof x === "boolean") {
+    return x ? "True" : "False";
+  }
+  if (Array.isArray(x)) {
+    return "[" + x.map((item) => py.repr(item)).join(", ") + "]";
+  }
+  if (x instanceof Map) {
+    const entries = Array.from(x.entries()).map(([k, v]) => `${py.repr(k)}: ${py.repr(v)}`).join(", ");
+    return "{" + entries + "}";
+  }
+  if (x instanceof Set) {
+    if (x.size === 0) {
+      return "set()";
+    }
+    return "{" + Array.from(x).map((item) => py.repr(item)).join(", ") + "}";
+  }
+  return String(x);
+}
+function repr(x) {
+  if (typeof x === "string") {
+    return `'${x}'`;
+  }
+  return str(x);
+}
+function bool(x) {
+  if (x === null || x === void 0) {
+    return false;
+  }
+  if (typeof x === "boolean") {
+    return x;
+  }
+  if (typeof x === "number") {
+    return x !== 0;
+  }
+  if (typeof x === "string") {
+    return x.length > 0;
+  }
+  if (Array.isArray(x)) {
+    return x.length > 0;
+  }
+  if (x instanceof Map || x instanceof Set) {
+    return x.size > 0;
+  }
+  return true;
+}
+function ascii(x) {
+  const s = repr(x);
+  let result = "";
+  for (const char of s) {
+    const code = char.charCodeAt(0);
+    if (code > 127) {
+      if (code > 65535) {
+        result += `\\U${code.toString(16).padStart(8, "0")}`;
+      } else {
+        result += `\\u${code.toString(16).padStart(4, "0")}`;
+      }
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+function isinstance(obj, classInfo) {
+  if (classInfo === Number || classInfo === "int" || classInfo === "float") {
+    return typeof obj === "number";
+  }
+  if (classInfo === String || classInfo === "str") {
+    return typeof obj === "string";
+  }
+  if (classInfo === Boolean || classInfo === "bool") {
+    return typeof obj === "boolean";
+  }
+  if (classInfo === Array || classInfo === "list") {
+    return Array.isArray(obj);
+  }
+  if (classInfo === Map || classInfo === "dict") {
+    return obj instanceof Map;
+  }
+  if (classInfo === Set || classInfo === "set") {
+    return obj instanceof Set;
+  }
+  if (typeof classInfo === "function") {
+    return obj instanceof classInfo;
+  }
+  return false;
+}
+function type(obj) {
+  if (obj === null) return "NoneType";
+  if (typeof obj === "number") {
+    return Number.isInteger(obj) ? "int" : "float";
+  }
+  if (typeof obj === "string") return "str";
+  if (typeof obj === "boolean") return "bool";
+  if (Array.isArray(obj)) return "list";
+  if (obj instanceof Map) return "dict";
+  if (obj instanceof Set) return "set";
+  return typeof obj;
+}
+function input(prompt) {
+  if (prompt) {
+    process.stdout.write(prompt);
+  }
+  throw new Error("input() requires async implementation");
+}
+function formatNumber(num, sign, _hash, grouping, precision, isInteger = true) {
+  let result;
+  if (isInteger) {
+    result = Math.trunc(num).toString();
+  } else {
+    result = num.toFixed(precision ?? 6);
+  }
+  if (grouping) {
+    const sep = grouping === "_" ? "_" : ",";
+    const parts = result.split(".");
+    const intPart = parts[0];
+    const signChar = intPart[0] === "-" ? "-" : "";
+    const digits2 = signChar ? intPart.slice(1) : intPart;
+    const grouped = digits2.replace(/\B(?=(\d{3})+(?!\d))/g, sep);
+    parts[0] = signChar + grouped;
+    result = parts.join(".");
+  }
+  if (num >= 0) {
+    if (sign === "+") {
+      result = "+" + result;
+    } else if (sign === " ") {
+      result = " " + result;
+    }
+  }
+  return result;
+}
+function format(value, spec) {
+  if (spec === "") {
+    return str(value);
+  }
+  const match = spec.match(
+    /^(.?[<>=^])?([+\- ])?([#])?(0)?(\d+)?([,_])?(?:\.(\d+))?([bcdeEfFgGnosxX%])?$/
+  );
+  if (!match) {
+    return str(value);
+  }
+  const [, alignPart, sign, hash, zero, widthStr, grouping, precisionStr, typeChar] = match;
+  let fill = " ";
+  let align = "";
+  if (alignPart) {
+    if (alignPart.length === 2) {
+      fill = alignPart[0];
+      align = alignPart[1];
+    } else {
+      align = alignPart;
+    }
+  }
+  const width = widthStr ? parseInt(widthStr, 10) : 0;
+  const precision = precisionStr !== void 0 ? parseInt(precisionStr, 10) : void 0;
+  if (zero && !alignPart) {
+    fill = "0";
+    align = "=";
+  }
+  let result;
+  if (typeChar === "s" || !typeChar && typeof value === "string") {
+    result = str(value);
+    if (precision !== void 0) {
+      result = result.slice(0, precision);
+    }
+  } else if (typeChar === "d" || !typeChar && typeof value === "number" && Number.isInteger(value)) {
+    const num = typeof value === "number" ? value : int(value);
+    result = formatNumber(num, sign, "", grouping);
+  } else if (typeChar === "f" || typeChar === "F") {
+    const num = typeof value === "number" ? value : float(value);
+    const prec = precision ?? 6;
+    result = formatNumber(num, sign, "", grouping, prec, false);
+    if (typeChar === "F") result = result.toUpperCase();
+  } else if (typeChar === "e" || typeChar === "E") {
+    const num = typeof value === "number" ? value : float(value);
+    const prec = precision ?? 6;
+    result = num.toExponential(prec);
+    if (sign === "+" && num >= 0) result = "+" + result;
+    else if (sign === " " && num >= 0) result = " " + result;
+    if (typeChar === "E") result = result.toUpperCase();
+  } else if (typeChar === "g" || typeChar === "G") {
+    const num = typeof value === "number" ? value : float(value);
+    const prec = precision ?? 6;
+    result = num.toPrecision(prec);
+    if (sign === "+" && num >= 0) result = "+" + result;
+    else if (sign === " " && num >= 0) result = " " + result;
+    if (typeChar === "G") result = result.toUpperCase();
+  } else if (typeChar === "x" || typeChar === "X") {
+    const num = typeof value === "number" ? Math.trunc(value) : int(value);
+    result = Math.abs(num).toString(16);
+    if (hash) result = "0x" + result;
+    if (num < 0) result = "-" + result;
+    else if (sign === "+") result = "+" + result;
+    else if (sign === " ") result = " " + result;
+    if (typeChar === "X") result = result.toUpperCase();
+  } else if (typeChar === "o") {
+    const num = typeof value === "number" ? Math.trunc(value) : int(value);
+    result = Math.abs(num).toString(8);
+    if (hash) result = "0o" + result;
+    if (num < 0) result = "-" + result;
+    else if (sign === "+") result = "+" + result;
+    else if (sign === " ") result = " " + result;
+  } else if (typeChar === "b") {
+    const num = typeof value === "number" ? Math.trunc(value) : int(value);
+    result = Math.abs(num).toString(2);
+    if (hash) result = "0b" + result;
+    if (num < 0) result = "-" + result;
+    else if (sign === "+") result = "+" + result;
+    else if (sign === " ") result = " " + result;
+  } else if (typeChar === "c") {
+    const code = typeof value === "number" ? value : int(value);
+    result = String.fromCharCode(code);
+  } else if (typeChar === "%") {
+    const num = typeof value === "number" ? value : float(value);
+    const prec = precision ?? 6;
+    result = (num * 100).toFixed(prec) + "%";
+    if (sign === "+" && num >= 0) result = "+" + result;
+    else if (sign === " " && num >= 0) result = " " + result;
+  } else if (typeChar === "n") {
+    const num = typeof value === "number" ? value : float(value);
+    result = num.toLocaleString();
+  } else {
+    result = str(value);
+  }
+  if (width > result.length) {
+    const padding = fill.repeat(width - result.length);
+    if (align === "<") {
+      result = result + padding;
+    } else if (align === ">" || align === "") {
+      result = padding + result;
+    } else if (align === "^") {
+      const leftPad = Math.floor((width - result.length) / 2);
+      const rightPad = width - result.length - leftPad;
+      result = fill.repeat(leftPad) + result + fill.repeat(rightPad);
+    } else if (align === "=") {
+      const signMatch = result.match(/^([+\- ]|0[xXoObB])?(.*)$/);
+      if (signMatch) {
+        const signPart = signMatch[1] ?? "";
+        const numPart = signMatch[2] ?? "";
+        result = signPart + padding + numPart;
+      }
+    }
+  }
+  return result;
+}
+
+// src/list.ts
+var list2 = {
+  /**
+   * Python list.append() - modifies array in place
+   */
+  append(arr, item) {
+    arr.push(item);
+  },
+  /**
+   * Python list.extend() - modifies array in place
+   */
+  extend(arr, items) {
+    arr.push(...items);
+  },
+  /**
+   * Python list.insert() - modifies array in place
+   */
+  insert(arr, index, item) {
+    arr.splice(index, 0, item);
+  },
+  /**
+   * Python list.remove() - removes first occurrence, modifies in place
+   */
+  remove(arr, value) {
+    const index = arr.indexOf(value);
+    if (index === -1) {
+      throw new Error("list.remove(x): x not in list");
+    }
+    arr.splice(index, 1);
+  },
+  /**
+   * Python list.pop() - removes and returns item at index
+   */
+  pop(arr, index) {
+    if (arr.length === 0) {
+      throw new Error("pop from empty list");
+    }
+    const i = index ?? arr.length - 1;
+    const normalizedIndex = i < 0 ? arr.length + i : i;
+    if (normalizedIndex < 0 || normalizedIndex >= arr.length) {
+      throw new Error("pop index out of range");
+    }
+    return arr.splice(normalizedIndex, 1)[0];
+  },
+  /**
+   * Python list.clear() - removes all items
+   */
+  clear(arr) {
+    arr.length = 0;
+  },
+  /**
+   * Python list.index() - finds first occurrence
+   */
+  index(arr, value, start, end) {
+    const searchStart = start ?? 0;
+    const searchEnd = end ?? arr.length;
+    for (let i = searchStart; i < searchEnd; i++) {
+      if (arr[i] === value) {
+        return i;
+      }
+    }
+    throw new Error("x not in list");
+  },
+  /**
+   * Python list.count() - counts occurrences
+   */
+  count(arr, value) {
+    let count = 0;
+    for (const item of arr) {
+      if (item === value) count++;
+    }
+    return count;
+  },
+  /**
+   * Python list.sort() with key function - modifies in place
+   */
+  sort(arr, options) {
+    const key = options?.key ?? ((x) => x);
+    const reverse = options?.reverse ?? false;
+    arr.sort((a, b) => {
+      const aKey = key(a);
+      const bKey = key(b);
+      let cmp = 0;
+      if (aKey < bKey) cmp = -1;
+      else if (aKey > bKey) cmp = 1;
+      return reverse ? -cmp : cmp;
+    });
+  },
+  /**
+   * Python list.reverse() - reverses in place
+   */
+  reverse(arr) {
+    arr.reverse();
+  },
+  /**
+   * Python list.copy() - shallow copy
+   */
+  copy(arr) {
+    return [...arr];
+  },
+  /**
+   * Python slice assignment: arr[start:end:step] = values
+   * Replaces a slice of the array with new values, modifying in place
+   */
+  sliceAssign(arr, start, end, step, values) {
+    const len3 = arr.length;
+    const actualStep = step ?? 1;
+    let actualStart = start ?? (actualStep > 0 ? 0 : len3 - 1);
+    let actualEnd = end ?? (actualStep > 0 ? len3 : -len3 - 1);
+    if (actualStart < 0) actualStart = Math.max(0, len3 + actualStart);
+    if (actualEnd < 0) actualEnd = Math.max(0, len3 + actualEnd);
+    actualStart = Math.min(actualStart, len3);
+    actualEnd = Math.min(actualEnd, len3);
+    if (actualStep === 1) {
+      const deleteCount = Math.max(0, actualEnd - actualStart);
+      arr.splice(actualStart, deleteCount, ...values);
+    } else {
+      const indices = [];
+      if (actualStep > 0) {
+        for (let i = actualStart; i < actualEnd; i += actualStep) {
+          indices.push(i);
+        }
+      } else {
+        for (let i = actualStart; i > actualEnd; i += actualStep) {
+          indices.push(i);
+        }
+      }
+      if (indices.length !== values.length) {
+        throw new Error(
+          `attempt to assign sequence of size ${String(values.length)} to extended slice of size ${String(indices.length)}`
+        );
+      }
+      for (let i = 0; i < indices.length; i++) {
+        const idx = indices[i];
+        if (idx !== void 0) {
+          arr[idx] = values[i];
+        }
+      }
+    }
+  }
+};
+
+// src/dict.ts
+var dict2 = {
+  /**
+   * Python dict.get() - get value with optional default
+   */
+  get(obj, key, defaultValue) {
+    return key in obj ? obj[key] : defaultValue;
+  },
+  /**
+   * Python dict.setdefault() - get value or set default
+   */
+  setdefault(obj, key, defaultValue) {
+    if (!(key in obj)) {
+      obj[key] = defaultValue;
+    }
+    return obj[key];
+  },
+  /**
+   * Python dict.pop() - remove and return value
+   */
+  pop(obj, key, defaultValue) {
+    if (key in obj) {
+      const value = obj[key];
+      delete obj[key];
+      return value;
+    }
+    if (defaultValue !== void 0) {
+      return defaultValue;
+    }
+    throw new Error("KeyError");
+  },
+  /**
+   * Python dict.popitem() - remove and return last item
+   */
+  popitem(obj) {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+      throw new Error("dictionary is empty");
+    }
+    const key = keys[keys.length - 1];
+    const value = obj[key];
+    delete obj[key];
+    return [key, value];
+  },
+  /**
+   * Python dict.update() - update with another dict
+   */
+  update(obj, other) {
+    if (Symbol.iterator in other) {
+      for (const [k, v] of other) {
+        obj[k] = v;
+      }
+    } else {
+      Object.assign(obj, other);
+    }
+  },
+  /**
+   * Python dict.clear() - remove all items
+   */
+  clear(obj) {
+    for (const key of Object.keys(obj)) {
+      delete obj[key];
+    }
+  },
+  /**
+   * Python dict.copy() - shallow copy
+   */
+  copy(obj) {
+    return { ...obj };
+  },
+  /**
+   * Python dict.keys() - returns iterable of keys
+   */
+  keys(obj) {
+    return Object.keys(obj);
+  },
+  /**
+   * Python dict.values() - returns iterable of values
+   */
+  values(obj) {
+    return Object.values(obj);
+  },
+  /**
+   * Python dict.items() - returns iterable of [key, value] pairs
+   */
+  items(obj) {
+    return Object.entries(obj);
+  },
+  /**
+   * Python dict.fromkeys() - create dict from keys
+   */
+  fromkeys(keys, value) {
+    const result = {};
+    for (const key of keys) {
+      result[key] = value;
+    }
+    return result;
+  }
+};
+
+// src/set.ts
+var set2 = {
+  /**
+   * Python set.add() - add element
+   */
+  add(s, item) {
+    s.add(item);
+  },
+  /**
+   * Python set.remove() - remove element, raises error if not found
+   */
+  remove(s, item) {
+    if (!s.has(item)) {
+      throw new Error("KeyError");
+    }
+    s.delete(item);
+  },
+  /**
+   * Python set.discard() - remove element if present
+   */
+  discard(s, item) {
+    s.delete(item);
+  },
+  /**
+   * Python set.pop() - remove and return arbitrary element
+   */
+  pop(s) {
+    if (s.size === 0) {
+      throw new Error("pop from an empty set");
+    }
+    const item = s.values().next().value;
+    s.delete(item);
+    return item;
+  },
+  /**
+   * Python set.clear() - remove all elements
+   */
+  clear(s) {
+    s.clear();
+  },
+  /**
+   * Python set.copy() - shallow copy
+   */
+  copy(s) {
+    return new Set(s);
+  },
+  /**
+   * Python set.update() - add elements from iterable
+   */
+  update(s, ...iterables) {
+    for (const iterable of iterables) {
+      for (const item of iterable) {
+        s.add(item);
+      }
+    }
+  },
+  /**
+   * Python set.union() - returns new set with all elements
+   */
+  union(a, ...others) {
+    const result = new Set(a);
+    for (const other of others) {
+      for (const item of other) {
+        result.add(item);
+      }
+    }
+    return result;
+  },
+  /**
+   * Python set.intersection() - returns new set with common elements
+   */
+  intersection(a, b) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of a) {
+      if (b.has(item)) result.add(item);
+    }
+    return result;
+  },
+  /**
+   * Python set.intersection_update() - keep only common elements
+   */
+  intersectionUpdate(a, b) {
+    for (const item of a) {
+      if (!b.has(item)) a.delete(item);
+    }
+  },
+  /**
+   * Python set.difference() - returns new set with elements in a but not in b
+   */
+  difference(a, b) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of a) {
+      if (!b.has(item)) result.add(item);
+    }
+    return result;
+  },
+  /**
+   * Python set.difference_update() - remove elements found in b
+   */
+  differenceUpdate(a, b) {
+    for (const item of b) {
+      a.delete(item);
+    }
+  },
+  /**
+   * Python set.symmetric_difference() - returns new set with elements in either but not both
+   */
+  symmetricDifference(a, b) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of a) {
+      if (!b.has(item)) result.add(item);
+    }
+    for (const item of b) {
+      if (!a.has(item)) result.add(item);
+    }
+    return result;
+  },
+  /**
+   * Python set.symmetric_difference_update() - update with symmetric difference
+   */
+  symmetricDifferenceUpdate(a, b) {
+    const toAdd = [];
+    const toRemove = [];
+    for (const item of a) {
+      if (b.has(item)) toRemove.push(item);
+    }
+    for (const item of b) {
+      if (!a.has(item)) toAdd.push(item);
+    }
+    for (const item of toRemove) a.delete(item);
+    for (const item of toAdd) a.add(item);
+  },
+  /**
+   * Python set.issubset() - test if all elements are in other
+   */
+  issubset(a, b) {
+    for (const item of a) {
+      if (!b.has(item)) return false;
+    }
+    return true;
+  },
+  /**
+   * Python set.issuperset() - test if all other elements are in this set
+   */
+  issuperset(a, b) {
+    for (const item of b) {
+      if (!a.has(item)) return false;
+    }
+    return true;
+  },
+  /**
+   * Python set.isdisjoint() - test if no common elements
+   */
+  isdisjoint(a, b) {
+    for (const item of a) {
+      if (b.has(item)) return false;
+    }
+    return true;
+  }
+};
+
+// src/index.ts
+var itertools = itertools_exports;
+var functools = functools_exports;
+var collections = collections_exports;
+var math = math_exports;
+var random = random_exports;
+var json = json_exports;
+var os = os_exports;
+var datetime = datetime_exports;
+var re = re_exports;
+var string2 = {
+  ...string,
+  ascii_lowercase,
+  ascii_uppercase,
+  ascii_letters,
+  digits,
+  hexdigits,
+  octdigits,
+  punctuation,
+  whitespace,
+  printable,
+  capwords,
+  Template
+};
+var list3 = Object.assign(
+  (iterable) => list(iterable),
+  list2
+);
+var dict3 = Object.assign(
+  (entries) => dict(entries),
+  dict2
+);
+var set3 = Object.assign(
+  (iterable) => set(iterable),
+  set2
+);
+var floordiv2 = floordiv;
+var mod2 = mod;
+var divmod2 = divmod;
+var sprintf2 = sprintf;
+var strFormat2 = strFormat;
+var slice2 = slice;
+var at2 = at;
+var contains2 = contains;
+var is2 = is;
+var range2 = range;
+var enumerate2 = enumerate;
+var zip2 = zip;
+var iter2 = iter;
+var reversed2 = reversed;
+var sorted2 = sorted;
+var map2 = map;
+var filter2 = filter;
+var tuple2 = tuple;
+var len2 = len;
+var abs2 = abs;
+var min2 = min;
+var max2 = max;
+var sum2 = sum;
+var all2 = all;
+var any2 = any;
+var round2 = round;
+var ord2 = ord;
+var chr2 = chr;
+var hex2 = hex;
+var oct2 = oct;
+var bin2 = bin;
+var int2 = int;
+var float2 = float;
+var str2 = str;
+var repr2 = repr;
+var bool2 = bool;
+var ascii2 = ascii;
+var isinstance2 = isinstance;
+var type2 = type;
+var input2 = input;
+var format2 = format;
+var py2 = {
+  // Namespaced methods
+  string,
+  list: list3,
+  dict: dict3,
+  set: set3,
+  // Core operations
+  floordiv,
+  pow,
+  mod,
+  divmod,
+  sprintf,
+  strFormat,
+  slice,
+  at,
+  repeat,
+  in: contains,
+  is,
+  // Iterables
+  range,
+  enumerate,
+  zip,
+  iter,
+  reversed,
+  sorted,
+  map,
+  filter,
+  // Collection constructors
+  tuple,
+  // Built-in functions
+  len,
+  abs,
+  min,
+  max,
+  sum,
+  all,
+  any,
+  round,
+  ord,
+  chr,
+  hex,
+  oct,
+  bin,
+  // Type conversions
+  int,
+  float,
+  str,
+  repr,
+  bool,
+  ascii,
+  // Type checking
+  isinstance,
+  type,
+  input,
+  format,
+  // Modules
+  itertools: itertools_exports,
+  functools: functools_exports,
+  math: math_exports,
+  random: random_exports,
+  json: json_exports,
+  os: os_exports,
+  datetime: datetime_exports,
+  re: re_exports,
+  // collections
+  Counter,
+  defaultdict,
+  deque,
+  // string module
+  Template,
+  ascii_lowercase,
+  ascii_uppercase,
+  ascii_letters,
+  digits,
+  hexdigits,
+  octdigits,
+  punctuation,
+  whitespace,
+  printable,
+  capwords
+};
+_setPyRef(py2);
+var index_default = py2;
+export {
+  abs2 as abs,
+  all2 as all,
+  any2 as any,
+  ascii2 as ascii,
+  at2 as at,
+  bin2 as bin,
+  bool2 as bool,
+  chr2 as chr,
+  collections,
+  contains2 as contains,
+  datetime,
+  index_default as default,
+  dict3 as dict,
+  divmod2 as divmod,
+  enumerate2 as enumerate,
+  filter2 as filter,
+  float2 as float,
+  floordiv2 as floordiv,
+  format2 as format,
+  functools,
+  hex2 as hex,
+  input2 as input,
+  int2 as int,
+  is2 as is,
+  isinstance2 as isinstance,
+  iter2 as iter,
+  itertools,
+  json,
+  len2 as len,
+  list3 as list,
+  map2 as map,
+  math,
+  max2 as max,
+  min2 as min,
+  mod2 as mod,
+  oct2 as oct,
+  ord2 as ord,
+  os,
+  pow,
+  py2 as py,
+  random,
+  range2 as range,
+  re,
+  repeat as repeatValue,
+  repr2 as repr,
+  reversed2 as reversed,
+  round2 as round,
+  set3 as set,
+  slice2 as slice,
+  sorted2 as sorted,
+  sprintf2 as sprintf,
+  str2 as str,
+  strFormat2 as strFormat,
+  string2 as string,
+  sum2 as sum,
+  tuple2 as tuple,
+  type2 as type,
+  zip2 as zip
+};
+//# sourceMappingURL=index.js.map