@cortexkit/pi-magic-context 0.42.5 → 0.43.0

package/dist/transformers-web.js

@@ -1,12 +1,12 @@
-// ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/dist/transformers.web.js
+// ../../node_modules/.bun/@huggingface+transformers@4.3.0+4d96f45ad8218cb4/node_modules/@huggingface/transformers/dist/transformers.web.js
 import * as ONNX_WEB from "onnxruntime-web/webgpu";
 
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/backend-impl.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/backend-impl.js
 var backends = new Map;
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/version.js
-var version = "1.24.3";
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/version.js
+var version = "1.30.0";
 
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/env-impl.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/env-impl.js
 var logLevelValue = "warning";
 var env = {
   wasm: {},
@@ -27,7 +27,7 @@ var env = {
   }
 };
 Object.defineProperty(env, "logLevel", { enumerable: true });
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/tensor-conversion-impl.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/tensor-conversion-impl.js
 var tensorToDataURL = (tensor, options) => {
   const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(1, 1);
   canvas.width = tensor.dims[3];
@@ -186,7 +186,7 @@ var tensorToImageData = (tensor, options) => {
   return image;
 };
 
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/tensor-factory-impl.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/tensor-factory-impl.js
 var bufferToTensor = (buffer, options) => {
   if (buffer === undefined) {
     throw new Error("Image buffer must be defined");
@@ -395,7 +395,7 @@ var tensorFromMLTensor = (mlTensor, options) => {
 };
 var tensorFromPinnedBuffer = (type, buffer, dims) => new Tensor({ location: "cpu-pinned", type, data: buffer, dims: dims ?? [buffer.length] });
 
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/tensor-impl-type-mapping.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/tensor-impl-type-mapping.js
 var NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map([
   ["float32", Float32Array],
   ["uint8", Uint8Array],
@@ -444,7 +444,7 @@ var checkTypedArray = () => {
   }
 };
 
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/tensor-utils-impl.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/tensor-utils-impl.js
 var calculateSize = (dims) => {
   let size = 1;
   for (let i = 0;i < dims.length; i++) {
@@ -496,7 +496,7 @@ var tensorReshape = (tensor, dims) => {
   }
 };
 
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/tensor-impl.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/tensor-impl.js
 class Tensor {
   constructor(arg0, arg1, arg2) {
     checkTypedArray();
@@ -749,10 +749,10 @@ class Tensor {
   }
 }
 
-// ../../node_modules/.bun/onnxruntime-common@1.24.3/node_modules/onnxruntime-common/dist/esm/tensor.js
+// ../../node_modules/.bun/onnxruntime-common@1.30.0/node_modules/onnxruntime-common/dist/esm/tensor.js
 var Tensor2 = Tensor;
-// ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/dist/transformers.web.js
-var __dirname = "/home/runner/work/magic-context/magic-context/node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/dist";
+// ../../node_modules/.bun/@huggingface+transformers@4.3.0+4d96f45ad8218cb4/node_modules/@huggingface/transformers/dist/transformers.web.js
+var __dirname = "/home/runner/work/magic-context/magic-context/node_modules/.bun/@huggingface+transformers@4.3.0+4d96f45ad8218cb4/node_modules/@huggingface/transformers/dist";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -761,7 +761,7 @@ var __export = (target, all) => {
 var node_fs_default = {};
 var node_path_default = {};
 var node_url_default = {};
-var VERSION = "4.2.0";
+var VERSION = "4.3.0";
 var HAS_SELF = typeof self !== "undefined";
 var IS_FS_AVAILABLE = !isEmpty(node_fs_default);
 var IS_PATH_AVAILABLE = !isEmpty(node_path_default);
@@ -779,17 +779,19 @@ var IS_WEBNN_AVAILABLE = typeof navigator !== "undefined" && "ml" in navigator;
 var IS_CRYPTO_AVAILABLE = typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function";
 var IS_CHROME_AVAILABLE = typeof chrome !== "undefined" && typeof chrome.runtime !== "undefined" && typeof chrome.runtime.id === "string";
 var IS_SERVICE_WORKER_ENV = typeof ServiceWorkerGlobalScope !== "undefined" && HAS_SELF && self instanceof ServiceWorkerGlobalScope;
-var isSafari = () => {
+var isSafariBelow26 = () => {
   if (typeof navigator === "undefined") {
     return false;
   }
   const userAgent = navigator.userAgent;
-  const vendor = navigator.vendor || "";
-  const isAppleVendor = vendor.indexOf("Apple") > -1;
-  const notOtherBrowser = !userAgent.match(/CriOS|FxiOS|EdgiOS|OPiOS|mercury|brave/i) && !userAgent.includes("Chrome") && !userAgent.includes("Android");
-  return isAppleVendor && notOtherBrowser;
+  const isSafari = (navigator.vendor || "").indexOf("Apple") > -1 && !userAgent.match(/CriOS|FxiOS|EdgiOS|OPiOS|mercury|brave/i) && !userAgent.includes("Chrome") && !userAgent.includes("Android");
+  if (!isSafari) {
+    return false;
+  }
+  const match = userAgent.match(/Version\/(\d+)/);
+  return match ? parseInt(match[1], 10) < 26 : false;
 };
-var IS_SAFARI = isSafari();
+var IS_SAFARI_BELOW_26 = isSafariBelow26();
 var apis = Object.freeze({
   IS_BROWSER_ENV,
   IS_WEBWORKER_ENV,
@@ -799,7 +801,7 @@ var apis = Object.freeze({
   IS_WEB_CACHE_AVAILABLE,
   IS_WEBGPU_AVAILABLE,
   IS_WEBNN_AVAILABLE,
-  IS_SAFARI,
+  IS_SAFARI_BELOW_26,
   IS_PROCESS_AVAILABLE,
   IS_NODE_ENV,
   IS_FS_AVAILABLE,
@@ -810,7 +812,7 @@ var apis = Object.freeze({
 var RUNNING_LOCALLY = IS_FS_AVAILABLE && IS_PATH_AVAILABLE;
 var dirname__ = "./";
 if (RUNNING_LOCALLY) {
-  const _import_meta_url = Object(import.meta).url;
+  const _import_meta_url = import.meta.url;
   if (_import_meta_url) {
     dirname__ = node_path_default.dirname(node_path_default.dirname(node_url_default.fileURLToPath(_import_meta_url)));
   } else if (typeof __dirname !== "undefined") {
@@ -880,6 +882,7 @@ var DefaultProgressCallback = class extends Callable {
     super();
     this.callback = callback;
     this.files_loading = files_loading;
+    this.loads = /* @__PURE__ */ new Map;
   }
   _call(info) {
     if (info.status === "progress") {
@@ -1027,75 +1030,46 @@ var AddedToken = class {
   }
 };
 var AddedToken_default = AddedToken;
-var BYTES_TO_UNICODE = (() => {
-  const bs = [
-    ...Array.from({ length: 126 - 33 + 1 }, (_, i) => i + 33),
-    ...Array.from({ length: "¬".charCodeAt(0) - "¡".charCodeAt(0) + 1 }, (_, i) => i + "¡".charCodeAt(0)),
-    ...Array.from({ length: "ÿ".charCodeAt(0) - "®".charCodeAt(0) + 1 }, (_, i) => i + "®".charCodeAt(0))
-  ];
-  const cs = bs.slice();
-  let n = 0;
-  for (let b = 0;b < 256; ++b) {
-    if (!bs.includes(b)) {
-      bs.push(b);
-      cs.push(256 + n);
-      n += 1;
-    }
-  }
-  const ccs = cs.map((n2) => String.fromCharCode(n2));
-  return Object.fromEntries(bs.map((b, i) => [b, ccs[i]]));
-})();
-var reverse_dictionary = (data) => Object.fromEntries(Object.entries(data).map(([key, value]) => [value, key]));
-var UNICODE_TO_BYTES = reverse_dictionary(BYTES_TO_UNICODE);
-var BLOOM_SPLIT_CHARS = ".,!?…。，、।۔،";
-var PROBLEMATIC_REGEX_MAP = /* @__PURE__ */ new Map([
-  [
-    "(?i:'s|'t|'re|'ve|'m|'ll|'d)",
-    "(?:'([sS]|[tT]|[rR][eE]|[vV][eE]|[mM]|[lL][lL]|[dD]))"
-  ],
-  [
-    "(?i:[sdmt]|ll|ve|re)",
-    "(?:[sS]|[dD]|[mM]|[tT]|[lL][lL]|[vV][eE]|[rR][eE])"
-  ],
-  ["[^\\r\\n\\p{L}\\p{N}]?+", "[^\\r\\n\\p{L}\\p{N}]?"],
-  ["[^\\s\\p{L}\\p{N}]++", "[^\\s\\p{L}\\p{N}]+"],
-  ["(?>\\p{Nd}{510})", "(?:\\p{Nd}{510})"],
-  ["\\p{Nd}{3}+", "(?:\\p{Nd}{3})+"],
-  ["\\G", ""],
-  [` ?[^(\\s|[${BLOOM_SPLIT_CHARS}])]+`, ` ?[^\\s${BLOOM_SPLIT_CHARS}]+`]
-]);
-var PUNCTUATION_REGEX = "\\p{P}\\u0021-\\u002F\\u003A-\\u0040\\u005B-\\u0060\\u007B-\\u007E";
-var clean_up_tokenization = (text) => text.replace(/ \./g, ".").replace(/ \?/g, "?").replace(/ \!/g, "!").replace(/ ,/g, ",").replace(/ \' /g, "'").replace(/ n't/g, "n't").replace(/ 'm/g, "'m").replace(/ 's/g, "'s").replace(/ 've/g, "'ve").replace(/ 're/g, "'re");
-var create_pattern = (pattern, invert = true) => {
-  if (pattern.Regex !== undefined) {
-    let regex = pattern.Regex.replace(/\\([#&~])/g, "$1");
-    regex = regex.replace(/\\A/g, "^").replace(/\\z/g, "$").replace(/\\Z/g, "(?=\\r?\\n?$)");
-    for (const [key, value] of PROBLEMATIC_REGEX_MAP) {
-      regex = regex.replaceAll(key, value);
-    }
-    try {
-      return new RegExp(regex, "gu");
-    } catch (error) {
-      if (!(error instanceof SyntaxError) || !error.message.toLowerCase().includes("invalid property name"))
-        throw error;
-      let changed = false;
-      const fixed = regex.replace(/(\\[pP])\{([^}=]+)\}/g, (_, p, n) => {
+var compile_unicode_regexp = (source, flags) => {
+  try {
+    return new RegExp(source, flags);
+  } catch (error) {
+    if (!(error instanceof SyntaxError))
+      throw error;
+    const property_names = /* @__PURE__ */ new Map;
+    const rewritten = source.replace(/(\\[pP])\{([^}=]+)\}/g, (text, p, n, offset) => {
+      let preceding_backslashes = 0;
+      for (let i = offset - 1;i >= 0 && source[i] === "\\"; --i) {
+        ++preceding_backslashes;
+      }
+      if (preceding_backslashes % 2 === 1)
+        return text;
+      let property_name = property_names.get(n);
+      if (property_name === undefined) {
         try {
           new RegExp(`\\p{${n}}`, "u");
-          return `${p}{${n}}`;
+          property_name = n;
         } catch {
-          changed = true;
-          return `${p}{Script=${n}}`;
+          property_name = `Script=${n}`;
         }
-      });
-      if (!changed)
-        throw error;
-      try {
-        return new RegExp(fixed, "gu");
-      } catch (e) {
-        throw error;
+        property_names.set(n, property_name);
       }
+      return `${p}{${property_name}}`;
+    });
+    if (rewritten === source)
+      throw error;
+    try {
+      return new RegExp(rewritten, flags);
+    } catch {
+      throw error;
     }
+  }
+};
+var clean_up_tokenization = (text) => text.replace(/ \./g, ".").replace(/ \?/g, "?").replace(/ \!/g, "!").replace(/ ,/g, ",").replace(/ \' /g, "'").replace(/ n't/g, "n't").replace(/ 'm/g, "'m").replace(/ 's/g, "'s").replace(/ 've/g, "'ve").replace(/ 're/g, "'re");
+var create_pattern = (pattern, invert = true) => {
+  if (pattern.Regex !== undefined) {
+    const regex = rewrite_oniguruma_to_js(normalize_bloom_split_char_class(pattern.Regex));
+    return compile_unicode_regexp(regex, "gu");
   } else if (pattern.String !== undefined) {
     const escaped = escape_reg_exp(pattern.String);
     return new RegExp(invert ? escaped : `(${escaped})`, "gu");
@@ -1104,6 +1078,473 @@ var create_pattern = (pattern, invert = true) => {
     return null;
   }
 };
+var UNICODE_WORD_CHARS_IN_CLASS = "\\p{Alphabetic}\\p{M}\\p{Nd}\\p{Pc}";
+var UNICODE_WORD_CHARS = `${UNICODE_WORD_CHARS_IN_CLASS}\\u00B2\\u00B3\\u00B9\\u00BC-\\u00BE`;
+var UNICODE_WORD_CLASS = `[${UNICODE_WORD_CHARS}]`;
+var UNICODE_NON_WORD_CLASS = `[^${UNICODE_WORD_CHARS}]`;
+var UNICODE_WORD_BOUNDARY = `(?:(?<!${UNICODE_WORD_CLASS})(?=${UNICODE_WORD_CLASS})|(?<=${UNICODE_WORD_CLASS})(?!${UNICODE_WORD_CLASS}))`;
+var UNICODE_NON_WORD_BOUNDARY = `(?:(?<!${UNICODE_WORD_CLASS})(?!${UNICODE_WORD_CLASS})|(?<=${UNICODE_WORD_CLASS})(?=${UNICODE_WORD_CLASS}))`;
+var LINE_START_ANCHOR = "(?:(?<![\\s\\S])|(?<=\\n))";
+var LINE_END_ANCHOR = "(?:(?=\\n)|(?![\\s\\S]))";
+var HEX_DIGIT_CHARS = "0-9A-Fa-f";
+var ESCAPE_REWRITES = /* @__PURE__ */ new Map([
+  ["A", "(?<![\\s\\S])"],
+  ["z", "(?![\\s\\S])"],
+  ["Z", "(?=\\n?(?![\\s\\S]))"],
+  ["h", `[${HEX_DIGIT_CHARS}]`],
+  ["H", `[^${HEX_DIGIT_CHARS}]`],
+  ["w", UNICODE_WORD_CLASS],
+  ["W", UNICODE_NON_WORD_CLASS],
+  ["d", "\\p{Nd}"],
+  ["D", "\\P{Nd}"],
+  ["s", "\\p{White_Space}"],
+  ["S", "\\P{White_Space}"],
+  ["b", UNICODE_WORD_BOUNDARY],
+  ["B", UNICODE_NON_WORD_BOUNDARY],
+  ["a", "\\x07"],
+  ["e", "\\x1B"]
+]);
+var CLASS_ESCAPE_REWRITES = /* @__PURE__ */ new Map([
+  ["h", HEX_DIGIT_CHARS],
+  ["w", UNICODE_WORD_CHARS_IN_CLASS],
+  ["d", "\\p{Nd}"],
+  ["D", "\\P{Nd}"],
+  ["s", "\\p{White_Space}"],
+  ["S", "\\P{White_Space}"],
+  ["a", "\\x07"],
+  ["e", "\\x1B"]
+]);
+var CLASS_COMPLEMENT_ALTERNATIVES = /* @__PURE__ */ new Map([
+  ["W", `[^${UNICODE_WORD_CHARS_IN_CLASS}]`],
+  ["H", `[^${HEX_DIGIT_CHARS}]`]
+]);
+var RAW_WHITESPACE_ESCAPES = /* @__PURE__ */ new Map([
+  [`
+`, "\\n"],
+  ["\r", "\\r"],
+  ["\t", "\\t"],
+  ["\f", "\\f"],
+  ["\v", "\\v"]
+]);
+var POSIX_CLASS_FRAGMENTS = /* @__PURE__ */ new Map([
+  ["alpha", "\\p{Alphabetic}"],
+  ["alnum", "\\p{Alphabetic}\\p{Nd}"],
+  ["digit", "\\p{Nd}"],
+  ["lower", "\\p{Lowercase}"],
+  ["upper", "\\p{Uppercase}"],
+  ["space", "\\p{White_Space}"],
+  ["blank", "\\t\\p{Zs}"],
+  ["punct", "\\p{P}\\p{S}"],
+  ["cntrl", "\\p{Cc}"],
+  ["word", UNICODE_WORD_CHARS_IN_CLASS],
+  ["xdigit", HEX_DIGIT_CHARS]
+]);
+var JS_SYNTAX_CHARS = "^$\\.*+?()[]{}|/";
+var GROUP_PREFIX_RE = /^\(\?(?:<[=!]|<[A-Za-z_][A-Za-z0-9_]*>|[:=!>])/;
+var BRACED_ESCAPE_RE = /^\\([pPxu])\{([^}]*)\}/;
+var QUANTIFIER_BRACE_RE = /^\{(\d+(?:,\d*)?|,\d+)\}/;
+var POSIX_BRACKET_RE = /^\[:(\^?)(\p{Alphabetic}+):\]/u;
+var EMPTY_NEGATED_POSIX_BRACKET_RE = /^\[:\^:\]/;
+var UNSUPPORTED_POSIX_BRACKET_RE = /^\[(?:\.[^\]]*\.\]|=[^\]]*=\])/;
+var FIXED_WIDTH_ESCAPE_RE = /^(?:\\x[0-9A-Fa-f]{2}|\\u[0-9A-Fa-f]{4}|\\c[A-Za-z])/;
+var is_ascii_letter = (char) => char >= "A" && char <= "Z" || char >= "a" && char <= "z";
+var character_at = (text, index) => String.fromCodePoint(text.codePointAt(index));
+var get_ascii_folded_hex_atom = (hex) => {
+  if (!/^[0-9A-Fa-f]{1,8}$/.test(hex))
+    return null;
+  const code_point = Number.parseInt(hex, 16);
+  if (code_point > 127)
+    return null;
+  const letter = String.fromCharCode(code_point);
+  return is_ascii_letter(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : null;
+};
+var normalize_bloom_split_char_class = (regex) => regex.replace(/\[\^\(\\s\|\[([^\]]+)\]\)\]/g, "[^()|\\s$1]");
+var ANY_CODE_POINT = "[\\s\\S]";
+var MAX_CHARACTER_CLASS_NESTING_DEPTH = 256;
+var create_character_class_operand = () => ({
+  fragment: "",
+  alternatives: [],
+  tail: null,
+  contains_complex_set: false
+});
+var throw_character_class_range_error = (index) => {
+  throw new SyntaxError(`Unsupported range with a set-valued character-class operand at index ${index}`);
+};
+var add_character_class_atom = (operand, atom, index, contains_complex_set = true) => {
+  if (operand.tail === "range")
+    throw_character_class_range_error(index);
+  operand.alternatives.push(atom);
+  operand.tail = "set";
+  operand.contains_complex_set = operand.contains_complex_set || contains_complex_set;
+};
+var append_character_class_fragment = (operand, fragment, set_valued = false, index = -1) => {
+  if (set_valued && operand.tail === "range") {
+    throw_character_class_range_error(index);
+  }
+  if (operand.tail === "range") {
+    operand.fragment += fragment;
+    operand.tail = "complete_range";
+    return;
+  }
+  operand.fragment += fragment;
+  operand.tail = set_valued ? "set" : "scalar";
+  operand.contains_complex_set = operand.contains_complex_set || set_valued;
+};
+var rewrite_character_class_escape = (regex, index, operand) => {
+  const braced = BRACED_ESCAPE_RE.exec(regex.slice(index));
+  if (braced) {
+    const [text, kind, body] = braced;
+    if (kind === "P" && body === "Word") {
+      add_character_class_atom(operand, `[^${UNICODE_WORD_CHARS_IN_CLASS}]`, index);
+    } else {
+      const replacement2 = kind === "x" ? `\\u{${body}}` : kind === "p" && body === "Word" ? UNICODE_WORD_CHARS_IN_CLASS : text;
+      append_character_class_fragment(operand, replacement2, kind === "p" || kind === "P", index);
+    }
+    return index + text.length;
+  }
+  const fixed_width = FIXED_WIDTH_ESCAPE_RE.exec(regex.slice(index));
+  if (fixed_width) {
+    append_character_class_fragment(operand, fixed_width[0]);
+    return index + fixed_width[0].length;
+  }
+  if (index + 1 >= regex.length) {
+    throw new SyntaxError(`Unterminated escape in character class at index ${index}`);
+  }
+  const next = character_at(regex, index + 1);
+  const next_end = index + 1 + next.length;
+  const raw_whitespace = RAW_WHITESPACE_ESCAPES.get(next);
+  if (raw_whitespace !== undefined) {
+    append_character_class_fragment(operand, raw_whitespace);
+    return next_end;
+  }
+  const complement = CLASS_COMPLEMENT_ALTERNATIVES.get(next);
+  if (complement !== undefined) {
+    add_character_class_atom(operand, complement, index);
+    return next_end;
+  }
+  const rewrite = CLASS_ESCAPE_REWRITES.get(next);
+  let replacement;
+  let set_valued = false;
+  if (rewrite !== undefined) {
+    replacement = rewrite;
+    set_valued = next !== "a" && next !== "e";
+  } else if (/[A-Za-z0-9]/.test(next)) {
+    replacement = `\\${next}`;
+  } else if (JS_SYNTAX_CHARS.includes(next) || next === "-") {
+    replacement = `\\${next}`;
+  } else {
+    replacement = next;
+  }
+  append_character_class_fragment(operand, replacement, set_valued, index);
+  return next_end;
+};
+var compile_character_set_union = (pieces) => {
+  if (pieces.length === 1)
+    return pieces[0];
+  return `(?:(?=(?:${pieces.join("|")}))${ANY_CODE_POINT})`;
+};
+var compile_character_class_operand = (operand) => {
+  const pieces = operand.fragment.length === 0 ? operand.alternatives : [`[${operand.fragment}]`, ...operand.alternatives];
+  return compile_character_set_union(pieces);
+};
+var get_ascii_fold_additions = (positive_atom) => {
+  const membership = compile_unicode_regexp(`^(?:${positive_atom})$`, "u");
+  let additions = "";
+  for (let offset = 0;offset < 26; ++offset) {
+    const upper = String.fromCharCode(65 + offset);
+    const lower = String.fromCharCode(97 + offset);
+    const has_upper = membership.test(upper);
+    const has_lower = membership.test(lower);
+    if (has_upper !== has_lower)
+      additions += has_upper ? lower : upper;
+  }
+  return additions;
+};
+var parse_character_class = (regex, start, ascii_fold, apply_ascii_fold = true, nesting_depth = 1) => {
+  if (nesting_depth > MAX_CHARACTER_CLASS_NESTING_DEPTH) {
+    throw new SyntaxError(`Maximum character-class nesting depth of ${MAX_CHARACTER_CLASS_NESTING_DEPTH} exceeded at index ${start}`);
+  }
+  let i = start + 1;
+  const negated = regex[i] === "^";
+  if (negated)
+    ++i;
+  const first_content_index = i;
+  const operands = [create_character_class_operand()];
+  let operand = operands[0];
+  let contains_nested_negated_complex_set = false;
+  while (i < regex.length) {
+    const char = character_at(regex, i);
+    if (char === "\\") {
+      i = rewrite_character_class_escape(regex, i, operand);
+      continue;
+    }
+    if (char === "]") {
+      if (i === first_content_index) {
+        append_character_class_fragment(operand, "\\]");
+        ++i;
+        continue;
+      }
+      if (operand.tail === null) {
+        if (operands.length > 1) {
+          throw new SyntaxError(`Malformed character-class intersection with an empty operand at index ${i}`);
+        }
+        throw new SyntaxError(`Empty character class at index ${start}`);
+      }
+      const contains_complex_set = operands.some((candidate) => candidate.contains_complex_set);
+      if (negated && operands.length > 1 && contains_nested_negated_complex_set) {
+        throw new SyntaxError(`Unsupported outer-negated character-class intersection with a nested negated class containing a Unicode property, POSIX class, or shorthand at index ${start}`);
+      }
+      const first_atom = compile_character_class_operand(operands[0]);
+      let positive_atom = first_atom;
+      if (operands.length > 1) {
+        let lookaheads = "";
+        for (let j = 1;j < operands.length; ++j) {
+          lookaheads += `(?=${compile_character_class_operand(operands[j])})`;
+        }
+        positive_atom = `(?:${lookaheads}${first_atom})`;
+      }
+      const is_direct_class = operands.length === 1 && operand.alternatives.length === 0;
+      let direct_fragment = operand.fragment;
+      if (ascii_fold && apply_ascii_fold) {
+        const additions = get_ascii_fold_additions(positive_atom);
+        if (additions.length > 0) {
+          if (is_direct_class) {
+            direct_fragment += additions;
+            positive_atom = `[${direct_fragment}]`;
+          } else {
+            positive_atom = compile_character_set_union([
+              positive_atom,
+              `[${additions}]`
+            ]);
+          }
+        }
+      }
+      const atom = negated ? is_direct_class ? `[^${direct_fragment}]` : `(?:(?!${positive_atom})${ANY_CODE_POINT})` : positive_atom;
+      return {
+        atom,
+        end: i + 1,
+        negated,
+        contains_complex_set,
+        contains_nested_negated_complex_set
+      };
+    }
+    if (regex.startsWith("&&", i)) {
+      if (operand.tail === null) {
+        throw new SyntaxError(`Malformed character-class intersection with an empty operand at index ${i}`);
+      }
+      operand = create_character_class_operand();
+      operands.push(operand);
+      i += 2;
+      continue;
+    }
+    if (char === "[") {
+      const suffix = regex.slice(i);
+      if (EMPTY_NEGATED_POSIX_BRACKET_RE.test(suffix)) {
+        throw new SyntaxError(`Malformed empty negated POSIX character class at index ${i}`);
+      }
+      const posix = POSIX_BRACKET_RE.exec(suffix);
+      if (posix) {
+        const [, posix_negated, name] = posix;
+        const fragment = POSIX_CLASS_FRAGMENTS.get(name);
+        if (fragment === undefined) {
+          throw new SyntaxError(`Unsupported POSIX character class "${name}" at index ${i}`);
+        }
+        if (ascii_fold && posix_negated && (name === "lower" || name === "upper")) {
+          throw new SyntaxError(`Unsupported negated POSIX ${name} class inside an inline case-insensitive group`);
+        }
+        if (posix_negated) {
+          add_character_class_atom(operand, `[^${fragment}]`, i);
+        } else {
+          append_character_class_fragment(operand, fragment, true, i);
+        }
+        i += posix[0].length;
+        continue;
+      }
+      if (UNSUPPORTED_POSIX_BRACKET_RE.test(suffix)) {
+        throw new SyntaxError(`Unsupported POSIX collating or equivalence bracket expression at index ${i}`);
+      }
+      const nested = parse_character_class(regex, i, ascii_fold, false, nesting_depth + 1);
+      add_character_class_atom(operand, nested.atom, i, nested.contains_complex_set);
+      contains_nested_negated_complex_set ||= nested.contains_nested_negated_complex_set || nested.negated && nested.contains_complex_set;
+      i = nested.end;
+      continue;
+    }
+    if (char === "-") {
+      const is_terminal_literal = regex[i + 1] === "]" || regex.startsWith("&&", i + 1);
+      if (operand.tail === "set" && !is_terminal_literal) {
+        throw_character_class_range_error(i);
+      }
+      if (operand.tail === null || operand.tail === "range" || operand.tail === "complete_range" || is_terminal_literal) {
+        append_character_class_fragment(operand, "\\-");
+      } else {
+        operand.fragment += "-";
+        operand.tail = "range";
+      }
+      ++i;
+      continue;
+    }
+    append_character_class_fragment(operand, char === "^" && operand.fragment.length === 0 ? "\\^" : char);
+    i += char.length;
+  }
+  throw new SyntaxError(`${operands.length > 1 ? "Unterminated character-class intersection" : "Unterminated character class"} at index ${start}`);
+};
+var rewrite_oniguruma_to_js = (regex) => {
+  let out = "";
+  let atom_start = -1;
+  let last_was_quantifier = false;
+  let ascii_fold = false;
+  const group_states = [];
+  const emit_atom = (text) => {
+    atom_start = out.length;
+    out += text;
+    last_was_quantifier = false;
+  };
+  for (let i = 0;i < regex.length; ) {
+    const char = character_at(regex, i);
+    if (char === "\\") {
+      const braced = BRACED_ESCAPE_RE.exec(regex.slice(i));
+      if (braced) {
+        const [text, kind, body] = braced;
+        let replacement2 = text;
+        if (kind === "x") {
+          const code_point_escape = `\\u{${body}}`;
+          replacement2 = ascii_fold ? get_ascii_folded_hex_atom(body) ?? code_point_escape : code_point_escape;
+        } else if (body === "Word") {
+          replacement2 = kind === "p" ? UNICODE_WORD_CLASS : UNICODE_NON_WORD_CLASS;
+        }
+        emit_atom(replacement2);
+        i += text.length;
+        continue;
+      }
+      const fixed_width = FIXED_WIDTH_ESCAPE_RE.exec(regex.slice(i));
+      if (fixed_width) {
+        const text = fixed_width[0];
+        const replacement2 = ascii_fold && text[1] !== "c" ? get_ascii_folded_hex_atom(text.slice(2)) ?? text : text;
+        emit_atom(replacement2);
+        i += text.length;
+        continue;
+      }
+      if (i + 1 >= regex.length) {
+        out += char;
+        break;
+      }
+      const next = character_at(regex, i + 1);
+      i += 1 + next.length;
+      if (next === "G") {
+        continue;
+      }
+      const raw_whitespace = RAW_WHITESPACE_ESCAPES.get(next);
+      if (raw_whitespace !== undefined) {
+        emit_atom(raw_whitespace);
+        continue;
+      }
+      const rewrite = ESCAPE_REWRITES.get(next);
+      let replacement;
+      if (rewrite !== undefined) {
+        replacement = rewrite;
+      } else if (/[A-Za-z0-9]/.test(next)) {
+        replacement = `\\${next}`;
+      } else if (JS_SYNTAX_CHARS.includes(next)) {
+        replacement = `\\${next}`;
+      } else {
+        replacement = next;
+      }
+      emit_atom(replacement);
+      continue;
+    }
+    switch (char) {
+      case "[": {
+        const parsed = parse_character_class(regex, i, ascii_fold);
+        emit_atom(parsed.atom);
+        i = parsed.end;
+        continue;
+      }
+      case "]":
+        emit_atom("\\]");
+        ++i;
+        continue;
+      case ".":
+        emit_atom("[^\\n]");
+        ++i;
+        continue;
+      case "^":
+        emit_atom(LINE_START_ANCHOR);
+        ++i;
+        continue;
+      case "$":
+        emit_atom(LINE_END_ANCHOR);
+        ++i;
+        continue;
+      case "(": {
+        const inline_case_insensitive = regex.startsWith("(?i:", i);
+        const source_prefix = inline_case_insensitive ? "(?i:" : GROUP_PREFIX_RE.exec(regex.slice(i))?.[0] ?? "(";
+        const output_prefix = inline_case_insensitive ? "(?:" : source_prefix === "(?>" ? "(?:" : source_prefix;
+        group_states.push([out.length, ascii_fold]);
+        if (inline_case_insensitive)
+          ascii_fold = true;
+        out += output_prefix;
+        last_was_quantifier = false;
+        i += source_prefix.length;
+        continue;
+      }
+      case ")":
+        out += char;
+        [atom_start, ascii_fold] = group_states.pop() ?? [-1, false];
+        last_was_quantifier = false;
+        ++i;
+        continue;
+      case "|":
+        out += char;
+        atom_start = -1;
+        last_was_quantifier = false;
+        ++i;
+        continue;
+      case "{": {
+        const quant = QUANTIFIER_BRACE_RE.exec(regex.slice(i));
+        if (!quant || atom_start < 0) {
+          emit_atom("\\{");
+          ++i;
+          continue;
+        }
+        const body = quant[1].startsWith(",") ? `0${quant[1]}` : quant[1];
+        i += quant[0].length;
+        const following = regex[i];
+        if (following === "+" || following === "*") {
+          out = `${out.slice(0, atom_start)}(?:${out.slice(atom_start)}{${body}})${following}`;
+          ++i;
+        } else {
+          out += `{${body}}`;
+        }
+        last_was_quantifier = true;
+        continue;
+      }
+      case "}":
+        emit_atom("\\}");
+        ++i;
+        continue;
+      case "+":
+        if (last_was_quantifier) {
+          ++i;
+          continue;
+        }
+        out += char;
+        last_was_quantifier = true;
+        ++i;
+        continue;
+      case "*":
+      case "?":
+        out += char;
+        last_was_quantifier = true;
+        ++i;
+        continue;
+      default:
+        emit_atom(ascii_fold && is_ascii_letter(char) ? `[${char.toLowerCase()}${char.toUpperCase()}]` : char);
+        i += char.length;
+        continue;
+    }
+  }
+  return out;
+};
 var escape_reg_exp = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var fuse_unk = (arr, tokens_to_ids, unk_token_id) => {
   const fused = [];
@@ -1279,9 +1720,12 @@ var Sequence = class extends Normalizer_default {
 };
 var Sequence_default = Sequence;
 var Replace = class extends Normalizer_default {
+  constructor(config) {
+    super(config);
+    this.pattern = create_pattern(this.config.pattern ?? {});
+  }
   normalize(text) {
-    const pattern = create_pattern(this.config.pattern ?? {});
-    return pattern === null ? text : text.replaceAll(pattern, this.config.content ?? "");
+    return this.pattern === null ? text : text.replaceAll(this.pattern, this.config.content ?? "");
   }
 };
 var Replace_default = Replace;
@@ -1401,6 +1845,27 @@ var PreTokenizer = class extends Callable_default {
   }
 };
 var PreTokenizer_default = PreTokenizer;
+var BYTES_TO_UNICODE = (() => {
+  const bs = [
+    ...Array.from({ length: 126 - 33 + 1 }, (_, i) => i + 33),
+    ...Array.from({ length: "¬".charCodeAt(0) - "¡".charCodeAt(0) + 1 }, (_, i) => i + "¡".charCodeAt(0)),
+    ...Array.from({ length: "ÿ".charCodeAt(0) - "®".charCodeAt(0) + 1 }, (_, i) => i + "®".charCodeAt(0))
+  ];
+  const cs = bs.slice();
+  let n = 0;
+  for (let b = 0;b < 256; ++b) {
+    if (!bs.includes(b)) {
+      bs.push(b);
+      cs.push(256 + n);
+      n += 1;
+    }
+  }
+  const ccs = cs.map((n2) => String.fromCharCode(n2));
+  return Object.fromEntries(bs.map((b, i) => [b, ccs[i]]));
+})();
+var reverse_dictionary = (data) => Object.fromEntries(Object.entries(data).map(([key, value]) => [value, key]));
+var UNICODE_TO_BYTES = reverse_dictionary(BYTES_TO_UNICODE);
+var PUNCTUATION_REGEX = "\\p{P}\\u0021-\\u002F\\u003A-\\u0040\\u005B-\\u0060\\u007B-\\u007E";
 var ByteLevel = class extends PreTokenizer_default {
   constructor(config) {
     super();
@@ -1455,7 +1920,7 @@ var Split = class extends PreTokenizer_default {
       return [];
     }
     if (this.config.invert) {
-      return text.match(this.pattern) || [];
+      return (text.match(this.pattern) || []).filter((x) => x);
     } else if (this.config.behavior?.toLowerCase() === "removed") {
       return text.split(this.pattern).filter((x) => x);
     } else {
@@ -1681,12 +2146,13 @@ var CharTrie = class {
     }
     node.is_leaf = true;
   }
-  *common_prefix_search(text) {
+  *common_prefix_search(chars, start = 0) {
     let node = this.root;
     if (node === undefined)
       return;
     let prefix = "";
-    for (const ch of text) {
+    for (let i = start;i < chars.length; ++i) {
+      const ch = chars[i];
       prefix += ch;
       node = node.children.get(ch);
       if (node === undefined)
@@ -1836,11 +2302,8 @@ var Unigram = class extends TokenizerModel_default {
     let begin_pos = 0;
     while (begin_pos < chars.length) {
       let has_single_node = false;
-      const tokens = [];
-      const sliced = chars.slice(begin_pos).join("");
-      const prefixed_tokens = this.trie.common_prefix_search(sliced);
+      const prefixed_tokens = this.trie.common_prefix_search(chars, begin_pos);
       for (const token of prefixed_tokens) {
-        tokens.push(token);
         const token_id = this.tokens_to_ids.get(token);
         const token_score = this.scores[token_id];
         const n = len(token);
@@ -2445,9 +2908,13 @@ var Sequence4 = class extends Decoder_default {
 };
 var Sequence_default4 = Sequence4;
 var Replace3 = class extends Decoder_default {
+  constructor(config) {
+    super(config);
+    this.pattern = create_pattern(this.config.pattern);
+  }
   decode_chain(tokens) {
-    const pattern = create_pattern(this.config.pattern);
     const content = this.config.content ?? "";
+    const pattern = this.pattern;
     return pattern === null ? tokens : tokens.map((token) => token.replaceAll(pattern, content));
   }
 };
@@ -2751,6 +3218,12 @@ var Tokenizer = class {
   }
 };
 var Tokenizer_default = Tokenizer;
+var __defProp2 = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 var TOKEN_TYPES = Object.freeze({
   Text: "Text",
   NumericLiteral: "NumericLiteral",
@@ -2774,6 +3247,7 @@ var TOKEN_TYPES = Object.freeze({
   CallOperator: "CallOperator",
   AdditiveBinaryOperator: "AdditiveBinaryOperator",
   MultiplicativeBinaryOperator: "MultiplicativeBinaryOperator",
+  ExponentiationBinaryOperator: "ExponentiationBinaryOperator",
   ComparisonBinaryOperator: "ComparisonBinaryOperator",
   UnaryOperator: "UnaryOperator",
   Comment: "Comment"
@@ -2817,7 +3291,9 @@ var ORDERED_MAPPING_TABLE = [
   ["+", TOKEN_TYPES.AdditiveBinaryOperator],
   ["-", TOKEN_TYPES.AdditiveBinaryOperator],
   ["~", TOKEN_TYPES.AdditiveBinaryOperator],
+  ["**", TOKEN_TYPES.ExponentiationBinaryOperator],
   ["*", TOKEN_TYPES.MultiplicativeBinaryOperator],
+  ["//", TOKEN_TYPES.MultiplicativeBinaryOperator],
   ["/", TOKEN_TYPES.MultiplicativeBinaryOperator],
   ["%", TOKEN_TYPES.MultiplicativeBinaryOperator],
   ["=", TOKEN_TYPES.Equals]
@@ -2845,7 +3321,7 @@ function preprocess(template, options = {}) {
   if (options.trim_blocks) {
     template = template.replace(/([#%-]})\n/g, "$1");
   }
-  return template.replace(/{%\s*(end)?generation\s*%}/gs, "");
+  return template.replace(/(\s*){%(-?)\s*(?:end)?generation\s*(-?)%}(\s*)/gs, (_, before, lstrip, rstrip, after) => (lstrip ? "" : before) + (rstrip ? "" : after));
 }
 function tokenize(source, options = {}) {
   const tokens = [];
@@ -2857,8 +3333,9 @@ function tokenize(source, options = {}) {
     while (predicate(src[cursorPosition])) {
       if (src[cursorPosition] === "\\") {
         ++cursorPosition;
-        if (cursorPosition >= src.length)
+        if (cursorPosition >= src.length) {
           throw new SyntaxError("Unexpected end of input");
+        }
         const escaped = src[cursorPosition++];
         const unescaped = ESCAPE_CHARACTERS.get(escaped);
         if (unescaped === undefined) {
@@ -2868,8 +3345,9 @@ function tokenize(source, options = {}) {
         continue;
       }
       str += src[cursorPosition++];
-      if (cursorPosition >= src.length)
+      if (cursorPosition >= src.length) {
         throw new SyntaxError("Unexpected end of input");
+      }
     }
     return str;
   };
@@ -2968,7 +3446,12 @@ function tokenize(source, options = {}) {
             break;
           default: {
             ++cursorPosition;
-            const num = consumeWhile(isInteger);
+            let num = consumeWhile(isInteger);
+            if (num.length > 0 && src[cursorPosition] === "." && isInteger(src[cursorPosition + 1])) {
+              ++cursorPosition;
+              const frac = consumeWhile(isInteger);
+              num = `${num}.${frac}`;
+            }
             tokens.push(new Token(`${char}${num}`, num.length > 0 ? TOKEN_TYPES.NumericLiteral : TOKEN_TYPES.UnaryOperator));
             continue;
           }
@@ -3001,7 +3484,7 @@ function tokenize(source, options = {}) {
       }
       if (isInteger(char)) {
         let num = consumeWhile(isInteger);
-        if (src[cursorPosition] === "." && isInteger(src[cursorPosition + 1])) {
+        if (tokens.at(-1)?.type !== TOKEN_TYPES.Dot && src[cursorPosition] === "." && isInteger(src[cursorPosition + 1])) {
           ++cursorPosition;
           const frac = consumeWhile(isInteger);
           num = `${num}.${frac}`;
@@ -3204,6 +3687,13 @@ var SpreadExpression = class extends Expression {
   }
   type = "SpreadExpression";
 };
+var KeywordSpreadExpression = class extends Expression {
+  constructor(argument) {
+    super();
+    this.argument = argument;
+  }
+  type = "KeywordSpreadExpression";
+};
 var CallStatement = class extends Statement {
   constructor(call, callerArgs, body) {
     super();
@@ -3301,13 +3791,13 @@ function parse(tokens) {
         ++current;
         let callerArgs = null;
         if (is(TOKEN_TYPES.OpenParen)) {
-          callerArgs = parseArgs();
+          callerArgs = parseArgs("parameters");
         }
         const callee = parsePrimaryExpression();
         if (callee.type !== "Identifier") {
           throw new SyntaxError(`Expected identifier following call statement`);
         }
-        const callArgs = parseArgs();
+        const callArgs = parseArgs("call");
         expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
         const body = [];
         while (!isStatement("endcall")) {
@@ -3404,7 +3894,7 @@ function parse(tokens) {
     if (name.type !== "Identifier") {
       throw new SyntaxError(`Expected identifier following macro statement`);
     }
-    const args = parseArgs();
+    const args = parseArgs("parameters");
     expect(TOKEN_TYPES.CloseStatement, "Expected closing statement token");
     const body = [];
     while (!isStatement("endmacro")) {
@@ -3536,24 +4026,47 @@ function parse(tokens) {
     return member;
   }
   function parseCallExpression(callee) {
-    let expression = new CallExpression(callee, parseArgs());
+    let expression = new CallExpression(callee, parseArgs("call"));
     expression = parseMemberExpression(expression);
     if (is(TOKEN_TYPES.OpenParen)) {
       expression = parseCallExpression(expression);
     }
     return expression;
   }
-  function parseArgs() {
+  function parseArgs(mode) {
     expect(TOKEN_TYPES.OpenParen, "Expected opening parenthesis for arguments list");
-    const args = parseArgumentsList();
+    const args = parseArgumentsList(mode);
     expect(TOKEN_TYPES.CloseParen, "Expected closing parenthesis for arguments list");
     return args;
   }
-  function parseArgumentsList() {
+  function parseArgumentsList(mode) {
     const args = [];
+    const parameterNames = /* @__PURE__ */ new Set;
+    let sawKeywordOrDefault = false;
+    let sawSpreadArgument = false;
     while (!is(TOKEN_TYPES.CloseParen)) {
+      const isKeywordSpread = is(TOKEN_TYPES.ExponentiationBinaryOperator);
+      const isPositionalSpread = is(TOKEN_TYPES.MultiplicativeBinaryOperator) && tokens[current].value === "*";
+      if (mode === "parameters" && (isKeywordSpread || isPositionalSpread)) {
+        throw new SyntaxError("Argument unpacking is not allowed in parameter declarations");
+      }
+      if (isKeywordSpread) {
+        ++current;
+        args.push(new KeywordSpreadExpression(parseExpression()));
+        if (is(TOKEN_TYPES.Comma)) {
+          ++current;
+        }
+        if (!is(TOKEN_TYPES.CloseParen)) {
+          throw new SyntaxError("Expected closing parenthesis: `**` must be applied to the final argument");
+        }
+        break;
+      }
       let argument;
-      if (tokens[current].type === TOKEN_TYPES.MultiplicativeBinaryOperator && tokens[current].value === "*") {
+      if (isPositionalSpread) {
+        if (sawSpreadArgument) {
+          throw new SyntaxError("Only one `*` argument unpacking is allowed");
+        }
+        sawSpreadArgument = true;
         ++current;
         const expr = parseExpression();
         argument = new SpreadExpression(expr);
@@ -3562,11 +4075,28 @@ function parse(tokens) {
         if (is(TOKEN_TYPES.Equals)) {
           ++current;
           if (!(argument instanceof Identifier)) {
-            throw new SyntaxError(`Expected identifier for keyword argument`);
+            throw new SyntaxError(mode === "parameters" ? "Expected identifier for parameter declaration" : "Expected identifier for keyword argument");
           }
           const value = parseExpression();
           argument = new KeywordArgumentExpression(argument, value);
         }
+        if (mode === "parameters") {
+          if (!(argument instanceof Identifier || argument instanceof KeywordArgumentExpression)) {
+            throw new SyntaxError("Expected identifier for parameter declaration");
+          }
+          const parameterName = argument instanceof Identifier ? argument.value : argument.key.value;
+          if (parameterNames.has(parameterName)) {
+            throw new SyntaxError(`Duplicate parameter name: ${parameterName}`);
+          }
+          parameterNames.add(parameterName);
+        }
+        if (argument instanceof KeywordArgumentExpression) {
+          sawKeywordOrDefault = true;
+        } else if (sawKeywordOrDefault) {
+          throw new SyntaxError(mode === "call" ? "Positional arguments must come before keyword arguments" : "Non-default argument follows default argument");
+        } else if (sawSpreadArgument) {
+          throw new SyntaxError("Positional arguments must not follow `*` argument unpacking");
+        }
       }
       args.push(argument);
       if (is(TOKEN_TYPES.Comma)) {
@@ -3613,8 +4143,8 @@ function parse(tokens) {
         expect(TOKEN_TYPES.CloseSquareBracket, "Expected closing square bracket");
       } else {
         property = parsePrimaryExpression();
-        if (property.type !== "Identifier") {
-          throw new SyntaxError(`Expected identifier following dot operator`);
+        if (property.type !== "Identifier" && property.type !== "IntegerLiteral") {
+          throw new SyntaxError(`Expected identifier or integer following dot operator`);
         }
       }
       object = new MemberExpression(object, property, computed);
@@ -3622,8 +4152,17 @@ function parse(tokens) {
     return object;
   }
   function parseMultiplicativeExpression() {
-    let left = parseTestExpression();
+    let left = parsePowerExpression();
     while (is(TOKEN_TYPES.MultiplicativeBinaryOperator)) {
+      const operator = tokens[current++];
+      const right = parsePowerExpression();
+      left = new BinaryExpression(operator, left, right);
+    }
+    return left;
+  }
+  function parsePowerExpression() {
+    let left = parseTestExpression();
+    while (is(TOKEN_TYPES.ExponentiationBinaryOperator)) {
       const operator = tokens[current++];
       const right = parseTestExpression();
       left = new BinaryExpression(operator, left, right);
@@ -3647,7 +4186,7 @@ function parse(tokens) {
     return operand;
   }
   function parseFilterExpression() {
-    let operand = parseCallMemberExpression();
+    let operand = parseUnarySignExpression();
     while (is(TOKEN_TYPES.Pipe)) {
       ++current;
       let filter = parsePrimaryExpression();
@@ -3661,6 +4200,15 @@ function parse(tokens) {
     }
     return operand;
   }
+  function parseUnarySignExpression() {
+    const token = tokens[current];
+    if (token && (token.type === TOKEN_TYPES.UnaryOperator || token.type === TOKEN_TYPES.AdditiveBinaryOperator) && (token.value === "-" || token.value === "+")) {
+      const operator = tokens[current++];
+      const argument = parseUnarySignExpression();
+      return new UnaryExpression(operator, argument);
+    }
+    return parseCallMemberExpression();
+  }
   function parsePrimaryExpression() {
     const token = tokens[current++];
     switch (token.type) {
@@ -3788,8 +4336,9 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function replace(str, oldvalue, newvalue, count2) {
-  if (count2 === 0)
+  if (count2 === 0) {
     return str;
+  }
   let remaining = count2 == null || count2 < 0 ? Infinity : count2;
   const pattern = oldvalue.length === 0 ? new RegExp("(?=)", "gu") : new RegExp(escapeRegExp(oldvalue), "gu");
   return str.replaceAll(pattern, (match) => {
@@ -3804,10 +4353,13 @@ var BreakControl = class extends Error {
 };
 var ContinueControl = class extends Error {
 };
+var EMPTY_BUILTINS = /* @__PURE__ */ new Map;
 var RuntimeValue = class {
   type = "RuntimeValue";
   value;
-  builtins = /* @__PURE__ */ new Map;
+  get builtins() {
+    return EMPTY_BUILTINS;
+  }
   constructor(value = undefined) {
     this.value = value;
   }
@@ -3824,162 +4376,168 @@ var IntegerValue = class extends RuntimeValue {
 var FloatValue = class extends RuntimeValue {
   type = "FloatValue";
   toString() {
+    if (Object.is(this.value, -0)) {
+      return "-0.0";
+    }
     return this.value % 1 === 0 ? this.value.toFixed(1) : this.value.toString();
   }
 };
 var StringValue = class extends RuntimeValue {
   type = "StringValue";
-  builtins = /* @__PURE__ */ new Map([
-    [
-      "upper",
-      new FunctionValue(() => {
-        return new StringValue(this.value.toUpperCase());
-      })
-    ],
-    [
-      "lower",
-      new FunctionValue(() => {
-        return new StringValue(this.value.toLowerCase());
-      })
-    ],
-    [
-      "strip",
-      new FunctionValue(() => {
-        return new StringValue(this.value.trim());
-      })
-    ],
-    [
-      "title",
-      new FunctionValue(() => {
-        return new StringValue(titleCase(this.value));
-      })
-    ],
-    [
-      "capitalize",
-      new FunctionValue(() => {
-        return new StringValue(this.value.charAt(0).toUpperCase() + this.value.slice(1));
-      })
-    ],
-    ["length", new IntegerValue(this.value.length)],
-    [
-      "rstrip",
-      new FunctionValue(() => {
-        return new StringValue(this.value.trimEnd());
-      })
-    ],
-    [
-      "lstrip",
-      new FunctionValue(() => {
-        return new StringValue(this.value.trimStart());
-      })
-    ],
-    [
-      "startswith",
-      new FunctionValue((args) => {
-        if (args.length === 0) {
-          throw new Error("startswith() requires at least one argument");
-        }
-        const pattern = args[0];
-        if (pattern instanceof StringValue) {
-          return new BooleanValue(this.value.startsWith(pattern.value));
-        } else if (pattern instanceof ArrayValue) {
-          for (const item of pattern.value) {
-            if (!(item instanceof StringValue)) {
-              throw new Error("startswith() tuple elements must be strings");
+  _builtins;
+  get builtins() {
+    return this._builtins ??= /* @__PURE__ */ new Map([
+      [
+        "upper",
+        new FunctionValue(() => {
+          return new StringValue(this.value.toUpperCase());
+        })
+      ],
+      [
+        "lower",
+        new FunctionValue(() => {
+          return new StringValue(this.value.toLowerCase());
+        })
+      ],
+      [
+        "strip",
+        new FunctionValue(() => {
+          return new StringValue(this.value.trim());
+        })
+      ],
+      [
+        "title",
+        new FunctionValue(() => {
+          return new StringValue(titleCase(this.value));
+        })
+      ],
+      [
+        "capitalize",
+        new FunctionValue(() => {
+          return new StringValue(this.value.charAt(0).toUpperCase() + this.value.slice(1));
+        })
+      ],
+      ["length", new IntegerValue(this.value.length)],
+      [
+        "rstrip",
+        new FunctionValue(() => {
+          return new StringValue(this.value.trimEnd());
+        })
+      ],
+      [
+        "lstrip",
+        new FunctionValue(() => {
+          return new StringValue(this.value.trimStart());
+        })
+      ],
+      [
+        "startswith",
+        new FunctionValue((args) => {
+          if (args.length === 0) {
+            throw new Error("startswith() requires at least one argument");
+          }
+          const pattern = args[0];
+          if (pattern instanceof StringValue) {
+            return new BooleanValue(this.value.startsWith(pattern.value));
+          } else if (pattern instanceof ArrayValue) {
+            for (const item of pattern.value) {
+              if (!(item instanceof StringValue)) {
+                throw new Error("startswith() tuple elements must be strings");
+              }
+              if (this.value.startsWith(item.value)) {
+                return new BooleanValue(true);
+              }
             }
-            if (this.value.startsWith(item.value)) {
-              return new BooleanValue(true);
+            return new BooleanValue(false);
+          }
+          throw new Error("startswith() argument must be a string or tuple of strings");
+        })
+      ],
+      [
+        "endswith",
+        new FunctionValue((args) => {
+          if (args.length === 0) {
+            throw new Error("endswith() requires at least one argument");
+          }
+          const pattern = args[0];
+          if (pattern instanceof StringValue) {
+            return new BooleanValue(this.value.endsWith(pattern.value));
+          } else if (pattern instanceof ArrayValue) {
+            for (const item of pattern.value) {
+              if (!(item instanceof StringValue)) {
+                throw new Error("endswith() tuple elements must be strings");
+              }
+              if (this.value.endsWith(item.value)) {
+                return new BooleanValue(true);
+              }
             }
+            return new BooleanValue(false);
           }
-          return new BooleanValue(false);
-        }
-        throw new Error("startswith() argument must be a string or tuple of strings");
-      })
-    ],
-    [
-      "endswith",
-      new FunctionValue((args) => {
-        if (args.length === 0) {
-          throw new Error("endswith() requires at least one argument");
-        }
-        const pattern = args[0];
-        if (pattern instanceof StringValue) {
-          return new BooleanValue(this.value.endsWith(pattern.value));
-        } else if (pattern instanceof ArrayValue) {
-          for (const item of pattern.value) {
-            if (!(item instanceof StringValue)) {
-              throw new Error("endswith() tuple elements must be strings");
+          throw new Error("endswith() argument must be a string or tuple of strings");
+        })
+      ],
+      [
+        "split",
+        new FunctionValue((args) => {
+          const sep = args[0] ?? new NullValue;
+          if (!(sep instanceof StringValue || sep instanceof NullValue)) {
+            throw new Error("sep argument must be a string or null");
+          }
+          const maxsplit = args[1] ?? new IntegerValue(-1);
+          if (!(maxsplit instanceof IntegerValue)) {
+            throw new Error("maxsplit argument must be a number");
+          }
+          let result = [];
+          if (sep instanceof NullValue) {
+            const text = this.value.trimStart();
+            for (const { 0: match, index } of text.matchAll(/\S+/g)) {
+              if (maxsplit.value !== -1 && result.length >= maxsplit.value && index !== undefined) {
+                result.push(match + text.slice(index + match.length));
+                break;
+              }
+              result.push(match);
             }
-            if (this.value.endsWith(item.value)) {
-              return new BooleanValue(true);
+          } else {
+            if (sep.value === "") {
+              throw new Error("empty separator");
             }
-          }
-          return new BooleanValue(false);
-        }
-        throw new Error("endswith() argument must be a string or tuple of strings");
-      })
-    ],
-    [
-      "split",
-      new FunctionValue((args) => {
-        const sep = args[0] ?? new NullValue;
-        if (!(sep instanceof StringValue || sep instanceof NullValue)) {
-          throw new Error("sep argument must be a string or null");
-        }
-        const maxsplit = args[1] ?? new IntegerValue(-1);
-        if (!(maxsplit instanceof IntegerValue)) {
-          throw new Error("maxsplit argument must be a number");
-        }
-        let result = [];
-        if (sep instanceof NullValue) {
-          const text = this.value.trimStart();
-          for (const { 0: match, index } of text.matchAll(/\S+/g)) {
-            if (maxsplit.value !== -1 && result.length >= maxsplit.value && index !== undefined) {
-              result.push(match + text.slice(index + match.length));
-              break;
+            result = this.value.split(sep.value);
+            if (maxsplit.value !== -1 && result.length > maxsplit.value) {
+              result.push(result.splice(maxsplit.value).join(sep.value));
             }
-            result.push(match);
           }
-        } else {
-          if (sep.value === "") {
-            throw new Error("empty separator");
+          return new ArrayValue(result.map((part) => new StringValue(part)));
+        })
+      ],
+      [
+        "replace",
+        new FunctionValue((args) => {
+          if (args.length < 2) {
+            throw new Error("replace() requires at least two arguments");
           }
-          result = this.value.split(sep.value);
-          if (maxsplit.value !== -1 && result.length > maxsplit.value) {
-            result.push(result.splice(maxsplit.value).join(sep.value));
+          const oldValue = args[0];
+          const newValue = args[1];
+          if (!(oldValue instanceof StringValue && newValue instanceof StringValue)) {
+            throw new Error("replace() arguments must be strings");
           }
-        }
-        return new ArrayValue(result.map((part) => new StringValue(part)));
-      })
-    ],
-    [
-      "replace",
-      new FunctionValue((args) => {
-        if (args.length < 2) {
-          throw new Error("replace() requires at least two arguments");
-        }
-        const oldValue = args[0];
-        const newValue = args[1];
-        if (!(oldValue instanceof StringValue && newValue instanceof StringValue)) {
-          throw new Error("replace() arguments must be strings");
-        }
-        let count2;
-        if (args.length > 2) {
-          if (args[2].type === "KeywordArgumentsValue") {
-            count2 = args[2].value.get("count") ?? new NullValue;
+          let count2;
+          if (args.length > 2) {
+            if (args[2].type === "KeywordArgumentsValue") {
+              count2 = args[2].value.get("count") ?? new NullValue;
+            } else {
+              count2 = args[2];
+            }
           } else {
-            count2 = args[2];
+            count2 = new NullValue;
           }
-        } else {
-          count2 = new NullValue;
-        }
-        if (!(count2 instanceof IntegerValue || count2 instanceof NullValue)) {
-          throw new Error("replace() count argument must be a number or null");
-        }
-        return new StringValue(replace(this.value, oldValue.value, newValue.value, count2.value));
-      })
-    ]
-  ]);
+          if (!(count2 instanceof IntegerValue || count2 instanceof NullValue)) {
+            throw new Error("replace() count argument must be a number or null");
+          }
+          return new StringValue(replace(this.value, oldValue.value, newValue.value, count2.value));
+        })
+      ]
+    ]);
+  }
 };
 var BooleanValue = class extends RuntimeValue {
   type = "BooleanValue";
@@ -4018,6 +4576,7 @@ function toJSON(input, options = {}, depth = 0, convertUndefinedToNull = true) {
       return result;
     }
     case "ArrayValue":
+    case "NamespaceValue":
     case "ObjectValue": {
       const indentValue = indent ? " ".repeat(indent) : "";
       const basePadding = `
@@ -4048,59 +4607,62 @@ function toJSON(input, options = {}, depth = 0, convertUndefinedToNull = true) {
 }
 var ObjectValue = class extends RuntimeValue {
   type = "ObjectValue";
+  _builtins;
   __bool__() {
     return new BooleanValue(this.value.size > 0);
   }
-  builtins = /* @__PURE__ */ new Map([
-    [
-      "get",
-      new FunctionValue(([key, defaultValue]) => {
-        if (!(key instanceof StringValue)) {
-          throw new Error(`Object key must be a string: got ${key.type}`);
-        }
-        return this.value.get(key.value) ?? defaultValue ?? new NullValue;
-      })
-    ],
-    ["items", new FunctionValue(() => this.items())],
-    ["keys", new FunctionValue(() => this.keys())],
-    ["values", new FunctionValue(() => this.values())],
-    [
-      "dictsort",
-      new FunctionValue((args) => {
-        let kwargs = /* @__PURE__ */ new Map;
-        const positionalArgs = args.filter((arg) => {
-          if (arg instanceof KeywordArgumentsValue) {
-            kwargs = arg.value;
-            return false;
+  get builtins() {
+    return this._builtins ??= /* @__PURE__ */ new Map([
+      [
+        "get",
+        new FunctionValue(([key, defaultValue]) => {
+          if (!(key instanceof StringValue)) {
+            throw new Error(`Object key must be a string: got ${key.type}`);
           }
-          return true;
-        });
-        const caseSensitive = positionalArgs.at(0) ?? kwargs.get("case_sensitive") ?? new BooleanValue(false);
-        if (!(caseSensitive instanceof BooleanValue)) {
-          throw new Error("case_sensitive must be a boolean");
-        }
-        const by = positionalArgs.at(1) ?? kwargs.get("by") ?? new StringValue("key");
-        if (!(by instanceof StringValue)) {
-          throw new Error("by must be a string");
-        }
-        if (!["key", "value"].includes(by.value)) {
-          throw new Error("by must be either 'key' or 'value'");
-        }
-        const reverse = positionalArgs.at(2) ?? kwargs.get("reverse") ?? new BooleanValue(false);
-        if (!(reverse instanceof BooleanValue)) {
-          throw new Error("reverse must be a boolean");
-        }
-        const items = Array.from(this.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value])).sort((a, b) => {
-          const index = by.value === "key" ? 0 : 1;
-          const aVal = a.value[index];
-          const bVal = b.value[index];
-          const result = compareRuntimeValues(aVal, bVal, caseSensitive.value);
-          return reverse.value ? -result : result;
-        });
-        return new ArrayValue(items);
-      })
-    ]
-  ]);
+          return this.value.get(key.value) ?? defaultValue ?? new NullValue;
+        })
+      ],
+      ["items", new FunctionValue(() => this.items())],
+      ["keys", new FunctionValue(() => this.keys())],
+      ["values", new FunctionValue(() => this.values())],
+      [
+        "dictsort",
+        new FunctionValue((args) => {
+          let kwargs = /* @__PURE__ */ new Map;
+          const positionalArgs = args.filter((arg) => {
+            if (arg instanceof KeywordArgumentsValue) {
+              kwargs = arg.value;
+              return false;
+            }
+            return true;
+          });
+          const caseSensitive = positionalArgs.at(0) ?? kwargs.get("case_sensitive") ?? new BooleanValue(false);
+          if (!(caseSensitive instanceof BooleanValue)) {
+            throw new Error("case_sensitive must be a boolean");
+          }
+          const by = positionalArgs.at(1) ?? kwargs.get("by") ?? new StringValue("key");
+          if (!(by instanceof StringValue)) {
+            throw new Error("by must be a string");
+          }
+          if (!["key", "value"].includes(by.value)) {
+            throw new Error("by must be either 'key' or 'value'");
+          }
+          const reverse = positionalArgs.at(2) ?? kwargs.get("reverse") ?? new BooleanValue(false);
+          if (!(reverse instanceof BooleanValue)) {
+            throw new Error("reverse must be a boolean");
+          }
+          const items = Array.from(this.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value])).sort((a, b) => {
+            const index = by.value === "key" ? 0 : 1;
+            const aVal = a.value[index];
+            const bVal = b.value[index];
+            const result = compareRuntimeValues(aVal, bVal, caseSensitive.value);
+            return reverse.value ? -result : result;
+          });
+          return new ArrayValue(items);
+        })
+      ]
+    ]);
+  }
   items() {
     return new ArrayValue(Array.from(this.value.entries()).map(([key, value]) => new ArrayValue([new StringValue(key), value])));
   }
@@ -4117,9 +4679,18 @@ var ObjectValue = class extends RuntimeValue {
 var KeywordArgumentsValue = class extends ObjectValue {
   type = "KeywordArgumentsValue";
 };
+var NamespaceValue = class extends RuntimeValue {
+  type = "NamespaceValue";
+  toString() {
+    return toJSON(this, {}, 0, false);
+  }
+};
 var ArrayValue = class extends RuntimeValue {
   type = "ArrayValue";
-  builtins = /* @__PURE__ */ new Map([["length", new IntegerValue(this.value.length)]]);
+  _builtins;
+  get builtins() {
+    return this._builtins ??= /* @__PURE__ */ new Map([["length", new IntegerValue(this.value.length)]]);
+  }
   __bool__() {
     return new BooleanValue(this.value.length > 0);
   }
@@ -4139,7 +4710,23 @@ var NullValue = class extends RuntimeValue {
 var UndefinedValue = class extends RuntimeValue {
   type = "UndefinedValue";
 };
-var Environment = class {
+function normalizeNamespaceEntry(pair) {
+  let values;
+  if (pair instanceof ArrayValue) {
+    values = pair.value;
+  } else if (pair instanceof StringValue) {
+    values = Array.from(pair.value, (char) => new StringValue(char));
+  }
+  if (!values || values.length !== 2) {
+    throw new Error("namespace expected an object or an iterable of [key, value] pairs");
+  }
+  const [key, value] = values;
+  if (!(key instanceof StringValue)) {
+    throw new Error("namespace keys must be strings");
+  }
+  return [key, value];
+}
+var _Environment = class {
   constructor(parent) {
     this.parent = parent;
   }
@@ -4147,69 +4734,40 @@ var Environment = class {
     [
       "namespace",
       new FunctionValue((args) => {
-        if (args.length === 0) {
-          return new ObjectValue(/* @__PURE__ */ new Map);
+        const positional = args.slice();
+        let kwargs;
+        if (positional.at(-1) instanceof KeywordArgumentsValue) {
+          kwargs = positional.pop();
         }
-        if (args.length !== 1 || !(args[0] instanceof ObjectValue)) {
-          throw new Error("`namespace` expects either zero arguments or a single object argument");
+        if (positional.length > 1) {
+          throw new Error(`namespace expected at most 1 argument, got ${positional.length}`);
         }
-        return args[0];
+        const entries = /* @__PURE__ */ new Map;
+        if (positional.length === 1) {
+          const source = positional[0];
+          if (source instanceof ObjectValue) {
+            for (const [key, value] of source.value) {
+              entries.set(key, value);
+            }
+          } else if (source instanceof ArrayValue) {
+            for (const pair of source.value) {
+              const [key, value] = normalizeNamespaceEntry(pair);
+              entries.set(key.value, value);
+            }
+          } else {
+            throw new Error(`'${source.type}' object is not iterable`);
+          }
+        }
+        if (kwargs) {
+          for (const [key, value] of kwargs.value) {
+            entries.set(key, value);
+          }
+        }
+        return new NamespaceValue(entries);
       })
     ]
   ]);
-  tests = /* @__PURE__ */ new Map([
-    ["boolean", (operand) => operand.type === "BooleanValue"],
-    ["callable", (operand) => operand instanceof FunctionValue],
-    [
-      "odd",
-      (operand) => {
-        if (!(operand instanceof IntegerValue)) {
-          throw new Error(`cannot odd on ${operand.type}`);
-        }
-        return operand.value % 2 !== 0;
-      }
-    ],
-    [
-      "even",
-      (operand) => {
-        if (!(operand instanceof IntegerValue)) {
-          throw new Error(`cannot even on ${operand.type}`);
-        }
-        return operand.value % 2 === 0;
-      }
-    ],
-    ["false", (operand) => operand.type === "BooleanValue" && !operand.value],
-    ["true", (operand) => operand.type === "BooleanValue" && operand.value],
-    ["none", (operand) => operand.type === "NullValue"],
-    ["string", (operand) => operand.type === "StringValue"],
-    ["number", (operand) => operand instanceof IntegerValue || operand instanceof FloatValue],
-    ["integer", (operand) => operand instanceof IntegerValue],
-    ["iterable", (operand) => operand.type === "ArrayValue" || operand.type === "StringValue"],
-    ["mapping", (operand) => operand instanceof ObjectValue],
-    [
-      "sequence",
-      (operand) => operand instanceof ArrayValue || operand instanceof ObjectValue || operand instanceof StringValue
-    ],
-    [
-      "lower",
-      (operand) => {
-        const str = operand.value;
-        return operand.type === "StringValue" && str === str.toLowerCase();
-      }
-    ],
-    [
-      "upper",
-      (operand) => {
-        const str = operand.value;
-        return operand.type === "StringValue" && str === str.toUpperCase();
-      }
-    ],
-    ["none", (operand) => operand.type === "NullValue"],
-    ["defined", (operand) => operand.type !== "UndefinedValue"],
-    ["undefined", (operand) => operand.type === "UndefinedValue"],
-    ["equalto", (a, b) => a.value === b.value],
-    ["eq", (a, b) => a.value === b.value]
-  ]);
+  tests = _Environment.TESTS;
   set(name, value) {
     return this.declareVariable(name, convertToRuntimeValues(value));
   }
@@ -4241,6 +4799,60 @@ var Environment = class {
     }
   }
 };
+var Environment = _Environment;
+__publicField(Environment, "TESTS", /* @__PURE__ */ new Map([
+  ["boolean", (operand) => operand.type === "BooleanValue"],
+  ["callable", (operand) => operand instanceof FunctionValue],
+  [
+    "odd",
+    (operand) => {
+      if (!(operand instanceof IntegerValue)) {
+        throw new Error(`cannot odd on ${operand.type}`);
+      }
+      return operand.value % 2 !== 0;
+    }
+  ],
+  [
+    "even",
+    (operand) => {
+      if (!(operand instanceof IntegerValue)) {
+        throw new Error(`cannot even on ${operand.type}`);
+      }
+      return operand.value % 2 === 0;
+    }
+  ],
+  ["false", (operand) => operand.type === "BooleanValue" && !operand.value],
+  ["true", (operand) => operand.type === "BooleanValue" && operand.value],
+  ["none", (operand) => operand.type === "NullValue"],
+  ["string", (operand) => operand.type === "StringValue"],
+  ["number", (operand) => operand instanceof IntegerValue || operand instanceof FloatValue],
+  ["integer", (operand) => operand instanceof IntegerValue],
+  ["iterable", (operand) => operand.type === "ArrayValue" || operand.type === "StringValue"],
+  ["mapping", (operand) => operand instanceof ObjectValue],
+  [
+    "sequence",
+    (operand) => operand instanceof ArrayValue || operand instanceof ObjectValue || operand instanceof StringValue
+  ],
+  [
+    "lower",
+    (operand) => {
+      const str = operand.value;
+      return operand.type === "StringValue" && str === str.toLowerCase();
+    }
+  ],
+  [
+    "upper",
+    (operand) => {
+      const str = operand.value;
+      return operand.type === "StringValue" && str === str.toUpperCase();
+    }
+  ],
+  ["none", (operand) => operand.type === "NullValue"],
+  ["defined", (operand) => operand.type !== "UndefinedValue"],
+  ["undefined", (operand) => operand.type === "UndefinedValue"],
+  ["equalto", (a, b) => a.value === b.value],
+  ["eq", (a, b) => a.value === b.value]
+]));
 function setupGlobals(env2) {
   env2.set("false", false);
   env2.set("true", true);
@@ -4254,11 +4866,20 @@ function setupGlobals(env2) {
   env2.set("False", false);
   env2.set("None", null);
 }
+function isAttributeContainer(value) {
+  return value instanceof ObjectValue || value instanceof NamespaceValue;
+}
+function isNumericLikeValue(value) {
+  return value instanceof IntegerValue || value instanceof FloatValue || value instanceof BooleanValue;
+}
+function getNumericValue(value) {
+  return value instanceof BooleanValue ? Number(value.value) : value.value;
+}
 function getAttributeValue(item, attributePath) {
   const parts = attributePath.split(".");
   let value = item;
   for (const part of parts) {
-    if (value instanceof ObjectValue) {
+    if (isAttributeContainer(value)) {
       value = value.value.get(part) ?? new UndefinedValue;
     } else if (value instanceof ArrayValue) {
       const index = parseInt(part, 10);
@@ -4286,14 +4907,7 @@ function compareRuntimeValues(a, b, caseSensitive = false) {
   if (a instanceof UndefinedValue || b instanceof UndefinedValue) {
     throw new Error(`Cannot compare ${a.type} with ${b.type}`);
   }
-  const isNumericLike = (v) => v instanceof IntegerValue || v instanceof FloatValue || v instanceof BooleanValue;
-  const getNumericValue = (v) => {
-    if (v instanceof BooleanValue) {
-      return v.value ? 1 : 0;
-    }
-    return v.value;
-  };
-  if (isNumericLike(a) && isNumericLike(b)) {
+  if (isNumericLikeValue(a) && isNumericLikeValue(b)) {
     const aNum = getNumericValue(a);
     const bNum = getNumericValue(b);
     return aNum < bNum ? -1 : aNum > bNum ? 1 : 0;
@@ -4309,11 +4923,165 @@ function compareRuntimeValues(a, b, caseSensitive = false) {
         aStr = aStr.toLowerCase();
         bStr = bStr.toLowerCase();
       }
-      return aStr < bStr ? -1 : aStr > bStr ? 1 : 0;
+      return aStr < bStr ? -1 : aStr > bStr ? 1 : 0;
+    }
+    default:
+      throw new Error(`Cannot compare type: ${a.type}`);
+  }
+}
+function getParameterDescriptor(argument) {
+  if (argument.type === "Identifier") {
+    return { name: argument.value };
+  }
+  const keywordArgument = argument;
+  return { name: keywordArgument.key.value, defaultValue: keywordArgument.value };
+}
+function isSpecialMacroArgument(name) {
+  return name === "kwargs" || name === "varargs";
+}
+function findAccessedSpecialMacroArguments(parameters, body) {
+  const declared = /* @__PURE__ */ new Set;
+  const accessed = /* @__PURE__ */ new Set;
+  const declareName = (name) => {
+    if (isSpecialMacroArgument(name)) {
+      declared.add(name);
+    }
+  };
+  const declareTarget = (target) => {
+    if (target.type === "Identifier") {
+      declareName(target.value);
+    } else if (target.type === "TupleLiteral") {
+      for (const item of target.value) {
+        declareTarget(item);
+      }
+    }
+  };
+  const declareArgument = (argument) => {
+    declareName(getParameterDescriptor(argument).name);
+  };
+  const visitArgumentDefaults = (args) => {
+    for (const argument of args) {
+      const parameter = getParameterDescriptor(argument);
+      if (parameter.defaultValue) {
+        visit(parameter.defaultValue);
+      }
+    }
+  };
+  const visitFilter = (filter) => {
+    if (filter.type === "CallExpression") {
+      visit(filter.args);
+    }
+  };
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        visit(item);
+      }
+      return;
+    }
+    if (node instanceof Map) {
+      for (const [key, value] of node) {
+        visit(key);
+        visit(value);
+      }
+      return;
+    }
+    if (!(node instanceof Statement)) {
+      return;
+    }
+    switch (node.type) {
+      case "For": {
+        const statement = node;
+        declareTarget(statement.loopvar);
+        if (statement.iterable.type === "SelectExpression") {
+          const iterable = statement.iterable;
+          visit(iterable.lhs);
+          visit(statement.body);
+          visit(statement.defaultBlock);
+          visit(iterable.test);
+          return;
+        }
+        visit(statement.iterable);
+        visit(statement.body);
+        visit(statement.defaultBlock);
+        return;
+      }
+      case "Set": {
+        const statement = node;
+        declareTarget(statement.assignee);
+        visit(statement.value);
+        visit(statement.body);
+        return;
+      }
+      case "Macro": {
+        const statement = node;
+        for (const argument of statement.args) {
+          declareArgument(argument);
+        }
+        visitArgumentDefaults(statement.args);
+        visit(statement.body);
+        return;
+      }
+      case "CallStatement": {
+        const statement = node;
+        visit(statement.call);
+        for (const argument of statement.callerArgs ?? []) {
+          declareArgument(argument);
+        }
+        visitArgumentDefaults(statement.callerArgs ?? []);
+        visit(statement.body);
+        return;
+      }
+      case "FilterStatement": {
+        const statement = node;
+        visit(statement.body);
+        visitFilter(statement.filter);
+        return;
+      }
+      case "Identifier": {
+        const name = node.value;
+        if (isSpecialMacroArgument(name) && !declared.has(name)) {
+          accessed.add(name);
+        }
+        return;
+      }
+      case "MemberExpression": {
+        const expression = node;
+        visit(expression.object);
+        if (expression.computed) {
+          visit(expression.property);
+        }
+        return;
+      }
+      case "FilterExpression": {
+        const expression = node;
+        visit(expression.operand);
+        visitFilter(expression.filter);
+        return;
+      }
+      case "TestExpression":
+        visit(node.operand);
+        return;
+      case "SelectExpression": {
+        const expression = node;
+        visit(expression.test);
+        visit(expression.lhs);
+        return;
+      }
+      case "KeywordArgumentExpression":
+        visit(node.value);
+        return;
+      default:
+        for (const child of Object.values(node)) {
+          visit(child);
+        }
     }
-    default:
-      throw new Error(`Cannot compare type: ${a.type}`);
+  };
+  for (const parameter of parameters) {
+    declareArgument(parameter);
   }
+  visit(body);
+  return accessed;
 }
 var Interpreter = class {
   global;
@@ -4347,6 +5115,18 @@ var Interpreter = class {
       throw new Error("Cannot perform operation on null values");
     } else if (node.operator.value === "~") {
       return new StringValue(left.value.toString() + right.value.toString());
+    } else if (node.operator.value === "**" && isNumericLikeValue(left) && isNumericLikeValue(right)) {
+      const a = getNumericValue(left);
+      const b = getNumericValue(right);
+      if (a === 0 && b < 0) {
+        throw new Error("0.0 cannot be raised to a negative power");
+      }
+      const result = a ** b;
+      if (!Number.isFinite(result)) {
+        throw new Error("Exponentiation result is not a finite real number");
+      }
+      const isFloat = left instanceof FloatValue || right instanceof FloatValue || b < 0;
+      return isFloat ? new FloatValue(result) : new IntegerValue(result);
     } else if ((left instanceof IntegerValue || left instanceof FloatValue) && (right instanceof IntegerValue || right instanceof FloatValue)) {
       const a = left.value, b = right.value;
       switch (node.operator.value) {
@@ -4359,6 +5139,11 @@ var Interpreter = class {
         }
         case "/":
           return new FloatValue(a / b);
+        case "//": {
+          const res = Math.floor(a / b);
+          const isFloat = left instanceof FloatValue || right instanceof FloatValue;
+          return isFloat ? new FloatValue(res) : new IntegerValue(res);
+        }
         case "%": {
           const rem = a % b;
           const isFloat = left instanceof FloatValue || right instanceof FloatValue;
@@ -4414,6 +5199,12 @@ var Interpreter = class {
   evaluateArguments(args, environment) {
     const positionalArguments = [];
     const keywordArguments = /* @__PURE__ */ new Map;
+    const addKeywordArgument = (key, value) => {
+      if (keywordArguments.has(key)) {
+        throw new Error(`Got multiple values for keyword argument '${key}'`);
+      }
+      keywordArguments.set(key, value);
+    };
     for (const argument of args) {
       if (argument.type === "SpreadExpression") {
         const spreadNode = argument;
@@ -4424,14 +5215,23 @@ var Interpreter = class {
         for (const item of val.value) {
           positionalArguments.push(item);
         }
-      } else if (argument.type === "KeywordArgumentExpression") {
+      } else if (argument.type !== "KeywordArgumentExpression" && argument.type !== "KeywordSpreadExpression") {
+        positionalArguments.push(this.evaluate(argument, environment));
+      }
+    }
+    for (const argument of args) {
+      if (argument.type === "KeywordArgumentExpression") {
         const kwarg = argument;
-        keywordArguments.set(kwarg.key.value, this.evaluate(kwarg.value, environment));
-      } else {
-        if (keywordArguments.size > 0) {
-          throw new Error("Positional arguments must come before keyword arguments");
+        addKeywordArgument(kwarg.key.value, this.evaluate(kwarg.value, environment));
+      } else if (argument.type === "KeywordSpreadExpression") {
+        const spreadNode = argument;
+        const val = this.evaluate(spreadNode.argument, environment);
+        if (!(val instanceof ObjectValue)) {
+          throw new Error(`Argument after ** must be a mapping, not ${val.type}`);
+        }
+        for (const [key, value] of val.value) {
+          addKeywordArgument(key, value);
         }
-        positionalArguments.push(this.evaluate(argument, environment));
       }
     }
     return [positionalArguments, keywordArguments];
@@ -4672,7 +5472,7 @@ var Interpreter = class {
           case "selectattr":
           case "rejectattr": {
             const select = filterName === "selectattr";
-            if (operand.value.some((x) => !(x instanceof ObjectValue))) {
+            if (operand.value.some((item) => !isAttributeContainer(item))) {
               throw new Error(`\`${filterName}\` can only be applied to array of objects`);
             }
             if (filter.args.some((x) => x.type !== "StringLiteral")) {
@@ -4705,7 +5505,7 @@ var Interpreter = class {
               }
               const defaultValue = kwargs.get("default");
               const mapped = operand.value.map((item) => {
-                if (!(item instanceof ObjectValue)) {
+                if (!isAttributeContainer(item)) {
                   throw new Error("items in map must be an object");
                 }
                 const value = getAttributeValue(item, attr.value);
@@ -4786,6 +5586,16 @@ var Interpreter = class {
     switch (node.operator.value) {
       case "not":
         return new BooleanValue(!argument.value);
+      case "+":
+      case "-": {
+        const sign = node.operator.value === "-" ? -1 : 1;
+        if (argument instanceof IntegerValue || argument instanceof FloatValue || argument instanceof BooleanValue) {
+          const value = argument instanceof BooleanValue ? argument.value ? 1 : 0 : argument.value;
+          const result = sign * value;
+          return argument instanceof FloatValue ? new FloatValue(result) : new IntegerValue(result);
+        }
+        throw new SyntaxError(`Unknown operator "${node.operator.value}" for ${argument.type}`);
+      }
       default:
         throw new SyntaxError(`Unknown operator: ${node.operator.value}`);
     }
@@ -4852,15 +5662,17 @@ var Interpreter = class {
       } else {
         property = this.evaluate(expr.property, environment);
       }
+    } else if (expr.property.type === "IntegerLiteral") {
+      property = new IntegerValue(expr.property.value);
     } else {
       property = new StringValue(expr.property.value);
     }
     let value;
-    if (object instanceof ObjectValue) {
+    if (isAttributeContainer(object)) {
       if (!(property instanceof StringValue)) {
         throw new Error(`Cannot access property with non-string: got ${property.type}`);
       }
-      value = object.value.get(property.value) ?? object.builtins.get(property.value);
+      value = object.value.get(property.value) ?? (object instanceof ObjectValue ? object.builtins.get(property.value) : undefined);
     } else if (object instanceof ArrayValue || object instanceof StringValue) {
       if (property instanceof IntegerValue) {
         value = object.value.at(property.value);
@@ -4904,8 +5716,8 @@ var Interpreter = class {
     } else if (node.assignee.type === "MemberExpression") {
       const member = node.assignee;
       const object = this.evaluate(member.object, environment);
-      if (!(object instanceof ObjectValue)) {
-        throw new Error("Cannot assign to member of non-object");
+      if (!(object instanceof NamespaceValue)) {
+        throw new Error("cannot assign attribute on non-namespace object");
       }
       if (member.property.type !== "Identifier") {
         throw new Error("Cannot assign to member with non-identifier property");
@@ -5010,47 +5822,54 @@ var Interpreter = class {
     }
     return new StringValue(result);
   }
+  bindMacroArguments(displayName, parameters, specialArguments, args, scope) {
+    const positionalArguments = args.slice();
+    let keywordArguments = /* @__PURE__ */ new Map;
+    if (positionalArguments.at(-1) instanceof KeywordArgumentsValue) {
+      keywordArguments = new Map(positionalArguments.pop().value);
+    }
+    const pendingDefaults = [];
+    for (let i = 0;i < parameters.length; ++i) {
+      const { name, defaultValue } = getParameterDescriptor(parameters[i]);
+      let value = positionalArguments[i];
+      if (value === undefined && keywordArguments.has(name)) {
+        value = keywordArguments.get(name);
+        keywordArguments.delete(name);
+      }
+      if (value === undefined && defaultValue !== undefined) {
+        pendingDefaults.push([name, defaultValue]);
+      }
+      scope.setVariable(name, value ?? new UndefinedValue);
+    }
+    if (specialArguments.has("kwargs")) {
+      scope.setVariable("kwargs", new ObjectValue(keywordArguments));
+    } else if (keywordArguments.size > 0) {
+      throw new Error(`macro ${displayName} takes no keyword argument '${keywordArguments.keys().next().value}'`);
+    }
+    if (specialArguments.has("varargs")) {
+      scope.setVariable("varargs", new ArrayValue(positionalArguments.slice(parameters.length)));
+    } else if (positionalArguments.length > parameters.length) {
+      throw new Error(`macro ${displayName} takes not more than ${parameters.length} argument(s)`);
+    }
+    for (const [name, defaultValue] of pendingDefaults) {
+      scope.setVariable(name, this.evaluate(defaultValue, scope));
+    }
+  }
   evaluateMacro(node, environment) {
+    const specialArguments = findAccessedSpecialMacroArguments(node.args, node.body);
     environment.setVariable(node.name.value, new FunctionValue((args, scope) => {
       const macroScope = new Environment(scope);
-      args = args.slice();
-      let kwargs;
-      if (args.at(-1)?.type === "KeywordArgumentsValue") {
-        kwargs = args.pop();
-      }
-      for (let i = 0;i < node.args.length; ++i) {
-        const nodeArg = node.args[i];
-        const passedArg = args[i];
-        if (nodeArg.type === "Identifier") {
-          const identifier = nodeArg;
-          if (!passedArg) {
-            throw new Error(`Missing positional argument: ${identifier.value}`);
-          }
-          macroScope.setVariable(identifier.value, passedArg);
-        } else if (nodeArg.type === "KeywordArgumentExpression") {
-          const kwarg = nodeArg;
-          const value = passedArg ?? kwargs?.value.get(kwarg.key.value) ?? this.evaluate(kwarg.value, macroScope);
-          macroScope.setVariable(kwarg.key.value, value);
-        } else {
-          throw new Error(`Unknown argument type: ${nodeArg.type}`);
-        }
-      }
+      this.bindMacroArguments(`'${node.name.value}'`, node.args, specialArguments, args, macroScope);
       return this.evaluateBlock(node.body, macroScope);
     }));
     return new NullValue;
   }
   evaluateCallStatement(node, environment) {
-    const callerFn = new FunctionValue((callerArgs, callerEnv) => {
-      const callBlockEnv = new Environment(callerEnv);
-      if (node.callerArgs) {
-        for (let i = 0;i < node.callerArgs.length; ++i) {
-          const param = node.callerArgs[i];
-          if (param.type !== "Identifier") {
-            throw new Error(`Caller parameter must be an identifier, got ${param.type}`);
-          }
-          callBlockEnv.setVariable(param.value, callerArgs[i] ?? new UndefinedValue);
-        }
-      }
+    const parameters = node.callerArgs ?? [];
+    const specialArguments = findAccessedSpecialMacroArguments(parameters, node.body);
+    const callerFn = new FunctionValue((callerArguments) => {
+      const callBlockEnv = new Environment(environment);
+      this.bindMacroArguments("None", parameters, specialArguments, callerArguments, callBlockEnv);
       return this.evaluateBlock(node.body, callBlockEnv);
     });
     const [macroArgs, macroKwargs] = this.evaluateArguments(node.call.args, environment);
@@ -5068,8 +5887,9 @@ var Interpreter = class {
     return this.applyFilter(rendered, node.filter, environment);
   }
   evaluate(statement, environment) {
-    if (!statement)
+    if (!statement) {
       return new UndefinedValue;
+    }
     switch (statement.type) {
       case "Program":
         return this.evalProgram(statement, environment);
@@ -5166,22 +5986,61 @@ var NEWLINE = `
 `;
 var OPEN_STATEMENT = "{%- ";
 var CLOSE_STATEMENT = " -%}";
+var PRECEDENCE = Object.freeze({
+  CONDITIONAL: 0,
+  LOGICAL_OR: 1,
+  LOGICAL_AND: 2,
+  LOGICAL_NOT: 3,
+  COMPARISON: 4,
+  ADDITIVE: 5,
+  MULTIPLICATIVE: 6,
+  EXPONENTIATION: 7,
+  TEST: 8,
+  FILTER: 9,
+  UNARY_SIGN: 10,
+  ATOM: 11
+});
 function getBinaryOperatorPrecedence(expr) {
   switch (expr.operator.type) {
+    case "ExponentiationBinaryOperator":
+      return PRECEDENCE.EXPONENTIATION;
     case "MultiplicativeBinaryOperator":
-      return 4;
+      return PRECEDENCE.MULTIPLICATIVE;
     case "AdditiveBinaryOperator":
-      return 3;
+      return PRECEDENCE.ADDITIVE;
     case "ComparisonBinaryOperator":
-      return 2;
+      return PRECEDENCE.COMPARISON;
     case "Identifier":
-      if (expr.operator.value === "and")
-        return 1;
-      if (expr.operator.value === "in" || expr.operator.value === "not in")
-        return 2;
-      return 0;
+      if (expr.operator.value === "and") {
+        return PRECEDENCE.LOGICAL_AND;
+      }
+      if (expr.operator.value === "in" || expr.operator.value === "not in") {
+        return PRECEDENCE.COMPARISON;
+      }
+      return PRECEDENCE.LOGICAL_OR;
+  }
+  return PRECEDENCE.LOGICAL_OR;
+}
+function getPrecedence(node) {
+  switch (node.type) {
+    case "SelectExpression":
+    case "Ternary":
+      return PRECEDENCE.CONDITIONAL;
+    case "BinaryExpression":
+      return getBinaryOperatorPrecedence(node);
+    case "UnaryExpression":
+      return node.operator.value === "not" ? PRECEDENCE.LOGICAL_NOT : PRECEDENCE.UNARY_SIGN;
+    case "TestExpression":
+      return PRECEDENCE.TEST;
+    case "FilterExpression":
+      return PRECEDENCE.FILTER;
+    default:
+      return PRECEDENCE.ATOM;
   }
-  return 0;
+}
+function formatOperand(node, minPrecedence) {
+  const expr = formatExpression(node);
+  return getPrecedence(node) < minPrecedence ? `(${expr})` : expr;
 }
 function format(program, indent = "\t") {
   const indentStr = typeof indent === "number" ? " ".repeat(indent) : indent;
@@ -5194,6 +6053,9 @@ function createStatement(...text) {
 function formatStatements(stmts, depth, indentStr) {
   return stmts.map((stmt) => formatStatement(stmt, depth, indentStr)).join(NEWLINE);
 }
+function formatExpressionList(expressions) {
+  return expressions.map((expression) => formatExpression(expression)).join(", ");
+}
 function formatStatement(node, depth, indentStr) {
   const pad = indentStr.repeat(depth);
   switch (node.type) {
@@ -5271,12 +6133,12 @@ function formatSet(node, depth, indentStr) {
 }
 function formatMacro(node, depth, indentStr) {
   const pad = indentStr.repeat(depth);
-  const args = node.args.map(formatExpression).join(", ");
+  const args = formatExpressionList(node.args);
   return pad + createStatement("macro", `${node.name.value}(${args})`) + NEWLINE + formatStatements(node.body, depth + 1, indentStr) + NEWLINE + pad + createStatement("endmacro");
 }
 function formatCallStatement(node, depth, indentStr) {
   const pad = indentStr.repeat(depth);
-  const params = node.callerArgs && node.callerArgs.length > 0 ? `(${node.callerArgs.map(formatExpression).join(", ")})` : "";
+  const params = node.callerArgs && node.callerArgs.length > 0 ? `(${formatExpressionList(node.callerArgs)})` : "";
   const callExpr = formatExpression(node.call);
   let out = pad + createStatement(`call${params}`, callExpr) + NEWLINE;
   out += formatStatements(node.body, depth + 1, indentStr) + NEWLINE;
@@ -5291,63 +6153,58 @@ function formatFilterStatement(node, depth, indentStr) {
   out += pad + createStatement("endfilter");
   return out;
 }
-function formatExpression(node, parentPrec = -1) {
+function formatExpression(node) {
   switch (node.type) {
     case "SpreadExpression": {
       const n = node;
       return `*${formatExpression(n.argument)}`;
     }
+    case "KeywordSpreadExpression": {
+      const n = node;
+      return `**${formatExpression(n.argument)}`;
+    }
     case "Identifier":
       return node.value;
     case "IntegerLiteral":
       return `${node.value}`;
-    case "FloatLiteral":
-      return `${node.value}`;
+    case "FloatLiteral": {
+      const value = node.value;
+      if (Object.is(value, -0)) {
+        return "-0.0";
+      }
+      return value % 1 === 0 ? value.toFixed(1) : value.toString();
+    }
     case "StringLiteral":
       return JSON.stringify(node.value);
     case "BinaryExpression": {
       const n = node;
       const thisPrecedence = getBinaryOperatorPrecedence(n);
-      const left = formatExpression(n.left, thisPrecedence);
-      const right = formatExpression(n.right, thisPrecedence + 1);
-      const expr = `${left} ${n.operator.value} ${right}`;
-      return thisPrecedence < parentPrec ? `(${expr})` : expr;
+      const left = formatOperand(n.left, thisPrecedence);
+      const right = formatOperand(n.right, thisPrecedence + 1);
+      return `${left} ${n.operator.value} ${right}`;
     }
     case "UnaryExpression": {
       const n = node;
-      const val = n.operator.value + (n.operator.value === "not" ? " " : "") + formatExpression(n.argument, Infinity);
-      return val;
+      const operandPrecedence = n.argument.type === "UnaryExpression" ? getPrecedence(n) : PRECEDENCE.ATOM;
+      return n.operator.value + (n.operator.value === "not" ? " " : "") + formatOperand(n.argument, operandPrecedence);
     }
     case "CallExpression": {
       const n = node;
-      const args = n.args.map(formatExpression).join(", ");
+      const args = formatExpressionList(n.args);
       return `${formatExpression(n.callee)}(${args})`;
     }
     case "MemberExpression": {
       const n = node;
-      let obj = formatExpression(n.object);
-      if (![
-        "Identifier",
-        "MemberExpression",
-        "CallExpression",
-        "StringLiteral",
-        "IntegerLiteral",
-        "FloatLiteral",
-        "ArrayLiteral",
-        "TupleLiteral",
-        "ObjectLiteral"
-      ].includes(n.object.type)) {
-        obj = `(${obj})`;
-      }
+      const obj = formatOperand(n.object, PRECEDENCE.ATOM);
       let prop = formatExpression(n.property);
-      if (!n.computed && n.property.type !== "Identifier") {
+      if (!n.computed && n.property.type !== "Identifier" && n.property.type !== "IntegerLiteral") {
         prop = `(${prop})`;
       }
       return n.computed ? `${obj}[${prop}]` : `${obj}.${prop}`;
     }
     case "FilterExpression": {
       const n = node;
-      const operand = formatExpression(n.operand, Infinity);
+      const operand = formatOperand(n.operand, PRECEDENCE.FILTER);
       if (n.filter.type === "CallExpression") {
         return `${operand} | ${formatExpression(n.filter)}`;
       }
@@ -5355,17 +6212,17 @@ function formatExpression(node, parentPrec = -1) {
     }
     case "SelectExpression": {
       const n = node;
-      return `${formatExpression(n.lhs)} if ${formatExpression(n.test)}`;
+      return `${formatOperand(n.lhs, PRECEDENCE.LOGICAL_OR)} if ${formatOperand(n.test, PRECEDENCE.LOGICAL_OR)}`;
     }
     case "TestExpression": {
       const n = node;
-      return `${formatExpression(n.operand)} is${n.negate ? " not" : ""} ${n.test.value}`;
+      return `${formatOperand(n.operand, PRECEDENCE.TEST)} is${n.negate ? " not" : ""} ${n.test.value}`;
     }
     case "ArrayLiteral":
     case "TupleLiteral": {
-      const elems = node.value.map(formatExpression);
+      const elems = formatExpressionList(node.value);
       const brackets = node.type === "ArrayLiteral" ? "[]" : "()";
-      return `${brackets[0]}${elems.join(", ")}${brackets[1]}`;
+      return `${brackets[0]}${elems}${brackets[1]}`;
     }
     case "ObjectLiteral": {
       const entries = Array.from(node.value.entries()).map(([k, v]) => `${formatExpression(k)}: ${formatExpression(v)}`);
@@ -5384,8 +6241,7 @@ function formatExpression(node, parentPrec = -1) {
     }
     case "Ternary": {
       const n = node;
-      const expr = `${formatExpression(n.trueExpr)} if ${formatExpression(n.condition, 0)} else ${formatExpression(n.falseExpr)}`;
-      return parentPrec > -1 ? `(${expr})` : expr;
+      return `${formatOperand(n.trueExpr, PRECEDENCE.LOGICAL_OR)} if ${formatOperand(n.condition, PRECEDENCE.LOGICAL_OR)} else ${formatOperand(n.falseExpr, PRECEDENCE.CONDITIONAL)}`;
     }
     default:
       throw new Error(`Unknown expression type: ${node.type}`);
@@ -5712,12 +6568,33 @@ function isValidHfModelId(string) {
     return false;
   return true;
 }
+function makePretrainedOptionsKey(model_id, options = {}, ...parts) {
+  return JSON.stringify([
+    model_id,
+    options.revision ?? "main",
+    options.cache_dir ?? null,
+    options.local_files_only ?? false,
+    ...parts
+  ]);
+}
+var ModelFileNotFoundError = class extends Error {
+  constructor(message, { status = null } = {}) {
+    super(message);
+    this.name = "ModelFileNotFoundError";
+    this.status = status;
+  }
+};
+var NOT_FOUND_STATUSES = /* @__PURE__ */ new Set([401, 403, 404]);
 function handleError(status, remoteURL, fatal) {
   if (!fatal) {
     return null;
   }
   const message = ERROR_MAPPING[status] ?? `Error (${status}) occurred while trying to load file`;
-  throw Error(`${message}: "${remoteURL}".`);
+  const fullMessage = `${message}: "${remoteURL}".`;
+  if (NOT_FOUND_STATUSES.has(status)) {
+    throw new ModelFileNotFoundError(fullMessage, { status });
+  }
+  throw Error(fullMessage);
 }
 async function readResponse(response, progress_callback, expectedSize) {
   const contentLength = response.headers.get("Content-Length");
@@ -5751,7 +6628,7 @@ async function readResponse(response, progress_callback, expectedSize) {
 function isBlobURL(url) {
   return isValidUrl(url, ["blob:"]);
 }
-function toAbsoluteURL(url) {
+function toAbsoluteURL(url, { allowUnresolved = false } = {}) {
   let baseURL;
   if (typeof location !== "undefined" && location.href) {
     baseURL = location.href;
@@ -5760,7 +6637,14 @@ function toAbsoluteURL(url) {
   } else {
     return url;
   }
-  return new URL(url, baseURL).href;
+  try {
+    return new URL(url, baseURL).href;
+  } catch (error) {
+    if (!allowUnresolved) {
+      throw error;
+    }
+    return url;
+  }
 }
 var HASH_ALGORITHM = "SHA-256";
 var HASH_CACHE_NAME = "experimental_transformers-hash-cache";
@@ -5778,7 +6662,7 @@ var CrossOriginStorage = class {
       return;
     }
     try {
-      const [handle] = await navigator.crossOriginStorage.requestFileHandles([makeHashDescriptor(hashValue)]);
+      const handle = await navigator.crossOriginStorage.requestFileHandle(makeHashDescriptor(hashValue));
       const blob = await handle.getFile();
       return new Response(blob, {
         headers: {
@@ -5799,8 +6683,9 @@ var CrossOriginStorage = class {
     }
   };
   _storeBlobInCOS = async (blob, hashHex) => {
-    const [handle] = await navigator.crossOriginStorage.requestFileHandles([makeHashDescriptor(hashHex)], {
-      create: true
+    const handle = await navigator.crossOriginStorage.requestFileHandle(makeHashDescriptor(hashHex), {
+      create: true,
+      origins: "*"
     });
     const writableStream = await handle.createWritable();
     await writableStream.write(blob);
@@ -5964,13 +6849,7 @@ async function fetch_file_head(urlOrPath) {
   return env3.fetch(urlOrPath, { method: "GET", headers, cache: "no-store" });
 }
 function get_file_metadata(path_or_repo_id, filename, options = {}) {
-  const key = JSON.stringify([
-    path_or_repo_id,
-    filename,
-    options?.revision,
-    options?.cache_dir,
-    options?.local_files_only
-  ]);
+  const key = makePretrainedOptionsKey(path_or_repo_id, options, filename);
   return memoizePromise(key, () => _get_file_metadata(path_or_repo_id, filename, options));
 }
 async function _get_file_metadata(path_or_repo_id, filename, options) {
@@ -6006,37 +6885,36 @@ async function _get_file_metadata(path_or_repo_id, filename, options) {
     }
   }
   if (env3.allowRemoteModels && !options.local_files_only && validModelId) {
-    try {
-      const rangeResponse = await fetch_file_head(remoteURL);
-      if (rangeResponse && rangeResponse.status >= 200 && rangeResponse.status < 300) {
-        let size;
-        const contentType = rangeResponse.headers.get("content-type");
-        if (rangeResponse.status === 206) {
-          const contentRange = rangeResponse.headers.get("content-range");
-          if (contentRange) {
-            const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
-            if (match) {
-              size = parseInt(match[1], 10);
-            }
+    const rangeResponse = await fetch_file_head(remoteURL);
+    if (rangeResponse && rangeResponse.status >= 200 && rangeResponse.status < 300) {
+      let size;
+      const contentType = rangeResponse.headers.get("content-type");
+      if (rangeResponse.status === 206) {
+        const contentRange = rangeResponse.headers.get("content-range");
+        if (contentRange) {
+          const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+          if (match) {
+            size = parseInt(match[1], 10);
           }
-        } else if (rangeResponse.status === 200) {
-          try {
-            await rangeResponse.body?.cancel();
-          } catch (cancelError) {}
-        }
-        if (size === undefined) {
-          const contentLength = rangeResponse.headers.get("content-length");
-          size = contentLength ? parseInt(contentLength, 10) : undefined;
         }
-        return {
-          exists: true,
-          size,
-          contentType: contentType || undefined,
-          fromCache: false
-        };
+      } else if (rangeResponse.status === 200) {
+        try {
+          await rangeResponse.body?.cancel();
+        } catch (cancelError) {}
       }
-    } catch (e) {
-      logger.warn(`Unable to fetch file metadata for "${remoteURL}": ${e}`);
+      if (size === undefined) {
+        const contentLength = rangeResponse.headers.get("content-length");
+        size = contentLength ? parseInt(contentLength, 10) : undefined;
+      }
+      return {
+        exists: true,
+        size,
+        contentType: contentType || undefined,
+        fromCache: false
+      };
+    }
+    if (rangeResponse && rangeResponse.status !== 404 && rangeResponse.status !== 416) {
+      handleError(rangeResponse.status, remoteURL, true);
     }
   }
   return { exists: false, fromCache: false };
@@ -6092,6 +6970,9 @@ async function storeCachedResource(path_or_repo_id, filename, cache2, cacheKey,
   if (await cache2.match(cacheKey) !== undefined) {
     return;
   }
+  if (typeof Cache !== "undefined" && cache2 instanceof Cache && !isValidUrl(toAbsoluteURL(cacheKey, { allowUnresolved: true }), ["http:", "https:"])) {
+    return;
+  }
   if (!result) {
     const wrapped_progress = options.progress_callback ? (data) => dispatchCallback(options.progress_callback, {
       status: "progress",
@@ -6138,13 +7019,13 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
     if (response === undefined || typeof response !== "string" && response.status === 404) {
       if (options.local_files_only || !env3.allowRemoteModels) {
         if (fatal) {
-          throw Error(`\`local_files_only=true\` or \`env.allowRemoteModels=false\` and file was not found locally at "${localPath}".`);
+          throw new ModelFileNotFoundError(`\`local_files_only=true\` or \`env.allowRemoteModels=false\` and file was not found locally at "${localPath}".`);
         } else {
           return null;
         }
       }
       if (!validModelId) {
-        throw Error(`Local file missing at "${localPath}" and download aborted due to invalid model ID "${path_or_repo_id}".`);
+        throw new ModelFileNotFoundError(`Local file missing at "${localPath}" and download aborted due to invalid model ID "${path_or_repo_id}".`);
       }
       response = await getFile(remoteURL);
       if (response.status !== 200) {
@@ -6247,23 +7128,21 @@ async function getModelFile(path_or_repo_id, filename, fatal = true, options = {
       throw Error("Invalid configuration detected: both local and remote models are disabled. Fix by setting `env.allowLocalModels` or `env.allowRemoteModels` to `true`.");
     }
   }
-  dispatchCallback(options.progress_callback, {
-    status: "initiate",
-    name: path_or_repo_id,
-    file: filename
-  });
-  const key = `${path_or_repo_id}::${filename}`;
-  let pending = INFLIGHT_LOADS.get(key);
+  const key = makePretrainedOptionsKey(path_or_repo_id, options, filename, fatal, return_path);
+  const { progress_callback } = options;
+  const loads = progress_callback instanceof DefaultProgressCallback ? progress_callback.loads : INFLIGHT_LOADS;
+  let pending = loads.get(key);
   if (!pending) {
-    const cache2 = await getCache(options?.cache_dir);
-    pending = loadResourceFile(path_or_repo_id, filename, fatal, options, return_path, cache2).then((result) => {
-      INFLIGHT_LOADS.delete(key);
-      return result;
-    }, (err) => {
-      INFLIGHT_LOADS.delete(key);
-      throw err;
+    dispatchCallback(progress_callback, {
+      status: "initiate",
+      name: path_or_repo_id,
+      file: filename
     });
-    INFLIGHT_LOADS.set(key, pending);
+    pending = getCache(options.cache_dir).then((cache2) => loadResourceFile(path_or_repo_id, filename, fatal, options, return_path, cache2));
+    if (loads === INFLIGHT_LOADS) {
+      pending = pending.finally(() => INFLIGHT_LOADS.delete(key));
+    }
+    loads.set(key, pending);
   }
   return await pending;
 }
@@ -6915,11 +7794,7 @@ var uint16_to_float32 = /* @__PURE__ */ function() {
     return out;
   };
 }();
-var onnxruntime_node_exports = {};
-__export(onnxruntime_node_exports, {
-  default: () => onnxruntime_node_default
-});
-var onnxruntime_node_default = {};
+var onnx_node_default = {};
 async function loadAndCacheFile(url) {
   const fileName = url.split("/").pop();
   let cache2;
@@ -7016,7 +7891,7 @@ var ORT_SYMBOL = /* @__PURE__ */ Symbol.for("onnxruntime");
 if (ORT_SYMBOL in globalThis) {
   ONNX = globalThis[ORT_SYMBOL];
 } else if (apis.IS_NODE_ENV) {
-  ONNX = onnxruntime_node_exports;
+  ONNX = onnx_node_default;
   switch (process.platform) {
     case "win32":
       supportedDevices.push("dml");
@@ -7136,12 +8011,13 @@ if (ONNX_ENV) {
   if (ONNX_ENV.wasm) {
     if (!(typeof ServiceWorkerGlobalScope !== "undefined" && self instanceof ServiceWorkerGlobalScope) && ONNX_ENV.versions?.web && !ONNX_ENV.wasm.wasmPaths) {
       const wasmPathPrefix = `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ONNX_ENV.versions.web}/dist/`;
-      ONNX_ENV.wasm.wasmPaths = apis.IS_SAFARI ? {
-        mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.mjs`,
-        wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.wasm`
-      } : {
-        mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.mjs`,
-        wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.wasm`
+      let wasmPathSuffix = ".asyncify";
+      if (apis.IS_SAFARI_BELOW_26 && !apis.IS_WEBGPU_AVAILABLE) {
+        wasmPathSuffix = "";
+      }
+      ONNX_ENV.wasm.wasmPaths = {
+        mjs: `${wasmPathPrefix}ort-wasm-simd-threaded${wasmPathSuffix}.mjs`,
+        wasm: `${wasmPathPrefix}ort-wasm-simd-threaded${wasmPathSuffix}.wasm`
       };
     }
     ONNX_ENV.wasm.proxy = false;
@@ -7850,10 +8726,8 @@ var TensorOpRegistry = class {
       this._rfft = wrap([
         8,
         9,
-        18,
-        0,
         58,
-        97,
+        93,
         10,
         33,
         10,
@@ -7893,28 +8767,26 @@ var TensorOpRegistry = class {
         1,
         100,
         90,
-        21,
+        19,
         10,
         1,
         120,
         18,
-        16,
-        10,
         14,
+        10,
+        12,
         8,
         1,
         18,
+        8,
         10,
+        0,
         10,
-        3,
-        18,
-        1,
-        115,
+        0,
         10,
-        3,
-        18,
+        2,
+        8,
         1,
-        99,
         90,
         11,
         10,
@@ -7929,28 +8801,26 @@ var TensorOpRegistry = class {
         18,
         0,
         98,
-        21,
+        19,
         10,
         1,
         121,
         18,
-        16,
-        10,
         14,
+        10,
+        12,
         8,
         1,
         18,
+        8,
         10,
+        0,
         10,
-        3,
-        18,
-        1,
-        115,
+        0,
         10,
-        3,
-        18,
-        1,
-        99,
+        2,
+        8,
+        2,
         66,
         2,
         16,
@@ -8358,15 +9228,6 @@ var Tensor22 = class _Tensor {
       return new _Tensor(this.type, [this.data[index]], iterDims);
     }
   }
-  indexOf(item) {
-    const this_data = this.data;
-    for (let index = 0;index < this_data.length; ++index) {
-      if (this_data[index] == item) {
-        return index;
-      }
-    }
-    return -1;
-  }
   _subarray(index, iterSize, iterDims) {
     const o1 = index * iterSize;
     const o2 = (index + 1) * iterSize;
@@ -8443,6 +9304,26 @@ var Tensor22 = class _Tensor {
     }
     return this;
   }
+  remainder(val) {
+    return this.clone().remainder_(val);
+  }
+  remainder_(val) {
+    const this_data = this.data;
+    const is_bigint = this_data instanceof BigInt64Array || this_data instanceof BigUint64Array;
+    const divisor = is_bigint ? BigInt(val) : Number(val);
+    if ((divisor === 0 || divisor === 0n) && (this.type.includes("int") || this.type === "bool")) {
+      throw new RangeError("Division by zero");
+    }
+    if (divisor < 0 && (this.type.startsWith("uint") || this.type === "bool")) {
+      throw new RangeError("Negative divisors are not supported for unsigned or boolean tensors");
+    }
+    for (let i = 0;i < this_data.length; ++i) {
+      const remainder = this_data[i] % divisor;
+      const needs_shift = remainder < 0 && divisor > 0 || remainder > 0 && divisor < 0;
+      this_data[i] = needs_shift ? remainder + divisor : remainder;
+    }
+    return this;
+  }
   clone() {
     return new _Tensor(this.type, this.data.slice(), this.dims.slice());
   }
@@ -8766,7 +9647,7 @@ var Tensor22 = class _Tensor {
 };
 function reshape(data, dimensions) {
   const totalElements = data.length;
-  const dimensionSize = dimensions.reduce((a, b) => a * b);
+  const dimensionSize = dimensions.length === 0 ? 1 : dimensions.reduce((a, b) => a * b);
   if (totalElements !== dimensionSize) {
     throw Error(`cannot reshape array of size ${totalElements} into shape (${dimensions})`);
   }
@@ -8830,8 +9711,9 @@ async function matmul(a, b) {
   return await op({ a, b });
 }
 async function rfft(x, a) {
+  const axis = safeIndex(Number(a.item()), x.dims.length);
   const op = await TensorOpRegistry.rfft;
-  return await op({ x, a });
+  return await op({ x: x.unsqueeze(-1), a: new Tensor22("int64", [BigInt(axis)], []) });
 }
 async function topk(x, k) {
   const op = await TensorOpRegistry.top_k;
@@ -9495,10 +10377,13 @@ function _build_translation_inputs(self2, raw_inputs, tokenizer_options, generat
     if (!self2.language_codes.includes(src_lang_token)) {
       throw new Error(`Source language code "${src_lang_token}" is not valid. Must be one of: {${self2.language_codes.join(", ")}}`);
     }
-    for (const item of self2._tokenizer.post_processor.config.single) {
-      if ("SpecialToken" in item && self2.languageRegex.test(item.SpecialToken.id)) {
-        item.SpecialToken.id = self2.lang_to_token(src_lang_token);
-        break;
+    const post_processor_config = self2._tokenizer.post_processor?.config;
+    if (post_processor_config && "single" in post_processor_config) {
+      for (const item of post_processor_config.single) {
+        if ("SpecialToken" in item && self2.languageRegex.test(item.SpecialToken.id)) {
+          item.SpecialToken.id = self2.lang_to_token(src_lang_token);
+          break;
+        }
       }
     }
   }
@@ -10263,7 +11148,7 @@ var AutoTokenizer = class {
 };
 var GITHUB_ISSUE_URL = "https://github.com/huggingface/transformers.js/issues/new/choose";
 var FEATURE_EXTRACTOR_NAME = "preprocessor_config.json";
-var IMAGE_PROCESSOR_NAME = FEATURE_EXTRACTOR_NAME;
+var IMAGE_PROCESSOR_NAME = "preprocessor_config.json";
 var PROCESSOR_NAME = "processor_config.json";
 var CHAT_TEMPLATE_NAME = "chat_template.jinja";
 var Processor = class extends Callable {
@@ -10378,7 +11263,7 @@ var FeatureExtractor = class extends Callable {
 };
 function validate_audio_inputs(audio, feature_extractor) {
   if (!(audio instanceof Float32Array || audio instanceof Float64Array)) {
-    throw new Error(`${feature_extractor} expects input to be a Float32Array or a Float64Array, but got ${audio?.constructor?.name ?? typeof audio} instead. If using the feature extractor directly, remember to use \`read_audio(url, sampling_rate)\` to obtain the raw audio data of the file/url.`);
+    throw new Error(`${feature_extractor} expects input to be a Float32Array or a Float64Array, but got ${audio?.constructor?.name ?? typeof audio} instead. If using the feature extractor directly, remember to use \`load_audio(url, sampling_rate)\` to obtain the raw audio data of the file/url.`);
   }
 }
 var feature_extractors_exports = {};
@@ -10453,7 +11338,9 @@ async function load_audio(url, sampling_rate) {
   }
   return audio;
 }
-var read_audio = load_audio;
+async function read_audio(url, sampling_rate) {
+  return await load_audio(url, sampling_rate);
+}
 function generalized_cosine_window(M, a_0) {
   if (M < 1) {
     return new Float64Array;
@@ -10833,9 +11720,10 @@ function encodeWAV(chunks, rate) {
   view.setUint16(34, 32, true);
   writeString(view, 36, "data");
   view.setUint32(40, totalLength * 4, true);
-  return new Blob([buffer, ...chunks.map((chunk2) => chunk2.buffer)], {
-    type: "audio/wav"
-  });
+  return new Blob([
+    buffer,
+    ...chunks.map((chunk2) => chunk2.buffer instanceof ArrayBuffer ? new Uint8Array(chunk2.buffer, chunk2.byteOffset, chunk2.byteLength) : chunk2.slice())
+  ], { type: "audio/wav" });
 }
 function writeString(view, offset, string) {
   for (let i = 0;i < string.length; ++i) {
@@ -11258,7 +12146,7 @@ var GraniteSpeechFeatureExtractor = class extends FeatureExtractor {
   async _call(audio) {
     validate_audio_inputs(audio, "GraniteSpeechFeatureExtractor");
     const { n_fft, hop_length, n_mels } = this.config.melspec_kwargs;
-    const num_frames = 1 + Math.floor((audio.length - 1) / hop_length);
+    const num_frames = Math.floor(audio.length / hop_length) + 1;
     const max_num_frames = num_frames - num_frames % 2;
     const mel = await spectrogram(audio, this.window, n_fft, hop_length, {
       power: 2,
@@ -11710,7 +12598,7 @@ var RawImage = class _RawImage {
       throw new Error(`Tensor should have 3 dimensions, but has ${tensor.dims.length} dimensions.`);
     }
     if (channel_format === "CHW") {
-      tensor = tensor.transpose(1, 2, 0);
+      tensor = tensor.permute(1, 2, 0);
     } else if (channel_format === "HWC") {} else {
       throw new Error(`Unsupported channel format: ${channel_format}`);
     }
@@ -14942,11 +15830,26 @@ function getNormalizedConfig(config) {
       break;
     case "youtu":
     case "deepseek_v3":
+    case "deepseek_v4":
     case "glm_moe_dsa":
     case "mistral4":
       mapping["num_heads"] = "num_key_value_heads";
       mapping["num_layers"] = "num_hidden_layers";
-      mapping["dim_kv"] = "qk_head_dim";
+      mapping["dim_kv"] = config.model_type === "deepseek_v4" ? "head_dim" : "qk_head_dim";
+      mapping["num_attention_heads"] = "num_attention_heads";
+      break;
+    case "zaya":
+      mapping["num_heads"] = "num_key_value_heads";
+      mapping["num_layers"] = "num_hidden_layers";
+      mapping["hidden_size"] = "hidden_size";
+      mapping["dim_kv"] = "head_dim";
+      mapping["num_attention_heads"] = "num_attention_heads";
+      break;
+    case "hrm_text":
+      mapping["num_heads"] = "num_key_value_heads";
+      mapping["num_layers"] = "num_hidden_layers";
+      mapping["hidden_size"] = "hidden_size";
+      mapping["dim_kv"] = "head_dim";
       mapping["num_attention_heads"] = "num_attention_heads";
       break;
     case "t5":
@@ -15049,7 +15952,7 @@ function getCacheNames(config, options) {
     config = new PretrainedConfig(config);
   }
   const pkv_prefix = options?.prefix ?? "past_key_values";
-  const conv_prefix = pkv_prefix === "present" ? "present" : "past";
+  const cache_prefix = pkv_prefix === "present" ? "present" : "past";
   const names = /* @__PURE__ */ new Set;
   if (["lfm2", "lfm2_moe"].includes(config.model_type)) {
     const { layer_types } = config;
@@ -15058,7 +15961,7 @@ function getCacheNames(config, options) {
         names.add(`${pkv_prefix}.${i}.key`);
         names.add(`${pkv_prefix}.${i}.value`);
       } else if (layer_types[i] === "conv") {
-        names.add(`${conv_prefix}_conv.${i}`);
+        names.add(`${cache_prefix}_conv.${i}`);
       } else {
         throw new Error(`Unsupported layer type: ${layer_types[i]}`);
       }
@@ -15070,8 +15973,8 @@ function getCacheNames(config, options) {
     const num_layers = c.num_hidden_layers ?? layer_types?.length;
     for (let i = 0;i < num_layers; ++i) {
       if (!layer_types || layer_types[i] === "mamba") {
-        names.add(`${conv_prefix}_conv.${i}`);
-        names.add(`${conv_prefix}_ssm.${i}`);
+        names.add(`${cache_prefix}_conv.${i}`);
+        names.add(`${cache_prefix}_ssm.${i}`);
       }
       if (!layer_types || layer_types[i] === "attention") {
         names.add(`${pkv_prefix}.${i}.key`);
@@ -15087,13 +15990,13 @@ function getCacheNames(config, options) {
         names.add(`${pkv_prefix}.${i}.value`);
       } else if (layer_types[i] === "linear_attention") {
         if (config.model_type === "olmo_hybrid") {
-          names.add(`${conv_prefix}_conv.${i}.key`);
-          names.add(`${conv_prefix}_conv.${i}.value`);
-          names.add(`${conv_prefix}_conv.${i}.query`);
+          names.add(`${cache_prefix}_conv.${i}.key`);
+          names.add(`${cache_prefix}_conv.${i}.value`);
+          names.add(`${cache_prefix}_conv.${i}.query`);
         } else {
-          names.add(`${conv_prefix}_conv.${i}`);
+          names.add(`${cache_prefix}_conv.${i}`);
         }
-        names.add(`${conv_prefix}_recurrent.${i}`);
+        names.add(`${cache_prefix}_recurrent.${i}`);
       } else {
         throw new Error(`Unsupported layer type: ${layer_types[i]}`);
       }
@@ -15109,6 +16012,35 @@ function getCacheNames(config, options) {
       names.add(`${pkv_prefix}.${i}.value`);
     }
     return names;
+  } else if (config.model_type === "deepseek_v4") {
+    const { layer_types, num_hidden_layers } = config;
+    for (let i = 0;i < num_hidden_layers; ++i) {
+      names.add(`${pkv_prefix}.${i}.key`);
+      names.add(`${pkv_prefix}.${i}.value`);
+      const layer_type = layer_types[i];
+      if (layer_type === "compressed_sparse_attention") {
+        names.add(`${cache_prefix}_compressor.${i}.kv`);
+        names.add(`${cache_prefix}_compressor.${i}.gate`);
+        names.add(`${cache_prefix}_indexer.${i}.kv`);
+        names.add(`${cache_prefix}_indexer.${i}.gate`);
+      } else if (layer_type === "heavily_compressed_attention") {
+        names.add(`${cache_prefix}_compressor.${i}.kv`);
+        names.add(`${cache_prefix}_compressor.${i}.gate`);
+      } else if (layer_type && layer_type !== "sliding_attention") {
+        throw new Error(`Unsupported layer type: ${layer_type}`);
+      }
+    }
+    return names;
+  } else if (config.model_type === "zaya") {
+    const { num_hidden_layers, cca_time1 } = config;
+    const stride = cca_time1 ?? 1;
+    for (let i = 0;i < num_hidden_layers; i += stride) {
+      names.add(`${pkv_prefix}.${i}.key`);
+      names.add(`${pkv_prefix}.${i}.value`);
+      names.add(`${pkv_prefix}.${i}.conv_state`);
+      names.add(`${pkv_prefix}.${i}.shift_state`);
+    }
+    return names;
   } else if (["lfm2_vl", "qwen3_5", "qwen3_5_moe", "voxtral_realtime"].includes(config.model_type)) {
     let subConfig;
     if (config.model_type === "voxtral_realtime" && options?.session_name === "audio_encoder") {
@@ -15352,6 +16284,14 @@ function validateInputs(session, inputs) {
 }
 var ModelOutput = class {
 };
+var BaseModelOutput = class extends ModelOutput {
+  constructor({ last_hidden_state, hidden_states = null, attentions = null }) {
+    super();
+    this.last_hidden_state = last_hidden_state;
+    this.hidden_states = hidden_states;
+    this.attentions = attentions;
+  }
+};
 var SequenceClassifierOutput = class extends ModelOutput {
   constructor({ logits, ...attentions }) {
     super();
@@ -15387,6 +16327,23 @@ var CausalLMOutput = class extends ModelOutput {
     this.logits = logits;
   }
 };
+var CausalLMOutputWithPast = class extends ModelOutput {
+  constructor({ logits, past_key_values }) {
+    super();
+    this.logits = logits;
+    this.past_key_values = past_key_values;
+  }
+};
+var Seq2SeqLMOutput = class extends ModelOutput {
+  constructor({ logits, past_key_values, encoder_outputs, decoder_attentions = null, cross_attentions = null }) {
+    super();
+    this.logits = logits;
+    this.past_key_values = past_key_values;
+    this.encoder_outputs = encoder_outputs;
+    this.decoder_attentions = decoder_attentions;
+    this.cross_attentions = cross_attentions;
+  }
+};
 var ImageMattingOutput = class extends ModelOutput {
   constructor({ alphas }) {
     super();
@@ -15678,7 +16635,7 @@ var ClassifierFreeGuidanceLogitsProcessor = class extends LogitsProcessor {
   constructor(guidance_scale) {
     super();
     if (guidance_scale <= 1) {
-      throw new Error(`Require guidance scale >1 to use the classifier free guidance processor, got guidance scale ${guidance_scale}.`);
+      throw new Error(`Require guidance scale >1 to use the classifier-free guidance processor, got guidance scale ${guidance_scale}.`);
     }
     this.guidance_scale = guidance_scale;
   }
@@ -16077,6 +17034,7 @@ var MODEL_SESSION_CONFIG = {
       }
       return s;
     },
+    cache_sessions: { decoder_model_merged: true },
     optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.Phi3V]: {
@@ -16179,7 +17137,7 @@ function get_config(modelId, { config = null, cache_dir = null, local_files_only
   if (config !== null) {
     return AutoConfig.from_pretrained(modelId, { config, cache_dir, local_files_only, revision });
   }
-  const key = JSON.stringify([modelId, cache_dir, local_files_only, revision]);
+  const key = makePretrainedOptionsKey(modelId, { cache_dir, local_files_only, revision });
   return memoizePromise(key, () => AutoConfig.from_pretrained(modelId, { config, cache_dir, local_files_only, revision }));
 }
 async function get_model_files(modelId, { config = null, dtype: overrideDtype = null, device: overrideDevice = null, model_file_name = null } = {}) {
@@ -16616,7 +17574,7 @@ var PreTrainedModel = class extends Callable {
           }, () => [decoder_start_token_id]);
         } else if (Array.isArray(decoder_start_token_id)) {
           if (decoder_start_token_id.length !== batch_size) {
-            throw new Error(`\`decoder_start_token_id\` expcted to have length ${batch_size} but got ${decoder_start_token_id.length}`);
+            throw new Error(`\`decoder_start_token_id\` expected to have length ${batch_size} but got ${decoder_start_token_id.length}`);
           }
           decoder_input_ids = decoder_start_token_id;
         } else {
@@ -16822,7 +17780,7 @@ function getPastKeyValues(decoderResults, pastKeyValues) {
   const pkvs = /* @__PURE__ */ Object.create(null);
   for (const name in decoderResults) {
     if (name.startsWith("present")) {
-      const newName = name.replace("present_ssm", "past_ssm").replace("present_conv", "past_conv").replace("present_recurrent", "past_recurrent").replace("present", "past_key_values");
+      const newName = name.replace("present_ssm", "past_ssm").replace("present_conv", "past_conv").replace("present_recurrent", "past_recurrent").replace("present_compressor", "past_compressor").replace("present_indexer", "past_indexer").replace("present", "past_key_values");
       const is_encoder_pkv = name.includes("encoder");
       if (is_encoder_pkv && pastKeyValues) {
         pkvs[newName] = pastKeyValues[newName];
@@ -16888,6 +17846,14 @@ function addPastKeyValues(self2, decoderFeeds, pastKeyValues) {
   }
   return new DynamicCache(entries);
 }
+function setNumLogitsToKeep(self2, model_inputs, value) {
+  if (model_inputs.num_logits_to_keep)
+    return;
+  const session = self2.sessions["decoder_model_merged"] ?? self2.sessions["model"];
+  if (session?.inputNames.includes("num_logits_to_keep")) {
+    model_inputs.num_logits_to_keep = new Tensor22("int64", [value], []);
+  }
+}
 async function decoder_forward(self2, model_inputs, is_encoder_decoder = false) {
   const session = self2.sessions[is_encoder_decoder ? "decoder_model_merged" : "model"];
   const { past_key_values, ...new_model_inputs } = model_inputs;
@@ -16898,9 +17864,7 @@ async function decoder_forward(self2, model_inputs, is_encoder_decoder = false)
     const start_index = ["paligemma", "gemma3_text", "gemma3"].includes(self2.config.model_type) ? 1 : 0;
     new_model_inputs.position_ids = create_position_ids(new_model_inputs, past_key_values, start_index);
   }
-  if (session.inputNames.includes("num_logits_to_keep") && !new_model_inputs.num_logits_to_keep) {
-    new_model_inputs.num_logits_to_keep = new Tensor22("int64", [0n], []);
-  }
+  setNumLogitsToKeep(self2, new_model_inputs, 0n);
   addPastKeyValues(self2, new_model_inputs, past_key_values);
   const fixed = pick(new_model_inputs, session.inputNames);
   return await sessionRun(session, fixed);
@@ -16917,6 +17881,7 @@ async function generic_text_to_text_forward(self2, {
   past_key_values = null,
   generation_config = null,
   logits_processor = null,
+  num_logits_to_keep = null,
   ...kwargs
 }) {
   if (!inputs_embeds) {
@@ -16971,7 +17936,8 @@ async function generic_text_to_text_forward(self2, {
     attention_mask,
     position_ids,
     generation_config,
-    logits_processor
+    logits_processor,
+    num_logits_to_keep
   }, true);
   return outputs;
 }
@@ -17024,10 +17990,7 @@ function create_position_ids(model_inputs, past_key_values = null, start_index =
 }
 function decoder_prepare_inputs_for_generation(self2, input_ids, model_inputs, generation_config) {
   const past_length = model_inputs.past_key_values ? model_inputs.past_key_values.get_seq_length() : 0;
-  const session = self2.sessions["decoder_model_merged"] ?? self2.sessions["model"];
-  if (session?.inputNames.includes("num_logits_to_keep") && !model_inputs.num_logits_to_keep) {
-    model_inputs.num_logits_to_keep = new Tensor22("int64", [1n], []);
-  }
+  setNumLogitsToKeep(self2, model_inputs, 1n);
   if (!model_inputs.attention_mask) {
     let dims;
     for (const key of ["input_ids", "inputs_embeds", "position_ids"]) {
@@ -17053,6 +18016,7 @@ function encoder_decoder_prepare_inputs_for_generation(self2, input_ids, model_i
   if (model_inputs.past_key_values) {
     input_ids = input_ids.map((x) => [x.at(-1)]);
   }
+  setNumLogitsToKeep(self2, model_inputs, 1n);
   return {
     ...model_inputs,
     decoder_input_ids: toI64Tensor(input_ids)
@@ -17151,6 +18115,7 @@ __export(models_exports, {
   BartForSequenceClassification: () => BartForSequenceClassification,
   BartModel: () => BartModel,
   BartPretrainedModel: () => BartPretrainedModel,
+  BaseModelOutput: () => BaseModelOutput,
   BeitForImageClassification: () => BeitForImageClassification,
   BeitModel: () => BeitModel,
   BeitPreTrainedModel: () => BeitPreTrainedModel,
@@ -17186,6 +18151,8 @@ __export(models_exports, {
   CamembertForTokenClassification: () => CamembertForTokenClassification,
   CamembertModel: () => CamembertModel,
   CamembertPreTrainedModel: () => CamembertPreTrainedModel,
+  CausalLMOutput: () => CausalLMOutput,
+  CausalLMOutputWithPast: () => CausalLMOutputWithPast,
   ChatterboxModel: () => ChatterboxModel,
   ChatterboxPreTrainedModel: () => ChatterboxPreTrainedModel,
   ChineseCLIPModel: () => ChineseCLIPModel,
@@ -17251,6 +18218,9 @@ __export(models_exports, {
   DeepseekV3ForCausalLM: () => DeepseekV3ForCausalLM,
   DeepseekV3Model: () => DeepseekV3Model,
   DeepseekV3PreTrainedModel: () => DeepseekV3PreTrainedModel,
+  DeepseekV4ForCausalLM: () => DeepseekV4ForCausalLM,
+  DeepseekV4Model: () => DeepseekV4Model,
+  DeepseekV4PreTrainedModel: () => DeepseekV4PreTrainedModel,
   DeiTForImageClassification: () => DeiTForImageClassification,
   DeiTModel: () => DeiTModel,
   DeiTPreTrainedModel: () => DeiTPreTrainedModel,
@@ -17375,6 +18345,9 @@ __export(models_exports, {
   HieraForImageClassification: () => HieraForImageClassification,
   HieraModel: () => HieraModel,
   HieraPreTrainedModel: () => HieraPreTrainedModel,
+  HrmTextForCausalLM: () => HrmTextForCausalLM,
+  HrmTextModel: () => HrmTextModel,
+  HrmTextPreTrainedModel: () => HrmTextPreTrainedModel,
   HubertForCTC: () => HubertForCTC,
   HubertForSequenceClassification: () => HubertForSequenceClassification,
   HubertModel: () => HubertModel,
@@ -17386,6 +18359,7 @@ __export(models_exports, {
   IJepaModel: () => IJepaModel,
   IJepaPreTrainedModel: () => IJepaPreTrainedModel,
   Idefics3ForConditionalGeneration: () => Idefics3ForConditionalGeneration,
+  ImageMattingOutput: () => ImageMattingOutput,
   JAISLMHeadModel: () => JAISLMHeadModel,
   JAISModel: () => JAISModel,
   JAISPreTrainedModel: () => JAISPreTrainedModel,
@@ -17437,6 +18411,7 @@ __export(models_exports, {
   MaskFormerForInstanceSegmentation: () => MaskFormerForInstanceSegmentation,
   MaskFormerModel: () => MaskFormerModel,
   MaskFormerPreTrainedModel: () => MaskFormerPreTrainedModel,
+  MaskedLMOutput: () => MaskedLMOutput,
   Metric3DForDepthEstimation: () => Metric3DForDepthEstimation,
   Metric3DPreTrainedModel: () => Metric3DPreTrainedModel,
   Metric3Dv2ForDepthEstimation: () => Metric3Dv2ForDepthEstimation,
@@ -17450,6 +18425,13 @@ __export(models_exports, {
   MimiEncoderOutput: () => MimiEncoderOutput,
   MimiModel: () => MimiModel,
   MimiPreTrainedModel: () => MimiPreTrainedModel,
+  Ministral3ForCausalLM: () => Ministral3ForCausalLM,
+  Ministral3Model: () => Ministral3Model,
+  Ministral3PreTrainedModel: () => Ministral3PreTrainedModel,
+  MinistralForCausalLM: () => MinistralForCausalLM,
+  MinistralModel: () => MinistralModel,
+  MinistralPreTrainedModel: () => MinistralPreTrainedModel,
+  Mistral3ForConditionalGeneration: () => Mistral3ForConditionalGeneration,
   Mistral4ForCausalLM: () => Mistral4ForCausalLM,
   Mistral4Model: () => Mistral4Model,
   Mistral4PreTrainedModel: () => Mistral4PreTrainedModel,
@@ -17486,6 +18468,7 @@ __export(models_exports, {
   MobileViTV2ForImageClassification: () => MobileViTV2ForImageClassification,
   MobileViTV2Model: () => MobileViTV2Model,
   MobileViTV2PreTrainedModel: () => MobileViTV2PreTrainedModel,
+  ModelOutput: () => ModelOutput,
   ModernBertDecoderForCausalLM: () => ModernBertDecoderForCausalLM,
   ModernBertDecoderModel: () => ModernBertDecoderModel,
   ModernBertDecoderPreTrainedModel: () => ModernBertDecoderPreTrainedModel,
@@ -17572,6 +18555,7 @@ __export(models_exports, {
   PyAnnoteForAudioFrameClassification: () => PyAnnoteForAudioFrameClassification,
   PyAnnoteModel: () => PyAnnoteModel,
   PyAnnotePreTrainedModel: () => PyAnnotePreTrainedModel,
+  QuestionAnsweringModelOutput: () => QuestionAnsweringModelOutput,
   Qwen2ForCausalLM: () => Qwen2ForCausalLM,
   Qwen2Model: () => Qwen2Model,
   Qwen2MoeForCausalLM: () => Qwen2MoeForCausalLM,
@@ -17642,6 +18626,8 @@ __export(models_exports, {
   SegformerForSemanticSegmentation: () => SegformerForSemanticSegmentation,
   SegformerModel: () => SegformerModel,
   SegformerPreTrainedModel: () => SegformerPreTrainedModel,
+  Seq2SeqLMOutput: () => Seq2SeqLMOutput,
+  SequenceClassifierOutput: () => SequenceClassifierOutput,
   SiglipModel: () => SiglipModel,
   SiglipPreTrainedModel: () => SiglipPreTrainedModel,
   SiglipTextModel: () => SiglipTextModel,
@@ -17691,6 +18677,7 @@ __export(models_exports, {
   TableTransformerModel: () => TableTransformerModel,
   TableTransformerObjectDetectionOutput: () => TableTransformerObjectDetectionOutput,
   TableTransformerPreTrainedModel: () => TableTransformerPreTrainedModel,
+  TokenClassifierOutput: () => TokenClassifierOutput,
   TrOCRForCausalLM: () => TrOCRForCausalLM,
   TrOCRPreTrainedModel: () => TrOCRPreTrainedModel,
   UltravoxModel: () => UltravoxModel,
@@ -17765,7 +18752,10 @@ __export(models_exports, {
   YolosPreTrainedModel: () => YolosPreTrainedModel,
   YoutuForCausalLM: () => YoutuForCausalLM,
   YoutuModel: () => YoutuModel,
-  YoutuPreTrainedModel: () => YoutuPreTrainedModel
+  YoutuPreTrainedModel: () => YoutuPreTrainedModel,
+  ZayaForCausalLM: () => ZayaForCausalLM,
+  ZayaModel: () => ZayaModel,
+  ZayaPreTrainedModel: () => ZayaPreTrainedModel
 });
 var AlbertPreTrainedModel = class extends PreTrainedModel {
 };
@@ -17931,6 +18921,7 @@ var ChatterboxModel = class extends ChatterboxPreTrainedModel {
     past_key_values = null,
     generation_config = null,
     logits_processor = null,
+    num_logits_to_keep = null,
     audio_features = null,
     audio_tokens = null,
     speaker_embeddings = null,
@@ -17981,7 +18972,8 @@ var ChatterboxModel = class extends ChatterboxPreTrainedModel {
       past_key_values,
       attention_mask,
       generation_config,
-      logits_processor
+      logits_processor,
+      num_logits_to_keep
     }, false);
     return {
       ...outputs,
@@ -18014,22 +19006,29 @@ var ChatterboxModel = class extends ChatterboxPreTrainedModel {
     return decoder_prepare_inputs_for_generation(this, input_ids, model_inputs, generation_config);
   }
   async generate(params) {
-    const { sequences, audio_tokens, speaker_embeddings, speaker_features } = await super.generate({
+    const supplied_past_key_values = params.past_key_values;
+    const { sequences, audio_tokens, speaker_embeddings, speaker_features, past_key_values } = await super.generate({
       ...params,
       return_dict_in_generate: true
     });
-    const new_tokens = sequences.slice(null, [
-      params.input_ids.dims[1],
-      -1
-    ]);
-    const silence_tokens = full([new_tokens.dims[0], 3], SILENCE_TOKEN);
-    const speech_tokens = cat([audio_tokens, new_tokens, silence_tokens], 1);
-    const { waveform } = await sessionRun(this.sessions["conditional_decoder"], {
-      speech_tokens,
-      speaker_features,
-      speaker_embeddings
-    });
-    return waveform;
+    try {
+      const new_tokens = sequences.slice(null, [
+        params.input_ids.dims[1],
+        -1
+      ]);
+      const silence_tokens = full([new_tokens.dims[0], 3], SILENCE_TOKEN);
+      const speech_tokens = cat([audio_tokens, new_tokens, silence_tokens], 1);
+      const { waveform } = await sessionRun(this.sessions["conditional_decoder"], {
+        speech_tokens,
+        speaker_features,
+        speaker_embeddings
+      });
+      return waveform;
+    } finally {
+      if (past_key_values !== supplied_past_key_values) {
+        await past_key_values?.dispose();
+      }
+    }
   }
 };
 var ChineseCLIPPreTrainedModel = class extends PreTrainedModel {
@@ -18266,6 +19265,12 @@ var DeepseekV3Model = class extends DeepseekV3PreTrainedModel {
 };
 var DeepseekV3ForCausalLM = class extends DeepseekV3PreTrainedModel {
 };
+var DeepseekV4PreTrainedModel = class extends PreTrainedModel {
+};
+var DeepseekV4Model = class extends DeepseekV4PreTrainedModel {
+};
+var DeepseekV4ForCausalLM = class extends DeepseekV4PreTrainedModel {
+};
 var DebertaV2PreTrainedModel = class extends PreTrainedModel {
 };
 var DebertaV2Model = class extends DebertaV2PreTrainedModel {
@@ -18563,7 +19568,8 @@ var Florence2ForConditionalGeneration = class extends Florence2PreTrainedModel {
     encoder_outputs,
     past_key_values,
     inputs_embeds,
-    decoder_inputs_embeds
+    decoder_inputs_embeds,
+    num_logits_to_keep = null
   }) {
     if (!inputs_embeds) {
       ({ inputs_embeds, attention_mask } = await this._prepare_inputs_embeds({
@@ -18588,7 +19594,8 @@ var Florence2ForConditionalGeneration = class extends Florence2PreTrainedModel {
       attention_mask: decoder_attention_mask,
       encoder_attention_mask: attention_mask,
       encoder_hidden_states: encoder_outputs,
-      past_key_values
+      past_key_values,
+      num_logits_to_keep
     };
     return await decoder_forward(this, decoderFeeds, true);
   }
@@ -18657,6 +19664,7 @@ var Gemma3nForConditionalGeneration = class extends Gemma3nPreTrainedModel {
     past_key_values = null,
     generation_config = null,
     logits_processor = null,
+    num_logits_to_keep = null,
     ...kwargs
   }) {
     if (!inputs_embeds || !per_layer_inputs) {
@@ -18694,7 +19702,8 @@ var Gemma3nForConditionalGeneration = class extends Gemma3nPreTrainedModel {
       attention_mask,
       position_ids,
       generation_config,
-      logits_processor
+      logits_processor,
+      num_logits_to_keep
     }, true);
     return outputs;
   }
@@ -18916,6 +19925,7 @@ var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
     });
   }
   prepare_inputs_for_generation(input_ids, model_inputs, generation_config) {
+    setNumLogitsToKeep(this, model_inputs, 1n);
     if (!model_inputs.attention_mask || model_inputs.position_ids) {
       return model_inputs;
     }
@@ -19094,6 +20104,18 @@ var HieraForImageClassification = class extends HieraPreTrainedModel {
     return new SequenceClassifierOutput(await super._call(model_inputs));
   }
 };
+var HrmTextPreTrainedModel = class extends PreTrainedModel {
+};
+var HrmTextModel = class extends HrmTextPreTrainedModel {
+};
+var HrmTextForCausalLM = class extends HrmTextPreTrainedModel {
+  forward_params = ["input_ids", "attention_mask", "token_type_ids", "past_key_values"];
+  prepare_inputs_for_generation(input_ids, model_inputs, generation_config) {
+    const prepared = decoder_prepare_inputs_for_generation(this, input_ids, model_inputs, generation_config);
+    prepared.token_type_ids = (prepared.past_key_values ? zeros_like : ones_like)(prepared.input_ids);
+    return prepared;
+  }
+};
 var Wav2Vec2PreTrainedModel = class extends PreTrainedModel {
 };
 var Wav2Vec2Model = class extends Wav2Vec2PreTrainedModel {
@@ -19341,12 +20363,26 @@ var MimiDecoderModel = class extends MimiPreTrainedModel {
     });
   }
 };
+var MinistralPreTrainedModel = class extends PreTrainedModel {
+};
+var MinistralModel = class extends MinistralPreTrainedModel {
+};
+var MinistralForCausalLM = class extends MinistralPreTrainedModel {
+};
+var Ministral3PreTrainedModel = class extends PreTrainedModel {
+};
+var Ministral3Model = class extends Ministral3PreTrainedModel {
+};
+var Ministral3ForCausalLM = class extends Ministral3PreTrainedModel {
+};
 var MistralPreTrainedModel = class extends PreTrainedModel {
 };
 var MistralModel = class extends MistralPreTrainedModel {
 };
 var MistralForCausalLM = class extends MistralPreTrainedModel {
 };
+var Mistral3ForConditionalGeneration = class extends LlavaForConditionalGeneration {
+};
 var Mistral4PreTrainedModel = class extends PreTrainedModel {
 };
 var Mistral4Model = class extends Mistral4PreTrainedModel {
@@ -19555,6 +20591,7 @@ var MultiModalityCausalLM = class extends MultiModalityPreTrainedModel {
   }
   prepare_inputs_for_generation(input_ids, model_inputs, generation_config) {
     const has_past_key_values = !!model_inputs.past_key_values;
+    setNumLogitsToKeep(this, model_inputs, 1n);
     if (generation_config.guidance_scale !== null && generation_config.guidance_scale > 1) {
       if (has_past_key_values) {
         model_inputs.input_ids = cat([model_inputs.input_ids, model_inputs.input_ids], 0);
@@ -19811,6 +20848,7 @@ var Phi3VForCausalLM = class extends Phi3VPreTrainedModel {
     past_key_values = null,
     generation_config = null,
     logits_processor = null,
+    num_logits_to_keep = null,
     ...kwargs
   }) {
     if (!inputs_embeds) {
@@ -19838,7 +20876,8 @@ var Phi3VForCausalLM = class extends Phi3VPreTrainedModel {
       attention_mask,
       position_ids,
       generation_config,
-      logits_processor
+      logits_processor,
+      num_logits_to_keep
     }, false);
     return outputs;
   }
@@ -20481,7 +21520,11 @@ function createEncoderState(model, input_features) {
     enc_kv_cache[meta.name] = new Tensor22(meta.type, new cls(size), shape);
   }
   const padding_cls = DataTypeMap[padding_type];
-  const enc_padding_cache = new Tensor22(padding_type, new padding_cls(PADDING_CACHE_CHANNELS * CONV1_LEFT_PAD), [1, PADDING_CACHE_CHANNELS, CONV1_LEFT_PAD]);
+  const enc_padding_cache = new Tensor22(padding_type, new padding_cls(PADDING_CACHE_CHANNELS * CONV1_LEFT_PAD), [
+    1,
+    PADDING_CACHE_CHANNELS,
+    CONV1_LEFT_PAD
+  ]);
   const chunks_iter = input_features[Symbol.asyncIterator]?.() ?? input_features[Symbol.iterator]?.();
   if (!chunks_iter) {
     throw new Error("input_features must be iterable or async iterable");
@@ -20889,7 +21932,7 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
         throw new Error(`Layer index ${l} is out of bounds for cross attentions (length ${cross_attentions.length}).`);
       }
       return num_frames ? cross_attentions[l].slice(null, h, null, [0, num_frames]) : cross_attentions[l].slice(null, h);
-    })).transpose(1, 0, 2, 3);
+    })).permute(1, 0, 2, 3);
     const [std, calculatedMean] = std_mean(weights, -2, 0, true);
     const smoothedWeights = weights.clone();
     for (let a = 0;a < smoothedWeights.dims[0]; ++a) {
@@ -21004,6 +22047,12 @@ var YoutuModel = class extends YoutuPreTrainedModel {
 };
 var YoutuForCausalLM = class extends YoutuPreTrainedModel {
 };
+var ZayaPreTrainedModel = class extends PreTrainedModel {
+};
+var ZayaModel = class extends ZayaPreTrainedModel {
+};
+var ZayaForCausalLM = class extends ZayaPreTrainedModel {
+};
 var MODEL_MAPPING_NAMES_ENCODER_ONLY = /* @__PURE__ */ new Map([
   ["bert", "BertModel"],
   ["eurobert", "EuroBertModel"],
@@ -21158,6 +22207,7 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["ernie4_5", "Ernie4_5ForCausalLM"],
   ["starcoder2", "Starcoder2Model"],
   ["deepseek_v3", "DeepseekV3Model"],
+  ["deepseek_v4", "DeepseekV4Model"],
   ["falcon", "FalconModel"],
   ["falcon_h1", "FalconH1Model"],
   ["nemotron_h", "NemotronHModel"],
@@ -21165,7 +22215,9 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["stablelm", "StableLmModel"],
   ["modernbert-decoder", "ModernBertDecoderModel"],
   ["hunyuan_v1_dense", "HunYuanDenseV1Model"],
-  ["youtu", "YoutuModel"]
+  ["youtu", "YoutuModel"],
+  ["zaya", "ZayaModel"],
+  ["hrm_text", "HrmTextModel"]
 ]);
 var MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["speecht5", "SpeechT5ForSpeechToText"],
@@ -21297,6 +22349,7 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["ernie4_5", "Ernie4_5ForCausalLM"],
   ["starcoder2", "Starcoder2ForCausalLM"],
   ["deepseek_v3", "DeepseekV3ForCausalLM"],
+  ["deepseek_v4", "DeepseekV4ForCausalLM"],
   ["falcon", "FalconForCausalLM"],
   ["falcon_h1", "FalconH1ForCausalLM"],
   ["nemotron_h", "NemotronHForCausalLM"],
@@ -21306,6 +22359,8 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["modernbert-decoder", "ModernBertDecoderForCausalLM"],
   ["hunyuan_v1_dense", "HunYuanDenseV1ForCausalLM"],
   ["youtu", "YoutuForCausalLM"],
+  ["zaya", "ZayaForCausalLM"],
+  ["hrm_text", "HrmTextForCausalLM"],
   ["phi3_v", "Phi3VForCausalLM"]
 ]);
 var MODEL_FOR_MULTIMODALITY_MAPPING_NAMES = /* @__PURE__ */ new Map([["multi_modality", "MultiModalityCausalLM"]]);
@@ -22386,7 +23441,7 @@ var AutomaticSpeechRecognitionPipeline = class extends Pipeline {
       const inputs = await this.processor(aud);
       const max_new_tokens = Math.floor(aud.length / sampling_rate) * 6;
       const outputs = await this.model.generate({ max_new_tokens, ...kwargs, ...inputs });
-      const text = this.processor.batch_decode(outputs, { skip_special_tokens: true })[0];
+      const text = this.tokenizer.batch_decode(outputs, { skip_special_tokens: true })[0];
       toReturn.push({ text });
     }
     return single ? toReturn[0] : toReturn;
@@ -23176,15 +24231,19 @@ async function pipeline2(task, model = null, {
   });
   let files_loading = {};
   if (progress_callback) {
-    const metadata = await Promise.all(expected_files.map(async (file) => get_file_metadata(model, file)));
-    metadata.forEach((m, i) => {
-      if (m.exists) {
-        files_loading[expected_files[i]] = {
-          loaded: 0,
-          total: m.size ?? 0
-        };
-      }
-    });
+    try {
+      const metadata = await Promise.all(expected_files.map(async (file) => get_file_metadata(model, file)));
+      metadata.forEach((m, i) => {
+        if (m.exists) {
+          files_loading[expected_files[i]] = {
+            loaded: 0,
+            total: m.size ?? 0
+          };
+        }
+      });
+    } catch (e) {
+      logger.warn(`Unable to fetch model file metadata for total progress tracking: ${e}`);
+    }
   }
   const pretrainedOptions = {
     progress_callback: progress_callback ? new DefaultProgressCallback(progress_callback, files_loading) : undefined,
@@ -23631,6 +24690,19 @@ var ModelRegistry = class {
     return clear_pipeline_cache(task, modelId, options);
   }
 };
+
+// ../plugin/src/features/magic-context/memory/transformers-remote-host.ts
+var DEFAULT_TRANSFORMERS_REMOTE_HOST = "https://huggingface.co/";
+function readHuggingFaceEndpoint() {
+  return globalThis.process?.env?.HF_ENDPOINT;
+}
+function configureTransformersRemoteHost(env, endpoint = readHuggingFaceEndpoint()) {
+  const normalized = endpoint?.trim().replace(/\/+$/, "");
+  env.remoteHost = normalized ? `${normalized}/` : DEFAULT_TRANSFORMERS_REMOTE_HOST;
+}
+
+// ../plugin/src/features/magic-context/memory/transformers-web-entry.ts
+configureTransformersRemoteHost(env3);
 export {
   ASTFeatureExtractor,
   ASTForAudioClassification,
@@ -23695,6 +24767,7 @@ export {
   BartModel,
   BartPretrainedModel,
   BartTokenizer,
+  BaseModelOutput,
   BaseStreamer,
   BeitFeatureExtractor,
   BeitForImageClassification,
@@ -23742,6 +24815,8 @@ export {
   CamembertModel,
   CamembertPreTrainedModel,
   CamembertTokenizer,
+  CausalLMOutput,
+  CausalLMOutputWithPast,
   ChatterboxFeatureExtractor,
   ChatterboxModel,
   ChatterboxPreTrainedModel,
@@ -23827,6 +24902,9 @@ export {
   DeepseekV3ForCausalLM,
   DeepseekV3Model,
   DeepseekV3PreTrainedModel,
+  DeepseekV4ForCausalLM,
+  DeepseekV4Model,
+  DeepseekV4PreTrainedModel,
   DeiTFeatureExtractor,
   DeiTForImageClassification,
   DeiTImageProcessor,
@@ -23957,6 +25035,7 @@ export {
   GemmaModel,
   GemmaPreTrainedModel,
   GemmaTokenizer,
+  GenerationConfig,
   Glm46VImageProcessor,
   Glm46VProcessor,
   GlmForCausalLM,
@@ -23991,6 +25070,9 @@ export {
   HieraForImageClassification,
   HieraModel,
   HieraPreTrainedModel,
+  HrmTextForCausalLM,
+  HrmTextModel,
+  HrmTextPreTrainedModel,
   HubertForCTC,
   HubertForSequenceClassification,
   HubertModel,
@@ -24007,6 +25089,7 @@ export {
   ImageClassificationPipeline,
   ImageFeatureExtractionPipeline,
   ImageProcessor as ImageFeatureExtractor,
+  ImageMattingOutput,
   ImageProcessor,
   ImageSegmentationPipeline,
   ImageToImagePipeline,
@@ -24082,6 +25165,7 @@ export {
   MaskFormerImageProcessor,
   MaskFormerModel,
   MaskFormerPreTrainedModel,
+  MaskedLMOutput,
   MaxLengthCriteria,
   Metric3DForDepthEstimation,
   Metric3DPreTrainedModel,
@@ -24100,6 +25184,13 @@ export {
   MimiPreTrainedModel,
   MinLengthLogitsProcessor,
   MinNewTokensLengthLogitsProcessor,
+  Ministral3ForCausalLM,
+  Ministral3Model,
+  Ministral3PreTrainedModel,
+  MinistralForCausalLM,
+  MinistralModel,
+  MinistralPreTrainedModel,
+  Mistral3ForConditionalGeneration,
   Mistral4ForCausalLM,
   Mistral4Model,
   Mistral4PreTrainedModel,
@@ -24147,6 +25238,8 @@ export {
   MobileViTV2ForImageClassification,
   MobileViTV2Model,
   MobileViTV2PreTrainedModel,
+  ModelFileNotFoundError,
+  ModelOutput,
   ModelRegistry,
   ModernBertDecoderForCausalLM,
   ModernBertDecoderModel,
@@ -24258,6 +25351,7 @@ export {
   PyAnnoteModel,
   PyAnnotePreTrainedModel,
   PyAnnoteProcessor,
+  QuestionAnsweringModelOutput,
   QuestionAnsweringPipeline,
   Qwen2ForCausalLM,
   Qwen2Model,
@@ -24353,6 +25447,8 @@ export {
   SegformerImageProcessor,
   SegformerModel,
   SegformerPreTrainedModel,
+  Seq2SeqLMOutput,
+  SequenceClassifierOutput,
   SiglipImageProcessor,
   SiglipModel,
   SiglipPreTrainedModel,
@@ -24426,6 +25522,7 @@ export {
   TextStreamer,
   TextToAudioPipeline,
   TokenClassificationPipeline,
+  TokenClassifierOutput,
   PreTrainedTokenizer as TokenizersBackend,
   TopKLogitsWarper,
   TopPLogitsWarper,
@@ -24530,6 +25627,9 @@ export {
   YoutuForCausalLM,
   YoutuModel,
   YoutuPreTrainedModel,
+  ZayaForCausalLM,
+  ZayaModel,
+  ZayaPreTrainedModel,
   ZeroShotAudioClassificationPipeline,
   ZeroShotClassificationPipeline,
   ZeroShotImageClassificationPipeline,