@mui/internal-docs-infra 0.1.1-canary.9 → 0.2.0-alpha.2

package/esm/CodeHighlighter/CodeHighlighterContext.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Code, ControlledCode } from "./types.js";
+import { Selection } from "../CodeControllerContext/index.js";
+export interface CodeHighlighterContextType {
+  code?: Code;
+  setCode?: React.Dispatch<React.SetStateAction<ControlledCode | undefined>>;
+  selection?: Selection;
+  setSelection?: React.Dispatch<React.SetStateAction<Selection>>;
+  components?: Record<string, React.ReactNode>;
+  availableTransforms?: string[];
+  url?: string;
+  deferHighlight?: boolean;
+}
+export declare const CodeHighlighterContext: React.Context<CodeHighlighterContextType | undefined>;
+export declare function useCodeHighlighterContext(): CodeHighlighterContextType;
+export declare function useCodeHighlighterContextOptional(): CodeHighlighterContextType | undefined;

package/esm/CodeHighlighter/CodeHighlighterContext.js

@@ -0,0 +1,15 @@
+'use client';
+
+import * as React from 'react';
+export var CodeHighlighterContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== "production") CodeHighlighterContext.displayName = "CodeHighlighterContext";
+export function useCodeHighlighterContext() {
+  var context = React.useContext(CodeHighlighterContext);
+  if (context === undefined) {
+    throw new Error('CodeHighlighterContext is missing. `useCodeHighlighterContext` must be used within a `CodeHighlighter` component.');
+  }
+  return context;
+}
+export function useCodeHighlighterContextOptional() {
+  return React.useContext(CodeHighlighterContext);
+}

package/esm/CodeHighlighter/CodeHighlighterFallbackContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { ContentLoadingVariant } from "./types.js";
+export interface CodeHighlighterFallbackContext extends ContentLoadingVariant {
+  extraVariants?: Record<string, ContentLoadingVariant>;
+}
+export declare const CodeHighlighterFallbackContext: React.Context<CodeHighlighterFallbackContext | undefined>;
+export declare function useCodeHighlighterFallbackContext(): CodeHighlighterFallbackContext;

package/esm/CodeHighlighter/CodeHighlighterFallbackContext.js

@@ -0,0 +1,14 @@
+'use client';
+
+import * as React from 'react';
+export var CodeHighlighterFallbackContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== "production") CodeHighlighterFallbackContext.displayName = "CodeHighlighterFallbackContext";
+export function useCodeHighlighterFallbackContext() {
+  var context = React.useContext(CodeHighlighterFallbackContext);
+  if (context === undefined) {
+    throw new Error('CodeHighlighterFallbackContext is missing. `useCodeHighlighterFallbackContext` must be used within a `CodeHighlighter` component.');
+  }
+  return context;
+}
+
+// TODO: rename to ContentMinimal

package/esm/CodeHighlighter/addPathsToVariant.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Add path utility to add path property to each file in a variant
+ * Uses calculateMainFilePath utility and URL resolution for simplified path calculation
+ */
+import type { VariantCode, VariantSource } from "./types.js";
+export interface FileWithPath {
+  source?: VariantSource;
+  metadata?: boolean;
+  path: string;
+}
+/**
+ * Add flat paths to all files in a variant
+ */
+export declare function addPathsToVariant(variant: VariantCode): VariantCode;

package/esm/CodeHighlighter/addPathsToVariant.js

@@ -0,0 +1,68 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+/**
+ * Add path utility to add path property to each file in a variant
+ * Uses calculateMainFilePath utility and URL resolution for simplified path calculation
+ */
+
+import { calculateMaxBackNavigation, createSyntheticDirectories } from "./pathUtils.js";
+import { calculateMainFilePath } from "./calculateMainFilePath.js";
+/**
+ * Add flat paths to all files in a variant
+ */
+export function addPathsToVariant(variant) {
+  var url = variant.url || '';
+  var fileName = variant.fileName || '';
+
+  // Calculate actual back navigation needed based on extraFiles
+  var backNavResult = variant.extraFiles ? calculateMaxBackNavigation(variant.extraFiles) : {
+    maxBackNavigation: 0,
+    maxSourceBackNavigation: 0
+  };
+
+  // Create a synthetic URL for variants without URL to ensure consistent processing
+  var effectiveUrl = url;
+  if (!url && fileName) {
+    effectiveUrl = "file:///".concat(fileName);
+  }
+
+  // Calculate main file path using only the back navigation needed by source files
+  var mainFileUrl = effectiveUrl ? calculateMainFilePath(effectiveUrl, backNavResult.maxBackNavigation, backNavResult.maxSourceBackNavigation, variant.metadataPrefix, fileName || undefined // Only pass fileName if it's not empty
+  ) : undefined;
+
+  // Extract just the path part from the file:// URL and remove leading slash
+  var path = mainFileUrl ? new URL(mainFileUrl).pathname.slice(1) : undefined;
+  return _extends(_extends({}, variant), {}, {
+    path: path,
+    extraFiles: calculateExtraFilesPaths(variant.extraFiles, mainFileUrl || "file:///".concat(backNavResult.maxBackNavigation > 0 ? "".concat(createSyntheticDirectories(backNavResult.maxBackNavigation).join('/'), "/") : '', "temp.txt"))
+  });
+}
+
+/**
+ * Calculate paths for all extra files using the same logic as the main file
+ */
+function calculateExtraFilesPaths(extraFiles, mainFileUrl) {
+  if (!extraFiles) {
+    return undefined;
+  }
+  var result = {};
+  for (var _i = 0, _Object$entries = Object.entries(extraFiles); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      relativePath = _Object$entries$_i[0],
+      fileContent = _Object$entries$_i[1];
+    // Resolve the relative path against the main file URL
+    try {
+      var resolvedUrl = new URL(relativePath, mainFileUrl);
+      var file = typeof fileContent === 'string' ? {
+        source: fileContent
+      } : fileContent;
+      result[relativePath] = _extends(_extends({}, file), {}, {
+        path: resolvedUrl.pathname.slice(1)
+      });
+    } catch (_unused) {
+      // If URL resolution fails, skip this file
+      continue;
+    }
+  }
+  return _extends(_extends({}, extraFiles), result);
+}

package/esm/CodeHighlighter/applyTransform.d.ts

@@ -0,0 +1,19 @@
+import type { VariantSource, Transforms } from "./types.js";
+/**
+ * Applies a specific transform to a variant source and returns the transformed source
+ * @param source - The original variant source (string, HastNodes, or hastJson object)
+ * @param transforms - Object containing all available transforms
+ * @param transformKey - The key of the specific transform to apply
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if the transform key doesn't exist or patching fails
+ */
+export declare function applyTransform(source: VariantSource, transforms: Transforms, transformKey: string): VariantSource;
+/**
+ * Applies multiple transforms to a variant source in sequence
+ * @param source - The original variant source
+ * @param transforms - Object containing all available transforms
+ * @param transformKeys - Array of transform keys to apply in order
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if any transform key doesn't exist or patching fails
+ */
+export declare function applyTransforms(source: VariantSource, transforms: Transforms, transformKeys: string[]): VariantSource;

package/esm/CodeHighlighter/applyTransform.js

