pythonlib 1.0.2 → 2.0.1

package/dist/chunk-5OKGPZBQ.js

@@ -0,0 +1,1106 @@
+// 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, type2) => {
+      if (type2 === "%") return "%";
+      if (index >= values.length) return match;
+      const value = values[index++];
+      switch (type2) {
+        case "s":
+          return String(value);
+        case "d":
+        case "i":
+          return String(Math.floor(Number(value)));
+        case "f":
+          if (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));
+        /* v8 ignore next 2 -- unreachable: regex only matches handled cases @preserve */
+        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 len2 = 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, len2);
+    actualStop = stop === void 0 ? len2 : normalizeIndex(stop, len2);
+  } else {
+    actualStart = start === void 0 ? len2 - 1 : normalizeIndex(start, len2, true);
+    actualStop = stop === void 0 ? -1 : normalizeIndex(stop, len2, true);
+  }
+  const result = [];
+  if (actualStep > 0) {
+    for (let i = actualStart; i < actualStop; i += actualStep) {
+      if (i >= 0 && i < len2) {
+        result.push(obj[i]);
+      }
+    }
+  } else {
+    for (let i = actualStart; i > actualStop; i += actualStep) {
+      if (i >= 0 && i < len2) {
+        result.push(obj[i]);
+      }
+    }
+  }
+  if (typeof obj === "string") {
+    return result.join("");
+  }
+  return result;
+}
+function at(obj, index) {
+  const len2 = obj.length;
+  const normalizedIndex = index < 0 ? len2 + index : index;
+  if (normalizedIndex < 0 || normalizedIndex >= len2) {
+    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
+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.isArray(iterable) ? iterable : Array.from(iterable);
+  return arr.toReversed();
+}
+function sorted(iterable, options) {
+  const key = options?.key ?? ((x) => x);
+  const reverse = options?.reverse ?? false;
+  const arr = Array.isArray(iterable) ? iterable : Array.from(iterable);
+  return arr.toSorted((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;
+  });
+}
+function getIterator(iterable) {
+  return iterable[Symbol.iterator]();
+}
+function map(fn, iterable) {
+  return getIterator(iterable).map(fn);
+}
+function filter(fn, iterable) {
+  const predicate = fn ?? ((x) => bool(x));
+  return getIterator(iterable).filter(predicate);
+}
+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) => repr(item)).join(", ") + "]";
+  }
+  if (x instanceof Map) {
+    const entries = Array.from(x.entries()).map(([k, v]) => `${repr(k)}: ${repr(v)}`).join(", ");
+    return "{" + entries + "}";
+  }
+  if (x instanceof Set) {
+    if (x.size === 0) {
+      return "set()";
+    }
+    return "{" + Array.from(x).map((item) => 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;
+    const signChar = intPart.startsWith("-") ? "-" : "";
+    const digits = signChar ? intPart.slice(1) : intPart;
+    const grouped = digits.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 = /^(.?[<>=^])?([+\- ])?([#])?(0)?(\d+)?([,_])?(?:\.(\d+))?([bcdeEfFgGnosxX%])?$/.exec(spec);
+  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.charAt(0);
+      align = alignPart.charAt(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 = /^([+\- ]|0[xXoObB])?(.*)$/.exec(result);
+      if (signMatch) {
+        const signPart = signMatch[1] ?? "";
+        const numPart = signMatch[2] ?? "";
+        result = signPart + padding + numPart;
+      }
+    }
+  }
+  return result;
+}
+function getattr(obj, name, defaultValue) {
+  if (obj === null || obj === void 0) {
+    if (arguments.length >= 3) {
+      return defaultValue;
+    }
+    throw new TypeError(
+      `'${obj === null ? "NoneType" : "undefined"}' object has no attribute '${name}'`
+    );
+  }
+  const target = obj;
+  if (name in target) {
+    return target[name];
+  }
+  if (arguments.length >= 3) {
+    return defaultValue;
+  }
+  throw new TypeError(`'${typeof obj}' object has no attribute '${name}'`);
+}
+function hasattr(obj, name) {
+  if (obj === null || obj === void 0) {
+    return false;
+  }
+  return name in obj;
+}
+function setattr(obj, name, value) {
+  if (obj === null || obj === void 0) {
+    throw new TypeError(
+      `'${obj === null ? "NoneType" : "undefined"}' object has no attribute '${name}'`
+    );
+  }
+  ;
+  obj[name] = value;
+}
+
+// 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 len2 = arr.length;
+    const actualStep = step ?? 1;
+    let actualStart = start ?? (actualStep > 0 ? 0 : len2 - 1);
+    let actualEnd = end ?? (actualStep > 0 ? len2 : -len2 - 1);
+    if (actualStart < 0) actualStart = Math.max(0, len2 + actualStart);
+    if (actualEnd < 0) actualEnd = Math.max(0, len2 + actualEnd);
+    actualStart = Math.min(actualStart, len2);
+    actualEnd = Math.min(actualEnd, len2);
+    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);
+    const key = keys.pop();
+    if (key === void 0) {
+      throw new Error("dictionary is empty");
+    }
+    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
+   * Uses ES2024 Set.prototype.union()
+   */
+  union(a, ...others) {
+    let result = new Set(a);
+    for (const other of others) {
+      result = result.union(other instanceof Set ? other : new Set(other));
+    }
+    return result;
+  },
+  /**
+   * Python set.intersection() - returns new set with common elements
+   * Uses ES2024 Set.prototype.intersection()
+   */
+  intersection(a, b) {
+    return a.intersection(b);
+  },
+  /**
+   * 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
+   * Uses ES2024 Set.prototype.difference()
+   */
+  difference(a, b) {
+    return a.difference(b);
+  },
+  /**
+   * 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
+   * Uses ES2024 Set.prototype.symmetricDifference()
+   */
+  symmetricDifference(a, b) {
+    return a.symmetricDifference(b);
+  },
+  /**
+   * Python set.symmetric_difference_update() - update with symmetric difference
+   * Uses ES2024 Set.prototype.symmetricDifference()
+   */
+  symmetricDifferenceUpdate(a, b) {
+    const result = a.symmetricDifference(b);
+    a.clear();
+    for (const item of result) a.add(item);
+  },
+  /**
+   * Python set.isSubset() - test if all elements are in other
+   * Uses ES2024 Set.prototype.isSubsetOf()
+   */
+  isSubset(a, b) {
+    return a.isSubsetOf(b);
+  },
+  /**
+   * Python set.isSuperset() - test if all other elements are in this set
+   * Uses ES2024 Set.prototype.isSupersetOf()
+   */
+  isSuperset(a, b) {
+    return a.isSupersetOf(b);
+  },
+  /**
+   * Python set.isDisjoint() - test if no common elements
+   * Uses ES2024 Set.prototype.isDisjointFrom()
+   */
+  isDisjoint(a, b) {
+    return a.isDisjointFrom(b);
+  }
+};
+
+export {
+  floorDiv,
+  pow,
+  mod,
+  divMod,
+  sprintf,
+  strFormat,
+  slice,
+  at,
+  repeat,
+  contains,
+  is,
+  range,
+  enumerate,
+  zip,
+  iter,
+  reversed,
+  sorted,
+  map,
+  filter,
+  list,
+  dict,
+  set,
+  tuple,
+  len,
+  abs,
+  min,
+  max,
+  sum,
+  all,
+  any,
+  round,
+  ord,
+  chr,
+  hex,
+  oct,
+  bin,
+  int,
+  float,
+  str,
+  repr,
+  bool,
+  ascii,
+  isinstance,
+  type,
+  input,
+  format,
+  getattr,
+  hasattr,
+  setattr,
+  list2,
+  dict2,
+  set2
+};
+/* v8 ignore next -- fallback for unrecognized format types @preserve */