kordoc 2.0.3 → 2.1.0

package/dist/index.js

@@ -63,6 +63,7 @@ async function ocrPages(doc, provider, pageFilter, effectivePageCount) {
         blocks.push({ type: "paragraph", text: text.trim(), pageNumber: i });
       }
     } catch {
+      blocks.push({ type: "paragraph", text: `[OCR \uC2E4\uD328: \uD398\uC774\uC9C0 ${i}]` });
     }
   }
   return blocks;
@@ -138,7 +139,7 @@ import { inflateRawSync } from "zlib";
 import { DOMParser } from "@xmldom/xmldom";
 
 // src/utils.ts
-var VERSION = true ? "2.0.3" : "0.0.0-dev";
+var VERSION = true ? "2.1.0" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -468,6 +469,9 @@ function tableToMarkdown(table) {
           if (dr === 0 && dc === 0) continue;
           if (r + dr < numRows && c + dc < numCols) {
             skip.add(`${r + dr},${c + dc}`);
+            if (dr === 0) {
+              display[r][c + dc] = cell.text.replace(/\n/g, "<br>");
+            }
           }
         }
       }
@@ -563,7 +567,12 @@ function parseCharProperties(doc, map) {
       if (!id) continue;
       const prop = {};
       const height = el.getAttribute("height");
-      if (height) prop.fontSize = parseInt(height, 10) / 100;
+      if (height) {
+        const parsedHeight = parseInt(height, 10);
+        if (!isNaN(parsedHeight) && parsedHeight > 0) {
+          prop.fontSize = parsedHeight / 100;
+        }
+      }
       const bold = el.getAttribute("bold");
       if (bold === "true" || bold === "1") prop.bold = true;
       const italic = el.getAttribute("italic");
@@ -703,7 +712,7 @@ async function extractImagesFromZip(zip, blocks, decompressed, warnings) {
         const data = await file.async("uint8array");
         decompressed.total += data.length;
         if (decompressed.total > MAX_DECOMPRESS_SIZE) throw new KordocError("ZIP \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (ZIP bomb \uC758\uC2EC)");
-        const ext = ref.includes(".") ? ref.split(".").pop() : "png";
+        const ext = ref.includes(".") ? ref.split(".").pop() || "png" : "png";
         const mimeType = imageExtToMime(ext);
         imageIndex++;
         const filename = `image_${String(imageIndex).padStart(3, "0")}.${mimeToExt(mimeType)}`;
@@ -997,8 +1006,10 @@ function walkSection(node, blocks, tableCtx, tableStack, styleMap, warnings, sec
         break;
       case "cellSpan":
         if (tableCtx?.cell) {
-          const cs = parseInt(el.getAttribute("colSpan") || "1", 10);
-          const rs = parseInt(el.getAttribute("rowSpan") || "1", 10);
+          const rawCs = parseInt(el.getAttribute("colSpan") || "1", 10);
+          const cs = isNaN(rawCs) ? 1 : rawCs;
+          const rawRs = parseInt(el.getAttribute("rowSpan") || "1", 10);
+          const rs = isNaN(rawRs) ? 1 : rawRs;
           tableCtx.cell.colSpan = clampSpan(cs, MAX_COLS);
           tableCtx.cell.rowSpan = clampSpan(rs, MAX_ROWS);
         }
@@ -1090,6 +1101,8 @@ function walkParagraphChildren(node, blocks, tableCtx, tableStack, styleMap, war
         extractDrawTextBlocks(el, blocks, styleMap, sectionNum);
       } else if (localTag === "r" || localTag === "run" || localTag === "ctrl" || localTag === "rect" || localTag === "ellipse" || localTag === "polygon" || localTag === "line" || localTag === "arc" || localTag === "curve" || localTag === "connectLine" || localTag === "container") {
         walkChildren(el, d + 1);
+      } else if (localTag === "run") {
+        tableCtx = walkParagraphChildren(el, blocks, tableCtx, tableStack, styleMap, warnings, sectionNum, depth + 1);
       }
     }
   };
@@ -2957,10 +2970,33 @@ var MIN_LINE_LENGTH = 10;
 var COORD_MERGE_TOL = 3;
 var CONNECT_TOL = 5;
 var CELL_PADDING = 2;
+var MAX_LINE_WIDTH = 5;
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function matMultiply(m1, m2) {
+  return [
+    m1[0] * m2[0] + m1[2] * m2[1],
+    m1[1] * m2[0] + m1[3] * m2[1],
+    m1[0] * m2[2] + m1[2] * m2[3],
+    m1[1] * m2[2] + m1[3] * m2[3],
+    m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+    m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+  ];
+}
+function matTransformPoint(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function matScale(m) {
+  return Math.max(
+    Math.sqrt(m[1] * m[1] + m[3] * m[3]),
+    Math.sqrt(m[0] * m[0] + m[2] * m[2])
+  );
+}
 function extractLines(fnArray, argsArray) {
   const horizontals = [];
   const verticals = [];
+  let ctm = [...IDENTITY];
   let lineWidth = 1;
+  const stateStack = [];
   let currentPath = [];
   let pathStartX = 0, pathStartY = 0;
   let curX = 0, curY = 0;
@@ -2978,13 +3014,53 @@ function extractLines(fnArray, argsArray) {
       );
     }
   }
-  function flushPath(isStroke) {
-    if (!isStroke) {
+  function tryConvertLinesToRectangle(path) {
+    if (path.length < 3 || path.length > 5) return false;
+    const first = path[0], last = path[path.length - 1];
+    const closed = Math.abs(first.x1 - last.x2) < 1 && Math.abs(first.y1 - last.y2) < 1;
+    if (!closed) return false;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const seg of path) {
+      minX = Math.min(minX, seg.x1, seg.x2);
+      minY = Math.min(minY, seg.y1, seg.y2);
+      maxX = Math.max(maxX, seg.x1, seg.x2);
+      maxY = Math.max(maxY, seg.y1, seg.y2);
+    }
+    const w = maxX - minX, h = maxY - minY;
+    if (w < MIN_LINE_LENGTH && h < MIN_LINE_LENGTH) return false;
+    path.length = 0;
+    if (h < ORIENTATION_TOL * 2 || w > MIN_LINE_LENGTH && h <= MAX_LINE_WIDTH) {
+      path.push({ x1: minX, y1: (minY + maxY) / 2, x2: maxX, y2: (minY + maxY) / 2 });
+    } else if (w < ORIENTATION_TOL * 2 || h > MIN_LINE_LENGTH && w <= MAX_LINE_WIDTH) {
+      path.push({ x1: (minX + maxX) / 2, y1: minY, x2: (minX + maxX) / 2, y2: maxY });
+    } else {
+      pushRectangle(path, minX, minY, w, h);
+    }
+    return true;
+  }
+  function flushPath(isStroke, isFill) {
+    if (!isStroke && !isFill) {
+      currentPath = [];
+      return;
+    }
+    if (isFill && !isStroke && currentPath.length >= 3) {
+      tryConvertLinesToRectangle(currentPath);
+    }
+    const scale = matScale(ctm);
+    const effectiveLW = lineWidth * scale;
+    if (effectiveLW > MAX_LINE_WIDTH && isStroke && !isFill) {
       currentPath = [];
       return;
     }
     for (const seg of currentPath) {
-      classifyAndAdd(seg, lineWidth, horizontals, verticals);
+      const [px1, py1] = matTransformPoint(ctm, seg.x1, seg.y1);
+      const [px2, py2] = matTransformPoint(ctm, seg.x2, seg.y2);
+      classifyAndAdd(
+        { x1: px1, y1: py1, x2: px2, y2: py2 },
+        effectiveLW,
+        horizontals,
+        verticals
+      );
     }
     currentPath = [];
   }
@@ -2992,9 +3068,28 @@ function extractLines(fnArray, argsArray) {
     const op = fnArray[i];
     const args = argsArray[i];
     switch (op) {
+      // ── Graphics State ──
+      case OPS.save:
+        stateStack.push({ ctm: [...ctm], lineWidth });
+        break;
+      case OPS.restore:
+        if (stateStack.length > 0) {
+          const state = stateStack.pop();
+          ctm = state.ctm;
+          lineWidth = state.lineWidth;
+        }
+        break;
+      case OPS.transform: {
+        const m = args;
+        if (m.length >= 6) {
+          ctm = matMultiply(ctm, [m[0], m[1], m[2], m[3], m[4], m[5]]);
+        }
+        break;
+      }
       case OPS.setLineWidth:
         lineWidth = args[0] || 1;
         break;
+      // ── Path Construction ──
       case OPS.constructPath: {
         const arg0 = args[0];
         if (Array.isArray(arg0)) {
@@ -3062,34 +3157,60 @@ function extractLines(fnArray, argsArray) {
               }
             }
           }
-          if (afterOp === OPS.stroke || afterOp === OPS.closeStroke) {
-            flushPath(true);
-          } else if (afterOp === OPS.fill || afterOp === OPS.eoFill || afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke) {
-            flushPath(true);
+          const isStroke5 = afterOp === OPS.stroke || afterOp === OPS.closeStroke;
+          const isFill5 = afterOp === OPS.fill || afterOp === OPS.eoFill;
+          const isBoth5 = afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke;
+          if (isStroke5 || isFill5 || isBoth5) {
+            flushPath(isStroke5 || isBoth5, isFill5 || isBoth5);
           } else if (afterOp === OPS.endPath) {
-            flushPath(false);
+            flushPath(false, false);
           }
         }
         break;
       }
+      // ── Paint Operations ──
       case OPS.stroke:
       case OPS.closeStroke:
-        flushPath(true);
+        flushPath(true, false);
         break;
       case OPS.fill:
       case OPS.eoFill:
+        flushPath(false, true);
+        break;
       case OPS.fillStroke:
       case OPS.eoFillStroke:
       case OPS.closeFillStroke:
       case OPS.closeEOFillStroke:
-        flushPath(true);
+        flushPath(true, true);
         break;
       case OPS.endPath:
-        flushPath(false);
+        flushPath(false, false);
         break;
     }
   }
-  return { horizontals, verticals };
+  return {
+    horizontals: deduplicateLines(horizontals),
+    verticals: deduplicateLines(verticals)
+  };
+}
+function deduplicateLines(lines) {
+  if (lines.length <= 1) return lines;
+  const result = [];
+  const tol = COORD_MERGE_TOL;
+  for (const line of lines) {
+    let isDuplicate = false;
+    for (const existing of result) {
+      if (Math.abs(line.y1 - existing.y1) <= tol && Math.abs(line.y2 - existing.y2) <= tol && Math.abs(line.x1 - existing.x1) <= tol && Math.abs(line.x2 - existing.x2) <= tol) {
+        if (line.lineWidth > existing.lineWidth) {
+          existing.lineWidth = line.lineWidth;
+        }
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) result.push(line);
+  }
+  return result;
 }
 function classifyAndAdd(seg, lineWidth, horizontals, verticals) {
   const dx = Math.abs(seg.x2 - seg.x1);
@@ -3685,6 +3806,7 @@ async function parsePdfDocument(buffer, options) {
     const medianFontSize = computeMedianFontSize(allFontSizes);
     if (medianFontSize > 0) {
       detectHeadings(blocks, medianFontSize);
+      mergeAdjacentHeadings(blocks);
     }
     detectMarkerHeadings(blocks);
     const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
@@ -3759,6 +3881,46 @@ function detectHeadings(blocks, medianFontSize) {
     }
   }
 }
+function mergeAdjacentHeadings(blocks) {
+  let i = 0;
+  while (i < blocks.length - 1) {
+    const curr = blocks[i];
+    const next = blocks[i + 1];
+    if (curr.type !== "heading" || next.type !== "heading") {
+      i++;
+      continue;
+    }
+    if (!curr.bbox || !next.bbox || !curr.text || !next.text) {
+      i++;
+      continue;
+    }
+    const currBaseline = curr.bbox.y + (curr.style?.fontSize || curr.bbox.height);
+    const nextBaseline = next.bbox.y + (next.style?.fontSize || next.bbox.height);
+    const yDiff = Math.abs(currBaseline - nextBaseline);
+    const maxFs = Math.max(curr.style?.fontSize || 12, next.style?.fontSize || 12);
+    const sameY = curr.bbox.page === next.bbox.page && yDiff < maxFs * 1.5;
+    const sameLevel = curr.level === next.level;
+    if (sameY && sameLevel) {
+      const currX = curr.bbox.x;
+      const nextX = next.bbox.x;
+      if (currX <= nextX) {
+        curr.text = curr.text + " " + next.text;
+      } else {
+        curr.text = next.text + " " + curr.text;
+      }
+      curr.bbox = {
+        page: curr.bbox.page,
+        x: Math.min(curr.bbox.x, next.bbox.x),
+        y: Math.min(curr.bbox.y, next.bbox.y),
+        width: Math.max(curr.bbox.x + curr.bbox.width, next.bbox.x + next.bbox.width) - Math.min(curr.bbox.x, next.bbox.x),
+        height: Math.max(curr.bbox.height, next.bbox.height)
+      };
+      blocks.splice(i + 1, 1);
+    } else {
+      i++;
+    }
+  }
+}
 function collapseEvenSpacing(text) {
   const tokens = text.split(" ");
   const singleCharCount = tokens.filter((t) => t.length === 1).length;
@@ -3767,6 +3929,169 @@ function collapseEvenSpacing(text) {
   }
   return text;
 }
+function buildXyCutBlocks(items, pageNum) {
+  const allY = items.map((i) => i.y);
+  const pageHeight = Math.max(...allY) - Math.min(...allY);
+  const gapThreshold = Math.max(15, pageHeight * 0.03);
+  const orderedGroups = xyCutOrder(items, gapThreshold);
+  const blocks = [];
+  for (const group of orderedGroups) {
+    if (group.length === 0) continue;
+    const yLines = groupByY(group);
+    for (const line of yLines) {
+      const text = mergeLineSimple(line);
+      if (!text.trim()) continue;
+      blocks.push({
+        type: "paragraph",
+        text,
+        pageNumber: pageNum,
+        bbox: computeBBox(line, pageNum),
+        style: dominantStyle(line)
+      });
+    }
+  }
+  return blocks.length > 0 ? blocks : null;
+}
+function normalizeUnderSegmentedTable(table, items, pageNum, bbox) {
+  const totalCells = table.cells.reduce((sum, row) => sum + row.filter((c) => c.text.trim()).length, 0);
+  const totalTextLines = table.cells.reduce((sum, row) => sum + row.reduce((s, c) => s + (c.text.trim() ? c.text.split("\n").length : 0), 0), 0);
+  const isUnderSegmented = table.rows === 1 && table.cols === 1 || totalCells <= 2 && totalTextLines >= 8 || totalCells <= 2 && items.length >= 6;
+  if (!isUnderSegmented) return null;
+  if (hasMultiColumnLayout(items)) return buildXyCutBlocks(items, pageNum);
+  const directTable = buildTableFromTextLayout(items, pageNum, bbox);
+  if (directTable) return directTable;
+  const clusterItems = items.map((i) => ({
+    text: i.text,
+    x: i.x,
+    y: i.y,
+    w: i.w,
+    h: i.h,
+    fontSize: i.fontSize,
+    fontName: i.fontName
+  }));
+  const clusterResults = detectClusterTables(clusterItems, pageNum);
+  if (clusterResults.length > 0) {
+    const blocks = [];
+    const ciToIdx = /* @__PURE__ */ new Map();
+    for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);
+    const usedIndices = /* @__PURE__ */ new Set();
+    for (const cr of clusterResults) {
+      for (const ci of cr.usedItems) {
+        const idx = ciToIdx.get(ci);
+        if (idx !== void 0) usedIndices.add(idx);
+      }
+      blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
+    }
+    const remaining = items.filter((_, idx) => !usedIndices.has(idx));
+    for (const item of remaining) {
+      if (!item.text.trim()) continue;
+      blocks.push({
+        type: "paragraph",
+        text: item.text,
+        pageNumber: pageNum,
+        bbox: computeBBox([item], pageNum),
+        style: { fontSize: item.fontSize, fontName: item.fontName }
+      });
+    }
+    blocks.sort((a, b) => {
+      const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
+      const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
+      return by - ay;
+    });
+    return blocks.length > 0 ? blocks : null;
+  }
+  return null;
+}
+function buildTableFromTextLayout(items, pageNum, bbox) {
+  if (items.length < 4) return null;
+  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
+  const yTol = 3;
+  const rows = [];
+  let curRow = [sorted[0]];
+  let curY = sorted[0].y;
+  for (let i = 1; i < sorted.length; i++) {
+    if (Math.abs(sorted[i].y - curY) <= yTol) {
+      curRow.push(sorted[i]);
+    } else {
+      rows.push(curRow);
+      curRow = [sorted[i]];
+      curY = sorted[i].y;
+    }
+  }
+  rows.push(curRow);
+  if (rows.length < 2) return null;
+  const gapPositions = [];
+  for (const row of rows) {
+    if (row.length < 2) continue;
+    const sortedX = [...row].sort((a, b) => a.x - b.x);
+    const avgFs = sortedX.reduce((s, i) => s + i.fontSize, 0) / sortedX.length;
+    for (let j = 1; j < sortedX.length; j++) {
+      const gap = sortedX[j].x - (sortedX[j - 1].x + sortedX[j - 1].w);
+      if (gap >= avgFs * 1.5) {
+        gapPositions.push(sortedX[j - 1].x + sortedX[j - 1].w + gap / 2);
+      }
+    }
+  }
+  if (gapPositions.length < 2) return null;
+  gapPositions.sort((a, b) => a - b);
+  const colBoundaries = [];
+  let clusterSum = gapPositions[0], clusterCount = 1;
+  for (let i = 1; i < gapPositions.length; i++) {
+    const avg = clusterSum / clusterCount;
+    if (Math.abs(gapPositions[i] - avg) <= 15) {
+      clusterSum += gapPositions[i];
+      clusterCount++;
+    } else {
+      if (clusterCount >= 2) colBoundaries.push(clusterSum / clusterCount);
+      clusterSum = gapPositions[i];
+      clusterCount = 1;
+    }
+  }
+  if (clusterCount >= 2) colBoundaries.push(clusterSum / clusterCount);
+  if (colBoundaries.length === 0) return null;
+  const numCols = colBoundaries.length + 1;
+  const tableRows = [];
+  for (const row of rows) {
+    const cells = Array(numCols).fill("");
+    const sortedX = [...row].sort((a, b) => a.x - b.x);
+    for (const item of sortedX) {
+      const cx = item.x + item.w / 2;
+      let col = 0;
+      for (let b = 0; b < colBoundaries.length; b++) {
+        if (cx > colBoundaries[b]) col = b + 1;
+      }
+      cells[col] = cells[col] ? cells[col] + " " + item.text : item.text;
+    }
+    if (cells[0].trim() === "" && tableRows.length > 0) {
+      const prevCells = tableRows[tableRows.length - 1].cells;
+      for (let c = 0; c < numCols; c++) {
+        if (cells[c].trim()) {
+          prevCells[c] = prevCells[c] ? prevCells[c] + " " + cells[c].trim() : cells[c].trim();
+        }
+      }
+    } else {
+      tableRows.push({ cells });
+    }
+  }
+  if (tableRows.length < 2) return null;
+  const nonEmptyCount = tableRows.reduce((sum, r) => sum + r.cells.filter((c) => c.trim()).length, 0);
+  const totalCount = tableRows.length * numCols;
+  if (nonEmptyCount < totalCount * 0.3) return null;
+  const irCells = tableRows.map(
+    (r) => r.cells.map((text, colIdx) => {
+      let cleaned = text.trim();
+      if (colIdx > 0) cleaned = cleaned.replace(/^[•○·\-]\s*/, "");
+      return { text: cleaned, colSpan: 1, rowSpan: 1 };
+    })
+  );
+  const irTable = {
+    rows: tableRows.length,
+    cols: numCols,
+    cells: irCells,
+    hasHeader: tableRows.length > 1
+  };
+  return [{ type: "table", table: irTable, pageNumber: pageNum, bbox }];
+}
 function shouldDemoteTable(table) {
   const allCells = table.cells.flatMap((row) => row.map((c) => c.text.trim())).filter(Boolean);
   const allText = allCells.join(" ");
@@ -3813,6 +4138,32 @@ function detectMarkerHeadings(blocks) {
     }
   }
 }