@@ -0,0 +1,75 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { patch, clone } from 'jsondiffpatch';
+/**
+ * Applies a specific transform to a variant source and returns the transformed source
+ * @param source - The original variant source (string, HastNodes, or hastJson object)
+ * @param transforms - Object containing all available transforms
+ * @param transformKey - The key of the specific transform to apply
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if the transform key doesn't exist or patching fails
+ */
+export function applyTransform(source, transforms, transformKey) {
+  var transform = transforms[transformKey];
+  if (!transform) {
+    throw new Error("Transform \"".concat(transformKey, "\" not found in transforms"));
+  }
+
+  // Determine the format of the source and apply the appropriate transform strategy
+  if (typeof source === 'string') {
+    // For string sources, deltas are typically line-array based (from transformSource)
+    var sourceLines = source.split('\n');
+    var patched = patch(sourceLines, transform.delta);
+    if (!Array.isArray(patched)) {
+      throw new Error("Patch for transform \"".concat(transformKey, "\" did not return an array"));
+    }
+    return patched.join('\n');
+  }
+
+  // For Hast node sources, deltas are typically node-based (from transformParsedSource)
+  var sourceRoot;
+  var isHastJson = 'hastJson' in source;
+  if (isHastJson) {
+    sourceRoot = JSON.parse(source.hastJson);
+  } else {
+    sourceRoot = source;
+  }
+
+  // Apply the node-based delta
+  var patchedNodes = patch(clone(sourceRoot), transform.delta);
+  if (!patchedNodes) {
+    throw new Error("Patch for transform \"".concat(transformKey, "\" returned null/undefined"));
+  }
+
+  // Return in the same format as the input
+  if (isHastJson) {
+    return {
+      hastJson: JSON.stringify(patchedNodes)
+    };
+  }
+  return patchedNodes;
+}
+
+/**
+ * Applies multiple transforms to a variant source in sequence
+ * @param source - The original variant source
+ * @param transforms - Object containing all available transforms
+ * @param transformKeys - Array of transform keys to apply in order
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if any transform key doesn't exist or patching fails
+ */
+export function applyTransforms(source, transforms, transformKeys) {
+  var currentSource = source;
+  var _iterator = _createForOfIteratorHelper(transformKeys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var transformKey = _step.value;
+      currentSource = applyTransform(currentSource, transforms, transformKey);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return currentSource;
+}

package/esm/CodeHighlighter/calculateMainFilePath.d.ts

@@ -0,0 +1 @@
+export declare function calculateMainFilePath(url: string, maxBackNav: number, maxSourceBackNav?: number, metadataPrefix?: string, fileName?: string): string;

package/esm/CodeHighlighter/calculateMainFilePath.js

@@ -0,0 +1,108 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { createSyntheticDirectories, buildPath } from './pathUtils.js';
+export function calculateMainFilePath(url, maxBackNav, maxSourceBackNav, metadataPrefix, fileName) {
+  // Handle optional parameters with defaults
+  var actualMaxSourceBackNav = maxSourceBackNav != null ? maxSourceBackNav : maxBackNav;
+  var actualMetadataPrefix = metadataPrefix != null ? metadataPrefix : '';
+
+  // Handle empty URL
+  if (!url) {
+    return '';
+  }
+
+  // Extract URL parts and filename
+  var urlSegments;
+  var filename;
+  var hasTrailingSlash = false;
+  try {
+    // Try to parse as URL first
+    var urlObj = new URL(url);
+    hasTrailingSlash = urlObj.pathname.endsWith('/');
+    var pathSegments = urlObj.pathname.split('/').filter(Boolean);
+    var baseFilename;
+    if (hasTrailingSlash) {
+      // If URL ends with /, there's no filename - all segments are path segments
+      baseFilename = '';
+      urlSegments = pathSegments;
+    } else {
+      // Normal case - last segment is the filename
+      baseFilename = pathSegments.pop() || '';
+      urlSegments = pathSegments;
+    }
+
+    // Use provided fileName or preserve query and hash from URL
+    if (fileName !== undefined) {
+      filename = fileName;
+    } else {
+      filename = baseFilename + urlObj.search + urlObj.hash;
+      if (hasTrailingSlash && !baseFilename) {
+        filename = "".concat(filename, "/");
+      }
+    }
+  } catch (_unused) {
+    // Fallback to simple string parsing for relative paths
+    hasTrailingSlash = url.endsWith('/');
+    var urlParts = url.split('/');
+    var _baseFilename;
+    if (hasTrailingSlash) {
+      // If URL ends with /, there's no filename - all segments are path segments
+      _baseFilename = urlParts.pop() || ''; // Remove the empty string after trailing slash
+      urlSegments = urlParts.filter(function (part) {
+        return part !== '';
+      }); // Remove empty segments
+    } else {
+      // Normal case - last segment is the filename
+      _baseFilename = urlParts.pop() || '';
+      urlSegments = urlParts.filter(function (part) {
+        return part !== '';
+      }); // Remove empty segments
+    }
+
+    // Use provided fileName or fallback to extracted baseFilename
+    if (fileName !== undefined) {
+      filename = fileName;
+    } else {
+      filename = _baseFilename;
+      if (hasTrailingSlash && !_baseFilename) {
+        filename = "".concat(filename, "/");
+      }
+    }
+  }
+
+  // Work with a copy of URL segments to avoid mutations
+  var remainingUrlSegments = _toConsumableArray(urlSegments);
+
+  // Take actualMaxSourceBackNav items from the end for sourcePath
+  var sourcePath = remainingUrlSegments.splice(-actualMaxSourceBackNav, actualMaxSourceBackNav);
+
+  // Calculate unhandledBackNav, accounting for missing sourcePath segments
+  var unhandledBackNav = maxBackNav - actualMaxSourceBackNav;
+
+  // Add any missing sourcePath segments to unhandledBackNav
+  var missingSourcePathSegments = actualMaxSourceBackNav - sourcePath.length;
+  unhandledBackNav += missingSourcePathSegments;
+
+  // Split actualMetadataPrefix and subtract that count from unhandledBackNav
+  var metadataPrefixSegments = actualMetadataPrefix.split('/').filter(function (part) {
+    return part !== '';
+  });
+  unhandledBackNav -= metadataPrefixSegments.length;
+
+  // Calculate metadataPath from remaining URL segments (what's left after sourcePath)
+  var metadataSegmentsNeeded = Math.max(0, unhandledBackNav);
+  var metadataSegmentsAvailable = Math.min(metadataSegmentsNeeded, remainingUrlSegments.length);
+  var metadataPath = remainingUrlSegments.splice(-metadataSegmentsAvailable, metadataSegmentsAvailable);
+
+  // Update unhandledBackNav with segments we couldn't fulfill from URL
+  unhandledBackNav = metadataSegmentsNeeded - metadataSegmentsAvailable;
+
+  // Create synthetic directories for any remaining unhandledBackNav
+  var syntheticDirs = createSyntheticDirectories(unhandledBackNav);
+
+  // Combine all parts to create the final path using buildPath utility
+  // Order: [synthetic directories] + [metadataPath] + [metadataPrefix] + [sourcePath] + [filename]
+  var path = buildPath(syntheticDirs, metadataPath, metadataPrefixSegments, sourcePath, filename);
+
+  // Return as file:// URL unless the result is empty
+  return path ? "file:///".concat(path) : path;
+}

package/esm/CodeHighlighter/codeToFallbackProps.d.ts

@@ -0,0 +1,2 @@
+import { BaseContentLoadingProps, Code } from "./types.js";
+export declare function codeToFallbackProps(variant: string, code?: Code, fileName?: string, needsAllFiles?: boolean, needsAllVariants?: boolean): BaseContentLoadingProps;

package/esm/CodeHighlighter/codeToFallbackProps.js

@@ -0,0 +1,73 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { stringOrHastToJsx } from "../pipeline/hastUtils/index.js";
+function toExtraSource(variantCode, fileName) {
+  return Object.entries(variantCode.extraFiles || {}).reduce(function (acc, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      name = _ref2[0],
+      file = _ref2[1];
+    if (name !== fileName && _typeof(file) === 'object' && file != null && file.source) {
+      acc[name] = stringOrHastToJsx(file.source);
+    }
+    return acc;
+  }, {});
+}
+export function codeToFallbackProps(variant, code, fileName) {
+  var needsAllFiles = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var needsAllVariants = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var variantCode = code == null ? void 0 : code[variant];
+  if (!variantCode || typeof variantCode === 'string') {
+    return {};
+  }
+  var fileNames = [variantCode.fileName].concat(_toConsumableArray(Object.keys(variantCode.extraFiles || {}))).filter(function (name) {
+    return Boolean(name);
+  });
+  var source;
+  if (fileName && fileName !== variantCode.fileName) {
+    var _variantCode$extraFil;
+    var fileData = (_variantCode$extraFil = variantCode.extraFiles) == null ? void 0 : _variantCode$extraFil[fileName];
+    if (fileData && _typeof(fileData) === 'object' && 'source' in fileData && fileData.source) {
+      source = stringOrHastToJsx(fileData.source);
+    }
+  } else if (variantCode.source) {
+    source = stringOrHastToJsx(variantCode.source);
+  }
+  if (needsAllVariants || needsAllFiles) {
+    var extraSource = toExtraSource(variantCode, fileName);
+    if (needsAllVariants) {
+      var extraVariants = Object.entries(code || {}).reduce(function (acc, _ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          name = _ref4[0],
+          vCode = _ref4[1];
+        if (name !== variant && vCode && typeof vCode !== 'string') {
+          var extraVariantExtraSource = toExtraSource(vCode, vCode.fileName);
+          acc[name] = {
+            fileNames: [vCode.fileName].concat(_toConsumableArray(Object.keys(vCode.extraFiles || {}))).filter(function (fn) {
+              return Boolean(fn);
+            }),
+            // TODO: use filesOrder if provided
+            source: vCode.source && stringOrHastToJsx(vCode.source),
+            extraSource: extraVariantExtraSource
+          };
+        }
+        return acc;
+      }, {});
+      return {
+        fileNames: fileNames,
+        source: source,
+        extraSource: extraSource,
+        extraVariants: extraVariants
+      };
+    }
+    return {
+      fileNames: fileNames,
+      source: source,
+      extraSource: extraSource
+    };
+  }
+  return {
+    fileNames: fileNames,
+    source: source
+  };
+}

package/esm/CodeHighlighter/errors.d.ts

@@ -0,0 +1,141 @@
+export declare class ErrorCodeHighlighter extends Error {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterServer extends ErrorCodeHighlighter {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterClient extends ErrorCodeHighlighter {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterServerConfiguration extends ErrorCodeHighlighterServer {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterServerLoader extends ErrorCodeHighlighterServer {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterServerValidation extends ErrorCodeHighlighterServer {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterClientConfiguration extends ErrorCodeHighlighterClient {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterClientLoader extends ErrorCodeHighlighterClient {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterClientValidation extends ErrorCodeHighlighterClient {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterClientProvider extends ErrorCodeHighlighterClient {
+  constructor(message: string);
+}
+export declare class ErrorCodeHighlighterServerMissingLoadCodeMeta extends ErrorCodeHighlighterServerConfiguration {
+  constructor(context?: string);
+}
+export declare class ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals extends ErrorCodeHighlighterServerConfiguration {
+  constructor();
+}
+export declare class ErrorCodeHighlighterServerMissingUrl extends ErrorCodeHighlighterServerValidation {
+  constructor(context?: string);
+}
+export declare class ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta extends ErrorCodeHighlighterServerValidation {
+  constructor();
+}
+export declare class ErrorCodeHighlighterServerInvalidProps extends ErrorCodeHighlighterServerValidation {
+  constructor();
+}
+export declare class ErrorCodeHighlighterServerMissingData extends ErrorCodeHighlighterServerValidation {
+  constructor();
+}
+export declare class ErrorCodeHighlighterServerMissingVariant extends ErrorCodeHighlighterServerValidation {
+  constructor(variantName: string);
+}
+export declare class ErrorCodeHighlighterServerMissingFileName extends ErrorCodeHighlighterServerValidation {
+  constructor(variantName: string);
+}
+export declare class ErrorCodeHighlighterServerMissingContentLoading extends ErrorCodeHighlighterServerConfiguration {
+  constructor();
+}
+export declare class ErrorCodeHighlighterServerInvalidClientMode extends ErrorCodeHighlighterServerValidation {
+  constructor();
+}
+export declare class ErrorCodeHighlighterServerLoadCodeFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url: string, error: any);
+}
+export declare class ErrorCodeHighlighterServerLoadGlobalsFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url: string, error: any);
+}
+export declare class ErrorCodeHighlighterServerLoadVariantsFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url: string, errors: Error[]);
+}
+export declare class ErrorCodeHighlighterClientMissingLoadFallbackCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url?: string);
+}
+export declare class ErrorCodeHighlighterClientMissingLoadVariant extends ErrorCodeHighlighterClientProvider {
+  constructor(url?: string);
+}
+export declare class ErrorCodeHighlighterClientMissingLoadCodeMeta extends ErrorCodeHighlighterClientProvider {
+  constructor(context?: string);
+}
+export declare class ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url?: string);
+}
+export declare class ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals extends ErrorCodeHighlighterClientProvider {
+  constructor();
+}
+export declare class ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls extends ErrorCodeHighlighterClientProvider {
+  constructor();
+}
+export declare class ErrorCodeHighlighterClientMissingLoadSource extends ErrorCodeHighlighterClientProvider {
+  constructor(context?: string);
+}
+export declare class ErrorCodeHighlighterClientMissingLoadSourceForNoCode extends ErrorCodeHighlighterClientProvider {
+  constructor();
+}
+export declare class ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls extends ErrorCodeHighlighterClientProvider {
+  constructor();
+}
+export declare class ErrorCodeHighlighterClientMissingUrl extends ErrorCodeHighlighterClientValidation {
+  constructor(context?: string);
+}
+export declare class ErrorCodeHighlighterClientMissingUrlForFallback extends ErrorCodeHighlighterClientValidation {
+  constructor();
+}
+export declare class ErrorCodeHighlighterClientMissingUrlForVariants extends ErrorCodeHighlighterClientValidation {
+  constructor();
+}
+export declare class ErrorCodeHighlighterClientMissingData extends ErrorCodeHighlighterClientValidation {
+  constructor();
+}
+export declare class ErrorCodeHighlighterServerLoadVariantFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url: string, error: Error);
+}
+export declare class ErrorCodeHighlighterClientLoadFallbackFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(error: Error);
+}
+export declare class ErrorCodeHighlighterClientLoadVariantsFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(url: string, errors: Error[]);
+}
+export declare class ErrorCodeHighlighterClientLoadAllVariantsFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(url: string, error: Error);
+}
+export declare class ErrorCodeHighlighterClientMissingParseSource extends ErrorCodeHighlighterClientProvider {
+  constructor(url?: string, isForceClient?: boolean);
+}
+export declare class ErrorCodeHighlighterClientMissingParseCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url?: string, isForceClient?: boolean);
+}
+export declare class ErrorCodeHighlighterClientMissingParseControlledCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url?: string, isForceClient?: boolean);
+}
+export declare class ErrorCodeHighlighterClientTransformProcessingFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(error: Error);
+}
+export declare class ErrorCodeHighlighterClientMissingLoadVariantForGlobals extends ErrorCodeHighlighterClientProvider {
+  constructor();
+}
+export declare class ErrorCodeHighlighterClientLoadVariantFailureForGlobals extends ErrorCodeHighlighterClientLoader {
+  constructor(variantName: string, originalUrl?: string, error?: Error);
+}
+export declare class ErrorCodeHighlighterClientLoadGlobalsCodeFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(url: string, error: Error);
+}