@cortexkit/opencode-magic-context 0.41.2 → 0.41.3

package/dist/transformers-node-wasm.js

@@ -182,7 +182,7 @@ function mergeArrays(...arrs) {
   return Array.prototype.concat.apply([], arrs);
 }
 function product(...a) {
-  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e])));
+  return a.reduce((a, b) => a.flatMap((d) => b.map((e) => [d, e])));
 }
 function calculateReflectOffset(i, w) {
   return Math.abs((i + w) % (2 * w) - w);
@@ -195,12 +195,12 @@ function pick(o, props) {
   }));
 }
 function count(arr, value) {
-  let count2 = 0;
+  let count = 0;
   for (const v of arr) {
     if (v === value)
-      ++count2;
+      ++count;
   }
-  return count2;
+  return count;
 }
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/utils/logger.js
@@ -3060,10 +3060,10 @@ function strftime(date, format2) {
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function replace(str, oldvalue, newvalue, count2) {
-  if (count2 === 0)
+function replace(str, oldvalue, newvalue, count) {
+  if (count === 0)
     return str;
-  let remaining = count2 == null || count2 < 0 ? Infinity : count2;
+  let remaining = count == null || count < 0 ? Infinity : count;
   const pattern = oldvalue.length === 0 ? new RegExp("(?=)", "gu") : new RegExp(escapeRegExp(oldvalue), "gu");
   return str.replaceAll(pattern, (match) => {
     if (remaining > 0) {
@@ -3241,20 +3241,20 @@ var StringValue = class extends RuntimeValue {
           if (!(oldValue instanceof StringValue && newValue instanceof StringValue)) {
             throw new Error("replace() arguments must be strings");
           }
-          let count2;
+          let count;
           if (args.length > 2) {
             if (args[2].type === "KeywordArgumentsValue") {
-              count2 = args[2].value.get("count") ?? new NullValue;
+              count = args[2].value.get("count") ?? new NullValue;
             } else {
-              count2 = args[2];
+              count = args[2];
             }
           } else {
-            count2 = new NullValue;
+            count = new NullValue;
           }
-          if (!(count2 instanceof IntegerValue || count2 instanceof NullValue)) {
+          if (!(count instanceof IntegerValue || count 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));
+          return new StringValue(replace(this.value, oldValue.value, newValue.value, count.value));
         })
       ]
     ]);
@@ -3528,18 +3528,18 @@ __publicField(Environment, "TESTS", /* @__PURE__ */ new Map([
   ["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);
-  env2.set("none", null);
-  env2.set("raise_exception", (args) => {
+function setupGlobals(env) {
+  env.set("false", false);
+  env.set("true", true);
+  env.set("none", null);
+  env.set("raise_exception", (args) => {
     throw new Error(args);
   });
-  env2.set("range", range);
-  env2.set("strftime_now", strftime_now);
-  env2.set("True", true);
-  env2.set("False", false);
-  env2.set("None", null);
+  env.set("range", range);
+  env.set("strftime_now", strftime_now);
+  env.set("True", true);
+  env.set("False", false);
+  env.set("None", null);
 }
 function getAttributeValue(item, attributePath) {
   const parts = attributePath.split(".");
@@ -3604,8 +3604,8 @@ function compareRuntimeValues(a, b, caseSensitive = false) {
 }
 var Interpreter = class {
   global;
-  constructor(env2) {
-    this.global = env2 ?? new Environment;
+  constructor(env) {
+    this.global = env ?? new Environment;
   }
   run(program) {
     return this.evaluate(program, this.global);
@@ -4688,14 +4688,14 @@ var Template = class {
     this.parsed = parse(tokens);
   }
   render(items) {
-    const env2 = new Environment;
-    setupGlobals(env2);
+    const env = new Environment;
+    setupGlobals(env);
     if (items) {
       for (const [key, value] of Object.entries(items)) {
-        env2.set(key, value);
+        env.set(key, value);
       }
     }
-    const interpreter = new Interpreter(env2);
+    const interpreter = new Interpreter(env);
     const result = interpreter.run(this.parsed);
     return result.value;
   }
@@ -4831,8 +4831,8 @@ class Random {
     const mt = this._mt;
     if (this._idx >= 624) {
       for (let k = 0;k < 624; ++k) {
-        const y2 = mt[k] & 2147483648 | mt[(k + 1) % 624] & 2147483647;
-        mt[k] = (mt[(k + 397) % 624] ^ y2 >>> 1 ^ (y2 & 1 ? 2567483615 : 0)) >>> 0;
+        const y = mt[k] & 2147483648 | mt[(k + 1) % 624] & 2147483647;
+        mt[k] = (mt[(k + 397) % 624] ^ y >>> 1 ^ (y & 1 ? 2567483615 : 0)) >>> 0;
       }
       this._idx = 0;
     }
@@ -4898,8 +4898,8 @@ var _weightedIndex = (weights) => _weightedIndexWith(random.random, weights);
 var rng = new Random;
 
 class FileCache {
-  constructor(path3) {
-    this.path = path3;
+  constructor(path) {
+    this.path = path;
   }
   async match(request) {
     let filePath = path2.join(this.path, request);
@@ -4991,16 +4991,16 @@ function pathJoin(...parts) {
   return parts.join("/");
 }
 function isValidUrl(string, protocols = null, validHosts = null) {
-  let url2;
+  let url;
   try {
-    url2 = new URL(string);
+    url = new URL(string);
   } catch (_) {
     return false;
   }
-  if (protocols && !protocols.includes(url2.protocol)) {
+  if (protocols && !protocols.includes(url.protocol)) {
     return false;
   }
-  if (validHosts && !validHosts.includes(url2.hostname)) {
+  if (validHosts && !validHosts.includes(url.hostname)) {
     return false;
   }
   return true;
@@ -5050,19 +5050,19 @@ async function readResponse(response, progress_callback, expectedSize) {
   await read();
   return buffer;
 }
-function isBlobURL(url2) {
-  return isValidUrl(url2, ["blob:"]);
+function isBlobURL(url) {
+  return isValidUrl(url, ["blob:"]);
 }
-function toAbsoluteURL(url2) {
+function toAbsoluteURL(url) {
   let baseURL;
   if (typeof location !== "undefined" && location.href) {
     baseURL = location.href;
   } else if (typeof import.meta !== "undefined" && import.meta.url) {
     baseURL = import.meta.url;
   } else {
-    return url2;
+    return url;
   }
-  return new URL(url2, baseURL).href;
+  return new URL(url, baseURL).href;
 }
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/utils/cache/CrossOriginStorageCache.js
@@ -5134,16 +5134,16 @@ class CrossOriginStorage {
       return false;
     }
   };
-  _getFileHash = async (url2) => {
+  _getFileHash = async (url) => {
     try {
       const hashCache = await this._getHashCache();
-      const cached = await hashCache.match(url2);
+      const cached = await hashCache.match(url);
       if (cached) {
         return cached.text();
       }
-      const hash = await this._getLfsFileHash(url2);
+      const hash = await this._getLfsFileHash(url);
       if (hash) {
-        await hashCache.put(url2, new Response(hash));
+        await hashCache.put(url, new Response(hash));
         return hash;
       }
       return null;
@@ -5151,11 +5151,11 @@ class CrossOriginStorage {
       return null;
     }
   };
-  _getLfsFileHash = async (url2) => {
-    if (!url2.includes("/resolve/")) {
+  _getLfsFileHash = async (url) => {
+    if (!url.includes("/resolve/")) {
       return null;
     }
-    const rawUrl = url2.replace("/resolve/", "/raw/");
+    const rawUrl = url.replace("/resolve/", "/raw/");
     try {
       const text = await fetch(rawUrl).then((r) => r.text());
       const match = text.match(/^oid sha256:([0-9a-f]+)$/m);
@@ -5287,9 +5287,9 @@ function get_file_metadata(path_or_repo_id, filename, options = {}) {
   return memoizePromise(key, () => _get_file_metadata(path_or_repo_id, filename, options));
 }
 async function _get_file_metadata(path_or_repo_id, filename, options) {
-  const cache2 = await getCache(options?.cache_dir);
-  const { localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(path_or_repo_id, filename, options, cache2);
-  const cachedResponse = await checkCachedResource(cache2, localPath, proposedCacheKey);
+  const cache = await getCache(options?.cache_dir);
+  const { localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(path_or_repo_id, filename, options, cache);
+  const cachedResponse = await checkCachedResource(cache, localPath, proposedCacheKey);
   if (cachedResponse !== undefined && typeof cachedResponse !== "string") {
     const size = cachedResponse.headers.get("content-length");
     const contentType = cachedResponse.headers.get("content-type");
@@ -5382,13 +5382,13 @@ function getFetchHeaders(urlOrPath) {
   }
   return headers;
 }
-function buildResourcePaths(path_or_repo_id, filename, options = {}, cache2 = null) {
+function buildResourcePaths(path_or_repo_id, filename, options = {}, cache = null) {
   const revision = options.revision ?? "main";
   const requestURL = pathJoin(path_or_repo_id, filename);
   const validModelId = isValidHfModelId(path_or_repo_id);
   const localPath = validModelId ? pathJoin(env.localModelPath, requestURL) : requestURL;
   const remoteURL = pathJoin(env.remoteHost, env.remotePathTemplate.replaceAll("{model}", path_or_repo_id).replaceAll("{revision}", encodeURIComponent(revision)), filename);
-  const proposedCacheKey = cache2 instanceof FileCache ? revision === "main" ? requestURL : pathJoin(path_or_repo_id, revision, filename) : remoteURL;
+  const proposedCacheKey = cache instanceof FileCache ? revision === "main" ? requestURL : pathJoin(path_or_repo_id, revision, filename) : remoteURL;
   return {
     requestURL,
     localPath,
@@ -5397,14 +5397,14 @@ function buildResourcePaths(path_or_repo_id, filename, options = {}, cache2 = nu
     validModelId
   };
 }
-async function checkCachedResource(cache2, localPath, proposedCacheKey) {
-  if (!cache2) {
+async function checkCachedResource(cache, localPath, proposedCacheKey) {
+  if (!cache) {
     return;
   }
-  return await tryCache(cache2, localPath, proposedCacheKey);
+  return await tryCache(cache, localPath, proposedCacheKey);
 }
-async function storeCachedResource(path_or_repo_id, filename, cache2, cacheKey, response, result, options = {}) {
-  if (await cache2.match(cacheKey) !== undefined) {
+async function storeCachedResource(path_or_repo_id, filename, cache, cacheKey, response, result, options = {}) {
+  if (await cache.match(cacheKey) !== undefined) {
     return;
   }
   if (!result) {
@@ -5414,23 +5414,23 @@ async function storeCachedResource(path_or_repo_id, filename, cache2, cacheKey,
       file: filename,
       ...data
     }) : undefined;
-    await cache2.put(cacheKey, response, wrapped_progress);
+    await cache.put(cacheKey, response, wrapped_progress);
   } else if (typeof response !== "string") {
     const headers = new Headers(response.headers);
     headers.set("content-length", result.byteLength.toString());
-    await cache2.put(cacheKey, new Response(result, {
+    await cache.put(cacheKey, new Response(result, {
       headers
     })).catch((err) => {
       logger.warn(`Unable to add response to browser cache: ${err}.`);
     });
   }
 }
-async function loadResourceFile(path_or_repo_id, filename, fatal = true, options = {}, return_path = false, cache2 = null) {
-  const { requestURL, localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(path_or_repo_id, filename, options, cache2);
+async function loadResourceFile(path_or_repo_id, filename, fatal = true, options = {}, return_path = false, cache = null) {
+  const { requestURL, localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(path_or_repo_id, filename, options, cache);
   let cacheKey;
   let toCacheResponse = false;
   let response;
-  response = await checkCachedResource(cache2, localPath, proposedCacheKey);
+  response = await checkCachedResource(cache, localPath, proposedCacheKey);
   const cacheHit = response !== undefined;
   if (cacheHit) {
     cacheKey = proposedCacheKey;
@@ -5467,7 +5467,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
       }
       cacheKey = proposedCacheKey;
     }
-    toCacheResponse = cache2 && typeof Response !== "undefined" && response instanceof Response && response.status === 200;
+    toCacheResponse = cache && typeof Response !== "undefined" && response instanceof Response && response.status === 200;
   }
   dispatchCallback(options.progress_callback, {
     status: "download",
@@ -5516,7 +5516,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
     result = buffer;
   }
   if (toCacheResponse && cacheKey && typeof response !== "string") {
-    await storeCachedResource(path_or_repo_id, filename, cache2, cacheKey, response, result, options);
+    await storeCachedResource(path_or_repo_id, filename, cache, cacheKey, response, result, options);
   }
   if (apis.IS_NODE_ENV && return_path && options.progress_callback && typeof response !== "string") {
     const size = parseInt(response.headers.get("content-length"), 10) || 0;
@@ -5543,7 +5543,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
   if (response instanceof FileResponse) {
     return response.filePath;
   }
-  const cachedResponse = await cache2?.match(cacheKey);
+  const cachedResponse = await cache?.match(cacheKey);
   if (cachedResponse instanceof FileResponse) {
     return cachedResponse.filePath;
   } else if (cachedResponse instanceof Response) {
@@ -5570,8 +5570,8 @@ async function getModelFile(path_or_repo_id, filename, fatal = true, options = {
   const key = `${path_or_repo_id}::${filename}`;
   let pending = INFLIGHT_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) => {
+    const cache = await getCache(options?.cache_dir);
+    pending = loadResourceFile(path_or_repo_id, filename, fatal, options, return_path, cache).then((result) => {
       INFLIGHT_LOADS.delete(key);
       return result;
     }, (err) => {
@@ -5693,28 +5693,28 @@ function magnitude(arr) {
 function min2(arr) {
   if (arr.length === 0)
     throw Error("Array must not be empty");
-  let min3 = arr[0];
+  let min = arr[0];
   let indexOfMin = 0;
   for (let i = 1;i < arr.length; ++i) {
-    if (arr[i] < min3) {
-      min3 = arr[i];
+    if (arr[i] < min) {
+      min = arr[i];
       indexOfMin = i;
     }
   }
-  return [min3, indexOfMin];
+  return [min, indexOfMin];
 }
 function max(arr) {
   if (arr.length === 0)
     throw Error("Array must not be empty");
-  let max2 = arr[0];
+  let max = arr[0];
   let indexOfMax = 0;
   for (let i = 1;i < arr.length; ++i) {
-    if (arr[i] > max2) {
-      max2 = arr[i];
+    if (arr[i] > max) {
+      max = arr[i];
       indexOfMax = i;
     }
   }
-  return [max2, indexOfMax];
+  return [max, indexOfMax];
 }
 function isPowerOfTwo(number) {
   return number > 0 && (number & number - 1) === 0;
@@ -5783,26 +5783,26 @@ class P2FFT {
     const size = this._csize;
     const width = this._width;
     let step = 1 << width;
-    let len2 = size / step << 1;
+    let len = size / step << 1;
     let outOff;
     let t;
     const bitrev = this._bitrev;
-    if (len2 === 4) {
-      for (outOff = 0, t = 0;outOff < size; outOff += len2, ++t) {
+    if (len === 4) {
+      for (outOff = 0, t = 0;outOff < size; outOff += len, ++t) {
         const off = bitrev[t];
         this._singleTransform2(data, out, outOff, off, step);
       }
     } else {
-      for (outOff = 0, t = 0;outOff < size; outOff += len2, ++t) {
+      for (outOff = 0, t = 0;outOff < size; outOff += len, ++t) {
         const off = bitrev[t];
         this._singleTransform4(data, out, outOff, off, step, inv);
       }
     }
     const table = this.table;
     for (step >>= 2;step >= 2; step >>= 2) {
-      len2 = size / step << 1;
-      const quarterLen = len2 >>> 2;
-      for (outOff = 0;outOff < size; outOff += len2) {
+      len = size / step << 1;
+      const quarterLen = len >>> 2;
+      for (outOff = 0;outOff < size; outOff += len) {
         const limit = outOff + quarterLen - 1;
         for (let i = outOff, k = 0;i < limit; i += 2, k += step) {
           const A = i;
@@ -5891,28 +5891,28 @@ class P2FFT {
     const size = this._csize;
     const width = this._width;
     let step = 1 << width;
-    let len2 = size / step << 1;
+    let len = size / step << 1;
     let outOff;
     let t;
     const bitrev = this._bitrev;
-    if (len2 === 4) {
-      for (outOff = 0, t = 0;outOff < size; outOff += len2, ++t) {
+    if (len === 4) {
+      for (outOff = 0, t = 0;outOff < size; outOff += len, ++t) {
         const off = bitrev[t];
         this._singleRealTransform2(data, out, outOff, off >>> 1, step >>> 1);
       }
     } else {
-      for (outOff = 0, t = 0;outOff < size; outOff += len2, ++t) {
+      for (outOff = 0, t = 0;outOff < size; outOff += len, ++t) {
         const off = bitrev[t];
         this._singleRealTransform4(data, out, outOff, off >>> 1, step >>> 1, inv);
       }
     }
     const table = this.table;
     for (step >>= 2;step >= 2; step >>= 2) {
-      len2 = size / step << 1;
-      const halfLen = len2 >>> 1;
+      len = size / step << 1;
+      const halfLen = len >>> 1;
       const quarterLen = halfLen >>> 1;
       const hquarterLen = quarterLen >>> 1;
-      for (outOff = 0;outOff < size; outOff += len2) {
+      for (outOff = 0;outOff < size; outOff += len) {
         for (let i = 0, k = 0;i <= hquarterLen; i += 2, k += step) {
           const A = outOff + i;
           const B = A + quarterLen;
@@ -6140,11 +6140,11 @@ function dynamic_time_warping(matrix) {
   const cost = Array.from({ length: outputShape[0] }, () => Array(outputShape[1]).fill(Infinity));
   cost[0][0] = 0;
   const trace = Array.from({ length: outputShape[0] }, () => Array(outputShape[1]).fill(-1));
-  for (let j2 = 1;j2 < outputShape[1]; ++j2) {
-    for (let i2 = 1;i2 < outputShape[0]; ++i2) {
-      const c0 = cost[i2 - 1][j2 - 1];
-      const c1 = cost[i2 - 1][j2];
-      const c2 = cost[i2][j2 - 1];
+  for (let j = 1;j < outputShape[1]; ++j) {
+    for (let i = 1;i < outputShape[0]; ++i) {
+      const c0 = cost[i - 1][j - 1];
+      const c1 = cost[i - 1][j];
+      const c2 = cost[i][j - 1];
       let c, t;
       if (c0 < c1 && c0 < c2) {
         c = c0;
@@ -6156,15 +6156,15 @@ function dynamic_time_warping(matrix) {
         c = c2;
         t = 2;
       }
-      cost[i2][j2] = matrix[i2 - 1][j2 - 1] + c;
-      trace[i2][j2] = t;
+      cost[i][j] = matrix[i - 1][j - 1] + c;
+      trace[i][j] = t;
     }
   }
-  for (let i2 = 0;i2 < outputShape[1]; ++i2) {
-    trace[0][i2] = 2;
+  for (let i = 0;i < outputShape[1]; ++i) {
+    trace[0][i] = 2;
   }
-  for (let i2 = 0;i2 < outputShape[0]; ++i2) {
-    trace[i2][0] = 1;
+  for (let i = 0;i < outputShape[0]; ++i) {
+    trace[i][0] = 1;
   }
   let i = output_length;
   let j = input_length;
@@ -6248,13 +6248,13 @@ var onnxruntime_node_wasm_shim_default = ortWeb;
 import * as ONNX_WEB from "onnxruntime-web/webgpu";
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/backends/utils/cacheWasm.js
-async function loadAndCacheFile(url2) {
-  const fileName = url2.split("/").pop();
-  let cache2;
+async function loadAndCacheFile(url) {
+  const fileName = url.split("/").pop();
+  let cache;
   try {
-    cache2 = await getCache();
-    if (cache2) {
-      const result = await cache2.match(url2);
+    cache = await getCache();
+    if (cache) {
+      const result = await cache.match(url);
       if (result) {
         return result;
       }
@@ -6262,13 +6262,13 @@ async function loadAndCacheFile(url2) {
   } catch (error) {
     logger.warn(`Failed to load ${fileName} from cache:`, error);
   }
-  const response = await env.fetch(url2);
+  const response = await env.fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${fileName}: ${response.status} ${response.statusText}`);
   }
-  if (cache2) {
+  if (cache) {
     try {
-      await cache2.put(url2, response.clone());
+      await cache.put(url, response.clone());
     } catch (e) {
       logger.warn(`Failed to cache ${fileName}:`, e);
     }
@@ -7069,14 +7069,14 @@ var DEVICE_TO_EXECUTION_PROVIDER_MAPPING = Object.freeze({
   "webnn-gpu": { name: "webnn", deviceType: "gpu" },
   "webnn-cpu": { name: "webnn", deviceType: "cpu" }
 });
-function getOnnxLogSeverityLevel(logLevel2) {
-  if (logLevel2 <= LogLevel.DEBUG) {
+function getOnnxLogSeverityLevel(logLevel) {
+  if (logLevel <= LogLevel.DEBUG) {
     return 0;
-  } else if (logLevel2 <= LogLevel.INFO) {
+  } else if (logLevel <= LogLevel.INFO) {
     return 2;
-  } else if (logLevel2 <= LogLevel.WARNING) {
+  } else if (logLevel <= LogLevel.WARNING) {
     return 3;
-  } else if (logLevel2 <= LogLevel.ERROR) {
+  } else if (logLevel <= LogLevel.ERROR) {
     return 3;
   } else {
     return 4;
@@ -7209,8 +7209,8 @@ function isONNXProxy() {
   return ONNX_ENV?.wasm?.proxy;
 }
 if (ONNX_ENV) {
-  let setLogLevel = function(logLevel2) {
-    const severityLevel = getOnnxLogSeverityLevel(logLevel2);
+  let setLogLevel = function(logLevel) {
+    const severityLevel = getOnnxLogSeverityLevel(logLevel);
     ONNX_ENV.logLevel = ONNX_LOG_LEVEL_NAMES[severityLevel];
   };
   if (ONNX_ENV.wasm) {
@@ -8536,25 +8536,25 @@ class Tensor3 {
     const newTensorDims = [];
     const newOffsets = [];
     for (let sliceIndex = 0;sliceIndex < this.dims.length; ++sliceIndex) {
-      let slice2 = slices[sliceIndex];
-      if (slice2 === null || slice2 === undefined) {
+      let slice = slices[sliceIndex];
+      if (slice === null || slice === undefined) {
         newOffsets.push([0, this.dims[sliceIndex]]);
         newTensorDims.push(this.dims[sliceIndex]);
-      } else if (typeof slice2 === "number") {
-        slice2 = safeIndex(slice2, this.dims[sliceIndex], sliceIndex);
-        newOffsets.push([slice2, slice2 + 1]);
-      } else if (Array.isArray(slice2) && slice2.length === 2) {
-        let [start, end] = slice2;
+      } else if (typeof slice === "number") {
+        slice = safeIndex(slice, this.dims[sliceIndex], sliceIndex);
+        newOffsets.push([slice, slice + 1]);
+      } else if (Array.isArray(slice) && slice.length === 2) {
+        let [start, end] = slice;
         start = start === null ? 0 : safeIndex(start, this.dims[sliceIndex], sliceIndex, false);
         end = end === null ? this.dims[sliceIndex] : safeIndex(end, this.dims[sliceIndex], sliceIndex, false);
         if (start > end) {
-          throw new Error(`Invalid slice: ${slice2}`);
+          throw new Error(`Invalid slice: ${slice}`);
         }
         const offsets = [Math.max(start, 0), Math.min(end, this.dims[sliceIndex])];
         newOffsets.push(offsets);
         newTensorDims.push(offsets[1] - offsets[0]);
       } else {
-        throw new Error(`Invalid slice: ${slice2}`);
+        throw new Error(`Invalid slice: ${slice}`);
       }
     }
     const newDims = newOffsets.map(([start, end]) => end - start);
@@ -8701,8 +8701,8 @@ class Tensor3 {
     }
     const this_data = this.data;
     if (inferredIndex !== -1) {
-      const productOther = dims.reduce((product2, curr, index) => {
-        return index !== inferredIndex ? product2 * curr : product2;
+      const productOther = dims.reduce((product, curr, index) => {
+        return index !== inferredIndex ? product * curr : product;
       }, 1);
       dims[inferredIndex] = this_data.length / productOther;
     }
@@ -8734,15 +8734,15 @@ class Tensor3 {
     }
     return new Tensor3("bool", mask, this.dims);
   }
-  clamp_(min3, max2) {
+  clamp_(min, max) {
     const this_data = this.data;
     for (let i = 0;i < this_data.length; ++i) {
-      this_data[i] = Math.min(Math.max(this_data[i], min3), max2);
+      this_data[i] = Math.min(Math.max(this_data[i], min), max);
     }
     return this;
   }
-  clamp(min3, max2) {
-    return this.clone().clamp_(min3, max2);
+  clamp(min, max) {
+    return this.clone().clamp_(min, max);
   }
   round_() {
     const this_data = this.data;
@@ -8795,8 +8795,8 @@ class Tensor3 {
       if (repeats.length === this.dims.length) {
         return this.clone();
       }
-      const numPrependedDims2 = repeats.length - this.dims.length;
-      const newDims = Array(numPrependedDims2).fill(1).concat(this.dims);
+      const numPrependedDims = repeats.length - this.dims.length;
+      const newDims = Array(numPrependedDims).fill(1).concat(this.dims);
       return new Tensor3(this.type, this.data.slice(), newDims);
     }
     const numPrependedDims = repeats.length - this.dims.length;
@@ -8870,9 +8870,9 @@ function reshape(data, dimensions) {
   }
   return reshapedArray[0];
 }
-function permute(tensor2, axes) {
-  const [permutedData, shape] = permute_data(tensor2.data, tensor2.dims, axes);
-  return new Tensor3(tensor2.type, permutedData, shape);
+function permute(tensor, axes) {
+  const [permutedData, shape] = permute_data(tensor.data, tensor.dims, axes);
+  return new Tensor3(tensor.type, permutedData, shape);
 }
 function interpolate(input, [out_height, out_width], mode = "bilinear", align_corners = false) {
   const in_channels = input.dims.at(-3) ?? 1;
@@ -8953,15 +8953,15 @@ function mean_pooling(last_hidden_state, attention_mask) {
     const offset = i * embedDim * seqLength;
     for (let k = 0;k < embedDim; ++k) {
       let sum = 0;
-      let count2 = 0;
+      let count = 0;
       const attnMaskOffset = i * seqLength;
       const offset2 = offset + k;
       for (let j = 0;j < seqLength; ++j) {
         const attn = Number(attentionMaskData[attnMaskOffset + j]);
-        count2 += attn;
+        count += attn;
         sum += lastHiddenStateData[offset2 + j * embedDim] * attn;
       }
-      const avg = sum / count2;
+      const avg = sum / count;
       returnedData[outIndex++] = avg;
     }
   }
@@ -9032,8 +9032,8 @@ function cat(tensors, dim = 0) {
   const resultType = tensors[0].type;
   if (dim === 0) {
     let offset = 0;
-    for (const tensor2 of tensors) {
-      const tensorData = tensor2.data;
+    for (const tensor of tensors) {
+      const tensorData = tensor.data;
       result.set(tensorData, offset);
       offset += tensorData.length;
     }
@@ -9097,9 +9097,9 @@ function std_mean(input, dim = null, correction = 1, keepdim = false) {
     const sum = inputData.reduce((a, b) => a + b, 0);
     const mean = sum / inputData.length;
     const std = Math.sqrt(inputData.reduce((a, b) => a + (b - mean) ** 2, 0) / (inputData.length - correction));
-    const meanTensor2 = new Tensor3(input.type, [mean], []);
-    const stdTensor2 = new Tensor3(input.type, [std], []);
-    return [stdTensor2, meanTensor2];
+    const meanTensor = new Tensor3(input.type, [mean], []);
+    const stdTensor = new Tensor3(input.type, [std], []);
+    return [stdTensor, meanTensor];
   }
   dim = safeIndex(dim, inputDims.length);
   const meanTensor = mean(input, dim, keepdim);
@@ -9156,20 +9156,20 @@ function full(size, fill_value) {
   }
   return fullHelper(size, fill_value, dtype, typedArrayCls);
 }
-function full_like(tensor2, fill_value) {
-  return full(tensor2.dims, fill_value);
+function full_like(tensor, fill_value) {
+  return full(tensor.dims, fill_value);
 }
 function ones(size) {
   return fullHelper(size, 1n, "int64", BigInt64Array);
 }
-function ones_like(tensor2) {
-  return ones(tensor2.dims);
+function ones_like(tensor) {
+  return ones(tensor.dims);
 }
 function zeros(size) {
   return fullHelper(size, 0n, "int64", BigInt64Array);
 }
-function zeros_like(tensor2) {
-  return zeros(tensor2.dims);
+function zeros_like(tensor) {
+  return zeros(tensor.dims);
 }
 function rand(size) {
   const length = size.reduce((a, b) => a * b, 1);
@@ -9179,11 +9179,11 @@ function randn(size) {
   const length = size.reduce((a, b) => a * b, 1);
   return new Tensor3("float32", Float32Array.from({ length }, () => random.gauss()), size);
 }
-function quantize_embeddings(tensor2, precision) {
-  if (tensor2.dims.length !== 2) {
+function quantize_embeddings(tensor, precision) {
+  if (tensor.dims.length !== 2) {
     throw new Error("The tensor must have 2 dimensions");
   }
-  if (tensor2.dims.at(-1) % 8 !== 0) {
+  if (tensor.dims.at(-1) % 8 !== 0) {
     throw new Error("The last dimension of the tensor must be a multiple of 8");
   }
   if (!["binary", "ubinary"].includes(precision)) {
@@ -9192,7 +9192,7 @@ function quantize_embeddings(tensor2, precision) {
   const signed = precision === "binary";
   const dtype = signed ? "int8" : "uint8";
   const cls = signed ? Int8Array : Uint8Array;
-  const inputData = tensor2.data;
+  const inputData = tensor.data;
   const outputData = new cls(inputData.length / 8);
   for (let i = 0;i < inputData.length; ++i) {
     const bit = inputData[i] > 0 ? 1 : 0;
@@ -9203,7 +9203,7 @@ function quantize_embeddings(tensor2, precision) {
       outputData[arrayIndex] -= 128;
     }
   }
-  return new Tensor3(dtype, outputData, [tensor2.dims[0], tensor2.dims[1] / 8]);
+  return new Tensor3(dtype, outputData, [tensor.dims[0], tensor.dims[1] / 8]);
 }
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/utils/model_registry/get_tokenizer_files.js
@@ -9223,16 +9223,16 @@ async function loadTokenizer(pretrained_model_name_or_path, options) {
   const tokenizerFiles = await get_tokenizer_files(pretrained_model_name_or_path);
   return await Promise.all(tokenizerFiles.map((file) => getModelJSON(pretrained_model_name_or_path, file, true, options)));
 }
-function prepareTensorForDecode(tensor2) {
-  const dims = tensor2.dims;
+function prepareTensorForDecode(tensor) {
+  const dims = tensor.dims;
   switch (dims.length) {
     case 1:
-      return tensor2.tolist();
+      return tensor.tolist();
     case 2:
       if (dims[0] !== 1) {
         throw new Error("Unable to decode tensor with `batch size !== 1`. Use `tokenizer.batch_decode(...)` for batched inputs.");
       }
-      return tensor2.tolist()[0];
+      return tensor.tolist()[0];
     default:
       throw new Error(`Expected tensor to have 1-2 dimensions, got ${dims.length}.`);
   }
@@ -9520,7 +9520,7 @@ class PreTrainedTokenizer extends Callable {
       documents = null,
       chat_template = null,
       add_generation_prompt = false,
-      tokenize: tokenize2 = true,
+      tokenize = true,
       padding = false,
       truncation = false,
       max_length = null,
@@ -9553,7 +9553,7 @@ class PreTrainedTokenizer extends Callable {
       ...special_tokens_map,
       ...kwargs
     });
-    if (tokenize2) {
+    if (tokenize) {
       const out = this._call(rendered, {
         add_special_tokens: false,
         padding,
@@ -9757,11 +9757,11 @@ class MarianTokenizer extends PreTrainedTokenizer {
     if (remainder.length === 0) {
       return super._encode_text(matchInfo);
     } else if (remainder.length === 2) {
-      const [language, text2] = remainder;
+      const [language, text] = remainder;
       if (!this.supported_language_codes.includes(language)) {
         logger.warn(`Unsupported language code "${language}" detected, which may lead to unexpected behavior. Should be one of: ${JSON.stringify(this.supported_language_codes)}`);
       }
-      return mergeArrays([language], super._encode_text(text2));
+      return mergeArrays([language], super._encode_text(text));
     }
   }
 }
@@ -10144,21 +10144,21 @@ class WhisperTokenizer extends PreTrainedTokenizer {
       chunks.push(chunk);
     }
     let optional = Object.create(null);
-    const full_text = chunks.map((chunk2) => chunk2.text).join("");
+    const full_text = chunks.map((chunk) => chunk.text).join("");
     if (return_timestamps || return_language) {
       for (let i = 0;i < chunks.length; ++i) {
-        const chunk2 = chunks[i];
+        const chunk = chunks[i];
         if (!return_timestamps) {
-          delete chunk2["timestamp"];
+          delete chunk["timestamp"];
         }
         if (!return_language) {
-          delete chunk2["language"];
+          delete chunk["language"];
         }
       }
       if (returnWordTimestamps) {
         const new_chunks = [];
-        for (const chunk2 of chunks) {
-          for (const word of chunk2.words) {
+        for (const chunk of chunks) {
+          for (const word of chunk.words) {
             new_chunks.push(word);
           }
         }
@@ -10178,36 +10178,36 @@ class WhisperTokenizer extends PreTrainedTokenizer {
     let left_token_timestamp_sequence = use_token_timestamp_sequences ? token_timestamp_sequences[0] : null;
     for (let i = 1;i < sequences.length; ++i) {
       const rightSequence = sequences[i];
-      let max2 = 0;
+      let max = 0;
       let maxIndices = [leftLength, leftLength, 0, 0];
       const rightLength = rightSequence.length;
       for (let j = 1;j < leftLength + rightLength; ++j) {
-        const leftStart2 = Math.max(0, leftLength - j);
-        const leftStop2 = Math.min(leftLength, leftLength + rightLength - j);
-        const left = leftSequence.slice(leftStart2, leftStop2);
-        const rightStart2 = Math.max(0, j - leftLength);
-        const rightStop2 = Math.min(rightLength, j);
-        const right = rightSequence.slice(rightStart2, rightStop2);
+        const leftStart = Math.max(0, leftLength - j);
+        const leftStop = Math.min(leftLength, leftLength + rightLength - j);
+        const left = leftSequence.slice(leftStart, leftStop);
+        const rightStart = Math.max(0, j - leftLength);
+        const rightStop = Math.min(rightLength, j);
+        const right = rightSequence.slice(rightStart, rightStop);
         if (left.length !== right.length) {
           throw new Error("There is a bug within whisper `decode_asr` function, please report it. Dropping to prevent bad inference.");
         }
         let matches;
         if (use_token_timestamp_sequences) {
-          matches = left.filter((elem, idx) => elem === right[idx] && left_token_timestamp_sequence[leftStart2 + idx][0] - TIMESTAMP_MERGE_TOLERANCE <= token_timestamp_sequences[i][rightStart2 + idx][0]).length;
+          matches = left.filter((elem, idx) => elem === right[idx] && left_token_timestamp_sequence[leftStart + idx][0] - TIMESTAMP_MERGE_TOLERANCE <= token_timestamp_sequences[i][rightStart + idx][0]).length;
         } else {
           matches = left.filter((elem, idx) => elem === right[idx]).length;
         }
         const eps = j / 1e4;
         const matching = matches / j + eps;
-        if (matches > 1 && matching > max2) {
-          max2 = matching;
-          maxIndices = [leftStart2, leftStop2, rightStart2, rightStop2];
+        if (matches > 1 && matching > max) {
+          max = matching;
+          maxIndices = [leftStart, leftStop, rightStart, rightStop];
         }
       }
       const [leftStart, leftStop, rightStart, rightStop] = maxIndices;
       const leftMid = Math.floor((leftStop + leftStart) / 2);
       let rightMid = Math.floor((rightStop + rightStart) / 2);
-      if (use_token_timestamp_sequences && max2 === 0 && leftLength > 0) {
+      if (use_token_timestamp_sequences && max === 0 && leftLength > 0) {
         const lastLeftTs = left_token_timestamp_sequence[leftLength - 1][0];
         const idx = token_timestamp_sequences[i].findIndex((ts) => ts[0] >= lastLeftTs);
         rightMid = idx === -1 ? rightSequence.length : idx;
@@ -10563,7 +10563,7 @@ __export(exports_feature_extractors, {
 import fs4 from "node:fs";
 import { Readable } from "node:stream";
 import { pipeline as pipe } from "node:stream/promises";
-async function saveBlob(path3, blob) {
+async function saveBlob(path, blob) {
   if (apis.IS_BROWSER_ENV) {
     if (apis.IS_WEBWORKER_ENV) {
       throw new Error("Unable to save a file from a Web Worker.");
@@ -10571,14 +10571,14 @@ async function saveBlob(path3, blob) {
     const dataURL = URL.createObjectURL(blob);
     const downloadLink = document.createElement("a");
     downloadLink.href = dataURL;
-    downloadLink.download = path3;
+    downloadLink.download = path;
     downloadLink.click();
     downloadLink.remove();
     URL.revokeObjectURL(dataURL);
   } else if (apis.IS_FS_AVAILABLE) {
     const webStream = blob.stream();
     const nodeStream = Readable.fromWeb(webStream);
-    const fileStream = fs4.createWriteStream(path3);
+    const fileStream = fs4.createWriteStream(path);
     await pipe(nodeStream, fileStream);
   } else {
     throw new Error("Unable to save because filesystem is disabled in this environment.");
@@ -10586,11 +10586,11 @@ async function saveBlob(path3, blob) {
 }
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/utils/audio.js
-async function load_audio(url2, sampling_rate) {
+async function load_audio(url, sampling_rate) {
   if (typeof AudioContext === "undefined") {
     throw Error("Unable to load audio from path/URL since `AudioContext` is not available in your environment. " + "Instead, audio data should be passed directly to the pipeline/processor. " + "For more information and some example code, see https://huggingface.co/docs/transformers.js/guides/node-audio-processing.");
   }
-  const response = await (await getFile(url2)).arrayBuffer();
+  const response = await (await getFile(url)).arrayBuffer();
   const audioCTX = new AudioContext({ sampleRate: sampling_rate });
   if (typeof sampling_rate === "undefined") {
     logger.warn(`No sampling rate provided, using default of ${audioCTX.sampleRate}Hz.`);
@@ -10859,9 +10859,9 @@ async function spectrogram(waveform, window2, frame_length, hop_length, {
       for (let j = 0;j < buffer_size; ++j) {
         sum += inputBuffer[j];
       }
-      const mean2 = sum / buffer_size;
+      const mean = sum / buffer_size;
       for (let j = 0;j < buffer_size; ++j) {
-        inputBuffer[j] -= mean2;
+        inputBuffer[j] -= mean;
       }
     }
     if (preemphasis !== null) {
@@ -11032,8 +11032,8 @@ class RawAudio {
     }
     return encodeWAV(audio, this.sampling_rate);
   }
-  async save(path3) {
-    return saveBlob(path3, this.toBlob());
+  async save(path) {
+    return saveBlob(path, this.toBlob());
   }
 }
 
@@ -11226,13 +11226,13 @@ class ParakeetFeatureExtractor extends FeatureExtractor {
     }
     const divisor = features_length > 1 ? features_length - 1 : 1;
     for (let j = 0;j < num_features; ++j) {
-      const mean2 = sum[j] / features_length;
-      const variance = (sum_sq[j] - features_length * mean2 * mean2) / divisor;
+      const mean = sum[j] / features_length;
+      const variance = (sum_sq[j] - features_length * mean * mean) / divisor;
       const std = Math.sqrt(variance) + EPSILON;
       const inv_std = 1 / std;
       for (let i = 0;i < features_length; ++i) {
         const index = i * num_features + j;
-        features_data[index] = (features_data[index] - mean2) * inv_std;
+        features_data[index] = (features_data[index] - mean) * inv_std;
       }
     }
     const mask_data = new BigInt64Array(num_frames);
@@ -11250,9 +11250,9 @@ class CohereAsrFeatureExtractor extends ParakeetFeatureExtractor {
     const dither = this.config.dither ?? 0;
     if (dither <= 0)
       return waveform;
-    const rng2 = new Random(waveform.length);
+    const rng = new Random(waveform.length);
     for (let i = 0;i < waveform.length; ++i) {
-      waveform[i] += dither * rng2.gauss();
+      waveform[i] += dither * rng.gauss();
     }
     return waveform;
   }
@@ -11533,36 +11533,36 @@ class SeamlessM4TFeatureExtractor extends FeatureExtractor {
         for (let j = 0;j < num_features; ++j) {
           sum += data[j * feature_size + i];
         }
-        const mean2 = sum / num_features;
+        const mean = sum / num_features;
         let variance = 0;
         for (let j = 0;j < num_features; ++j) {
-          variance += (data[j * feature_size + i] - mean2) ** 2;
+          variance += (data[j * feature_size + i] - mean) ** 2;
         }
         variance /= num_features - 1;
         const std = Math.sqrt(variance + 0.0000001);
         for (let j = 0;j < num_features; ++j) {
           const index = j * feature_size + i;
-          data[index] = (data[index] - mean2) / std;
+          data[index] = (data[index] - mean) / std;
         }
       }
     }
     let padded_attention_mask;
     if (padding) {
-      const [num_frames2, num_channels2] = features.dims;
+      const [num_frames, num_channels] = features.dims;
       const data = features.data;
-      const pad_size = num_frames2 % pad_to_multiple_of;
+      const pad_size = num_frames % pad_to_multiple_of;
       if (pad_size > 0) {
-        const padded_data = new Float32Array(num_channels2 * (num_frames2 + pad_size));
+        const padded_data = new Float32Array(num_channels * (num_frames + pad_size));
         padded_data.set(data);
         padded_data.fill(this.config.padding_value, data.length);
-        const numPaddedFrames = num_frames2 + pad_size;
-        features = new Tensor3(features.type, padded_data, [numPaddedFrames, num_channels2]);
+        const numPaddedFrames = num_frames + pad_size;
+        features = new Tensor3(features.type, padded_data, [numPaddedFrames, num_channels]);
         if (return_attention_mask) {
           padded_attention_mask = new Tensor3("int64", new BigInt64Array(numPaddedFrames), [
             1,
             numPaddedFrames
           ]);
-          padded_attention_mask.data.fill(1n, 0, num_frames2);
+          padded_attention_mask.data.fill(1n, 0, num_frames);
         }
       }
     }
@@ -11600,9 +11600,9 @@ class SpeechT5FeatureExtractor extends FeatureExtractor {
 class Wav2Vec2FeatureExtractor extends FeatureExtractor {
   _zero_mean_unit_var_norm(input_values) {
     const sum = input_values.reduce((a, b) => a + b, 0);
-    const mean2 = sum / input_values.length;
-    const variance = input_values.reduce((a, b) => a + (b - mean2) ** 2, 0) / input_values.length;
-    return input_values.map((x) => (x - mean2) / Math.sqrt(variance + 0.0000001));
+    const mean = sum / input_values.length;
+    const variance = input_values.reduce((a, b) => a + (b - mean) ** 2, 0) / input_values.length;
+    return input_values.map((x) => (x - mean) / Math.sqrt(variance + 0.0000001));
   }
   async _call(audio) {
     validate_audio_inputs(audio, "Wav2Vec2FeatureExtractor");
@@ -11867,10 +11867,10 @@ class RawImage {
     const data = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
     return new RawImage(data, canvas.width, canvas.height, 4);
   }
-  static async fromURL(url2) {
-    const response = await getFile(url2);
+  static async fromURL(url) {
+    const response = await getFile(url);
     if (response.status !== 200) {
-      throw new Error(`Unable to read image from "${url2}" (${response.status} ${response.statusText})`);
+      throw new Error(`Unable to read image from "${url}" (${response.status} ${response.statusText})`);
     }
     const blob = await response.blob();
     return this.fromBlob(blob);
@@ -11886,26 +11886,26 @@ class RawImage {
       return await loadImageFunction(img);
     }
   }
-  static fromTensor(tensor2, channel_format = "CHW") {
-    if (tensor2.dims.length !== 3) {
-      throw new Error(`Tensor should have 3 dimensions, but has ${tensor2.dims.length} dimensions.`);
+  static fromTensor(tensor, channel_format = "CHW") {
+    if (tensor.dims.length !== 3) {
+      throw new Error(`Tensor should have 3 dimensions, but has ${tensor.dims.length} dimensions.`);
     }
     if (channel_format === "CHW") {
-      tensor2 = tensor2.transpose(1, 2, 0);
+      tensor = tensor.transpose(1, 2, 0);
     } else if (channel_format === "HWC") {} else {
       throw new Error(`Unsupported channel format: ${channel_format}`);
     }
-    if (!(tensor2.data instanceof Uint8ClampedArray || tensor2.data instanceof Uint8Array)) {
-      throw new Error(`Unsupported tensor type: ${tensor2.type}`);
+    if (!(tensor.data instanceof Uint8ClampedArray || tensor.data instanceof Uint8Array)) {
+      throw new Error(`Unsupported tensor type: ${tensor.type}`);
     }
-    switch (tensor2.dims[2]) {
+    switch (tensor.dims[2]) {
       case 1:
       case 2:
       case 3:
       case 4:
-        return new RawImage(tensor2.data, tensor2.dims[1], tensor2.dims[0], tensor2.dims[2]);
+        return new RawImage(tensor.data, tensor.dims[1], tensor.dims[0], tensor.dims[2]);
       default:
-        throw new Error(`Unsupported number of channels: ${tensor2.dims[2]}`);
+        throw new Error(`Unsupported number of channels: ${tensor.dims[2]}`);
     }
   }
   grayscale() {
@@ -12192,13 +12192,13 @@ class RawImage {
     return await canvas.convertToBlob({ type, quality });
   }
   toTensor(channel_format = "CHW") {
-    let tensor2 = new Tensor3("uint8", new Uint8Array(this.data), [this.height, this.width, this.channels]);
+    let tensor = new Tensor3("uint8", new Uint8Array(this.data), [this.height, this.width, this.channels]);
     if (channel_format === "HWC") {} else if (channel_format === "CHW") {
-      tensor2 = tensor2.permute(2, 0, 1);
+      tensor = tensor.permute(2, 0, 1);
     } else {
       throw new Error(`Unsupported channel format: ${channel_format}`);
     }
-    return tensor2;
+    return tensor;
   }
   toCanvas() {
     if (!apis.IS_WEB_ENV) {
@@ -12221,7 +12221,7 @@ class RawImage {
         split_data[j][i] = data[data_offset + j];
       }
     }
-    return split_data.map((data2) => new RawImage(data2, width, height, 1));
+    return split_data.map((data) => new RawImage(data, width, height, 1));
   }
   _update(data, width, height, channels = null) {
     this.data = data;
@@ -12253,18 +12253,18 @@ class RawImage {
     }
     return this;
   }
-  async save(path3) {
+  async save(path) {
     if (apis.IS_WEB_ENV) {
       if (apis.IS_WEBWORKER_ENV) {
         throw new Error("Unable to save an image from a Web Worker.");
       }
-      const extension = path3.split(".").pop().toLowerCase();
+      const extension = path.split(".").pop().toLowerCase();
       const mime = CONTENT_TYPE_MAP2.get(extension) ?? "image/png";
       const blob = await this.toBlob(mime);
-      return saveBlob(path3, blob);
+      return saveBlob(path, blob);
     } else if (apis.IS_FS_AVAILABLE) {
       const img = this.toSharp();
-      await img.toFile(path3);
+      await img.toFile(path);
     } else {
       throw new Error("Unable to save the image because filesystem is disabled in this environment.");
     }
@@ -12345,7 +12345,7 @@ function post_process_object_detection(outputs, threshold = 0.5, target_sizes =
         let box = bbox[j].data;
         box = center_to_corners_format(box);
         if (target_size !== null) {
-          box = box.map((x, i2) => x * target_size[(i2 + 1) % 2]);
+          box = box.map((x, i) => x * target_size[(i + 1) % 2]);
         }
         info.boxes.push(box);
         info.classes.push(index);
@@ -12519,9 +12519,9 @@ function post_process_panoptic_segmentation(outputs, threshold = 0.5, mask_thres
     let [mask_probs_item, pred_scores_item, pred_labels_item] = remove_low_and_no_objects(class_logits, mask_logits, threshold, num_labels);
     if (pred_labels_item.length === 0) {
       let [height, width] = target_size ?? mask_logits.dims.slice(-2);
-      let segmentation2 = new Tensor3("int32", new Int32Array(height * width).fill(-1), [height, width]);
+      let segmentation = new Tensor3("int32", new Int32Array(height * width).fill(-1), [height, width]);
       toReturn.push({
-        segmentation: segmentation2,
+        segmentation,
         segments_info: []
       });
       continue;
@@ -13388,8 +13388,8 @@ function get_target_ratios(min_tiles, max_tiles) {
   for (let n = min_tiles;n <= max_tiles; ++n) {
     for (let w = 1;w <= n; ++w) {
       for (let h = 1;h <= n; ++h) {
-        const product2 = w * h;
-        if (product2 >= min_tiles && product2 <= max_tiles) {
+        const product = w * h;
+        if (product >= min_tiles && product <= max_tiles) {
           const key = w << 16 | h;
           if (!seen.has(key)) {
             seen.add(key);
@@ -13429,11 +13429,11 @@ function convert_image_to_patches(images, patch_size) {
   return new Tensor3("float32", result, [B, ph * pw, patch_dim]);
 }
 function pad_along_first_dim(patches, target_length) {
-  const [, len2, dim] = patches.dims;
+  const [, len, dim] = patches.dims;
   const mask_data = new BigInt64Array(target_length);
-  mask_data.fill(1n, 0, len2);
+  mask_data.fill(1n, 0, len);
   let padded = patches;
-  if (len2 < target_length) {
+  if (len < target_length) {
     const padded_data = new Float32Array(target_length * dim);
     padded_data.set(patches.data);
     padded = new Tensor3("float32", padded_data, [1, target_length, dim]);
@@ -13678,10 +13678,10 @@ class Phi3VImageProcessor extends ImageProcessor {
     const original_sizes = imageData.map((x) => x.original_size);
     const reshaped_input_sizes = imageData.map((x) => x.reshaped_input_size);
     const all_pixel_values = [];
-    for (const { pixel_values: pixel_values2 } of imageData) {
-      pixel_values2.unsqueeze_(0);
-      const [height, width] = pixel_values2.dims.slice(-2);
-      const batch_pixel_values = await interpolate_4d(pixel_values2, {
+    for (const { pixel_values } of imageData) {
+      pixel_values.unsqueeze_(0);
+      const [height, width] = pixel_values.dims.slice(-2);
+      const batch_pixel_values = await interpolate_4d(pixel_values, {
         size: [IMAGE_SIZE, IMAGE_SIZE],
         mode: "bicubic"
       });
@@ -13709,7 +13709,7 @@ class Phi3VImageProcessor extends ImageProcessor {
             }
             const starts = [start_y, start_x];
             const ends = [end_y, end_x];
-            const patch = await slice2(pixel_values2, starts, ends, SLICE_AXES);
+            const patch = await slice2(pixel_values, starts, ends, SLICE_AXES);
             patches.push(patch);
           }
         }
@@ -13832,9 +13832,9 @@ class SamImageProcessor extends ImageProcessor {
       if (binarize) {
         const data = interpolated_mask.data;
         const binarizedMaskData = new Uint8Array(data.length);
-        for (let i2 = 0;i2 < data.length; ++i2) {
-          if (data[i2] > mask_threshold) {
-            binarizedMaskData[i2] = 1;
+        for (let i = 0;i < data.length; ++i) {
+          if (data[i] > mask_threshold) {
+            binarizedMaskData[i] = 1;
           }
         }
         interpolated_mask = new Tensor3("bool", binarizedMaskData, interpolated_mask.dims);
@@ -14633,11 +14633,11 @@ class MgpstrProcessor extends Processor {
   get wp_tokenizer() {
     return this.components.wp_tokenizer;
   }
-  _decode_helper(pred_logits, format2) {
-    if (!DECODE_TYPE_MAPPING.hasOwnProperty(format2)) {
-      throw new Error(`Format ${format2} is not supported.`);
+  _decode_helper(pred_logits, format) {
+    if (!DECODE_TYPE_MAPPING.hasOwnProperty(format)) {
+      throw new Error(`Format ${format} is not supported.`);
     }
-    const [decoder_name, eos_token] = DECODE_TYPE_MAPPING[format2];
+    const [decoder_name, eos_token] = DECODE_TYPE_MAPPING[format];
     const decoder = this[decoder_name].bind(this);
     const [batch_size, batch_max_length] = pred_logits.dims;
     const conf_scores = [];
@@ -14817,8 +14817,8 @@ class PixtralProcessor extends Processor {
         const width_tokens = image_token.repeat(num_width_tokens);
         const row = width_tokens + image_break_token;
         const finalRow = width_tokens + image_end_token;
-        const full2 = row.repeat(num_height_tokens - 1) + finalRow;
-        text[i] = text[i].replace(image_token, full2);
+        const full = row.repeat(num_height_tokens - 1) + finalRow;
+        text[i] = text[i].replace(image_token, full);
       }
     }
     const text_inputs = text ? this.tokenizer(text, kwargs) : {};
@@ -15505,11 +15505,11 @@ async function getModelDataFiles(pretrained_model_name_or_path, fileName, suffix
       throw new Error(`The number of external data chunks (${num_chunks}) exceeds the maximum allowed value (${MAX_EXTERNAL_DATA_CHUNKS}).`);
     }
     const chunkNames = getExternalDataChunkNames(baseName, num_chunks);
-    for (const path3 of chunkNames) {
-      const fullPath = `${options.subfolder ?? ""}/${path3}`;
+    for (const path of chunkNames) {
+      const fullPath = `${options.subfolder ?? ""}/${path}`;
       externalDataPromises.push(new Promise(async (resolve, reject) => {
         const data = await getModelFile(pretrained_model_name_or_path, fullPath, true, options, return_path);
-        resolve(data instanceof Uint8Array ? { path: path3, data } : path3);
+        resolve(data instanceof Uint8Array ? { path, data } : path);
       }));
     }
   } else if (session_options.externalData !== undefined) {
@@ -15604,25 +15604,25 @@ async function sessionRun(session, inputs) {
   const checkedInputs = validateInputs(session, inputs);
   try {
     const ortFeed = Object.fromEntries(Object.entries(checkedInputs).map(([k, v]) => {
-      const tensor2 = v.ort_tensor;
+      const tensor = v.ort_tensor;
       if (apis.IS_NODE_ENV) {
-        if (typeof Float16Array !== "undefined" && tensor2.cpuData instanceof Float16Array) {
-          tensor2.cpuData = new Uint16Array(tensor2.cpuData.buffer);
+        if (typeof Float16Array !== "undefined" && tensor.cpuData instanceof Float16Array) {
+          tensor.cpuData = new Uint16Array(tensor.cpuData.buffer);
         }
       }
-      return [k, tensor2];
+      return [k, tensor];
     }));
     const output = await runInferenceSession(session, ortFeed);
     return replaceTensors(output);
   } catch (e) {
-    const formatted = Object.fromEntries(Object.entries(checkedInputs).map(([k, tensor2]) => {
+    const formatted = Object.fromEntries(Object.entries(checkedInputs).map(([k, tensor]) => {
       const unpacked = {
-        type: tensor2.type,
-        dims: tensor2.dims,
-        location: tensor2.location
+        type: tensor.type,
+        dims: tensor.dims,
+        location: tensor.location
       };
       if (unpacked.location !== "gpu-buffer") {
-        unpacked.data = tensor2.data;
+        unpacked.data = tensor.data;
       }
       return [k, unpacked];
     }));
@@ -15635,12 +15635,12 @@ function validateInputs(session, inputs) {
   const checkedInputs = Object.create(null);
   const missingInputs = [];
   for (const inputName of session.inputNames) {
-    const tensor2 = inputs[inputName];
-    if (!(tensor2 instanceof Tensor3)) {
+    const tensor = inputs[inputName];
+    if (!(tensor instanceof Tensor3)) {
       missingInputs.push(inputName);
       continue;
     }
-    checkedInputs[inputName] = isONNXProxy() ? tensor2.clone() : tensor2;
+    checkedInputs[inputName] = isONNXProxy() ? tensor.clone() : tensor;
   }
   if (missingInputs.length > 0) {
     throw new Error(`An error occurred during model execution: "Missing the following inputs: ${missingInputs.join(", ")}.`);
@@ -15892,8 +15892,8 @@ class NoRepeatNGramLogitsProcessor extends LogitsProcessor {
       return bannedTokens;
     } else {
       const generatedNgrams = this.getNgrams(prevInputIds);
-      const bannedTokens2 = this.getGeneratedNgrams(generatedNgrams, prevInputIds);
-      return bannedTokens2;
+      const bannedTokens = this.getGeneratedNgrams(generatedNgrams, prevInputIds);
+      return bannedTokens;
     }
   }
   _call(input_ids, logits) {
@@ -17087,9 +17087,9 @@ class PreTrainedModel extends Callable {
     const sequences = new Tensor3("int64", all_input_ids.flat(), [all_input_ids.length, all_input_ids[0].length]);
     const past_key_values = getPastKeyValues(outputs, model_inputs.past_key_values);
     const cachedTensors = new Set(Object.values(past_key_values));
-    for (const tensor2 of Object.values(outputs)) {
-      if (tensor2.location === "gpu-buffer" && !cachedTensors.has(tensor2)) {
-        tensor2.dispose();
+    for (const tensor of Object.values(outputs)) {
+      if (tensor.location === "gpu-buffer" && !cachedTensors.has(tensor)) {
+        tensor.dispose();
       }
     }
     const keepCacheAlive = "past_key_values" in kwargs || generation_config.return_dict_in_generate;
@@ -17393,9 +17393,9 @@ function decoder_prepare_inputs_for_generation(self2, input_ids, model_inputs, g
     model_inputs.attention_mask = ones([dims[0], past_length + dims[1]]);
   }
   if (model_inputs.past_key_values) {
-    const { input_ids: input_ids2, attention_mask } = model_inputs;
-    if (attention_mask && attention_mask.dims[1] > input_ids2.dims[1]) {} else if (past_length < input_ids2.dims[1]) {
-      model_inputs.input_ids = input_ids2.slice(null, [past_length, null]);
+    const { input_ids, attention_mask } = model_inputs;
+    if (attention_mask && attention_mask.dims[1] > input_ids.dims[1]) {} else if (past_length < input_ids.dims[1]) {
+      model_inputs.input_ids = input_ids.slice(null, [past_length, null]);
     }
   }
   return model_inputs;
@@ -19367,13 +19367,13 @@ class Qwen2VLForConditionalGeneration extends Qwen2VLPreTrainedModel {
         }
       }
     }
-    let count2 = 0;
+    let count = 0;
     for (let y = 0;y < attn_mask.length; ++y) {
       if (attn_mask[y] == 1) {
         for (let x = 0;x < 3; ++x) {
-          position_ids_list[x][batch_idx][y] = llm_positions[x * total_len / 3 + count2];
+          position_ids_list[x][batch_idx][y] = llm_positions[x * total_len / 3 + count];
         }
-        ++count2;
+        ++count;
       }
     }
     return llm_positions;
@@ -20342,8 +20342,8 @@ class MultiModalityCausalLM extends MultiModalityPreTrainedModel {
     });
     const clamped = decoded_image.add_(1).mul_(255 / 2).clamp_(0, 255).to("uint8");
     const images = [];
-    for (const tensor2 of clamped) {
-      const img = RawImage.fromTensor(tensor2);
+    for (const tensor of clamped) {
+      const img = RawImage.fromTensor(tensor);
       images.push(img);
     }
     return images;
@@ -21103,10 +21103,10 @@ class SpeechT5ForTextToSpeech extends SpeechT5PreTrainedModel {
         break;
       }
     }
-    const spectrogram2 = cat(spectrogramParts);
-    const { waveform } = await sessionRun(vocoder.sessions["model"], { spectrogram: spectrogram2 });
+    const spectrogram = cat(spectrogramParts);
+    const { waveform } = await sessionRun(vocoder.sessions["model"], { spectrogram });
     return {
-      spectrogram: spectrogram2,
+      spectrogram,
       waveform
     };
   }
@@ -21395,10 +21395,10 @@ class VitPoseForPoseEstimation extends VitPosePreTrainedModel {
 }
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/models/vits/modeling_vits.js
 class VitsModelOutput extends ModelOutput {
-  constructor({ waveform, spectrogram: spectrogram2 }) {
+  constructor({ waveform, spectrogram }) {
     super();
     this.waveform = waveform;
-    this.spectrogram = spectrogram2;
+    this.spectrogram = spectrogram;
   }
 }
 
@@ -22996,8 +22996,8 @@ class QuestionAnsweringPipeline extends Pipeline {
       const options = product(start_scores, end_scores).filter((x) => x[0][1] <= x[1][1]).map((x) => [x[0][1], x[1][1], x[0][0] * x[1][0]]).sort((a, b) => b[2] - a[2]);
       const sampleResults = [];
       for (let k = 0;k < Math.min(options.length, top_k); ++k) {
-        const [start2, end2, score] = options[k];
-        const answer_tokens = ids.slice(start2, end2 + 1);
+        const [start, end, score] = options[k];
+        const answer_tokens = ids.slice(start, end + 1);
         const answer = this.tokenizer.decode(answer_tokens, {
           skip_special_tokens: true
         });
@@ -23037,11 +23037,11 @@ class FillMaskPipeline extends Pipeline {
       const scores = await topk(new Tensor3("float32", softmax(itemLogits.data), itemLogits.dims), top_k);
       const values = scores[0].tolist();
       const indices = scores[1].tolist();
-      toReturn.push(indices.map((x, i2) => {
+      toReturn.push(indices.map((x, i) => {
         const sequence = ids.slice();
         sequence[mask_token_index] = x;
         return {
-          score: values[i2],
+          score: values[i],
           token: Number(x),
           token_str: this.tokenizer.decode([x]),
           sequence: this.tokenizer.decode(sequence, {
@@ -23107,7 +23107,7 @@ class TranslationPipeline extends Text2TextGenerationPipeline {
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/pipelines/text-generation.js
 function isChat(x) {
-  return Array.isArray(x) && x.every((x2) => ("role" in x2) && ("content" in x2));
+  return Array.isArray(x) && x.every((x) => ("role" in x) && ("content" in x));
 }
 
 class TextGenerationPipeline extends Pipeline {
@@ -23404,10 +23404,10 @@ class AutomaticSpeechRecognitionPipeline extends Pipeline {
           }
         ];
       }
-      for (const chunk2 of chunks) {
-        generation_config.num_frames = Math.floor(chunk2.stride[0] / hop_length);
+      for (const chunk of chunks) {
+        generation_config.num_frames = Math.floor(chunk.stride[0] / hop_length);
         const data = await this.model.generate({
-          inputs: chunk2.input_features,
+          inputs: chunk.input_features,
           ...generation_config
         });
         if (return_timestamps === "word") {
@@ -23415,12 +23415,12 @@ class AutomaticSpeechRecognitionPipeline extends Pipeline {
           const token_ts = data.token_timestamps.tolist()[0];
           const timestamp_begin = this.tokenizer.timestamp_begin;
           const prefixLength = Math.max(sequences.findIndex((t) => Number(t) >= timestamp_begin), 0);
-          chunk2.tokens = sequences.slice(prefixLength);
-          chunk2.token_timestamps = token_ts.slice(prefixLength).map((x) => round(x, 2));
+          chunk.tokens = sequences.slice(prefixLength);
+          chunk.token_timestamps = token_ts.slice(prefixLength).map((x) => round(x, 2));
         } else {
-          chunk2.tokens = data[0].tolist();
+          chunk.tokens = data[0].tolist();
         }
-        chunk2.stride = chunk2.stride.map((x) => x / sampling_rate);
+        chunk.stride = chunk.stride.map((x) => x / sampling_rate);
       }
       const [full_text, optional] = this.tokenizer._decode_asr(chunks, {
         time_precision,
@@ -23458,8 +23458,8 @@ class AutomaticSpeechRecognitionPipeline extends Pipeline {
     for (const aud of preparedAudios) {
       const audioChunks = feature_extractor.split_audio(aud);
       const chunk_texts = [];
-      for (const chunk2 of audioChunks) {
-        const inputs = await this.processor(chunk2);
+      for (const chunk of audioChunks) {
+        const inputs = await this.processor(chunk);
         const outputs = await this.model.generate({
           ...inputs,
           decoder_input_ids,
@@ -23800,16 +23800,16 @@ class ZeroShotObjectDetectionPipeline extends Pipeline {
           text_threshold: threshold,
           target_sizes: imageSize
         })[0];
-        result = processed.boxes.map((box, i2) => ({
-          score: processed.scores[i2],
-          label: processed.labels[i2],
+        result = processed.boxes.map((box, i) => ({
+          score: processed.scores[i],
+          label: processed.labels[i],
           box: get_bounding_box(box, !percentage)
         }));
       } else {
         const processed = this.processor.image_processor.post_process_object_detection(output, threshold, imageSize, true)[0];
-        result = processed.boxes.map((box, i2) => ({
-          score: processed.scores[i2],
-          label: candidate_labels[processed.classes[i2]],
+        result = processed.boxes.map((box, i) => ({
+          score: processed.scores[i],
+          label: candidate_labels[processed.classes[i]],
           box: get_bounding_box(box, !percentage)
         }));
       }
@@ -24373,9 +24373,9 @@ class TextStreamer extends BaseStreamer {
       if (this.decode_kwargs.skip_special_tokens)
         return;
       if (this.token_cache.length > 0) {
-        const text2 = this.tokenizer.decode(this.token_cache, this.decode_kwargs);
-        const printable_text2 = text2.slice(this.print_len);
-        this.on_finalized_text(printable_text2, false);
+        const text = this.tokenizer.decode(this.token_cache, this.decode_kwargs);
+        const printable_text = text.slice(this.print_len);
+        this.on_finalized_text(printable_text, false);
         this.token_cache = [];
         this.print_len = 0;
       }
@@ -24530,16 +24530,16 @@ async function load_video(src, { num_frames = null, fps = null } = {}) {
     await new Promise((resolve) => video.onloadedmetadata = resolve);
   }
   const duration = video.duration;
-  let count2, step;
+  let count, step;
   if (num_frames != null) {
-    count2 = num_frames;
+    count = num_frames;
     step = num_frames === 1 ? 0 : duration / (num_frames - 1);
   } else {
     step = 1 / fps;
-    count2 = Math.floor(duration / step);
+    count = Math.floor(duration / step);
   }
   let sampleTimes = [];
-  for (let i = 0;i < count2; ++i) {
+  for (let i = 0;i < count; ++i) {
     sampleTimes.push(num_frames === 1 ? duration / 2 : i * step);
   }
   const canvas = document.createElement("canvas");
@@ -24562,24 +24562,24 @@ async function load_video(src, { num_frames = null, fps = null } = {}) {
 }
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/utils/model_registry/is_cached.js
 async function check_files_cache(modelId, files, options = {}) {
-  const cache2 = await getCache(options?.cache_dir);
-  if (!cache2) {
-    const fileStatuses2 = files.map((filename) => ({ file: filename, cached: false }));
-    return { allCached: false, files: fileStatuses2 };
+  const cache = await getCache(options?.cache_dir);
+  if (!cache) {
+    const fileStatuses = files.map((filename) => ({ file: filename, cached: false }));
+    return { allCached: false, files: fileStatuses };
   }
   const fileStatuses = await Promise.all(files.map(async (filename) => {
-    const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache2);
-    const cached = await checkCachedResource(cache2, localPath, proposedCacheKey);
+    const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
+    const cached = await checkCachedResource(cache, localPath, proposedCacheKey);
     return { file: filename, cached: !!cached };
   }));
   return { allCached: fileStatuses.every((f) => f.cached), files: fileStatuses };
 }
 async function is_file_cached(modelId, filename, options = {}) {
-  const cache2 = await getCache(options?.cache_dir);
-  if (!cache2)
+  const cache = await getCache(options?.cache_dir);
+  if (!cache)
     return false;
-  const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache2);
-  return !!await checkCachedResource(cache2, localPath, proposedCacheKey);
+  const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
+  return !!await checkCachedResource(cache, localPath, proposedCacheKey);
 }
 async function is_cached(modelId, options = {}) {
   if (!modelId) {
@@ -24626,25 +24626,25 @@ async function is_pipeline_cached_files(task, modelId, options = {}) {
 
 // ../../node_modules/.bun/@huggingface+transformers@4.2.0/node_modules/@huggingface/transformers/src/utils/model_registry/clear_cache.js
 async function clear_files_from_cache(modelId, files, options = {}) {
-  const cache2 = await getCache(options?.cache_dir);
-  if (!cache2) {
+  const cache = await getCache(options?.cache_dir);
+  if (!cache) {
     return {
       filesDeleted: 0,
       filesCached: 0,
       files: files.map((filename) => ({ file: filename, deleted: false, wasCached: false }))
     };
   }
-  if (!cache2.delete) {
+  if (!cache.delete) {
     throw new Error("Cache does not support delete operation");
   }
   const results = await Promise.all(files.map(async (filename) => {
-    const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache2);
-    const cached = await checkCachedResource(cache2, localPath, proposedCacheKey);
+    const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
+    const cached = await checkCachedResource(cache, localPath, proposedCacheKey);
     const wasCached = !!cached;
     let deleted = false;
     if (wasCached) {
-      const deletedWithProposed = await cache2.delete(proposedCacheKey);
-      const deletedWithLocal = !deletedWithProposed && proposedCacheKey !== localPath ? await cache2.delete(localPath) : false;
+      const deletedWithProposed = await cache.delete(proposedCacheKey);
+      const deletedWithLocal = !deletedWithProposed && proposedCacheKey !== localPath ? await cache.delete(localPath) : false;
       deleted = deletedWithProposed || deletedWithLocal;
     }
     return { file: filename, deleted, wasCached };