+function hasMultiColumnLayout(items) {
+  if (items.length < 30) return false;
+  const sorted = [...items].sort((a, b) => a.x - b.x);
+  const minX = sorted[0].x;
+  let maxX = minX;
+  for (const i of sorted) if (i.x + i.w > maxX) maxX = i.x + i.w;
+  const pageWidth = maxX - minX;
+  if (pageWidth < 200) return false;
+  let bestGap = 0;
+  let bestSplit = 0;
+  for (let j = 1; j < sorted.length; j++) {
+    const gap = sorted[j].x - (sorted[j - 1].x + sorted[j - 1].w);
+    if (gap > bestGap) {
+      bestGap = gap;
+      bestSplit = (sorted[j - 1].x + sorted[j - 1].w + sorted[j].x) / 2;
+    }
+  }
+  if (bestGap < 20) return false;
+  const splitRatio = (bestSplit - minX) / pageWidth;
+  if (splitRatio < 0.35 || splitRatio > 0.65) return false;
+  const leftCount = items.filter((i) => i.x + i.w / 2 < bestSplit).length;
+  const rightCount = items.filter((i) => i.x + i.w / 2 >= bestSplit).length;
+  if (leftCount < 15 || rightCount < 15) return false;
+  if (Math.min(leftCount, rightCount) / Math.max(leftCount, rightCount) < 0.35) return false;
+  return true;
+}
 var MAX_XYCUT_DEPTH = 50;
 function xyCutOrder(items, gapThreshold, depth = 0) {
   if (items.length === 0) return [];
@@ -3943,6 +4294,11 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       width: grid.bbox.x2 - grid.bbox.x1,
       height: grid.bbox.y2 - grid.bbox.y1
     };
