@ai-matrx/content-ir 0.14.0 → 0.14.2

package/dist/index.js

@@ -5233,6 +5233,7 @@ function isMathShape(content) {
   const words = content.match(/[A-Za-z]+/g);
   if (!words) return false;
   if (!words.every((w) => w.length === 1 || FUNCTION_NAMES.has(w))) return false;
+  if (/[A-Za-z]'+[A-Za-z]/.test(content) || /(?:^|[\s(,])[A-Za-z]\.(?:[A-Za-z]\.|\s|$)/.test(content)) return false;
   return /[A-Za-z]'*\(|[A-Za-z]'|\b[A-Za-z]\s+[A-Za-z]\b|\([^)]*[A-Za-z][^)]*\)/.test(content);
 }
 function isSingleDollarMath(content, after) {
@@ -5998,11 +5999,41 @@ var Tokenizer = class {
     for (let k = li + 1; k < this.lineCount; k++) {
       if (this.isOpenTail(k)) continue;
       if (close.test(this.lineText(k))) {
-        return this.island("fence", p, this.contentEnds[k], true, meta);
+        const tildeEnd = this.contentEnds[k];
+        const end = this.rendererOverflow(li + 1, k, tildeEnd);
+        return this.island("fence", p, end, end === this.n ? this.overflowComplete : true, meta);
       }
     }
     return this.island("fence", p, this.n, false, meta);
   }
+  /** Completion of the last `rendererOverflow` that ran to the end of the text. */
+  overflowComplete = true;
+  /**
+   * The renderer's splitter does not know ~~~ fences: it reads the lines inside
+   * one as ordinary lines, so a ```` ``` ```` fence (or an XML section, a JSON
+   * block…) that STARTS inside the tilde fence can run past its closer. The
+   * editor must lock at least what the renderer draws (verify-RC-B3 residual
+   * R5), so a tilde island extends over every block the renderer would detect
+   * starting inside it. Returns the island's end.
+   */
+  rendererOverflow(firstLine, closeLine, tildeEnd) {
+    let end = tildeEnd;
+    this.overflowComplete = true;
+    for (let j = firstLine; j <= closeLine && j < this.lineCount; j++) {
+      const start = this.lineStarts[j];
+      if (this.lineIsBlank(j)) continue;
+      if (this.lineText(j).trimStart().startsWith("~~~")) continue;
+      const inner = this.detectBlockUncached(start, j, false);
+      if (!inner) continue;
+      if (inner.end > end) {
+        end = inner.end;
+        this.overflowComplete = inner.complete;
+      }
+      const lastLine = this.lineOf(Math.max(start, inner.end - 1));
+      if (lastLine > j) j = lastLine;
+    }
+    return end;
+  }
   /**
    * A line-leading `$$` that OPENS a math pair (source/math-pairs.ts — the
    * core's rule). A closer, an unpaired `$$`, or a prose pair is never a block: