@mui/internal-docs-infra 0.11.1-canary.9 → 0.11.1

package/useCode/useSourceEditing.mjs

@@ -1,5 +1,25 @@
 import * as React from 'react';
+// `stringOrHastToString` is already part of the always-loaded `useCode` shell
+// (via `useCopyFunctionality`/`Pre`). Passing it into the lazy editing engine
+// keeps that engine chunk from statically pulling it (and `hastDecompress`).
 import { stringOrHastToString } from "../pipeline/hastUtils/index.mjs";
+import { useCodeContext } from "../CodeProvider/CodeContext.mjs";
+import { peekEditingEngine, loadEditingEngine, preloadEditingEngine, resetEditingEngineCache } from "./editingEngineCache.mjs";
+// The edit-time runtime (`analyzeSource`/`shiftComments`/`toControlledCode`) lives
+// in the shared `./EditingEngine` chunk — the SAME chunk `useEditable` loads, so
+// they download together. The shell warms it as soon as a block is editable (the
+// effect below); by the time the user can type — which itself waits on the
+// editable engine — the engine is ready and `setSource` runs synchronously. A
+// read-only block never loads it.
+
+/**
+ * Warms the editing engine so the next edit applies synchronously. Back-compat
+ * alias for {@link preloadEditingEngine}; the cache is shared with `useEditable`.
+ */
+export const preloadSourceEditingEngine = preloadEditingEngine;
+
+/** Clears the shared editing-engine cache. Back-compat alias; for tests. */
+export const resetSourceEditingEngineCache = resetEditingEngineCache;
 
 /**
  * Internal `setSource` shape used by the editing pipeline. The 3rd and 4th
@@ -9,254 +29,6 @@ import { stringOrHastToString } from "../pipeline/hastUtils/index.mjs";
  * `(source, fileName?) => void`.
  */
 