+    const normalized = normalizeUnderSegmentedTable(irTable, tableItems, pageNum, tableBbox);
+    if (normalized) {
+      blocks.push(...normalized);
+      continue;
+    }
     if (shouldDemoteTable(irTable)) {
       const demoted = demoteTableToText(irTable);
       if (demoted) {
@@ -3988,6 +4344,10 @@ function mergeAdjacentTableBlocks(blocks) {
 }
 function extractPageBlocksFallback(items, pageNum) {
   if (items.length === 0) return [];
+  if (hasMultiColumnLayout(items)) {
+    const xyBlocks = buildXyCutBlocks(items, pageNum) || [];
+    return detectSpecialKoreanTables(detectListBlocks(xyBlocks));
+  }
   const blocks = [];
   const allYLines = groupByY(items);
   const columns = detectColumns(allYLines);
@@ -4005,7 +4365,7 @@ function extractPageBlocksFallback(items, pageNum) {
       fontSize: i.fontSize,
       fontName: i.fontName
     }));
-    const clusterResults = detectClusterTables(clusterItems, pageNum);
+    const clusterResults = hasMultiColumnLayout(items) ? [] : detectClusterTables(clusterItems, pageNum);
     if (clusterResults.length > 0) {
       const ciToIdx = /* @__PURE__ */ new Map();
       for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);