@ashx-j/lunr 0.2.16 → 0.2.18

package/dist/node-runtime/chunk-AD6VXAO7.js

@@ -0,0 +1,342 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+
+// packages/coding-agent/dist/utils/exif-orientation.js
+function readOrientationFromTiff(bytes, tiffStart) {
+  if (tiffStart + 8 > bytes.length)
+    return 1;
+  let le = (bytes[tiffStart] << 8 | bytes[tiffStart + 1]) === 18761, read16 = (pos) => le ? bytes[pos] | bytes[pos + 1] << 8 : bytes[pos] << 8 | bytes[pos + 1], ifdOffset = ((pos) => le ? bytes[pos] | bytes[pos + 1] << 8 | bytes[pos + 2] << 16 | bytes[pos + 3] << 24 : (bytes[pos] << 24 | bytes[pos + 1] << 16 | bytes[pos + 2] << 8 | bytes[pos + 3]) >>> 0)(tiffStart + 4), ifdStart = tiffStart + ifdOffset;
+  if (ifdStart + 2 > bytes.length)
+    return 1;
+  let entryCount = read16(ifdStart);
+  for (let i = 0; i < entryCount; i++) {
+    let entryPos = ifdStart + 2 + i * 12;
+    if (entryPos + 12 > bytes.length)
+      return 1;
+    if (read16(entryPos) === 274) {
+      let value = read16(entryPos + 8);
+      return value >= 1 && value <= 8 ? value : 1;
+    }
+  }
+  return 1;
+}
+function findJpegTiffOffset(bytes) {
+  let offset = 2;
+  for (; offset < bytes.length - 1; ) {
+    if (bytes[offset] !== 255)
+      return -1;
+    let marker = bytes[offset + 1];
+    if (marker === 255) {
+      offset++;
+      continue;
+    }
+    if (marker === 225) {
+      if (offset + 4 >= bytes.length)
+        return -1;
+      let segmentStart = offset + 4;
+      return segmentStart + 6 > bytes.length || !hasExifHeader(bytes, segmentStart) ? -1 : segmentStart + 6;
+    }
+    if (offset + 4 > bytes.length)
+      return -1;
+    let length = bytes[offset + 2] << 8 | bytes[offset + 3];
+    offset += 2 + length;
+  }
+  return -1;
+}
+function findWebpTiffOffset(bytes) {
+  let offset = 12;
+  for (; offset + 8 <= bytes.length; ) {
+    let chunkId = String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]), chunkSize = bytes[offset + 4] | bytes[offset + 5] << 8 | bytes[offset + 6] << 16 | bytes[offset + 7] << 24, dataStart = offset + 8;
+    if (chunkId === "EXIF")
+      return dataStart + chunkSize > bytes.length ? -1 : chunkSize >= 6 && hasExifHeader(bytes, dataStart) ? dataStart + 6 : dataStart;
+    offset = dataStart + chunkSize + chunkSize % 2;
+  }
+  return -1;
+}
+function hasExifHeader(bytes, offset) {
+  return bytes[offset] === 69 && bytes[offset + 1] === 120 && bytes[offset + 2] === 105 && bytes[offset + 3] === 102 && bytes[offset + 4] === 0 && bytes[offset + 5] === 0;
+}
+function getExifOrientation(bytes) {
+  let tiffOffset = -1;
+  return bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 216 ? tiffOffset = findJpegTiffOffset(bytes) : bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80 && (tiffOffset = findWebpTiffOffset(bytes)), tiffOffset === -1 ? 1 : readOrientationFromTiff(bytes, tiffOffset);
+}
+function rotate90(photon, image, dstIndex) {
+  let w = image.get_width(), h = image.get_height(), src = image.get_raw_pixels(), dst = new Uint8Array(src.length);
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      let srcIdx = (y * w + x) * 4, dstIdx = dstIndex(x, y, w, h) * 4;
+      dst[dstIdx] = src[srcIdx], dst[dstIdx + 1] = src[srcIdx + 1], dst[dstIdx + 2] = src[srcIdx + 2], dst[dstIdx + 3] = src[srcIdx + 3];
+    }
+  return new photon.PhotonImage(dst, h, w);
+}
+function applyExifOrientation(photon, image, originalBytes) {
+  let orientation = getExifOrientation(originalBytes);
+  if (orientation === 1)
+    return image;
+  switch (orientation) {
+    case 2:
+      return photon.fliph(image), image;
+    case 3:
+      return photon.fliph(image), photon.flipv(image), image;
+    case 4:
+      return photon.flipv(image), image;
+    case 5: {
+      let rotated = rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+      return photon.fliph(rotated), rotated;
+    }
+    case 6:
+      return rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+    case 7: {
+      let rotated = rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+      return photon.fliph(rotated), rotated;
+    }
+    case 8:
+      return rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+    default:
+      return image;
+  }
+}
+
+// packages/coding-agent/dist/utils/image-convert.js
+async function convertImageBytesToPng(bytes) {
+  let photon = await loadPhoton();
+  if (!photon)
+    return null;
+  try {
+    let rawImage = photon.PhotonImage.new_from_byteslice(bytes), image = applyExifOrientation(photon, rawImage, bytes);
+    image !== rawImage && rawImage.free();
+    try {
+      return new Uint8Array(image.get_bytes());
+    } finally {
+      image.free();
+    }
+  } catch {
+    return null;
+  }
+}
+async function convertToPng(base64Data, mimeType) {
+  if (mimeType === "image/png")
+    return { data: base64Data, mimeType };
+  let bytes = new Uint8Array(Buffer.from(base64Data, "base64")), pngBytes = await convertImageBytesToPng(bytes);
+  return pngBytes ? {
+    data: Buffer.from(pngBytes).toString("base64"),
+    mimeType: "image/png"
+  } : null;
+}
+
+// packages/coding-agent/dist/utils/image-resize.js
+import { Worker } from "node:worker_threads";
+
+// packages/coding-agent/dist/utils/image-resize-core.js
+var DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024, DEFAULT_OPTIONS = {
+  maxWidth: 2e3,
+  maxHeight: 2e3,
+  maxBytes: DEFAULT_MAX_BYTES,
+  jpegQuality: 80
+};
+function encodeCandidate(buffer, mimeType) {
+  let data = Buffer.from(buffer).toString("base64");
+  return {
+    data,
+    encodedSize: Buffer.byteLength(data, "utf-8"),
+    mimeType
+  };
+}
+async function resizeImageInProcess(inputBytes, mimeType, options) {
+  let opts = { ...DEFAULT_OPTIONS, ...options }, inputBase64Size = Math.ceil(inputBytes.byteLength / 3) * 4, photon = await loadPhoton();
+  if (!photon)
+    return null;
+  let image;
+  try {
+    let tryEncodings = function(width, height, jpegQualities) {
+      let resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
+      try {
+        let candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
+        for (let quality of jpegQualities)
+          candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
+        return candidates;
+      } finally {
+        resized.free();
+      }
+    }, rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
+    image = applyExifOrientation(photon, rawImage, inputBytes), image !== rawImage && rawImage.free();
+    let originalWidth = image.get_width(), originalHeight = image.get_height(), format = mimeType.split("/")[1] ?? "png";
+    if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes)
+      return {
+        data: Buffer.from(inputBytes).toString("base64"),
+        mimeType: mimeType || `image/${format}`,
+        originalWidth,
+        originalHeight,
+        width: originalWidth,
+        height: originalHeight,
+        wasResized: !1
+      };
+    let targetWidth = originalWidth, targetHeight = originalHeight;
+    targetWidth > opts.maxWidth && (targetHeight = Math.round(targetHeight * opts.maxWidth / targetWidth), targetWidth = opts.maxWidth), targetHeight > opts.maxHeight && (targetWidth = Math.round(targetWidth * opts.maxHeight / targetHeight), targetHeight = opts.maxHeight);
+    let qualitySteps = Array.from(/* @__PURE__ */ new Set([opts.jpegQuality, 85, 70, 55, 40])), currentWidth = targetWidth, currentHeight = targetHeight;
+    for (; ; ) {
+      let candidates = tryEncodings(currentWidth, currentHeight, qualitySteps);
+      for (let candidate of candidates)
+        if (candidate.encodedSize < opts.maxBytes)
+          return {
+            data: candidate.data,
+            mimeType: candidate.mimeType,
+            originalWidth,
+            originalHeight,
+            width: currentWidth,
+            height: currentHeight,
+            wasResized: !0
+          };
+      if (currentWidth === 1 && currentHeight === 1)
+        break;
+      let nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75)), nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
+      if (nextWidth === currentWidth && nextHeight === currentHeight)
+        break;
+      currentWidth = nextWidth, currentHeight = nextHeight;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    image && image.free();
+  }
+}
+
+// packages/coding-agent/dist/utils/image-resize.js
+function toTransferableBytes(input) {
+  return new Uint8Array(input);
+}
+function isResizeImageWorkerResponse(value) {
+  return value !== null && typeof value == "object";
+}
+function createResizeWorker(workerSpecifier) {
+  return new Worker(workerSpecifier);
+}
+async function resizeImageInWorker(workerSpecifier, inputBytes, mimeType, options) {
+  let worker = createResizeWorker(workerSpecifier);
+  try {
+    let inputBytesForWorker = toTransferableBytes(inputBytes);
+    return await new Promise((resolve, reject) => {
+      let settled = !1, settle = (result) => {
+        settled || (settled = !0, resolve(result));
+      }, fail = (error) => {
+        settled || (settled = !0, reject(error));
+      };
+      worker.once("message", (message) => {
+        if (!isResizeImageWorkerResponse(message)) {
+          fail(new Error("Invalid image resize worker response"));
+          return;
+        }
+        if (message.error) {
+          fail(new Error(message.error));
+          return;
+        }
+        settle(message.result ?? null);
+      }), worker.once("error", fail), worker.once("exit", (code) => {
+        settled || fail(new Error(`Image resize worker exited with code ${code}`));
+      }), worker.postMessage({
+        inputBytes: inputBytesForWorker,
+        mimeType,
+        options
+      }, [inputBytesForWorker.buffer]);
+    });
+  } finally {
+    worker.terminate().catch(() => {
+    });
+  }
+}
+async function resizeImage(inputBytes, mimeType, options) {
+  let isTypeScriptRuntime = new URL("../utils/image-resize.js", import.meta.url).href.endsWith(".ts"), workerUrl = new URL(isTypeScriptRuntime ? "./image-resize-worker.ts" : "./image-resize-worker.js", new URL("../utils/image-resize.js", import.meta.url).href);
+  if (typeof process.versions.bun == "string")
+    try {
+      return await resizeImageInWorker("./src/utils/image-resize-worker.ts", inputBytes, mimeType, options);
+    } catch {
+    }
+  try {
+    return await resizeImageInWorker(workerUrl, inputBytes, mimeType, options);
+  } catch {
+    return resizeImageInProcess(inputBytes, mimeType, options);
+  }
+}
+function formatDimensionNote(result) {
+  if (!result.wasResized)
+    return;
+  let scale = result.originalWidth / result.width;
+  return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+}
+
+// packages/coding-agent/dist/utils/image-process.js
+function baseMimeType(mimeType) {
+  return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+function normalizeSupportedImageMimeType(mimeType) {
+  switch (baseMimeType(mimeType)) {
+    case "image/png":
+      return "image/png";
+    case "image/jpeg":
+    case "image/jpg":
+      return "image/jpeg";
+    case "image/gif":
+      return "image/gif";
+    case "image/webp":
+      return "image/webp";
+    default:
+      return null;
+  }
+}
+async function normalizeImage(bytes, mimeType) {
+  let normalizedMimeType = normalizeSupportedImageMimeType(mimeType);
+  if (normalizedMimeType)
+    return { bytes, mimeType: normalizedMimeType };
+  let pngBytes = await convertImageBytesToPng(bytes);
+  return pngBytes ? {
+    bytes: pngBytes,
+    mimeType: "image/png",
+    convertedFrom: baseMimeType(mimeType)
+  } : null;
+}
+function conversionHint(from, to) {
+  if (!(!from || from === to))
+    return `[Image converted from ${from} to ${to}.]`;
+}
+async function processImage(bytes, mimeType, options) {
+  let autoResizeImages = options?.autoResizeImages ?? !0, normalized = await normalizeImage(bytes, mimeType);
+  if (!normalized)
+    return {
+      ok: !1,
+      message: "[Image omitted: could not be converted to a supported inline image format.]"
+    };
+  if (autoResizeImages) {
+    let resized = await resizeImage(normalized.bytes, normalized.mimeType, options?.resizeOptions);
+    if (!resized)
+      return {
+        ok: !1,
+        message: "[Image omitted: could not be resized below the inline image size limit.]"
+      };
+    let hints2 = [], convertedHint2 = conversionHint(normalized.convertedFrom, resized.mimeType);
+    convertedHint2 && hints2.push(convertedHint2);
+    let dimensionNote = formatDimensionNote(resized);
+    return dimensionNote && hints2.push(dimensionNote), {
+      ok: !0,
+      data: resized.data,
+      mimeType: resized.mimeType,
+      hints: hints2
+    };
+  }
+  let hints = [], convertedHint = conversionHint(normalized.convertedFrom, normalized.mimeType);
+  return convertedHint && hints.push(convertedHint), {
+    ok: !0,
+    data: Buffer.from(normalized.bytes).toString("base64"),
+    mimeType: normalized.mimeType,
+    hints
+  };
+}
+
+export {
+  convertToPng,
+  resizeImage,
+  formatDimensionNote,
+  processImage
+};