@cortexkit/opencode-magic-context 0.41.2 → 0.41.4

package/dist/transformers-web.js

@@ -4241,18 +4241,18 @@ var Environment = class {
     }
   }
 };
-function setupGlobals(env22) {
-  env22.set("false", false);
-  env22.set("true", true);
-  env22.set("none", null);
-  env22.set("raise_exception", (args) => {
+function setupGlobals(env2) {
+  env2.set("false", false);
+  env2.set("true", true);
+  env2.set("none", null);
+  env2.set("raise_exception", (args) => {
     throw new Error(args);
   });
-  env22.set("range", range);
-  env22.set("strftime_now", strftime_now);
-  env22.set("True", true);
-  env22.set("False", false);
-  env22.set("None", null);
+  env2.set("range", range);
+  env2.set("strftime_now", strftime_now);
+  env2.set("True", true);
+  env2.set("False", false);
+  env2.set("None", null);
 }
 function getAttributeValue(item, attributePath) {
   const parts = attributePath.split(".");
@@ -4317,8 +4317,8 @@ function compareRuntimeValues(a, b, caseSensitive = false) {
 }
 var Interpreter = class {
   global;
-  constructor(env22) {
-    this.global = env22 ?? new Environment;
+  constructor(env2) {
+    this.global = env2 ?? new Environment;
   }
   run(program) {
     return this.evaluate(program, this.global);
@@ -5401,14 +5401,14 @@ var Template = class {
     this.parsed = parse(tokens);
   }
   render(items) {
-    const env22 = new Environment;
-    setupGlobals(env22);
+    const env2 = new Environment;
+    setupGlobals(env2);
     if (items) {
       for (const [key, value] of Object.entries(items)) {
-        env22.set(key, value);
+        env2.set(key, value);
       }
     }
-    const interpreter = new Interpreter(env22);
+    const interpreter = new Interpreter(env2);
     const result = interpreter.run(this.parsed);
     return result.value;
   }
@@ -6055,8 +6055,8 @@ function getFetchHeaders(urlOrPath) {
   const headers = new Headers;
   if (isNode) {
     const IS_CI = !!process.env?.TESTING_REMOTELY;
-    const version2 = env3.version;
-    headers.set("User-Agent", `transformers.js/${version2}; is_ci/${IS_CI};`);
+    const version = env3.version;
+    headers.set("User-Agent", `transformers.js/${version}; is_ci/${IS_CI};`);
     const isHFURL = isValidUrl(urlOrPath, ["http:", "https:"], ["huggingface.co", "hf.co"]);
     if (isHFURL) {
       const token = process.env?.HF_TOKEN ?? process.env?.HF_ACCESS_TOKEN;
@@ -6819,7 +6819,7 @@ function dynamic_time_warping(matrix) {
   const outputShape = [output_length + 1, input_length + 1];
   const cost = Array.from({ length: outputShape[0] }, () => Array(outputShape[1]).fill(Infinity));
   cost[0][0] = 0;
-  const trace2 = Array.from({ length: outputShape[0] }, () => Array(outputShape[1]).fill(-1));
+  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];
@@ -6837,14 +6837,14 @@ function dynamic_time_warping(matrix) {
         t = 2;
       }
       cost[i2][j2] = matrix[i2 - 1][j2 - 1] + c;
-      trace2[i2][j2] = t;
+      trace[i2][j2] = t;
     }
   }
   for (let i2 = 0;i2 < outputShape[1]; ++i2) {
-    trace2[0][i2] = 2;
+    trace[0][i2] = 2;
   }
   for (let i2 = 0;i2 < outputShape[0]; ++i2) {
-    trace2[i2][0] = 1;
+    trace[i2][0] = 1;
   }
   let i = output_length;
   let j = input_length;
@@ -6853,7 +6853,7 @@ function dynamic_time_warping(matrix) {
   while (i > 0 || j > 0) {
     text_indices.push(i - 1);
     time_indices.push(j - 1);
-    switch (trace2[i][j]) {
+    switch (trace[i][j]) {
       case 0:
         --i;
         --j;
@@ -8784,9 +8784,9 @@ function reshape(data, dimensions) {
   }
   return reshapedArray[0];
 }
-function permute(tensor2, axes) {
-  const [permutedData, shape] = permute_data(tensor2.data, tensor2.dims, axes);
-  return new Tensor22(tensor2.type, permutedData, shape);
+function permute(tensor, axes) {
+  const [permutedData, shape] = permute_data(tensor.data, tensor.dims, axes);
+  return new Tensor22(tensor.type, permutedData, shape);
 }
 function interpolate(input, [out_height, out_width], mode = "bilinear", align_corners = false) {
   const in_channels = input.dims.at(-3) ?? 1;
@@ -8946,8 +8946,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;
     }
@@ -9070,20 +9070,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);
@@ -9093,11 +9093,11 @@ function randn(size) {
   const length = size.reduce((a, b) => a * b, 1);
   return new Tensor22("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)) {
@@ -9106,7 +9106,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;
@@ -9117,7 +9117,7 @@ function quantize_embeddings(tensor2, precision) {
       outputData[arrayIndex] -= 128;
     }
   }
-  return new Tensor22(dtype, outputData, [tensor2.dims[0], tensor2.dims[1] / 8]);
+  return new Tensor22(dtype, outputData, [tensor.dims[0], tensor.dims[1] / 8]);
 }
 async function get_tokenizer_files(modelId) {
   if (!modelId) {
@@ -9133,16 +9133,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}.`);
   }
@@ -11705,26 +11705,26 @@ var RawImage = 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() {
@@ -12011,13 +12011,13 @@ var RawImage = class _RawImage {
     return await canvas.convertToBlob({ type, quality });
   }
   toTensor(channel_format = "CHW") {
-    let tensor2 = new Tensor22("uint8", new Uint8Array(this.data), [this.height, this.width, this.channels]);
+    let tensor = new Tensor22("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) {
@@ -15301,25 +15301,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];
     }));
@@ -15332,12 +15332,12 @@ function validateInputs(session, inputs) {
   const checkedInputs = /* @__PURE__ */ Object.create(null);
   const missingInputs = [];
   for (const inputName of session.inputNames) {
-    const tensor2 = inputs[inputName];
-    if (!(tensor2 instanceof Tensor22)) {
+    const tensor = inputs[inputName];
+    if (!(tensor instanceof Tensor22)) {
       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(", ")}.`);
@@ -16736,9 +16736,9 @@ var PreTrainedModel = class extends Callable {
     const sequences = new Tensor22("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;
@@ -19595,8 +19595,8 @@ var MultiModalityCausalLM = class 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;