@qwen-code/qwen-code 0.24.4 → 0.24.5-nightly.20260924.ffea2d024e

package/chunks/chunk-CLNDQINM.js

@@ -0,0 +1,523 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/binary-content.ts
+init_esbuild_shims();
+import { mkdir, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+var BINARY_APPLICATION_TYPES = /* @__PURE__ */ new Set([
+  "application/pdf",
+  "application/zip",
+  "application/gzip",
+  "application/x-gzip",
+  "application/octet-stream",
+  "application/msword",
+  "application/vnd.ms-excel",
+  "application/vnd.ms-powerpoint",
+  "application/x-tar",
+  "application/x-7z-compressed",
+  "application/x-rar-compressed",
+  "application/vnd.rar",
+  "application/wasm",
+  "application/java-archive"
+]);
+function isBinaryContentType(contentType) {
+  if (!contentType) return false;
+  const mt = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+  if (mt.startsWith("text/")) return false;
+  if (mt.endsWith("+json") || mt.endsWith("+xml")) return false;
+  if (mt.startsWith("image/") || mt.startsWith("audio/") || mt.startsWith("video/") || mt.startsWith("font/")) {
+    return true;
+  }
+  if (BINARY_APPLICATION_TYPES.has(mt)) return true;
+  if (mt.startsWith("application/vnd.openxmlformats")) return true;
+  if (mt.startsWith("application/vnd.oasis.opendocument")) return true;
+  return false;
+}
+__name(isBinaryContentType, "isBinaryContentType");
+var MIME_EXTENSIONS = /* @__PURE__ */ new Map([
+  ["application/pdf", "pdf"],
+  ["application/zip", "zip"],
+  [
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "docx"
+  ],
+  ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx"],
+  [
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "pptx"
+  ],
+  ["application/msword", "doc"],
+  ["application/vnd.ms-excel", "xls"],
+  ["application/vnd.ms-powerpoint", "ppt"],
+  ["application/gzip", "gz"],
+  ["application/x-gzip", "gz"],
+  ["application/x-tar", "tar"],
+  ["application/x-7z-compressed", "7z"],
+  ["application/x-rar-compressed", "rar"],
+  ["application/vnd.rar", "rar"],
+  ["application/wasm", "wasm"],
+  ["application/java-archive", "jar"],
+  ["audio/mpeg", "mp3"],
+  ["audio/wav", "wav"],
+  ["audio/ogg", "ogg"],
+  ["video/mp4", "mp4"],
+  ["video/webm", "webm"],
+  ["image/png", "png"],
+  ["image/jpeg", "jpg"],
+  ["image/gif", "gif"],
+  ["image/webp", "webp"],
+  ["image/svg+xml", "svg"]
+]);
+function extensionForMimeType(mimeType) {
+  if (!mimeType) return "bin";
+  const mt = (mimeType.split(";")[0] ?? "").trim().toLowerCase();
+  return MIME_EXTENSIONS.get(mt) ?? "bin";
+}
+__name(extensionForMimeType, "extensionForMimeType");
+var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set([...MIME_EXTENSIONS.values(), "jpeg", "bin"]);
+function extensionFromFilename(name) {
+  if (!name) return void 0;
+  const ext = name.split(".").pop()?.trim().toLowerCase();
+  return ext && ext !== name && KNOWN_EXTENSIONS.has(ext) ? ext : void 0;
+}
+__name(extensionFromFilename, "extensionFromFilename");
+function filenameFromContentDisposition(contentDisposition) {
+  const star = /filename\*\s*=\s*[^']*'[^']*'([^;]+)/i.exec(contentDisposition);
+  if (star?.[1]) {
+    try {
+      return decodeURIComponent(star[1].trim());
+    } catch {
+      return star[1].trim();
+    }
+  }
+  const plain = /filename\s*=\s*"?([^";]+)"?/i.exec(contentDisposition);
+  return plain?.[1]?.trim();
+}
+__name(filenameFromContentDisposition, "filenameFromContentDisposition");
+function sniffFileKind(bytes, contentType, contentDisposition, url) {
+  const dispositionExt = extensionFromFilename(
+    filenameFromContentDisposition(contentDisposition)
+  );
+  let urlExt;
+  try {
+    urlExt = extensionFromFilename(new URL(url).pathname.split("/").pop());
+  } catch {
+    urlExt = void 0;
+  }
+  if (bytes.length >= 5 && bytes.subarray(0, 5).toString("latin1") === "%PDF-") {
+    return {
+      extension: "pdf",
+      mimeType: "application/pdf",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 4 && bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4) {
+    const zipHint = dispositionExt ?? urlExt ?? extensionForMimeType(contentType);
+    const refined = zipHint && ["docx", "xlsx", "pptx", "jar"].includes(zipHint) ? zipHint : "zip";
+    return {
+      extension: refined,
+      mimeType: contentType || "application/zip",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 2 && bytes[0] === 31 && bytes[1] === 139) {
+    return {
+      extension: "gz",
+      mimeType: "application/gzip",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 7 && bytes.subarray(0, 4).toString("latin1") === "Rar!" && bytes[4] === 26 && bytes[5] === 7) {
+    return {
+      extension: "rar",
+      mimeType: "application/vnd.rar",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes.subarray(1, 4).toString("latin1") === "PNG") {
+    return {
+      extension: "png",
+      mimeType: "image/png",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return {
+      extension: "jpg",
+      mimeType: "image/jpeg",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 4 && bytes.subarray(0, 4).toString("latin1") === "GIF8") {
+    return {
+      extension: "gif",
+      mimeType: "image/gif",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  if (bytes.length >= 12 && bytes.subarray(0, 4).toString("latin1") === "RIFF" && bytes.subarray(8, 12).toString("latin1") === "WEBP") {
+    return {
+      extension: "webp",
+      mimeType: "image/webp",
+      magicMatched: true,
+      extensionSource: "magic"
+    };
+  }
+  const nameExt = dispositionExt ?? urlExt;
+  if (nameExt) {
+    return {
+      extension: nameExt,
+      mimeType: contentType,
+      magicMatched: false,
+      extensionSource: "name"
+    };
+  }
+  const mimeExt = extensionForMimeType(contentType);
+  return {
+    extension: mimeExt,
+    mimeType: contentType,
+    magicMatched: false,
+    extensionSource: mimeExt !== "bin" ? "mime" : "fallback"
+  };
+}
+__name(sniffFileKind, "sniffFileKind");
+function looksLikeText(bytes) {
+  const window = bytes.subarray(0, 8192);
+  if (window.includes(0)) return false;
+  const decoded = new TextDecoder("utf-8").decode(window);
+  let bad = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    if (decoded[i] === "\uFFFD" && ++bad > 2) return false;
+  }
+  return true;
+}
+__name(looksLikeText, "looksLikeText");
+async function persistBinaryContent(bytes, ext, dir, persistId) {
+  const filepath = path.join(dir, `${persistId}.${ext}`);
+  try {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    await writeFile(filepath, bytes, { mode: 384 });
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+  return { filepath, size: bytes.length, ext };
+}
+__name(persistBinaryContent, "persistBinaryContent");
+function formatByteSize(sizeInBytes) {
+  const kb = sizeInBytes / 1024;
+  if (kb < 1) return `${sizeInBytes} bytes`;
+  const fmt = /* @__PURE__ */ __name((n) => n.toFixed(1).replace(/\.0$/, ""), "fmt");
+  if (kb < 1024) return `${fmt(kb)}KB`;
+  const mb = kb / 1024;
+  if (mb < 1024) return `${fmt(mb)}MB`;
+  return `${fmt(mb / 1024)}GB`;
+}
+__name(formatByteSize, "formatByteSize");
+
+// packages/core/src/utils/image-view.ts
+init_esbuild_shims();
+import fs from "node:fs/promises";
+var IMAGE_VIEW_MAX_EDGE = 1568;
+var IMAGE_VIEW_MAX_PATCHES = 1568;
+var IMAGE_PATCH_SIZE = 28;
+var IMAGE_MAX_UPSCALE = 8;
+var IMAGE_JPEG_QUALITY = 92;
+var IMAGE_MAX_SOURCE_BYTES = 100 * 1024 * 1024;
+var IMAGE_MAX_OUTPUT_BYTES = 9 * 1024 * 1024;
+var SUPPORTED_IMAGE_FORMATS = /* @__PURE__ */ new Set(["jpeg", "png", "webp"]);
+var SUPPORTED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/webp"
+]);
+var ImageViewError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  static {
+    __name(this, "ImageViewError");
+  }
+};
+function orientedSize(metadata) {
+  const autoOrient = metadata.autoOrient;
+  if (autoOrient) {
+    return { width: autoOrient.width, height: autoOrient.height };
+  }
+  const width = metadata.width ?? 0;
+  const height = metadata.height ?? 0;
+  const orientation = metadata.orientation ?? 0;
+  return orientation >= 5 && orientation <= 8 ? { width: height, height: width } : { width, height };
+}
+__name(orientedSize, "orientedSize");
+function fitsVisualBudget({ width, height }) {
+  return width <= IMAGE_VIEW_MAX_EDGE && height <= IMAGE_VIEW_MAX_EDGE && Math.ceil(width / IMAGE_PATCH_SIZE) * Math.ceil(height / IMAGE_PATCH_SIZE) <= IMAGE_VIEW_MAX_PATCHES;
+}
+__name(fitsVisualBudget, "fitsVisualBudget");
+function boundedSize(width, height, maxUpscale) {
+  const widthIsLongEdge = width >= height;
+  const maxLongEdge = Math.min(
+    IMAGE_VIEW_MAX_EDGE,
+    Math.max(width, height) * maxUpscale
+  );
+  let low = 1;
+  let high = maxLongEdge;
+  let best = { width: 1, height: 1 };
+  while (low <= high) {
+    const longEdge = Math.floor((low + high) / 2);
+    const candidate = widthIsLongEdge ? {
+      width: longEdge,
+      height: Math.max(1, Math.round(height / width * longEdge))
+    } : {
+      width: Math.max(1, Math.round(width / height * longEdge)),
+      height: longEdge
+    };
+    if (fitsVisualBudget(candidate)) {
+      best = candidate;
+      low = longEdge + 1;
+    } else {
+      high = longEdge - 1;
+    }
+  }
+  return best;
+}
+__name(boundedSize, "boundedSize");
+async function loadSharp() {
+  let sharp;
+  try {
+    sharp = (await import("sharp")).default;
+  } catch {
+    throw new ImageViewError(
+      "renderer_unavailable",
+      'Image rendering is unavailable because the "sharp" image module could not be loaded.'
+    );
+  }
+  return sharp;
+}
+__name(loadSharp, "loadSharp");
+async function prepareImage(filePath, signal) {
+  signal.throwIfAborted();
+  await loadSharp();
+  let stats;
+  try {
+    stats = await fs.stat(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ImageViewError(
+        "file_not_found",
+        `Image file not found: ${filePath}`
+      );
+    }
+    throw error;
+  }
+  if (stats.isDirectory()) {
+    throw new ImageViewError(
+      "target_is_directory",
+      `Image path is a directory: ${filePath}`
+    );
+  }
+  if (!stats.isFile()) {
+    throw new ImageViewError(
+      "target_not_regular_file",
+      `Image path is not a regular file: ${filePath}`
+    );
+  }
+  if (stats.size > IMAGE_MAX_SOURCE_BYTES) {
+    throw new ImageViewError(
+      "source_too_large",
+      `Image file exceeds the 100 MB source limit: ${filePath}`
+    );
+  }
+  return prepareImageBuffer(
+    await fs.readFile(filePath, { signal }),
+    filePath,
+    signal
+  );
+}
+__name(prepareImage, "prepareImage");
+async function prepareImageBuffer(bytes, label, signal) {
+  signal.throwIfAborted();
+  const sharp = await loadSharp();
+  if (bytes.length > IMAGE_MAX_SOURCE_BYTES) {
+    throw new ImageViewError(
+      "source_too_large",
+      `Image exceeds the 100 MB source limit: ${label}`
+    );
+  }
+  let metadata;
+  try {
+    metadata = await sharp(bytes, {
+      failOn: "error",
+      limitInputPixels: true
+    }).metadata();
+  } catch {
+    signal.throwIfAborted();
+    throw new ImageViewError(
+      "decode_failed",
+      `Failed to decode image (may be corrupt or not a static PNG, JPEG, or WebP): ${label}`
+    );
+  }
+  signal.throwIfAborted();
+  if (!SUPPORTED_IMAGE_FORMATS.has(metadata.format)) {
+    throw new ImageViewError(
+      "unsupported_image",
+      `Unsupported image. Expected a static PNG, JPEG, or WebP image: ${label}`
+    );
+  }
+  if ((metadata.pages ?? 1) > 1) {
+    throw new ImageViewError(
+      "animated_image",
+      `Only static images are supported: ${label}`
+    );
+  }
+  return { bytes, metadata, sharp };
+}
+__name(prepareImageBuffer, "prepareImageBuffer");
+async function renderImageView(label, prepared, selection, outputSize, signal) {
+  const { bytes, metadata, sharp } = prepared;
+  const sourceSize = orientedSize(metadata);
+  let output;
+  try {
+    output = await sharp(bytes, {
+      failOn: "error",
+      limitInputPixels: true
+    }).rotate().extract(selection).resize(outputSize.width, outputSize.height, {
+      fit: "fill",
+      kernel: sharp.kernel.lanczos3
+    }).flatten({ background: "#ffffff" }).jpeg({
+      quality: IMAGE_JPEG_QUALITY,
+      chromaSubsampling: "4:4:4"
+    }).toBuffer();
+  } catch {
+    signal.throwIfAborted();
+    throw new ImageViewError(
+      "decode_failed",
+      `Failed to render image overview: ${label}`
+    );
+  }
+  signal.throwIfAborted();
+  if (output.length > IMAGE_MAX_OUTPUT_BYTES) {
+    throw new ImageViewError(
+      "output_too_large",
+      `Rendered image exceeds the 9 MB output limit: ${label}`
+    );
+  }
+  return {
+    bytes: output,
+    mimeType: "image/jpeg",
+    sourceWidth: sourceSize.width,
+    sourceHeight: sourceSize.height,
+    selectedWidth: selection.width,
+    selectedHeight: selection.height,
+    outputWidth: outputSize.width,
+    outputHeight: outputSize.height
+  };
+}
+__name(renderImageView, "renderImageView");
+async function renderFullFrameView(label, prepared, signal) {
+  const { width: sourceWidth, height: sourceHeight } = orientedSize(
+    prepared.metadata
+  );
+  return renderImageView(
+    label,
+    prepared,
+    { left: 0, top: 0, width: sourceWidth, height: sourceHeight },
+    boundedSize(sourceWidth, sourceHeight, 1),
+    signal
+  );
+}
+__name(renderFullFrameView, "renderFullFrameView");
+function sniffBoundableImageMime(header) {
+  const kind = sniffFileKind(header, "", "", "");
+  return kind.magicMatched && SUPPORTED_IMAGE_MIME_TYPES.has(kind.mimeType) ? kind.mimeType : null;
+}
+__name(sniffBoundableImageMime, "sniffBoundableImageMime");
+async function boundImageBuffer(bytes, label, signal, maxBytes) {
+  const prepared = await prepareImageBuffer(bytes, label, signal);
+  if (fitsVisualBudget(orientedSize(prepared.metadata)) && (maxBytes === void 0 || prepared.bytes.length <= maxBytes)) {
+    return null;
+  }
+  return renderFullFrameView(label, prepared, signal);
+}
+__name(boundImageBuffer, "boundImageBuffer");
+async function renderImageOverview(filePath, signal) {
+  const prepared = await prepareImage(filePath, signal);
+  return renderFullFrameView(filePath, prepared, signal);
+}
+__name(renderImageOverview, "renderImageOverview");
+async function renderNormalizedImageCrop(filePath, region, signal) {
+  const prepared = await prepareImage(filePath, signal);
+  const { width: sourceWidth, height: sourceHeight } = orientedSize(
+    prepared.metadata
+  );
+  const left = Math.min(
+    sourceWidth - 1,
+    Math.max(0, Math.floor(region.x1 / 1e3 * sourceWidth))
+  );
+  const top = Math.min(
+    sourceHeight - 1,
+    Math.max(0, Math.floor(region.y1 / 1e3 * sourceHeight))
+  );
+  const right = Math.min(
+    sourceWidth,
+    Math.max(left + 1, Math.ceil(region.x2 / 1e3 * sourceWidth))
+  );
+  const bottom = Math.min(
+    sourceHeight,
+    Math.max(top + 1, Math.ceil(region.y2 / 1e3 * sourceHeight))
+  );
+  const selectedWidth = right - left;
+  const selectedHeight = bottom - top;
+  const outputSize = boundedSize(
+    selectedWidth,
+    selectedHeight,
+    IMAGE_MAX_UPSCALE
+  );
+  return renderImageView(
+    filePath,
+    prepared,
+    { left, top, width: selectedWidth, height: selectedHeight },
+    outputSize,
+    signal
+  );
+}
+__name(renderNormalizedImageCrop, "renderNormalizedImageCrop");
+
+export {
+  isBinaryContentType,
+  extensionForMimeType,
+  sniffFileKind,
+  looksLikeText,
+  persistBinaryContent,
+  formatByteSize,
+  IMAGE_MAX_SOURCE_BYTES,
+  ImageViewError,
+  sniffBoundableImageMime,
+  boundImageBuffer,
+  renderImageOverview,
+  renderNormalizedImageCrop
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-LNUQA3OE.js → chunk-CVRZNFXO.js}

@@ -8,7 +8,7 @@ import {
   isPlanLifecycleToolUnavailableInSubagent,
   isSubagentLikeExecutionContext,
   isToolExcludedForCurrentContext
-} from "./chunk-47C3HPMW.js";
+} from "./chunk-O5YL6KSX.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation