@mui/internal-docs-infra 0.10.1-canary.6 → 0.11.1-canary.0

package/CodeControllerContext/CodeControllerContext.d.mts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import type { ControlledCode } from "../CodeHighlighter/types.mjs";
+import type { ControlledCode, SourceEnhancers } from "../CodeHighlighter/types.mjs";
 export type Selection = {
   variant: string;
   fileName?: string;
@@ -43,6 +43,11 @@ export interface CodeControllerContext {
    * e.g. `{ variantA: {}, variantB: {} }`.
    */
   components?: Record<string, React.ReactNode> | undefined;
+  /**
+   * Additional source enhancers to apply to parsed HAST sources.
+   * These are merged with enhancers from CodeProvider and useCode opts.
+   */
+  sourceEnhancers?: SourceEnhancers;
 }
 export declare const CodeControllerContext: React.Context<CodeControllerContext | undefined>;
 /**
@@ -66,4 +71,5 @@ export declare function useControlledCode(): {
   setCode: React.Dispatch<React.SetStateAction<ControlledCode | undefined>> | undefined;
   setSelection: React.Dispatch<React.SetStateAction<Selection>> | undefined;
   components: Record<string, React.ReactNode> | undefined;
+  sourceEnhancers: SourceEnhancers | undefined;
 };

package/CodeControllerContext/CodeControllerContext.mjs

@@ -35,6 +35,7 @@ export function useControlledCode() {
     selection: context?.selection,
     setCode: context?.setCode,
     setSelection: context?.setSelection,
-    components: context?.components
+    components: context?.components,
+    sourceEnhancers: context?.sourceEnhancers
   };
 }

package/CodeHighlighter/CodeHighlighterClient.mjs

@@ -354,7 +354,8 @@ function useCodeTransforms({
 function useControlledCodeParsing({
   code,
   forceClient,
-  url
+  url,
+  preParsedCache
 }) {
   const {
     parseSource,
@@ -384,8 +385,8 @@ function useControlledCodeParsing({
       }
       return undefined;
     }
-    return parseControlledCode(code, parseSource);
-  }, [code, parseSource, parseControlledCode, forceClient, url]);
+    return parseControlledCode(code, parseSource, preParsedCache);
+  }, [code, parseSource, parseControlledCode, forceClient, url, preParsedCache]);
   return {
     parsedControlledCode
   };
@@ -790,12 +791,20 @@ export function CodeHighlighterClient(props) {
     parsedCode,
     variantName
   });
+
+  // Per-highlighter pre-parsed HAST cache. Lives in a ref so the same Map
+  // instance is shared across renders without becoming a React dep. The
+  // editable populates it via `useSourceEditing` (which reads it from
+  // `CodeHighlighterContext`), and `parseControlledCode` consults it on
+  // every render to skip the sync main-thread parse on exact source matches.
+  const [preParsedCache] = React.useState(() => new Map());
   const {
     parsedControlledCode
   } = useControlledCodeParsing({
     code: controlled?.code,
     forceClient: props.forceClient,
-    url: props.url
+    url: props.url,
+    preParsedCache
   });
 
   // Determine the final overlaid code (controlled takes precedence)
@@ -803,7 +812,7 @@ export function CodeHighlighterClient(props) {
 
   // For fallback context, use the processed code or fall back to non-controlled code
   const codeForFallback = overlaidCode || (controlled?.code ? undefined : props.code || code);
-  const fallbackContext = React.useMemo(() => codeToFallbackProps(variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants), [variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants]);
+  const fallbackContext = React.useMemo(() => activeCodeReady ? undefined : codeToFallbackProps(variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants), [activeCodeReady, variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants]);
   const context = React.useMemo(() => ({
     code: overlaidCode,
     // Use processed/transformed code
@@ -813,8 +822,9 @@ export function CodeHighlighterClient(props) {
     components: controlled?.components || props.components,
     availableTransforms: isControlled ? [] : availableTransforms,
     url: props.url,
-    deferHighlight
-  }), [overlaidCode, controlled?.setCode, selection, controlled?.selection, controlled?.setSelection, controlled?.components, props.components, isControlled, availableTransforms, props.url, deferHighlight]);
+    deferHighlight,
+    preParsedCache
+  }), [overlaidCode, controlled?.setCode, selection, controlled?.selection, controlled?.setSelection, controlled?.components, props.components, isControlled, availableTransforms, props.url, deferHighlight, preParsedCache]);
   if (!props.variants && !props.components && !activeCode) {
     throw new Errors.ErrorCodeHighlighterClientMissingData();
   }

package/CodeHighlighter/CodeHighlighterContext.d.mts

@@ -1,6 +1,17 @@
 import * as React from 'react';
-import { type Code, type ControlledCode } from "./types.mjs";
+import { type Code, type ControlledCode, type HastRoot } from "./types.mjs";
 import { type Selection } from "../CodeControllerContext/index.mjs";
+/**
+ * One cached pre-parsed file. Stored per-fileName: each new write replaces
+ * any previous entry for that file. The `source` string is the cache key —
+ * `parseControlledCode` only reuses `hast` when the controlled-code source
+ * is byte-identical, which guarantees the cached HAST matches the input
+ * that produced it.
+ */
+export interface PreParsedCacheEntry {
+  source: string;
+  hast: HastRoot;
+}
 export interface CodeHighlighterContextType {
   code?: Code;
   setCode?: React.Dispatch<React.SetStateAction<ControlledCode | undefined>>;
@@ -10,6 +21,15 @@ export interface CodeHighlighterContextType {
   availableTransforms?: string[];
   url?: string;
   deferHighlight?: boolean;
+  /**
+   * Per-file pre-parsed HAST cache. Populated by `useSourceEditing` when the
+   * editable supplies a worker-parsed result alongside a source change, and
+   * read by `parseControlledCode` to skip the (sync, main-thread) parse on
+   * exact source matches. Owned by `CodeHighlighterClient` via `useRef` so
+   * the same `Map` instance is shared across render cycles without being a
+   * React dep.
+   */
+  preParsedCache?: Map<string, PreParsedCacheEntry>;
 }
 export declare const CodeHighlighterContext: React.Context<CodeHighlighterContextType | undefined>;
 export declare function useCodeHighlighterContext(): CodeHighlighterContextType;

package/CodeHighlighter/CodeHighlighterContext.mjs

@@ -1,6 +1,15 @@
 'use client';
 
 import * as React from 'react';
+
+/**
+ * One cached pre-parsed file. Stored per-fileName: each new write replaces
+ * any previous entry for that file. The `source` string is the cache key —
+ * `parseControlledCode` only reuses `hast` when the controlled-code source
+ * is byte-identical, which guarantees the cached HAST matches the input
+ * that produced it.
+ */
+
 export const CodeHighlighterContext = /*#__PURE__*/React.createContext(undefined);
 if (process.env.NODE_ENV !== "production") CodeHighlighterContext.displayName = "CodeHighlighterContext";
 export function useCodeHighlighterContext() {

package/CodeHighlighter/parseControlledCode.d.mts

@@ -1,6 +1,13 @@
 import type { Code, ControlledCode, ParseSource } from "./types.mjs";
+import type { PreParsedCacheEntry } from "./CodeHighlighterContext.mjs";
 /**
  * Pure function to parse controlled code and convert it to regular Code format.
  * Handles the conversion from ControlledCode (string|null sources) to Code (HAST nodes).
+ *
+ * When `preParsedCache` is supplied, each file's source is first looked up in
+ * the cache. If the cached entry's source string matches byte-for-byte, the
+ * cached HAST is reused and `parseSource` is skipped for that file. On a
+ * mismatch the stale entry is evicted before re-parsing so the cache cannot
+ * grow stale across rapid edits.
  */
-export declare function parseControlledCode(controlledCode: ControlledCode, parseSource: ParseSource): Code;
+export declare function parseControlledCode(controlledCode: ControlledCode, parseSource: ParseSource, preParsedCache?: Map<string, PreParsedCacheEntry>): Code;

package/CodeHighlighter/parseControlledCode.mjs

@@ -1,8 +1,32 @@
 /**
  * Pure function to parse controlled code and convert it to regular Code format.
  * Handles the conversion from ControlledCode (string|null sources) to Code (HAST nodes).
+ *
+ * When `preParsedCache` is supplied, each file's source is first looked up in
+ * the cache. If the cached entry's source string matches byte-for-byte, the
+ * cached HAST is reused and `parseSource` is skipped for that file. On a
+ * mismatch the stale entry is evicted before re-parsing so the cache cannot
+ * grow stale across rapid edits.
  */
-export function parseControlledCode(controlledCode, parseSource) {
+export function parseControlledCode(controlledCode, parseSource, preParsedCache) {
+  /**
+   * Try the cache for `fileName`/`source`. Returns the cached HAST on an
+   * exact match; evicts and returns `undefined` on a mismatch.
+   */
+  const tryCache = (fileName, source) => {
+    if (!preParsedCache) {
+      return undefined;
+    }
+    const entry = preParsedCache.get(fileName);
+    if (!entry) {
+      return undefined;
+    }
+    if (entry.source === source) {
+      return entry.hast;
+    }
+    preParsedCache.delete(fileName);
+    return undefined;
+  };
   const parsed = {};
   for (const [variant, variantCode] of Object.entries(controlledCode)) {
     if (variantCode === null) {
@@ -15,11 +39,16 @@ export function parseControlledCode(controlledCode, parseSource) {
       // Convert null to empty string, then parse
       const sourceToProcess = variantCode.source === null ? '' : variantCode.source;
       if (typeof sourceToProcess === 'string' && variantCode.fileName) {
-        try {
-          mainSource = parseSource(sourceToProcess, variantCode.fileName);
-        } catch (error) {
-          // Keep original string if parsing fails
-          mainSource = sourceToProcess;
+        const cached = tryCache(variantCode.fileName, sourceToProcess);
+        if (cached) {
+          mainSource = cached;
+        } else {
+          try {
+            mainSource = parseSource(sourceToProcess, variantCode.fileName);
+          } catch (error) {
+            // Keep original string if parsing fails
+            mainSource = sourceToProcess;
+          }
         }
       } else if (typeof sourceToProcess === 'string' && !variantCode.fileName) {
         // Return a basic HAST root node with the source text for unsupported file types
@@ -45,22 +74,32 @@ export function parseControlledCode(controlledCode, parseSource) {
           // Convert null to empty string, then parse
           const fileSourceToProcess = fileData.source === null ? '' : fileData.source;
           if (typeof fileSourceToProcess === 'string') {
-            // Parse string sources
-            try {
-              const parsedSource = parseSource(fileSourceToProcess, fileName);
-              parsedExtraFiles[fileName] = {
-                source: parsedSource
-              };
-            } catch (error) {
-              // Keep original if parsing fails
+            const cached = tryCache(fileName, fileSourceToProcess);
+            if (cached) {
               parsedExtraFiles[fileName] = {
-                source: fileSourceToProcess
+                source: cached,
+                comments: fileData.comments
               };
+            } else {
+              try {
+                const parsedSource = parseSource(fileSourceToProcess, fileName);
+                parsedExtraFiles[fileName] = {
+                  source: parsedSource,
+                  comments: fileData.comments
+                };
+              } catch (error) {
+                // Keep original if parsing fails
+                parsedExtraFiles[fileName] = {
+                  source: fileSourceToProcess,
+                  comments: fileData.comments
+                };
+              }
             }
           } else {
             // Keep other values as-is
             parsedExtraFiles[fileName] = {
-              source: fileSourceToProcess
+              source: fileSourceToProcess,
+              comments: fileData.comments
             };
           }
         }
@@ -71,7 +110,8 @@ export function parseControlledCode(controlledCode, parseSource) {
         url: variantCode.url,
         source: mainSource,
         extraFiles,
-        filesOrder: variantCode.filesOrder
+        filesOrder: variantCode.filesOrder,
+        comments: variantCode.comments
       };
     }
   }

package/CodeHighlighter/types.d.mts

@@ -26,6 +26,7 @@ export interface HastRoot extends Root {
     totalLines?: number;
     collapsible?: boolean;
     frameSize?: number;
+    appliedEnhancers?: string[];
   };
 }
 export type VariantSource = string | HastRoot | {
@@ -86,9 +87,22 @@ export type VariantCode = CodeMeta & {
 export type Code = {
   [key: string]: undefined | string | VariantCode;
 };
+/**
+ * Tracks comments that were collapsed onto a line when their original lines
+ * were deleted. Keyed by the line they collapsed onto; each entry records
+ * the original offset from the edit line so the collapse can be reversed.
+ */
+export type CollapseMap = Record<number, Array<{
+  offset: number;
+  comments: string[];
+}>>;
 export type ControlledVariantExtraFiles = {
   [fileName: string]: {
     source: string | null;
+    comments?: SourceComments;
+    collapseMap?: CollapseMap;
+    totalLines?: number;
+    emptyLines?: number[];
   };
 };
 export type ControlledVariantCode = CodeMeta & {
@@ -96,6 +110,10 @@ export type ControlledVariantCode = CodeMeta & {
   source?: string | null;
   extraFiles?: ControlledVariantExtraFiles;
   filesOrder?: string[];
+  comments?: SourceComments;
+  collapseMap?: CollapseMap;
+  totalLines?: number;
+  emptyLines?: number[];
 };
 export type ControlledCode = {
   [key: string]: undefined | null | ControlledVariantCode;
@@ -162,7 +180,16 @@ export type SourceComments = Record<number, string[]>;
  * @param fileName - The name of the file being processed
  * @returns The enhanced HAST root node (can be the same object, mutated)
  */
-export type SourceEnhancer = (root: HastRoot, comments: SourceComments | undefined, fileName: string) => HastRoot | Promise<HastRoot>;
+export interface SourceEnhancer {
+  (root: HastRoot, comments: SourceComments | undefined, fileName: string): HastRoot | Promise<HastRoot>;
+  /**
+   * Stable identifier for this enhancer. When set, the enhancer is recorded on
+   * the HAST root as `data.appliedEnhancers` after it runs, and subsequent
+   * passes (e.g. on the client after a server-side run) skip it instead of
+   * re-applying. Anonymous enhancers always run.
+   */
+  enhancerName?: string;
+}
 /**
  * Array of source enhancer functions that run in order after parsing.
  */

package/CodeProvider/CodeContext.d.mts

@@ -1,5 +1,7 @@
 import * as React from 'react';
 import type { LoadCodeMeta, LoadSource, LoadVariantMeta, ParseSource, SourceTransformers, SourceEnhancers, Code, ControlledCode, LoadFallbackCodeOptions, LoadVariantOptions, Externals, VariantCode } from "../CodeHighlighter/types.mjs";
+import type { ParseSourceAsync } from "./createParseSourceWorkerClient.mjs";
+import type { PreParsedCacheEntry } from "../CodeHighlighter/CodeHighlighterContext.mjs";
 export type LoadFallbackCodeFn = (url: string, initialVariant: string, loaded: Code | undefined, options?: LoadFallbackCodeOptions) => Promise<{
   code: Code;
   processedGlobalsCode?: Array<Code>;
@@ -10,7 +12,7 @@ export type LoadVariantFn = (url: string | undefined, variantName: string, varia
   externals: Externals;
 }>;
 export type ParseCodeFn = (code: Code, parseSource: ParseSource) => Code;
-export type ParseControlledCodeFn = (controlledCode: ControlledCode, parseSource: ParseSource) => Code;
+export type ParseControlledCodeFn = (controlledCode: ControlledCode, parseSource: ParseSource, preParsedCache?: Map<string, PreParsedCacheEntry>) => Code;
 export type ComputeHastDeltasFn = (parsedCode: Code, parseSource: ParseSource) => Promise<Code>;
 export type GetAvailableTransformsFn = (parsedCode: Code | undefined, variantName: string) => string[];
 /**
@@ -22,6 +24,12 @@ export interface CodeContext {
   sourceParser?: Promise<ParseSource>;
   /** Sync parser available after initial load completes */
   parseSource?: ParseSource;
+  /**
+   * Worker-backed asynchronous parser used for non-blocking syntax
+   * highlighting during live editing. Available in browser environments
+   * after the worker has initialized.
+   */
+  parseSourceAsync?: ParseSourceAsync;
   /** Source transformers for code transformation (e.g., TypeScript to JavaScript) */
   sourceTransformers?: SourceTransformers;
   /** Source enhancers for modifying parsed HAST */

package/CodeProvider/CodeProvider.mjs

@@ -1,17 +1,17 @@
 'use client';
 
 import * as React from 'react';
-import { createStarryNight } from '@wooorm/starry-night';
 import { CodeContext } from "./CodeContext.mjs";
-import { extensionMap, grammars } from "../pipeline/parseSource/grammars.mjs";
-import { starryNightGutter } from "../pipeline/parseSource/addLineGutters.mjs";
-import { extendSyntaxTokens } from "../pipeline/parseSource/extendSyntaxTokens.mjs";
+import { enhanceCodeEmphasis } from "../pipeline/enhanceCodeEmphasis/index.mjs";
+import { createParseSource } from "../pipeline/parseSource/parseSource.mjs";
 // Import the heavy functions
 import { loadCodeFallback } from "../pipeline/loadCodeVariant/loadCodeFallback.mjs";
 import { loadCodeVariant } from "../pipeline/loadCodeVariant/loadCodeVariant.mjs";
 import { parseCode } from "../pipeline/loadCodeVariant/parseCode.mjs";
 import { parseControlledCode } from "../CodeHighlighter/parseControlledCode.mjs";
 import { computeHastDeltas, getAvailableTransforms } from "../pipeline/loadCodeVariant/computeHastDeltas.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+const DEFAULT_SOURCE_ENHANCERS = [enhanceCodeEmphasis];
 
 /**
  * Provides client-side functions for fetching source code and highlighting it.
@@ -21,15 +21,15 @@ import { computeHastDeltas, getAvailableTransforms } from "../pipeline/loadCodeV
  * Implements the Props Context Layering pattern by providing heavy functions
  * via context that can't be serialized across the server-client boundary.
  */
-import { jsx as _jsx } from "react/jsx-runtime";
 export function CodeProvider({
   children,
   loadCodeMeta,
   loadVariantMeta,
   loadSource,
-  sourceEnhancers
+  sourceEnhancers = DEFAULT_SOURCE_ENHANCERS
 }) {
   const [parseSource, setParseSource] = React.useState(undefined);
+  const [parseSourceAsync, setParseSourceAsync] = React.useState(undefined);
   const sourceParser = React.useMemo(() => {
     // Only initialize Starry Night in the browser, not during SSR
     if (typeof window === 'undefined') {
@@ -37,38 +37,79 @@ export function CodeProvider({
         throw new Error('parseSource not available during SSR');
       });
     }
-    return createStarryNight(grammars).then(starryNight => {
-      const parseSourceFn = (source, fileName) => {
-        const fileType = fileName.slice(fileName.lastIndexOf('.'));
-        if (!extensionMap[fileType]) {
-          // Return a basic HAST root node with the source text for unsupported file types
-          return {
-            type: 'root',
-            children: [{
-              type: 'text',
-              value: source
-            }]
-          };
-        }
-        const grammarScope = extensionMap[fileType];
-        const highlighted = starryNight.highlight(source, grammarScope);
-        extendSyntaxTokens(highlighted, grammarScope);
-        const sourceLines = source.split(/\r?\n|\r/);
-        starryNightGutter(highlighted, sourceLines); // mutates the tree to add line gutters
-
-        return highlighted;
-      };
-      return parseSourceFn;
-    });
+    return createParseSource();
   }, []);
   React.useEffect(() => {
     // Update the sync version when available
     sourceParser.then(parseSourceFn => setParseSource(() => parseSourceFn));
   }, [sourceParser]);
+
+  // Worker for off-main-thread parsing during live editing. Lazily created
+  // once per provider, browser-only, and torn down on unmount. The worker
+  // client module is dynamically imported so the `new URL('./parseSourceWorker.ts',
+  // import.meta.url)` call (which bundlers resolve to a separate worker chunk)
+  // never runs in SSR bundles.
+  const workerRef = React.useRef(null);
+  React.useEffect(() => {
+    if (typeof window === 'undefined' || typeof Worker === 'undefined') {
+      return undefined;
+    }
+    let cancelled = false;
+    let client;
+    Promise.all([import("./createParseSourceWorkerClient.mjs"),
+    // Share the same (lazy) grammar chunk that `createParseSource()` uses,
+    // so the heavy TextMate JSON is fetched at most once per page load and
+    // then `postMessage`d into the worker.
+    import("../pipeline/parseSource/grammars.mjs")]).then(([{
+      createParseSourceWorkerClient
+    }, {
+      grammars
+    }]) => {
+      if (cancelled) {
+        return;
+      }
+      // `createParseSourceWorkerClient()` throws synchronously on browsers
+      // that expose `Worker` but reject module workers (the typeof gate
+      // above can't detect that). Treat the failure as "no async parser
+      // available" so consumers transparently fall back to the synchronous
+      // highlighter instead of leaving an unhandled rejection on the page.
+      try {
+        client = createParseSourceWorkerClient();
+      } catch {
+        return;
+      }
+      workerRef.current = client;
+      client.init(grammars).then(() => {
+        if (cancelled) {
+          return;
+        }
+        setParseSourceAsync(() => client.parseSourceAsync);
+      }).catch(() => {
+        // Worker-side init failure (e.g. `createStarryNight` rejected).
+        // Tear down so we don't leak the worker, and leave
+        // `parseSourceAsync` undefined so consumers fall back to sync.
+        if (workerRef.current === client) {
+          workerRef.current = null;
+        }
+        client?.terminate();
+        client = undefined;
+      });
+    }).catch(() => {
+      // Dynamic-import failure (network error, missing chunk). Same
+      // fallback policy: stay on the main-thread highlighter.
+    });
+    return () => {
+      cancelled = true;
+      workerRef.current = null;
+      client?.terminate();
+    };
+  }, []);
   const context = React.useMemo(() => ({
     sourceParser,
     parseSource,
     // Sync version when available
+    parseSourceAsync,
+    // Worker-backed async version when available
     loadSource,
     loadVariantMeta,
     loadCodeMeta,
@@ -80,7 +121,7 @@ export function CodeProvider({
     parseControlledCode,
     computeHastDeltas,
     getAvailableTransforms
-  }), [sourceParser, parseSource, loadSource, loadVariantMeta, loadCodeMeta, sourceEnhancers]);
+  }), [sourceParser, parseSource, parseSourceAsync, loadSource, loadVariantMeta, loadCodeMeta, sourceEnhancers]);
   return /*#__PURE__*/_jsx(CodeContext.Provider, {
     value: context,
     children: children

package/CodeProvider/createParseSourceWorkerClient.d.mts

@@ -0,0 +1,41 @@
+import type { Root as HastRoot } from 'hast';
+import type { createStarryNight } from '@wooorm/starry-night';
+type Grammar = Parameters<typeof createStarryNight>[0][number];
+/**
+ * Asynchronously parses source code into a HAST tree, typically off the main
+ * thread (e.g. via a Web Worker). Used during live typing so the UI thread
+ * stays responsive. Accepts an `AbortSignal` so a stale request can be
+ * cancelled when newer keystrokes arrive.
+ *
+ * Internal: not exported as part of the public API. Consumers wire up async
+ * parsing by passing a worker URL to `CodeProvider`; the produced client
+ * exposes a `parseSourceAsync` callable directly without referring to this
+ * type.
+ */
+export type ParseSourceAsync = (source: string, fileName: string, language?: string, signal?: AbortSignal) => Promise<HastRoot>;
+export interface ParseSourceWorkerClient {
+  /**
+   * Send the (heavy) grammar payload to the worker. Idempotent: subsequent
+   * calls return the same promise. Must be awaited (or composed via
+   * `parseSourceAsync`, which awaits it implicitly) before parse requests
+   * will be processed.
+   */
+  init(grammars: Grammar[]): Promise<void>;
+  /**
+   * Async syntax-highlighter that runs inside the worker. Returns the same
+   * HAST shape as the sync `parseSource`. If `signal` aborts before the
+   * worker responds, the in-flight request is dropped and the promise
+   * rejects with `signal.reason`.
+   */
+  parseSourceAsync: ParseSourceAsync;
+  terminate(): void;
+}
+/**
+ * Create a worker-backed `parseSourceAsync` implementation. The caller owns
+ * the lifecycle and must invoke `terminate()` on unmount.
+ *
+ * Each client owns exactly one underlying `Worker`. Concurrent in-flight
+ * requests are demuxed by a monotonically increasing `id`.
+ */
+export declare function createParseSourceWorkerClient(): ParseSourceWorkerClient;
+export {};