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

package/pipeline/loadIsomorphicCodeVariant/embedTransforms.mjs

@@ -0,0 +1,152 @@
+/**
+ * Recursively walks a jsondiffpatch delta looking for any inserted hast
+ * element with `className === 'collapse'`. Used to mark a manifest entry
+ * as layout-affecting (phase 1, coordinated barrier so peers stay in
+ * lockstep) so the runtime doesn't have to decompress the embedded hast
+ * payload on every selection change to classify the swap.
+ *
+ * Walks every nested value rather than interpreting jsondiffpatch's
+ * opcodes (`[value]` for insert, `[oldValue, 0, 0]` for delete, `_t: 'a'`
+ * + `_N` keys for array ops). The collapse placeholder is only ever
+ * produced by `compactCollapseInTreeInPlace` on the *transform* side of
+ * the diff, so any hast element with className 'collapse' anywhere in
+ * the delta tree is necessarily part of an insertion or in-place rewrite.
+ */
+export function deltaContainsCollapse(delta) {
+  if (delta === null || typeof delta !== 'object') {
+    return false;
+  }
+  const candidate = delta;
+  if (candidate.type === 'element') {
+    const cls = candidate.properties?.className;
+    if (cls === 'collapse') {
+      return true;
+    }
+    if (Array.isArray(cls) && cls.includes('collapse')) {
+      return true;
+    }
+  }
+  if (Array.isArray(delta)) {
+    for (const item of delta) {
+      if (deltaContainsCollapse(item)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  for (const value of Object.values(delta)) {
+    if (deltaContainsCollapse(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Splits a `Transforms` map (as produced by `diffHast`, which always
+ * carries deltas for entries that change the source — rename-only
+ * entries pass through with no delta) into the variant-level `manifest`
+ * (no `delta`) and the `embedded` map that should ride inside
+ * `source.data.transforms`.
+ *
+ * Entries with a meaningful delta land in both the manifest (with
+ * `hasDelta: true`) and the embedded map. Rename-only entries (no
+ * delta but a renamed `fileName`) land only in the manifest with
+ * `hasDelta` omitted or `false`; consumers use this flag to hide the
+ * transform toggle while still applying the rename when the user has
+ * the matching transform preference selected. Entries with neither a
+ * delta nor a rename are dropped from both.
+ *
+ * Returns `undefined` when no entry survived — callers should treat that
+ * as "no transforms to record".
+ *
+ * This is the single source of truth for the manifest / embedded split;
+ * both `computeHastDeltas` (per-file diffs) and the variant-level embed
+ * step in `loadIsomorphicCodeVariant` go through it so the wire shape
+ * stays consistent.
+ */
+export function splitTransformsForEmbed(transforms) {
+  const manifest = {};
+  const embedded = {};
+  let kept = false;
+  for (const [transformKey, transformValue] of Object.entries(transforms)) {
+    if (!transformValue) {
+      continue;
+    }
+    const hasMeaningfulDelta = !!transformValue.delta && typeof transformValue.delta === 'object' && Object.keys(transformValue.delta).length > 0;
+    const renamed = !!transformValue.fileName;
+    if (hasMeaningfulDelta) {
+      embedded[transformKey] = transformValue;
+      // The manifest entry keeps every field except `delta` (which only
+      // ever travels embedded inside `root.data.transforms`). In
+      // particular `comments` must survive serialization: transformers
+      // that add or relocate lines emit an explicit post-transform map,
+      // and the client-side `applyCodeTransformWithComments` consults
+      // it in preference to the auto-shift fallback. Dropping it here
+      // would silently downgrade those transforms to the wipe-only
+      // remap path on hydrated payloads. `hasDelta: true` flags this
+      // entry for `getAvailableTransforms` so the transform toggle is
+      // surfaced in the UI. `hasCollapse` is propagated here so the
+      // runtime can classify the swap as layout-affecting (phase 1)
+      // versus non-layout (phase 2) without decompressing the embedded
+      // hast payload — `diffHast` sets it directly from
+      // `wiped.size > 0`; the `deltaContainsCollapse` walk only runs
+      // for legacy callers that build a `Transforms` map without going
+      // through `diffHast`.
+      const hasCollapse = transformValue.hasCollapse ?? deltaContainsCollapse(transformValue.delta);
+      // `hasCollapseInFocus` only ever comes from `diffHast`; legacy
+      // callers (that bypass the diff and so never set it) fall back
+      // to `hasCollapse`, matching the pre-focus behavior of the
+      // runtime classifier.
+      const hasCollapseInFocus = transformValue.hasCollapseInFocus ?? hasCollapse;
+      const manifestEntry = {
+        ...transformValue,
+        hasDelta: true,
+        hasCollapse,
+        hasCollapseInFocus
+      };
+      delete manifestEntry.delta;
+      manifest[transformKey] = manifestEntry;
+      kept = true;
+    } else if (renamed) {
+      // Rename-only entry: no source-level change, just a `fileName`
+      // (and optionally `comments`). Keep it in the manifest so the
+      // runtime can still apply the rename when the user has the
+      // matching transform preference selected, but skip embedding —
+      // there's no delta to ride along inside `source.data.transforms`.
+      const {
+        delta: droppedDelta,
+        hasDelta: droppedHasDelta,
+        hasCollapse: droppedHasCollapse,
+        hasCollapseInFocus: droppedHasCollapseInFocus,
+        ...rest
+      } = transformValue;
+      manifest[transformKey] = {
+        ...rest,
+        hasDelta: false,
+        hasCollapse: false,
+        hasCollapseInFocus: false
+      };
+      kept = true;
+    }
+  }
+  if (!kept) {
+    return undefined;
+  }
+  return {
+    manifest,
+    embedded
+  };
+}
+
+/**
+ * Embeds `embedded` transforms inside `root.data.transforms` so they ride
+ * along inside the (possibly later compressed) hast payload and stay out
+ * of the variant-level wire shape that ends up in HTML / module graph.
+ */
+export function embedTransformsInRoot(root, embedded) {
+  root.data = {
+    ...(root.data || {}),
+    transforms: embedded
+  };
+}

package/pipeline/loadIsomorphicCodeVariant/findExpandingRanges.d.mts

@@ -0,0 +1,51 @@
+import type { SourceComments } from "../../CodeHighlighter/types.mjs";
+/**
+ * Sentinel substrings a transformer puts into its returned `comments`
+ * map to mark newly-added lines that should animate in (when the
+ * transform is applied) or out (when it is reverted). The markers are
+ * metadata only — they never appear in the rendered source text.
+ * Detection is substring-based so callers can decorate them however
+ * reads best alongside any neighbouring comments
+ * (e.g. `'// @expanding-start (api key)'`).
+ *
+ * Two flavours:
+ * - `@expanding-start` / `@expanding-end` delimit a contiguous,
+ *   multi-line range (inclusive on both ends).
+ * - `@expanding` on its own marks a single added line — equivalent
+ *   to a same-line start+end pair, but easier to write when the
+ *   addition is just one line.
+ */
+export declare const EXPANDING_START_MARKER = "@expanding-start";
+export declare const EXPANDING_END_MARKER = "@expanding-end";
+export declare const EXPANDING_SINGLE_MARKER = "@expanding";
+/**
+ * Scans a `SourceComments` map for `@expanding`, `@expanding-start`,
+ * and `@expanding-end` markers and returns the inclusive 1-indexed
+ * line ranges they delimit.
+ *
+ * Pairing rule: walk lines in ascending order. A standalone
+ * `@expanding` immediately produces a single-line `[line, line]`
+ * range. For ranges, the first `@expanding-start` opens a range and
+ * the next `@expanding-end` closes it. Unpaired range markers (a
+ * start with no matching end, or an end with no preceding start) are
+ * silently dropped — the most likely cause is a transformer
+ * mid-iteration and the safe behaviour is "no animation for that
+ * fragment" rather than either crashing or animating an unbounded
+ * region. Nested or overlapping ranges are not supported; a second
+ * `@expanding-start` before the previous one is closed replaces the
+ * open range's start.
+ *
+ * @param comments - The remapped 1-indexed comments map.
+ * @returns Sorted `[startLine, endLine]` pairs (inclusive on both
+ *   ends). Returns an empty array when `comments` is `undefined`,
+ *   empty, or contains no markers.
+ */
+export declare function findExpandingRanges(comments: SourceComments | undefined): Array<[number, number]>;
+/**
+ * Fast yes/no check used by the pipeline's layout-shift classifier so
+ * it can avoid materialising the full `findExpandingRanges` array when
+ * all it needs is a boolean. Equivalent to
+ * `findExpandingRanges(...).length > 0` but short-circuits on the first
+ * matched marker.
+ */
+export declare function hasExpandingRanges(comments: SourceComments | undefined): boolean;

package/pipeline/loadIsomorphicCodeVariant/findExpandingRanges.mjs

@@ -0,0 +1,161 @@
+/**
+ * Sentinel substrings a transformer puts into its returned `comments`
+ * map to mark newly-added lines that should animate in (when the
+ * transform is applied) or out (when it is reverted). The markers are
+ * metadata only — they never appear in the rendered source text.
+ * Detection is substring-based so callers can decorate them however
+ * reads best alongside any neighbouring comments
+ * (e.g. `'// @expanding-start (api key)'`).
+ *
+ * Two flavours:
+ * - `@expanding-start` / `@expanding-end` delimit a contiguous,
+ *   multi-line range (inclusive on both ends).
+ * - `@expanding` on its own marks a single added line — equivalent
+ *   to a same-line start+end pair, but easier to write when the
+ *   addition is just one line.
+ */
+export const EXPANDING_START_MARKER = '@expanding-start';
+export const EXPANDING_END_MARKER = '@expanding-end';
+export const EXPANDING_SINGLE_MARKER = '@expanding';
+
+// `@expanding` not followed by `-` — distinguishes the single-line
+// marker from the `-start` / `-end` variants without false matches.
+const SINGLE_MARKER_PATTERN = /@expanding(?!-)/;
+function classifyEntries(entries) {
+  let hasStart = false;
+  let hasEnd = false;
+  let hasSingle = false;
+  if (!entries) {
+    return {
+      hasStart,
+      hasEnd,
+      hasSingle
+    };
+  }
+  for (const entry of entries) {
+    if (typeof entry !== 'string') {
+      continue;
+    }
+    if (entry.includes(EXPANDING_START_MARKER)) {
+      hasStart = true;
+    }
+    if (entry.includes(EXPANDING_END_MARKER)) {
+      hasEnd = true;
+    }
+    if (SINGLE_MARKER_PATTERN.test(entry)) {
+      hasSingle = true;
+    }
+  }
+  return {
+    hasStart,
+    hasEnd,
+    hasSingle
+  };
+}
+function collectLineNumbers(comments) {
+  const lineNumbers = [];
+  for (const key of Object.keys(comments)) {
+    const line = Number(key);
+    if (Number.isFinite(line) && line > 0) {
+      lineNumbers.push(line);
+    }
+  }
+  lineNumbers.sort((a, b) => a - b);
+  return lineNumbers;
+}
+
+/**
+ * Scans a `SourceComments` map for `@expanding`, `@expanding-start`,
+ * and `@expanding-end` markers and returns the inclusive 1-indexed
+ * line ranges they delimit.
+ *
+ * Pairing rule: walk lines in ascending order. A standalone
+ * `@expanding` immediately produces a single-line `[line, line]`
+ * range. For ranges, the first `@expanding-start` opens a range and
+ * the next `@expanding-end` closes it. Unpaired range markers (a
+ * start with no matching end, or an end with no preceding start) are
+ * silently dropped — the most likely cause is a transformer
+ * mid-iteration and the safe behaviour is "no animation for that
+ * fragment" rather than either crashing or animating an unbounded
+ * region. Nested or overlapping ranges are not supported; a second
+ * `@expanding-start` before the previous one is closed replaces the
+ * open range's start.
+ *
+ * @param comments - The remapped 1-indexed comments map.
+ * @returns Sorted `[startLine, endLine]` pairs (inclusive on both
+ *   ends). Returns an empty array when `comments` is `undefined`,
+ *   empty, or contains no markers.
+ */
+export function findExpandingRanges(comments) {
+  if (!comments) {
+    return [];
+  }
+  const lineNumbers = collectLineNumbers(comments);
+  if (lineNumbers.length === 0) {
+    return [];
+  }
+  const ranges = [];
+  let openStart = null;
+  for (const line of lineNumbers) {
+    const {
+      hasStart,
+      hasEnd,
+      hasSingle
+    } = classifyEntries(comments[line]);
+    if (hasSingle) {
+      ranges.push([line, line]);
+    }
+    // Same-line start+end (multi-line addition collapsed to one line)
+    // is a valid range.
+    if (hasStart && hasEnd) {
+      ranges.push([line, line]);
+      openStart = null;
+      continue;
+    }
+    if (hasStart) {
+      openStart = line;
+      continue;
+    }
+    if (hasEnd && openStart !== null) {
+      ranges.push([openStart, line]);
+      openStart = null;
+    }
+  }
+  return ranges;
+}
+
+/**
+ * Fast yes/no check used by the pipeline's layout-shift classifier so
+ * it can avoid materialising the full `findExpandingRanges` array when
+ * all it needs is a boolean. Equivalent to
+ * `findExpandingRanges(...).length > 0` but short-circuits on the first
+ * matched marker.
+ */
+export function hasExpandingRanges(comments) {
+  if (!comments) {
+    return false;
+  }
+  const lineNumbers = collectLineNumbers(comments);
+  let openStart = false;
+  for (const line of lineNumbers) {
+    const {
+      hasStart,
+      hasEnd,
+      hasSingle
+    } = classifyEntries(comments[line]);
+    if (hasSingle) {
+      return true;
+    }
+    if (hasStart && hasEnd) {
+      return true;
+    }
+    if (hasStart) {
+      openStart = true;
+      continue;
+    }
+    if (hasEnd && openStart) {
+      return true;
+    }
+  }
+  return false;
+}

package/pipeline/loadIsomorphicCodeVariant/flattenCodeVariant.mjs

@@ -4,7 +4,7 @@
  * Uses addPathsToVariant for the core logic, then flattens the result
  */
 
-import { stringOrHastToString } from "../hastUtils/index.mjs";
+import { decodeSourceToText } from "./decodeSourceToText.mjs";
 import { addPathsToVariant } from "./addCodeVariantPaths.mjs";
 /**
  * Flatten a VariantCode into a flat files structure
@@ -20,7 +20,10 @@ export function flattenCodeVariant(variant) {
   // Add main file if it exists
   if (variantWithPaths.path && variantWithPaths.source !== undefined) {
     result[variantWithPaths.path] = {
-      source: stringOrHastToString(variantWithPaths.source)
+      // The source may be `hastCompressed`; its `fallback` is the DEFLATE
+      // dictionary needed to decode it back to text. `decodeSourceToText` reuses
+      // the shared decode cache rather than re-inflating on every export.
+      source: decodeSourceToText(variantWithPaths.source, variantWithPaths.fallback)
     };
   }
 
@@ -37,7 +40,7 @@ export function flattenCodeVariant(variant) {
         continue;
       }
       result[fileWithPath.path] = {
-        source: stringOrHastToString(fileWithPath.source || ''),
+        source: decodeSourceToText(fileWithPath.source, fileWithPath.fallback),
         ...(fileWithPath.metadata && {
           metadata: fileWithPath.metadata
         })

package/pipeline/loadIsomorphicCodeVariant/getAvailableTransforms.d.mts

@@ -0,0 +1,12 @@
+import type { Code } from "../../CodeHighlighter/types.mjs";
+/**
+ * Pure function to get available transforms from a specific variant.
+ *
+ * Variant-level `transforms` is a manifest produced by `splitTransformsForEmbed`
+ * (or by the legacy `Transforms` shape with deltas, for back-compat). Only
+ * entries that produced a real source delta are reported here — rename-only
+ * entries (manifest entries with `hasDelta: false`, kept around so the
+ * runtime can still apply the rename based on user preference) are filtered
+ * out so the transform toggle stays hidden when nothing meaningful changes.
+ */
+export declare function getAvailableTransforms(parsedCode: Code | undefined, variantName: string): string[];

package/pipeline/loadIsomorphicCodeVariant/getAvailableTransforms.mjs

@@ -0,0 +1,44 @@
+/**
+ * Pure function to get available transforms from a specific variant.
+ *
+ * Variant-level `transforms` is a manifest produced by `splitTransformsForEmbed`
+ * (or by the legacy `Transforms` shape with deltas, for back-compat). Only
+ * entries that produced a real source delta are reported here — rename-only
+ * entries (manifest entries with `hasDelta: false`, kept around so the
+ * runtime can still apply the rename based on user preference) are filtered
+ * out so the transform toggle stays hidden when nothing meaningful changes.
+ */
+export function getAvailableTransforms(parsedCode, variantName) {
+  const currentVariant = parsedCode?.[variantName];
+  if (!currentVariant || typeof currentVariant !== 'object') {
+    return [];
+  }
+  const transforms = new Set();
+  const addIfMeaningful = entries => {
+    if (!entries) {
+      return;
+    }
+    for (const [transformKey, entry] of Object.entries(entries)) {
+      if (!entry) {
+        continue;
+      }
+      // Manifest entries set `hasDelta: true` when a real delta survived
+      // serialization. Legacy entries that still carry an inline `delta`
+      // also qualify (back-compat for callers that haven't gone through
+      // `splitTransformsForEmbed`).
+      const inlineDelta = !!entry.delta && typeof entry.delta === 'object' && Object.keys(entry.delta).length > 0;
+      if (entry.hasDelta || inlineDelta) {
+        transforms.add(transformKey);
+      }
+    }
+  };
+  addIfMeaningful(currentVariant.transforms);
+  if (currentVariant.extraFiles) {
+    for (const fileData of Object.values(currentVariant.extraFiles)) {
+      if (fileData && typeof fileData === 'object' && 'transforms' in fileData) {
+        addIfMeaningful(fileData.transforms);
+      }
+    }
+  }
+  return Array.from(transforms);
+}

package/pipeline/loadIsomorphicCodeVariant/getInitialVisibleSourceLines.d.mts

@@ -0,0 +1,16 @@
+import type { Nodes } from 'hast';
+/**
+ * Returns the set of 1-indexed source line numbers that are visible when
+ * the rendered code block is collapsed (i.e. the user hasn't clicked
+ * "expand"). Mirrors the visibility rule applied at runtime by `<Pre>`:
+ *
+ *   - Frames whose `data-frame-type` is `'highlighted'`, `'focus'`,
+ *     `'padding-top'`, or `'padding-bottom'` are visible.
+ *   - When no such emphasis frame exists, only the first frame is shown
+ *     (this matches `getInitialVisibleFrames` in `<Pre>`).
+ *
+ * `tree` must be the output of `parseSource` (a `Root` whose top-level
+ * children are frame `Element`s with `'line'` `Element` descendants).
+ * Returns an empty set for an empty/invalid tree.
+ */
+export declare function getInitialVisibleSourceLines(tree: Nodes): Set<number>;

package/pipeline/loadIsomorphicCodeVariant/getInitialVisibleSourceLines.mjs

@@ -0,0 +1,74 @@
+import { COLLAPSED_VISIBLE_FRAME_TYPES } from "../parseSource/frameVisibility.mjs";
+import { isFrameSpan } from "../parseSource/isFrameSpan.mjs";
+
+/**
+ * Returns the set of 1-indexed source line numbers that are visible when
+ * the rendered code block is collapsed (i.e. the user hasn't clicked
+ * "expand"). Mirrors the visibility rule applied at runtime by `<Pre>`:
+ *
+ *   - Frames whose `data-frame-type` is `'highlighted'`, `'focus'`,
+ *     `'padding-top'`, or `'padding-bottom'` are visible.
+ *   - When no such emphasis frame exists, only the first frame is shown
+ *     (this matches `getInitialVisibleFrames` in `<Pre>`).
+ *
+ * `tree` must be the output of `parseSource` (a `Root` whose top-level
+ * children are frame `Element`s with `'line'` `Element` descendants).
+ * Returns an empty set for an empty/invalid tree.
+ */
+export function getInitialVisibleSourceLines(tree) {
+  const visible = new Set();
+  if (tree.type !== 'root') {
+    return visible;
+  }
+  const root = tree;
+  let lineNumber = 0;
+  let hasVisibleEmphasisFrame = false;
+  // First pass: collect lines under explicitly-visible emphasis frames.
+  for (const child of root.children) {
+    if (child.type !== 'element' || !isFrameSpan(child)) {
+      continue;
+    }
+    const frame = child;
+    const frameType = frame.properties?.dataFrameType;
+    const frameVisible = typeof frameType === 'string' && COLLAPSED_VISIBLE_FRAME_TYPES.has(frameType);
+    if (frameVisible) {
+      hasVisibleEmphasisFrame = true;
+    }
+    for (const grandChild of frame.children) {
+      if (grandChild.type === 'element' && grandChild.properties?.className === 'line') {
+        lineNumber += 1;
+        if (frameVisible) {
+          visible.add(lineNumber);
+        }
+      }
+    }
+  }
+
+  // Collapse-to-nothing (oversizedFocus: 'hide'): the source records
+  // `focusedLines === 0`, meaning the collapsed window is intentionally empty.
+  // Skip the first-frame fallback so nothing is shown when collapsed.
+  if (root.data?.focusedLines === 0) {
+    return visible;
+  }
+
+  // Fallback: no emphasis frame in the source — the first frame is the
+  // one shown when collapsed. Add its lines.
+  if (!hasVisibleEmphasisFrame && lineNumber > 0) {
+    let fallbackLine = 0;
+    for (const child of root.children) {
+      if (child.type !== 'element' || !isFrameSpan(child)) {
+        continue;
+      }
+      const frame = child;
+      for (const grandChild of frame.children) {
+        if (grandChild.type === 'element' && grandChild.properties?.className === 'line') {
+          fallbackLine += 1;
+          visible.add(fallbackLine);
+        }
+      }
+      // Only the first frame.
+      break;
+    }
+  }
+  return visible;
+}

package/pipeline/loadIsomorphicCodeVariant/loadCodeFallback.mjs

@@ -1,5 +1,5 @@
 import { loadIsomorphicCodeVariant } from "./loadIsomorphicCodeVariant.mjs";
-import { convertCommentsToOneIndexed, getFileNameFromUrl, getLanguageFromExtension } from "../loaderUtils/index.mjs";
+import { getFileNameFromUrl, getLanguageFromExtension } from "../loaderUtils/index.mjs";
 import { performanceMeasure } from "../loadPrecomputedCodeHighlighter/performanceLogger.mjs";
 
 // Helper function to get the source for a specific filename from a variant
@@ -74,9 +74,10 @@ function enrichVariantWithLoadedSource(base, source, comments, externals) {
     ...base,
     source
   };
-  const oneIndexedComments = convertCommentsToOneIndexed(comments);
-  if (oneIndexedComments) {
-    enriched.comments = oneIndexedComments;
+  // `loadSource` returns 1-indexed comments (the stored `Code` convention), so apply them
+  // as-is — no conversion at the source-loader boundary.
+  if (comments) {
+    enriched.comments = comments;
   }
   if (externals && Object.keys(externals).length > 0) {
     enriched.externals = Object.keys(externals);
@@ -112,6 +113,14 @@ export async function loadCodeFallback(url, initialVariant, loaded, options = {}
   loaded = {
     ...loaded
   };
+
+  // When not highlighting (deferred), pass `disableParsing: true`: the source must
+  // stay a plain string so the client knows it still needs syntax highlighting (a
+  // HAST source reads as "already loaded"). `loadIsomorphicCodeVariant` still frames
+  // the loading fallback itself in that mode — line gutters + enhancers → root
+  // fallback — only the syntax colors are deferred. When highlighting, the real
+  // `sourceParser` runs and the source becomes a highlighted HAST as before.
+
   const functionName = 'Load Fallback Code';
   let currentMark = performanceMeasure(undefined, {
     mark: 'Start',
@@ -381,8 +390,10 @@ export async function loadCodeFallback(url, initialVariant, loaded, options = {}
       sourceEnhancers,
       disableTransforms: true,
       // Don't apply transforms for fallback
+      // Deferred highlight: keep the source a plain string, but still frame the
+      // loading fallback (plain-text gutters + enhancers → root fallback).
       disableParsing: !shouldHighlight,
-      // Only parse if highlighting is needed
+      framePlainFallback: true,
       globalsCode: resolvedGlobalsCode,
       // Pass resolved globalsCode
       output,
@@ -478,6 +489,7 @@ export async function loadCodeFallback(url, initialVariant, loaded, options = {}
             sourceEnhancers,
             disableTransforms: true,
             disableParsing: !shouldHighlight,
+            framePlainFallback: true,
             output,
             urlPrefix,
             globalsCode: globalsCodeObjects && globalsCodeObjects.length > 0 ? (() => {