@ricsam/r5d-worker 0.0.132 → 0.0.133

package/dist/mjs/three-way-merge.mjs

@@ -0,0 +1,318 @@
+const BINARY_PROBE_BYTES = 8e3;
+const DEFAULT_MAX_LINES = 1e6;
+const DEFAULT_MAX_EDIT_DISTANCE = 2e4;
+const DEFAULT_MAX_ALIGNMENT_CELLS = 1e8;
+const DEFAULT_MAX_DIFF_WORK = 5e7;
+const NEWLINE = 10;
+const NO_COMMON_LINES = /* @__PURE__ */ Symbol("no-common-lines");
+function isBinaryContent(content) {
+  return content.subarray(0, BINARY_PROBE_BYTES).includes(0);
+}
+class LineTable {
+  ids = /* @__PURE__ */ new Map();
+  lines = [];
+  intern(line) {
+    const key = line.toString("latin1");
+    let id = this.ids.get(key);
+    if (id === void 0) {
+      id = this.lines.length;
+      this.ids.set(key, id);
+      this.lines.push(line);
+    }
+    return id;
+  }
+}
+function splitLines(content, table, maxLines) {
+  let count = 0;
+  for (let offset = 0; offset < content.length; ) {
+    const newline = content.indexOf(NEWLINE, offset);
+    count += 1;
+    if (count > maxLines) return null;
+    offset = newline < 0 ? content.length : newline + 1;
+  }
+  const ids = new Int32Array(count);
+  let index = 0;
+  for (let offset = 0; offset < content.length; ) {
+    const newline = content.indexOf(NEWLINE, offset);
+    const end = newline < 0 ? content.length : newline + 1;
+    ids[index] = table.intern(content.subarray(offset, end));
+    index += 1;
+    offset = end;
+  }
+  return ids;
+}
+function findSplit(a, a0, a1, b, b0, b1, forward, backward, maxEditDistance, budget) {
+  const n = a1 - a0;
+  const m = b1 - b0;
+  const maxD = Math.ceil((n + m) / 2);
+  const offset = maxD;
+  const length = 2 * maxD + 2;
+  forward.fill(-1, 0, length);
+  backward.fill(-1, 0, length);
+  forward[offset + 1] = 0;
+  backward[offset + 1] = 0;
+  const delta = n - m;
+  const meetOnForward = (delta & 1) !== 0;
+  let forwardStart = 0;
+  let forwardEnd = 0;
+  let backwardStart = 0;
+  let backwardEnd = 0;
+  for (let d = 0; d < maxD; d += 1) {
+    if (2 * d > maxEditDistance) return null;
+    budget.remaining -= 2 * (2 * d + 1);
+    if (budget.remaining < 0) return null;
+    for (let k = -d + forwardStart; k <= d - forwardEnd; k += 2) {
+      const kIndex = offset + k;
+      let x = k === -d || k !== d && forward[kIndex - 1] < forward[kIndex + 1] ? forward[kIndex + 1] : forward[kIndex - 1] + 1;
+      let y = x - k;
+      const snakeStart = x;
+      while (x < n && y < m && a[a0 + x] === b[b0 + y]) {
+        x += 1;
+        y += 1;
+      }
+      budget.remaining -= x - snakeStart;
+      forward[kIndex] = x;
+      if (x > n) forwardEnd += 2;
+      else if (y > m) forwardStart += 2;
+      else if (meetOnForward) {
+        const reverseIndex = offset + delta - k;
+        if (reverseIndex >= 0 && reverseIndex < length && backward[reverseIndex] !== -1 && x >= n - backward[reverseIndex]) {
+          return [a0 + x, b0 + y];
+        }
+      }
+    }
+    for (let k = -d + backwardStart; k <= d - backwardEnd; k += 2) {
+      const kIndex = offset + k;
+      let x = k === -d || k !== d && backward[kIndex - 1] < backward[kIndex + 1] ? backward[kIndex + 1] : backward[kIndex - 1] + 1;
+      let y = x - k;
+      const snakeStart = x;
+      while (x < n && y < m && a[a1 - x - 1] === b[b1 - y - 1]) {
+        x += 1;
+        y += 1;
+      }
+      budget.remaining -= x - snakeStart;
+      backward[kIndex] = x;
+      if (x > n) backwardEnd += 2;
+      else if (y > m) backwardStart += 2;
+      else if (!meetOnForward) {
+        const forwardIndex = offset + delta - k;
+        if (forwardIndex >= 0 && forwardIndex < length && forward[forwardIndex] !== -1) {
+          const forwardX = forward[forwardIndex];
+          if (forwardX >= n - x) return [a0 + forwardX, b0 + forwardX - (forwardIndex - offset)];
+        }
+      }
+    }
+  }
+  return n + m > maxEditDistance ? null : NO_COMMON_LINES;
+}
+function diffLines(a, b, options = {}) {
+  const maxEditDistance = options.maxEditDistance ?? DEFAULT_MAX_EDIT_DISTANCE;
+  if (maxEditDistance < 0) return null;
+  const budget = { remaining: options.maxWork ?? DEFAULT_MAX_DIFF_WORK };
+  const scratchLength = a.length + b.length + 4;
+  const forward = new Int32Array(scratchLength);
+  const backward = new Int32Array(scratchLength);
+  const hunks = [];
+  const stack = [0, a.length, 0, b.length];
+  let topLevel = true;
+  while (stack.length > 0) {
+    let b1 = stack.pop();
+    let b0 = stack.pop();
+    let a1 = stack.pop();
+    let a0 = stack.pop();
+    while (a0 < a1 && b0 < b1 && a[a0] === b[b0]) {
+      a0 += 1;
+      b0 += 1;
+    }
+    while (a0 < a1 && b0 < b1 && a[a1 - 1] === b[b1 - 1]) {
+      a1 -= 1;
+      b1 -= 1;
+    }
+    if (a0 === a1 && b0 === b1) continue;
+    let noCommonLines = a0 === a1 || b0 === b1;
+    if (!noCommonLines && topLevel) {
+      const seen = /* @__PURE__ */ new Set();
+      for (let index = a0; index < a1; index += 1) seen.add(a[index]);
+      noCommonLines = true;
+      for (let index = b0; index < b1; index += 1) {
+        if (seen.has(b[index])) {
+          noCommonLines = false;
+          break;
+        }
+      }
+      if (noCommonLines && a1 - a0 + (b1 - b0) > maxEditDistance) return null;
+    }
+    topLevel = false;
+    const split = noCommonLines ? NO_COMMON_LINES : findSplit(a, a0, a1, b, b0, b1, forward, backward, maxEditDistance, budget);
+    if (split === null) return null;
+    if (split === NO_COMMON_LINES) {
+      const previous = hunks[hunks.length - 1];
+      if (previous && previous.aEnd === a0 && previous.bEnd === b0) {
+        previous.aEnd = a1;
+        previous.bEnd = b1;
+      } else hunks.push({ aStart: a0, aEnd: a1, bStart: b0, bEnd: b1 });
+      continue;
+    }
+    stack.push(split[0], a1, split[1], b1, a0, split[0], b0, split[1]);
+  }
+  return hunks;
+}
+function analyzeAlignment(a, b, lcsLength, maxCells) {
+  const n = a.length;
+  const m = b.length;
+  const kMin = lcsLength - m;
+  const kMax = n - lcsLength;
+  const width = kMax - kMin + 1;
+  const certain = new Int32Array(n).fill(-1);
+  const ambiguous = new Uint8Array(n);
+  if (n === 0) return { certain, ambiguous };
+  if ((n + 1) * width > maxCells) return null;
+  const computeSuffixRow = (i, next, out) => {
+    for (let index = width - 1; index >= 0; index -= 1) {
+      const j = i - kMax + index;
+      if (j < 0 || j >= m) {
+        out[index] = 0;
+        continue;
+      }
+      const down = index > 0 ? next[index - 1] : 0;
+      const right = index + 1 < width ? out[index + 1] : 0;
+      const diagonal = next[index] + (a[i] === b[j] ? 1 : 0);
+      out[index] = down > right ? down > diagonal ? down : diagonal : right > diagonal ? right : diagonal;
+    }
+  };
+  const computePrefixRow = (i, previous, out) => {
+    for (let index = 0; index < width; index += 1) {
+      const j = i - kMax + index;
+      if (j <= 0 || j > m || i === 0) {
+        out[index] = 0;
+        continue;
+      }
+      const up = index + 1 < width ? previous[index + 1] : 0;
+      const left = index > 0 ? out[index - 1] : 0;
+      const diagonal = previous[index] + (a[i - 1] === b[j - 1] ? 1 : 0);
+      out[index] = up > left ? up > diagonal ? up : diagonal : left > diagonal ? left : diagonal;
+    }
+  };
+  const blockSize = Math.ceil(Math.sqrt(n + 1));
+  const checkpoints = /* @__PURE__ */ new Map();
+  let suffixNext = new Int32Array(width);
+  let suffixCurrent = new Int32Array(width);
+  checkpoints.set(n, new Int32Array(width));
+  for (let i = n - 1; i >= 0; i -= 1) {
+    computeSuffixRow(i, suffixNext, suffixCurrent);
+    if (i % blockSize === 0) checkpoints.set(i, suffixCurrent.slice());
+    [suffixNext, suffixCurrent] = [suffixCurrent, suffixNext];
+  }
+  const block = Array.from({ length: blockSize + 1 }, () => new Int32Array(width));
+  let prefixPrevious = new Int32Array(width);
+  let prefixCurrent = new Int32Array(width);
+  for (let blockStart = 0; blockStart < n; blockStart += blockSize) {
+    const blockEnd = Math.min(blockStart + blockSize, n);
+    block[blockEnd - blockStart] = checkpoints.get(blockEnd);
+    for (let i = blockEnd - 1; i > blockStart; i -= 1) computeSuffixRow(i, block[i + 1 - blockStart], block[i - blockStart]);
+    for (let i = blockStart; i < blockEnd; i += 1) {
+      computePrefixRow(i, prefixPrevious, prefixCurrent);
+      const suffix = block[i + 1 - blockStart];
+      let bestDeletion = 0;
+      let matches = 0;
+      let partner = -1;
+      for (let index = 0; index < width; index += 1) {
+        const j = i - kMax + index;
+        if (j < 0 || j > m) continue;
+        const prefix = prefixCurrent[index];
+        const deleted = prefix + (index > 0 ? suffix[index - 1] : 0);
+        if (deleted > bestDeletion) bestDeletion = deleted;
+        if (j < m && a[i] === b[j] && prefix + 1 + suffix[index] === lcsLength) {
+          matches += 1;
+          partner = j;
+        }
+      }
+      if (matches === 1 && bestDeletion < lcsLength) certain[i] = partner;
+      else if (matches > 0) ambiguous[i] = 1;
+      [prefixPrevious, prefixCurrent] = [prefixCurrent, prefixPrevious];
+    }
+  }
+  return { certain, ambiguous };
+}
+function rangesEqual(a, aStart, aEnd, b, bStart, bEnd) {
+  if (aEnd - aStart !== bEnd - bStart) return false;
+  for (let offset = 0; offset < aEnd - aStart; offset += 1) {
+    if (a[aStart + offset] !== b[bStart + offset]) return false;
+  }
+  return true;
+}
+function anyAmbiguous(flags, start, end) {
+  for (let index = start; index < end; index += 1) if (flags[index]) return true;
+  return false;
+}
+function sideAlignment(base, side, options) {
+  const maxEditDistance = Math.min(options.maxEditDistance, Math.floor(options.maxAlignmentCells / (base.length + 1)) - 1);
+  const hunks = diffLines(base, side, { maxEditDistance, maxWork: options.maxDiffWork });
+  if (!hunks) return null;
+  let deleted = 0;
+  for (const hunk of hunks) deleted += hunk.aEnd - hunk.aStart;
+  return analyzeAlignment(base, side, base.length - deleted, options.maxAlignmentCells);
+}
+function mergeThreeWay(base, ours, theirs, options = {}) {
+  if (ours.equals(base)) return { kind: "clean", content: theirs };
+  if (theirs.equals(base)) return { kind: "clean", content: ours };
+  if (ours.equals(theirs)) return { kind: "clean", content: ours };
+  if (isBinaryContent(base) || isBinaryContent(ours) || isBinaryContent(theirs)) return { kind: "conflict", conflicts: 1 };
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const bounds = {
+    maxEditDistance: options.maxEditDistance ?? DEFAULT_MAX_EDIT_DISTANCE,
+    maxAlignmentCells: options.maxAlignmentCells ?? DEFAULT_MAX_ALIGNMENT_CELLS,
+    maxDiffWork: options.maxDiffWork ?? DEFAULT_MAX_DIFF_WORK
+  };
+  const table = new LineTable();
+  const baseLines = splitLines(base, table, maxLines);
+  const oursLines = splitLines(ours, table, maxLines);
+  const theirsLines = splitLines(theirs, table, maxLines);
+  if (!baseLines || !oursLines || !theirsLines) return { kind: "conflict", conflicts: 1 };
+  const oursAlignment = sideAlignment(baseLines, oursLines, bounds);
+  const theirsAlignment = sideAlignment(baseLines, theirsLines, bounds);
+  if (!oursAlignment || !theirsAlignment) return { kind: "conflict", conflicts: 1 };
+  const oursMatch = oursAlignment.certain;
+  const theirsMatch = theirsAlignment.certain;
+  const output = [];
+  let conflicts = 0;
+  let i = 0;
+  let o = 0;
+  let t = 0;
+  for (; ; ) {
+    while (i < baseLines.length && oursMatch[i] === o && theirsMatch[i] === t) {
+      output.push(table.lines[baseLines[i]]);
+      i += 1;
+      o += 1;
+      t += 1;
+    }
+    if (i === baseLines.length && o === oursLines.length && t === theirsLines.length) break;
+    let j = i;
+    while (j < baseLines.length && (oursMatch[j] < 0 || theirsMatch[j] < 0)) j += 1;
+    const oursEnd = j < baseLines.length ? oursMatch[j] : oursLines.length;
+    const theirsEnd = j < baseLines.length ? theirsMatch[j] : theirsLines.length;
+    if (rangesEqual(baseLines, i, j, oursLines, o, oursEnd)) {
+      for (let index = t; index < theirsEnd; index += 1) output.push(table.lines[theirsLines[index]]);
+    } else if (rangesEqual(baseLines, i, j, theirsLines, t, theirsEnd)) {
+      for (let index = o; index < oursEnd; index += 1) output.push(table.lines[oursLines[index]]);
+    } else if (rangesEqual(oursLines, o, oursEnd, theirsLines, t, theirsEnd) && // Git compares its hunks, not the region text: the same text reached by
+    // differently shaped hunks still conflicts there, so only a region whose
+    // alignment is unique on both sides is safely the same change.
+    !anyAmbiguous(oursAlignment.ambiguous, i, j) && !anyAmbiguous(theirsAlignment.ambiguous, i, j)) {
+      for (let index = o; index < oursEnd; index += 1) output.push(table.lines[oursLines[index]]);
+    } else conflicts += 1;
+    i = j;
+    o = oursEnd;
+    t = theirsEnd;
+  }
+  if (conflicts > 0) return { kind: "conflict", conflicts };
+  return { kind: "clean", content: Buffer.concat(output) };
+}
+const threeWayMergeTestHarness = { diffLines, analyzeAlignment };
+export {
+  analyzeAlignment,
+  diffLines,
+  isBinaryContent,
+  mergeThreeWay,
+  threeWayMergeTestHarness
+};