@createiq/htmldiff 1.0.4 → 1.0.5-beta.1

package/dist/HtmlDiff.d.mts

@@ -11,9 +11,20 @@ declare class HtmlDiff {
   private static SpecialCaseClosingTagsSet;
   private static SpecialCaseOpeningTagRegex;
   private static FormattingTags;
+  /**
+   * Hard cap on nested `HtmlDiff.execute` calls (table preprocessing
+   * recurses through `diffCell` for cell content). Each level allocates
+   * fresh DP matrices and word arrays; without a guard a maliciously
+   * nested table-in-cell-in-table-in-cell input could blow stack and
+   * memory. Set high enough to comfortably handle real legal documents
+   * (tables nested 2-3 deep at most), low enough to short-circuit
+   * pathological input.
+   */
+  private static MaxTablePreprocessDepth;
   private content;
   private newText;
   private oldText;
+  private readonly tablePreprocessDepth;
   private specialTagDiffStack;
   private newWords;
   private oldWords;
@@ -26,8 +37,17 @@ declare class HtmlDiff {
   /** Maps content-word index → original word index */
   private oldContentToOriginal;
   private newContentToOriginal;
-  /** Tracks the last original old word index output, so equal operations can include leading structural tags */
+  /**
+   * Tracks the next unwritten word index in oldWords/newWords. Mutated only by
+   * {@link sliceOriginalWordsForOp} (each op reads a slice and advances its cursor).
+   * Advances monotonically. Used so:
+   *   - subsequent equal/delete ops know where in old to resume from
+   *   - subsequent insert ops know where in new to resume from
+   * The two cursors are independent: equal/delete output from old and advance the old
+   * cursor; insert outputs from new and advances the new cursor.
+   */
   private lastOriginalOldOutputIndex;
+  private lastOriginalNewOutputIndex;
   private matchGranularity;
   private blockExpressions;
   /**
@@ -67,9 +87,12 @@ declare class HtmlDiff {
    * Initializes a new instance of the class.
    * @param oldText The old text.
    * @param newText The new text.
+   * @param tablePreprocessDepth Internal: nested-call depth for table
+   *   preprocessing. Callers should leave at default (0); the recursive
+   *   `diffCell` callback in TableDiff bumps it.
    */
-  constructor(oldText: string, newText: string);
-  static execute(oldText: string, newText: string): string;
+  constructor(oldText: string, newText: string, tablePreprocessDepth?: number);
+  static execute(oldText: string, newText: string, tablePreprocessDepth?: number): string;
   /**
    * Builds the HTML diff output
    * @return HTML diff markup
@@ -82,11 +105,18 @@ declare class HtmlDiff {
   addBlockExpression(expression: RegExp): void;
   private splitInputsToWords;
   /**
-   * Checks whether the two word arrays have structural HTML differences (different non-formatting tags
-   * or different whitespace between structural tags). When they do, builds "content projections" that
-   * strip structural noise so the diff algorithm only sees meaningful content and formatting changes.
+   * Builds "content projections" — word arrays with structural wrapper tags stripped — when
+   * structural normalization is appropriate for these inputs. The diff algorithm operates on
+   * the projections so wrapper-tag differences (e.g. `<p>` vs `<div>`) don't appear as content
+   * changes; structural tags are then folded back in at output time.
    */
   private buildContentProjections;
+  /**
+   * Decides whether structural normalization should be activated for this pair of inputs.
+   * Each clause is a distinct correctness or fitness check — extend by adding a named
+   * sub-predicate rather than chaining ad-hoc conditions.
+   */
+  private static shouldUseContentProjections;
   /**
    * Tags that commonly serve as content wrappers and may change structurally
    * without affecting the actual content. Only these tags are stripped during
@@ -94,6 +124,8 @@ declare class HtmlDiff {
    */
   private static WrapperTags;
   private static isStructuralTag;
+  /** True when the word is a structural opening tag (e.g. `<p>`, `<div>`). */
+  private static isOpeningStructuralTag;
   /**
    * Returns true if words between structural tags are just whitespace (indentation).
    */
@@ -105,21 +137,25 @@ declare class HtmlDiff {
   private processInsertOperation;
   private processDeleteOperation;
   private processEqualOperation;
+  /** True when content projections are active for both sides — i.e. structural normalization is in effect. */
+  private usingContentProjections;
   /**
-   * Gets original old words for a content-index range, including only content and formatting tags
-   * (used for delete/replace operations where we don't want structural tags).
-   */
-  private getOriginalOldWords;
-  /**
-   * Gets original new words for a content-index range, including only content and formatting tags
-   * (used for insert/replace operations where we don't want structural tags).
-   */
-  private getOriginalNewWords;
-  /**
-   * Gets original old words for a content-index range, INCLUDING structural tags and whitespace
-   * between the content words (used for equal operations to preserve old HTML structure).
+   * Returns the slice of original (old or new) words covering a content-index range,
+   * including the structural tags that surround the content. Advances the side's cursor
+   * past the slice so the next op resumes correctly.
+   *
+   * The slice extends:
+   *   - LEADING: from the side's cursor (or the first content word's original index,
+   *     whichever is smaller) so structural tags that precede the first content word
+   *     are picked up by this op rather than left orphaned.
+   *   - TRAILING (non-last range): from just after the last content word, including
+   *     closing structural tags that close *this* op's paragraphs, but stopping at
+   *     the first opening structural tag — that opening tag belongs to the next
+   *     op's paragraph and would otherwise be emitted twice.
+   *   - TRAILING (last range): all the way to the end of words, since there is no next
+   *     op to claim the trailing tags.
    */
-  private getOriginalOldWordsWithStructure;
+  private sliceOriginalWordsForOp;
   /**
    * This method encloses words within a specified tag (ins or del), and adds this into "content",
    * with a twist: if there are words contain tags, it actually creates multiple ins or del,