-/**
- * Counts the number of lines in a string and records which 1-indexed lines are
- * empty/whitespace-only, in a single pass, without allocating a line array.
- * `emptyLines` is omitted when no blank lines were found to keep the common
- * case allocation-free.
- */
-function analyzeSource(source) {
-  let totalLines = 1;
-  let emptyLines;
-  let lineStart = 0;
-  const len = source.length;
-  for (let i = 0; i <= len; i += 1) {
-    if (i === len || source.charCodeAt(i) === 0x0a /* \n */) {
-      let isEmpty = true;
-      for (let j = lineStart; j < i; j += 1) {
-        const ch = source.charCodeAt(j);
-        // 0x20=space, 0x09=tab, 0x0D=CR, 0x0B=VT, 0x0C=FF
-        if (ch !== 0x20 && ch !== 0x09 && ch !== 0x0d && ch !== 0x0b && ch !== 0x0c) {
-          isEmpty = false;
-          break;
-        }
-      }
-      if (isEmpty) {
-        if (!emptyLines) {
-          emptyLines = [];
-        }
-        emptyLines.push(totalLines);
-      }
-      if (i < len) {
-        totalLines += 1;
-        lineStart = i + 1;
-      }
-    }
-  }
-  return emptyLines ? {
-    totalLines,
-    emptyLines
-  } : {
-    totalLines
-  };
-}
-
-/**
- * Shifts 1-indexed comment line numbers after a source edit.
- * Accepts a precomputed `lineDelta` (positive = lines added, negative = lines deleted)
- * and the cursor `position` (0-indexed in the new text) to determine which
- * comments move and by how much.
- *
- * When lines are deleted, comments from the deleted range are collapsed
- * onto the edit line and recorded in a collapseMap so they can be restored
- * if the deletion is undone (lines re-added at the same position).
- *
- * Empty/whitespace-only deleted lines are special: since they had no real
- * content that "shifted upward" into editLine, their comments are pushed
- * to editLine + 1 (like `-end` boundary markers) so the highlighted region
- * shrinks instead of shifting onto the previous line.
- */
-function shiftComments(comments, lineDelta, position, existingCollapseMap, oldEmptyLines) {
-  if (!comments || Object.keys(comments).length === 0) {
-    return {
-      comments,
-      collapseMap: existingCollapseMap
-    };
-  }
-  if (lineDelta === 0) {
-    return {
-      comments,
-      collapseMap: existingCollapseMap
-    };
-  }
-
-  // position.line is 0-indexed in the new text.
-  // lineDelta is positive for insertions and negative for deletions.
-  // Convert to the 1-indexed line in old text that the cursor was on:
-  // For additions (lineDelta > 0):
-  //   - Forward typing: position is the POST-edit cursor (extent === 0).
-  //     Cursor moved down by lineDelta, so old line = position.line - lineDelta.
-  //   - Undo of a multi-line delete: the saved position has extent > 0 and
-  //     points to the SELECTION-START in the redone text — i.e. where the
-  //     re-inserted lines begin. The "edit line" is that line itself; the
-  //     new lines come AFTER it.
-  // For deletions (lineDelta < 0): cursor stayed where it was, old line = position.line.
-  const isUndoOfMultiLineDelete = lineDelta > 0 && position.extent > 0;
-  const editLine = isUndoOfMultiLineDelete ? position.line + 1 : position.line - Math.max(0, lineDelta) + 1; // 1-indexed
-
-  const shifted = {};
-  let collapseMap = existingCollapseMap ? {
-    ...existingCollapseMap
-  } : {};
-  const newCollapsed = [];
-
-  // Build a list of comment strings to exclude from the edit line after restore.
-  // Uses an array (not Set) to correctly handle duplicate comment strings
-  // across separate collapsed entries.
-  let restoredComments;
-
-  // On expansion, check if we can restore previously collapsed comments
-  if (lineDelta > 0 && collapseMap[editLine]) {
-    const entries = collapseMap[editLine];
-    const restored = [];
-    const remaining = [];
-    for (const entry of entries) {
-      if (entry.offset <= lineDelta) {
-        restored.push(entry);
-      } else {
-        remaining.push(entry);
-      }
-    }
-
-    // Place restored comments at their original offsets from the edit line
-    restoredComments = [];
-    for (const entry of restored) {
-      const restoredLine = editLine + entry.offset;
-      shifted[restoredLine] = [...(shifted[restoredLine] ?? []), ...entry.comments];
-      restoredComments.push(...entry.comments);
-    }
-    if (remaining.length > 0) {
-      collapseMap[editLine] = remaining;
-    } else {
-      delete collapseMap[editLine];
-    }
-  }
-
-  // O(1) lookup against the precomputed empty-line set from the old source.
-  const oldEmptyLineSet = oldEmptyLines && oldEmptyLines.length > 0 ? new Set(oldEmptyLines) : undefined;
-  for (const [lineStr, commentArr] of Object.entries(comments)) {
-    const line = Number(lineStr);
-    if (line <= editLine) {
-      // Before or at the edit line — unchanged.
-      // If this is the edit line and we restored comments from it, filter them out.
-      let arr = commentArr;
-      if (line === editLine && restoredComments) {
-        const remaining = [...commentArr];
-        for (const c of restoredComments) {
-          const idx = remaining.indexOf(c);
-          if (idx !== -1) {
-            remaining.splice(idx, 1);
-          }
-        }
-        arr = remaining;
-      }
-      if (arr.length > 0) {
-        shifted[line] = [...(shifted[line] ?? []), ...arr];
-      }
-    } else if (lineDelta < 0 && line <= editLine - lineDelta) {
-      // Within the deleted range — collapse comments onto the edit line.
-      // Boundary comments (ending with '-end') go to editLine + 1 instead,
-      // so range-end markers stay at the first line after the highlighted range.
-      // Boundary comments are NOT tracked in collapseMap — they shift normally
-      // on subsequent edits so the range naturally expands/contracts.
-      //
-      // Empty/whitespace-only deleted lines also push their regular comments
-      // to editLine + 1: nothing actually shifted upward into editLine, so the
-      // highlighted region should shrink rather than expand onto the line above.
-      const wasEmptyLine = oldEmptyLineSet?.has(line) ?? false;
-      const regular = commentArr.filter(c => !c.endsWith('-end'));
-      const boundary = commentArr.filter(c => c.endsWith('-end'));
-      if (regular.length > 0) {
-        if (wasEmptyLine) {
-          const target = editLine + 1;
-          shifted[target] = [...(shifted[target] ?? []), ...regular];
-        } else {
-          shifted[editLine] = [...(shifted[editLine] ?? []), ...regular];
-          newCollapsed.push({
-            offset: line - editLine,
-            comments: regular
-          });
-        }
-      }
-      if (boundary.length > 0) {
-        const boundaryTarget = editLine + 1;
-        shifted[boundaryTarget] = [...(shifted[boundaryTarget] ?? []), ...boundary];
-      }
-    } else {
-      // After the edit — shift
-      const newLine = line + lineDelta;
-      shifted[newLine] = [...(shifted[newLine] ?? []), ...commentArr];
-    }
-  }
-
-  // Also shift existing collapse map entries that are after the edit line
-  const shiftedCollapseMap = {};
-  for (const [lineStr, entries] of Object.entries(collapseMap)) {
-    const line = Number(lineStr);
-    if (line <= editLine) {
-      shiftedCollapseMap[line] = entries;
-    } else {
-      shiftedCollapseMap[line + lineDelta] = entries;
-    }
-  }
-  collapseMap = shiftedCollapseMap;
-  if (newCollapsed.length > 0) {
-    collapseMap[editLine] = [...(collapseMap[editLine] ?? []), ...newCollapsed];
-  }
-  const finalCollapseMap = Object.keys(collapseMap).length > 0 ? collapseMap : undefined;
-  return {
-    comments: shifted,
-    collapseMap: finalCollapseMap
-  };
-}
-
-/**
- * Converts Code to ControlledCode, normalizing sources and extraFiles entries.
- * VariantSource can be HAST nodes; ControlledCode requires plain strings.
- * VariantExtraFiles allows plain string entries; ControlledVariantExtraFiles
- * requires `{ source }` objects. Without this normalization, parseControlledCode
- * reads `.source` on a string and gets `undefined`, dropping file content.
- */
-function toControlledCode(code) {
-  const result = {};
-  for (const [key, variant] of Object.entries(code)) {
-    if (!variant || typeof variant === 'string') {
-      continue;
-    }
-    const source = variant.source != null ? stringOrHastToString(variant.source) : variant.source;
-    let extraFiles;
-    if (variant.extraFiles) {
-      extraFiles = {};
-      for (const [fileName, entry] of Object.entries(variant.extraFiles)) {
-        if (typeof entry === 'string') {
-          extraFiles[fileName] = {
-            source: entry,
-            ...analyzeSource(entry)
-          };
-        } else {
-          const extraSource = entry.source != null ? stringOrHastToString(entry.source) : null;
-          extraFiles[fileName] = {
-            source: extraSource,
-            ...(entry.comments ? {
-              comments: entry.comments
-            } : {}),
-            ...(extraSource != null ? analyzeSource(extraSource) : {})
-          };
-        }
-      }
-    }
-    result[key] = {
-      ...variant,
-      source,
-      ...(source != null ? analyzeSource(source) : {}),
-      ...(extraFiles ? {
-        extraFiles
-      } : {})
-    };
-  }
-  return result;
-}
-
 /**
  * Hook for managing source code editing functionality.
  *
@@ -272,12 +44,28 @@ export function useSourceEditing({
   disabled
 }) {
   const contextSetCode = context?.setCode;
+  // The provider's editing-engine loader (shared with `useEditable`); dedupes the
+  // chunk fetch page-wide. Undefined without a provider → the built-in default.
+  const {
+    editingEngineLoader
+  } = useCodeContext();
+
+  // Monotonic token bumped by every `setSource`/`reset`. A cold first edit
+  // defers its commit into a microtask; if a later edit or a `reset` happens
+  // before the engine resolves, the stale deferred commit must NOT run (it would
+  // re-apply a superseded edit and, after a reset, reverse it). The deferred
+  // callback captures the token at schedule time and bails if it changed.
+  const editTokenRef = React.useRef(0);
   const setSource = React.useCallback((source, fileName, position, preParsed) => {
     if (!contextSetCode) {
       console.warn('setCode is not available in the current context. Ensure you are using CodeControllerContext.');
       return;
     }
 
+    // Mark this edit as the latest; a deferred (cold) commit checks this.
+    editTokenRef.current += 1;
+    const editToken = editTokenRef.current;
+
     // Stash any pre-computed parse result against the resolved file name
     // BEFORE the controlled-code update commits, so that the synchronous
     // `parseControlledCode` pass triggered by the resulting React render
@@ -293,80 +81,136 @@ export function useSourceEditing({
         hast: preParsed
       });
     }
-    contextSetCode(currentCode => {
-      const newCode = currentCode ? {
-        ...currentCode
-      } : toControlledCode(effectiveCode);
-      const variant = newCode[selectedVariantKey];
-      if (!variant) {
-        return newCode;
-      }
-      const effectiveFileName = fileName ?? selectedVariant?.fileName;
-      const isMainFile = effectiveFileName === selectedVariant?.fileName;
-      if (isMainFile) {
-        if (source === variant.source) {
-          return currentCode ?? newCode;
+    const applyUpdate = engine => {
+      contextSetCode(currentCode => {
+        const newCode = currentCode ? {
+          ...currentCode
+        } : engine.toControlledCode(effectiveCode, selectedVariantKey, context?.fallbacks, stringOrHastToString);
+        const variant = newCode[selectedVariantKey];
+        if (!variant) {
+          return newCode;
         }
-        const {
-          totalLines: newLineCount,
-          emptyLines: newEmptyLines
-        } = analyzeSource(source);
-        const oldLineCount = variant.totalLines ?? (variant.source != null ? analyzeSource(variant.source).totalLines : 0);
-        const {
-          comments: shiftedComments,
-          collapseMap: newCollapseMap
-        } = position ? shiftComments(variant.comments, newLineCount - oldLineCount, position, variant.collapseMap, variant.emptyLines) : {
-          comments: undefined,
-          collapseMap: undefined
-        };
-        newCode[selectedVariantKey] = {
-          ...variant,
-          source,
-          totalLines: newLineCount,
-          emptyLines: newEmptyLines,
-          comments: shiftedComments,
-          collapseMap: newCollapseMap
-        };
-      } else if (effectiveFileName) {
-        const extraEntry = variant.extraFiles?.[effectiveFileName];
-        if (source === extraEntry?.source) {
-          return currentCode ?? newCode;
-        }
-        const {
-          totalLines: newLineCount,
-          emptyLines: newEmptyLines
-        } = analyzeSource(source);
-        const oldLineCount = extraEntry?.totalLines ?? (extraEntry?.source != null ? analyzeSource(extraEntry.source).totalLines : 0);
-        const {
-          comments: shiftedComments,
-          collapseMap: newCollapseMap
-        } = position ? shiftComments(extraEntry?.comments, newLineCount - oldLineCount, position, extraEntry?.collapseMap, extraEntry?.emptyLines) : {
-          comments: undefined,
-          collapseMap: undefined
-        };
-        newCode[selectedVariantKey] = {
-          ...variant,
-          extraFiles: {
-            ...variant.extraFiles,
-            [effectiveFileName]: {
-              ...extraEntry,
-              source,
-              totalLines: newLineCount,
-              emptyLines: newEmptyLines,
-              comments: shiftedComments,
-              collapseMap: newCollapseMap
-            }
+        const effectiveFileName = fileName ?? selectedVariant?.fileName;
+        const isMainFile = effectiveFileName === selectedVariant?.fileName;
+
+        // Recompute the edited file's comment/window state for `source`.
+        // `shiftComments` shifts the comment map by the line delta relative to
+        // the edit position; on undo/redo the `position.history` flag tells it
+        // to reverse the edit (re-inserting deleted lines after the pre-edit
+        // caret), and its `collapseMap` restores comments that a deletion
+        // collapsed — so undo/redo is reversed from existing state, with no
+        // per-edit snapshots kept. `entry` is the file being edited (main
+        // variant or an extra file); both expose the same
+        // source/comments/collapseMap/totalLines/emptyLines shape.
+        const deriveFileState = (entry, nextSource) => {
+          // `analyzeSource` ignores a single trailing newline, so the host
+          // source (often unterminated) and the live contentEditable text
+          // (always terminated) report consistent line counts — the delta is
+          // 0 when no line was actually added or removed.
+          const {
+            totalLines,
+            emptyLines
+          } = engine.analyzeSource(nextSource);
+          if (!position) {
+            return {
+              comments: undefined,
+              collapseMap: undefined,
+              totalLines,
+              emptyLines
+            };
           }
+          const oldLineCount = entry?.totalLines ?? (entry?.source != null ? engine.analyzeSource(entry.source).totalLines : 0);
+          const {
+            comments,
+            collapseMap
+          } = engine.shiftComments(entry?.comments, totalLines - oldLineCount, position, entry?.collapseMap, entry?.emptyLines);
+          return {
+            comments,
+            collapseMap,
+            totalLines,
+            emptyLines
+          };
         };
-      }
-      return newCode;
-    });
-  }, [contextSetCode, selectedVariantKey, effectiveCode, selectedVariant, context?.preParsedCache]);
+        if (isMainFile) {
+          if (source === variant.source) {
+            return currentCode ?? newCode;
+          }
+          const {
+            totalLines,
+            emptyLines,
+            comments,
+            collapseMap
+          } = deriveFileState(variant, source);
+          newCode[selectedVariantKey] = {
+            ...variant,
+            source,
+            totalLines,
+            emptyLines,
+            comments,
+            collapseMap
+          };
+        } else if (effectiveFileName) {
+          const extraEntry = variant.extraFiles?.[effectiveFileName];
+          if (source === extraEntry?.source) {
+            return currentCode ?? newCode;
+          }
+          const {
+            totalLines,
+            emptyLines,
+            comments,
+            collapseMap
+          } = deriveFileState(extraEntry, source);
+          newCode[selectedVariantKey] = {
+            ...variant,
+            extraFiles: {
+              ...variant.extraFiles,
+              [effectiveFileName]: {
+                ...extraEntry,
+                source,
+                totalLines,
+                emptyLines,
+                comments,
+                collapseMap
+              }
+            }
+          };
+        }
+        return newCode;
+      });
+    };
+
+    // Apply synchronously from the warm cache (the common case — the warm
+    // effect below loads the engine as soon as the block is editable). On a
+    // cold first edit, defer this one update until the chunk resolves; later
+    // edits are synchronous.
+    const warmEngine = peekEditingEngine();
+    if (warmEngine) {
+      applyUpdate(warmEngine);
+    } else {
+      Promise.resolve(loadEditingEngine(editingEngineLoader)).then(loaded => {
+        // Bail if a later edit or a reset superseded this one while loading.
+        if (editTokenRef.current === editToken) {
+          applyUpdate(loaded);
+        }
+      }).catch(() => {});
+    }
+  }, [contextSetCode, selectedVariantKey, effectiveCode, selectedVariant, context?.preParsedCache, context?.fallbacks, editingEngineLoader]);
+
+  // Warm the edit-time runtime as soon as the block is editable, so the first
+  // edit applies synchronously (no flash). Read-only blocks never load it.
+  React.useEffect(() => {
+    if (peekEditingEngine() || !contextSetCode || disabled) {
+      return;
+    }
+    preloadEditingEngine(editingEngineLoader).catch(() => {});
+  }, [contextSetCode, disabled, editingEngineLoader]);
   const reset = React.useCallback(() => {
     if (!contextSetCode) {
       console.warn('setCode is not available in the current context. Ensure you are using CodeControllerContext.');
       return;
     }
+    // Supersede any pending cold edit so it can't re-apply after this reset.
+    editTokenRef.current += 1;
     contextSetCode(undefined);
   }, [contextSetCode]);
   const isEditable = !disabled && Boolean(contextSetCode) && Boolean(selectedVariant);

package/useCode/useSourceEnhancing.d.mts

@@ -1,4 +1,5 @@
 import type { SourceEnhancers, SourceComments, VariantSource } from "../CodeHighlighter/types.mjs";
+import type { FallbackNode } from "../CodeHighlighter/fallbackFormat.mjs";
 export interface UseSourceEnhancingProps {
   /** The source to enhance (from transformed files or variant) */
   source: VariantSource | null | undefined;
@@ -8,6 +9,8 @@ export interface UseSourceEnhancingProps {
   comments: SourceComments | undefined;
   /** Array of enhancer functions to apply */
   sourceEnhancers?: SourceEnhancers;
+  /** Fallback data for deriving the DEFLATE decompression dictionary */
+  fallback?: FallbackNode[];
 }
 export interface UseSourceEnhancingResult {
   /** The enhanced source */
@@ -19,5 +22,6 @@ export declare function useSourceEnhancing({
   source,
   fileName,
   comments,
-  sourceEnhancers
+  sourceEnhancers,
+  fallback
 }: UseSourceEnhancingProps): UseSourceEnhancingResult;

package/useCode/useSourceEnhancing.mjs

@@ -1,44 +1,29 @@
 'use client';
 
 import * as React from 'react';
-import { decompressHast } from "../pipeline/hastUtils/index.mjs";
+import { decodeHastSource } from "../pipeline/loadIsomorphicCodeVariant/decodeHastSource.mjs";
 import { recordEnhancerApplied, shouldSkipEnhancer } from "../pipeline/loadIsomorphicCodeVariant/runSourceEnhancers.mjs";
 
 /**
- * Type guard to check if a source value is a HAST root node.
- * Used to determine if the source can be enhanced.
- */
-function isHastRoot(source) {
-  if (typeof source !== 'object' || source === null) {
-    return false;
-  }
-  return 'type' in source && source.type === 'root';
-}
-
-/**
- * Resolves a VariantSource to a HastRoot if possible.
- * Handles decompression of compressed HAST and parsing of JSON HAST.
+ * Resolves a `VariantSource` to a HAST root that is safe to mutate.
  *
- * @param source - The source to resolve (can be HAST, hastJson, hastCompressed, or string)
- * @returns The resolved HastRoot or null if the source cannot be resolved
+ * Uses the shared `decodeHastSource` cache to amortize decompression and
+ * `JSON.parse` across other consumers (`Pre`, `useFileNavigation`,
+ * `sourceLineCounts`), then `structuredClone`s the result because the
+ * enhancer pipeline mutates `root.data` via `recordEnhancerApplied`.
+ * Returns `null` for string or unrecognized sources.
+ *
+ * The variant `fallback` is forwarded to `decodeHastSource` so the compressed
+ * payload is decompressed with the matching DEFLATE dictionary and each frame's
+ * `data.fallback` is restored — enhancers then keep that per-frame fallback in
+ * sync as they mutate the tree.
  */
-function resolveHastRoot(source) {
-  if (!source) {
+function resolveHastRoot(source, fallback) {
+  if (!source || typeof source === 'string') {
     return null;
   }
-  if (typeof source === 'string') {
-    return null; // String sources need parsing first
-  }
-  if ('hastJson' in source) {
-    return JSON.parse(source.hastJson);
-  }
-  if ('hastCompressed' in source) {
-    return JSON.parse(decompressHast(source.hastCompressed));
-  }
-  if (isHastRoot(source)) {
-    return source;
-  }
-  return null;
+  const cached = decodeHastSource(source, fallback);
+  return cached ? structuredClone(cached) : null;
 }
 
 /**
@@ -138,14 +123,14 @@ function applyEnhancersUntilAsync(source, comments, fileName, enhancers) {
  * Enhancers are run in order; sync ones apply immediately, and the first
  * async enhancer's promise is captured so it can be continued in an effect.
  */
-function computeEnhanceState(source, comments, fileName, sourceEnhancers) {
+function computeEnhanceState(source, comments, fileName, sourceEnhancers, fallback) {
   if (!source || !sourceEnhancers || sourceEnhancers.length === 0) {
     return {
       enhancedSource: source ?? null,
       asyncWork: null
     };
   }
-  const resolved = resolveHastRoot(source);
+  const resolved = resolveHastRoot(source, fallback);
   if (!resolved) {
     return {
       enhancedSource: source ?? null,
@@ -169,14 +154,15 @@ export function useSourceEnhancing({
   source,
   fileName,
   comments,
-  sourceEnhancers
+  sourceEnhancers,
+  fallback
 }) {
   // Track previous values to detect changes
   const [prevSource, setPrevSource] = React.useState(source);
   const [prevEnhancers, setPrevEnhancers] = React.useState(sourceEnhancers);
   const [prevComments, setPrevComments] = React.useState(comments);
   const [prevFileName, setPrevFileName] = React.useState(fileName);
-  const [state, setState] = React.useState(() => computeEnhanceState(source, comments, fileName, sourceEnhancers));
+  const [state, setState] = React.useState(() => computeEnhanceState(source, comments, fileName, sourceEnhancers, fallback));
   const hasChanged = source !== prevSource || sourceEnhancers !== prevEnhancers || comments !== prevComments || fileName !== prevFileName;
 
   // When inputs change, apply sync enhancers immediately during render
@@ -193,7 +179,7 @@ export function useSourceEnhancing({
     if (fileName !== prevFileName) {
       setPrevFileName(fileName);
     }
-    setState(computeEnhanceState(source, comments, fileName, sourceEnhancers));
+    setState(computeEnhanceState(source, comments, fileName, sourceEnhancers, fallback));
   }
 
   // Continue from the first async enhancer without re-running sync ones