@mui/internal-docs-infra 0.1.1-canary.8 → 0.2.0-alpha.1

package/esm/CodeHighlighter/errors.js

@@ -0,0 +1,441 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _callSuper from "@babel/runtime/helpers/esm/callSuper";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
+// Base error class for all CodeHighlighter errors
+export var ErrorCodeHighlighter = /*#__PURE__*/function (_Error) {
+  function ErrorCodeHighlighter(message) {
+    var _this;
+    _classCallCheck(this, ErrorCodeHighlighter);
+    _this = _callSuper(this, ErrorCodeHighlighter, ["CodeHighlighter: ".concat(message)]);
+    _this.name = _this.constructor.name;
+    return _this;
+  }
+  _inherits(ErrorCodeHighlighter, _Error);
+  return _createClass(ErrorCodeHighlighter);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+// Server-side errors (during SSR/precomputation)
+export var ErrorCodeHighlighterServer = /*#__PURE__*/function (_ErrorCodeHighlighter) {
+  function ErrorCodeHighlighterServer(message) {
+    _classCallCheck(this, ErrorCodeHighlighterServer);
+    return _callSuper(this, ErrorCodeHighlighterServer, ["[Server] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterServer, _ErrorCodeHighlighter);
+  return _createClass(ErrorCodeHighlighterServer);
+}(ErrorCodeHighlighter);
+
+// Client-side errors (during hydration/runtime)
+export var ErrorCodeHighlighterClient = /*#__PURE__*/function (_ErrorCodeHighlighter2) {
+  function ErrorCodeHighlighterClient(message) {
+    _classCallCheck(this, ErrorCodeHighlighterClient);
+    return _callSuper(this, ErrorCodeHighlighterClient, ["[Client] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterClient, _ErrorCodeHighlighter2);
+  return _createClass(ErrorCodeHighlighterClient);
+}(ErrorCodeHighlighter);
+
+// === SERVER ERROR TYPES ===
+
+// Configuration errors on server
+export var ErrorCodeHighlighterServerConfiguration = /*#__PURE__*/function (_ErrorCodeHighlighter3) {
+  function ErrorCodeHighlighterServerConfiguration(message) {
+    _classCallCheck(this, ErrorCodeHighlighterServerConfiguration);
+    return _callSuper(this, ErrorCodeHighlighterServerConfiguration, ["[Configuration] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterServerConfiguration, _ErrorCodeHighlighter3);
+  return _createClass(ErrorCodeHighlighterServerConfiguration);
+}(ErrorCodeHighlighterServer);
+
+// Loading errors on server
+export var ErrorCodeHighlighterServerLoader = /*#__PURE__*/function (_ErrorCodeHighlighter4) {
+  function ErrorCodeHighlighterServerLoader(message) {
+    _classCallCheck(this, ErrorCodeHighlighterServerLoader);
+    return _callSuper(this, ErrorCodeHighlighterServerLoader, ["[Loader] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterServerLoader, _ErrorCodeHighlighter4);
+  return _createClass(ErrorCodeHighlighterServerLoader);
+}(ErrorCodeHighlighterServer);
+
+// Validation errors on server
+export var ErrorCodeHighlighterServerValidation = /*#__PURE__*/function (_ErrorCodeHighlighter5) {
+  function ErrorCodeHighlighterServerValidation(message) {
+    _classCallCheck(this, ErrorCodeHighlighterServerValidation);
+    return _callSuper(this, ErrorCodeHighlighterServerValidation, ["[Validation] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterServerValidation, _ErrorCodeHighlighter5);
+  return _createClass(ErrorCodeHighlighterServerValidation);
+}(ErrorCodeHighlighterServer);
+
+// === CLIENT ERROR TYPES ===
+
+// Configuration errors on client
+export var ErrorCodeHighlighterClientConfiguration = /*#__PURE__*/function (_ErrorCodeHighlighter6) {
+  function ErrorCodeHighlighterClientConfiguration(message) {
+    _classCallCheck(this, ErrorCodeHighlighterClientConfiguration);
+    return _callSuper(this, ErrorCodeHighlighterClientConfiguration, ["[Configuration] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientConfiguration, _ErrorCodeHighlighter6);
+  return _createClass(ErrorCodeHighlighterClientConfiguration);
+}(ErrorCodeHighlighterClient);
+
+// Loading errors on client
+export var ErrorCodeHighlighterClientLoader = /*#__PURE__*/function (_ErrorCodeHighlighter7) {
+  function ErrorCodeHighlighterClientLoader(message) {
+    _classCallCheck(this, ErrorCodeHighlighterClientLoader);
+    return _callSuper(this, ErrorCodeHighlighterClientLoader, ["[Loader] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientLoader, _ErrorCodeHighlighter7);
+  return _createClass(ErrorCodeHighlighterClientLoader);
+}(ErrorCodeHighlighterClient);
+
+// Validation errors on client
+export var ErrorCodeHighlighterClientValidation = /*#__PURE__*/function (_ErrorCodeHighlighter8) {
+  function ErrorCodeHighlighterClientValidation(message) {
+    _classCallCheck(this, ErrorCodeHighlighterClientValidation);
+    return _callSuper(this, ErrorCodeHighlighterClientValidation, ["[Validation] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientValidation, _ErrorCodeHighlighter8);
+  return _createClass(ErrorCodeHighlighterClientValidation);
+}(ErrorCodeHighlighterClient);
+
+// Provider errors on client
+export var ErrorCodeHighlighterClientProvider = /*#__PURE__*/function (_ErrorCodeHighlighter9) {
+  function ErrorCodeHighlighterClientProvider(message) {
+    _classCallCheck(this, ErrorCodeHighlighterClientProvider);
+    return _callSuper(this, ErrorCodeHighlighterClientProvider, ["[Provider] ".concat(message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientProvider, _ErrorCodeHighlighter9);
+  return _createClass(ErrorCodeHighlighterClientProvider);
+}(ErrorCodeHighlighterClient);
+
+// === SERVER SPECIFIC ERRORS ===
+
+// Server Configuration Errors
+export var ErrorCodeHighlighterServerMissingLoadCodeMeta = /*#__PURE__*/function (_ErrorCodeHighlighter0) {
+  function ErrorCodeHighlighterServerMissingLoadCodeMeta(context) {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingLoadCodeMeta);
+    var message = context ? "Missing loadCodeMeta function - ".concat(context) : 'Missing loadCodeMeta function - No code provided and "loadCodeMeta" function is not defined';
+    return _callSuper(this, ErrorCodeHighlighterServerMissingLoadCodeMeta, [message]);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingLoadCodeMeta, _ErrorCodeHighlighter0);
+  return _createClass(ErrorCodeHighlighterServerMissingLoadCodeMeta);
+}(ErrorCodeHighlighterServerConfiguration);
+export var ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter1) {
+  function ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals() {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals);
+    return _callSuper(this, ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals, ['Missing loadCodeMeta function - loadCodeMeta function is required when globalsCode contains string URLs']);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals, _ErrorCodeHighlighter1);
+  return _createClass(ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals);
+}(ErrorCodeHighlighterServerConfiguration);
+export var ErrorCodeHighlighterServerMissingUrl = /*#__PURE__*/function (_ErrorCodeHighlighter10) {
+  function ErrorCodeHighlighterServerMissingUrl(context) {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingUrl);
+    var message = context ? "Missing URL - URL is required ".concat(context) : 'Missing URL - URL is required for loading initial source';
+    return _callSuper(this, ErrorCodeHighlighterServerMissingUrl, [message]);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingUrl, _ErrorCodeHighlighter10);
+  return _createClass(ErrorCodeHighlighterServerMissingUrl);
+}(ErrorCodeHighlighterServerValidation);
+export var ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta = /*#__PURE__*/function (_ErrorCodeHighlighter11) {
+  function ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta() {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta);
+    return _callSuper(this, ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta, ['Missing URL - URL is required when loading code with "loadCodeMeta"']);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta, _ErrorCodeHighlighter11);
+  return _createClass(ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta);
+}(ErrorCodeHighlighterServerValidation);
+export var ErrorCodeHighlighterServerInvalidProps = /*#__PURE__*/function (_ErrorCodeHighlighter12) {
+  function ErrorCodeHighlighterServerInvalidProps() {
+    _classCallCheck(this, ErrorCodeHighlighterServerInvalidProps);
+    return _callSuper(this, ErrorCodeHighlighterServerInvalidProps, ['Invalid props - Cannot provide both "children" and "code" or "precompute" props']);
+  }
+  _inherits(ErrorCodeHighlighterServerInvalidProps, _ErrorCodeHighlighter12);
+  return _createClass(ErrorCodeHighlighterServerInvalidProps);
+}(ErrorCodeHighlighterServerValidation);
+export var ErrorCodeHighlighterServerMissingData = /*#__PURE__*/function (_ErrorCodeHighlighter13) {
+  function ErrorCodeHighlighterServerMissingData() {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingData);
+    return _callSuper(this, ErrorCodeHighlighterServerMissingData, ['Missing data - No code or components provided']);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingData, _ErrorCodeHighlighter13);
+  return _createClass(ErrorCodeHighlighterServerMissingData);
+}(ErrorCodeHighlighterServerValidation);
+export var ErrorCodeHighlighterServerMissingVariant = /*#__PURE__*/function (_ErrorCodeHighlighter14) {
+  function ErrorCodeHighlighterServerMissingVariant(variantName) {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingVariant);
+    return _callSuper(this, ErrorCodeHighlighterServerMissingVariant, ["Missing variant - No code or component for variant \"".concat(variantName, "\"")]);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingVariant, _ErrorCodeHighlighter14);
+  return _createClass(ErrorCodeHighlighterServerMissingVariant);
+}(ErrorCodeHighlighterServerValidation);
+export var ErrorCodeHighlighterServerMissingFileName = /*#__PURE__*/function (_ErrorCodeHighlighter15) {
+  function ErrorCodeHighlighterServerMissingFileName(variantName) {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingFileName);
+    return _callSuper(this, ErrorCodeHighlighterServerMissingFileName, ["Missing fileName - fileName or url is required for variant \"".concat(variantName, "\" when extraFiles are provided")]);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingFileName, _ErrorCodeHighlighter15);
+  return _createClass(ErrorCodeHighlighterServerMissingFileName);
+}(ErrorCodeHighlighterServerValidation);
+export var ErrorCodeHighlighterServerMissingContentLoading = /*#__PURE__*/function (_ErrorCodeHighlighter16) {
+  function ErrorCodeHighlighterServerMissingContentLoading() {
+    _classCallCheck(this, ErrorCodeHighlighterServerMissingContentLoading);
+    return _callSuper(this, ErrorCodeHighlighterServerMissingContentLoading, ["Missing ContentLoading component - ContentLoading component is required for stream highlighting"]);
+  }
+  _inherits(ErrorCodeHighlighterServerMissingContentLoading, _ErrorCodeHighlighter16);
+  return _createClass(ErrorCodeHighlighterServerMissingContentLoading);
+}(ErrorCodeHighlighterServerConfiguration);
+export var ErrorCodeHighlighterServerInvalidClientMode = /*#__PURE__*/function (_ErrorCodeHighlighter17) {
+  function ErrorCodeHighlighterServerInvalidClientMode() {
+    _classCallCheck(this, ErrorCodeHighlighterServerInvalidClientMode);
+    return _callSuper(this, ErrorCodeHighlighterServerInvalidClientMode, ["Invalid client mode - Client only mode with highlightAt: init requires precomputed and parsed source code"]);
+  }
+  _inherits(ErrorCodeHighlighterServerInvalidClientMode, _ErrorCodeHighlighter17);
+  return _createClass(ErrorCodeHighlighterServerInvalidClientMode);
+}(ErrorCodeHighlighterServerValidation);
+
+// Server Loading Errors
+export var ErrorCodeHighlighterServerLoadCodeFailure = /*#__PURE__*/function (_ErrorCodeHighlighter18) {
+  function ErrorCodeHighlighterServerLoadCodeFailure(url, error) {
+    _classCallCheck(this, ErrorCodeHighlighterServerLoadCodeFailure);
+    return _callSuper(this, ErrorCodeHighlighterServerLoadCodeFailure, ["Failed to load code from URL:\n\n".concat(url, "\n\nError:\n").concat(JSON.stringify(error, null, 2))]);
+  }
+  _inherits(ErrorCodeHighlighterServerLoadCodeFailure, _ErrorCodeHighlighter18);
+  return _createClass(ErrorCodeHighlighterServerLoadCodeFailure);
+}(ErrorCodeHighlighterServerLoader);
+export var ErrorCodeHighlighterServerLoadGlobalsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter19) {
+  function ErrorCodeHighlighterServerLoadGlobalsFailure(url, error) {
+    _classCallCheck(this, ErrorCodeHighlighterServerLoadGlobalsFailure);
+    return _callSuper(this, ErrorCodeHighlighterServerLoadGlobalsFailure, ["Failed to load globalsCode from URL:\n\n".concat(url, "\n\nError:\n").concat(JSON.stringify(error, null, 2))]);
+  }
+  _inherits(ErrorCodeHighlighterServerLoadGlobalsFailure, _ErrorCodeHighlighter19);
+  return _createClass(ErrorCodeHighlighterServerLoadGlobalsFailure);
+}(ErrorCodeHighlighterServerLoader);
+export var ErrorCodeHighlighterServerLoadVariantsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter20) {
+  function ErrorCodeHighlighterServerLoadVariantsFailure(url, errors) {
+    _classCallCheck(this, ErrorCodeHighlighterServerLoadVariantsFailure);
+    return _callSuper(this, ErrorCodeHighlighterServerLoadVariantsFailure, ["Failed to load all variants of URL:\n\n".concat(url, ":\n\n").concat(errors.map(function (error) {
+      return error.message;
+    }).join('\n'))]);
+  }
+  _inherits(ErrorCodeHighlighterServerLoadVariantsFailure, _ErrorCodeHighlighter20);
+  return _createClass(ErrorCodeHighlighterServerLoadVariantsFailure);
+}(ErrorCodeHighlighterServerLoader);
+
+// === CLIENT SPECIFIC ERRORS ===
+
+// Client Provider Errors
+export var ErrorCodeHighlighterClientMissingLoadFallbackCode = /*#__PURE__*/function (_ErrorCodeHighlighter21) {
+  function ErrorCodeHighlighterClientMissingLoadFallbackCode(url) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadFallbackCode);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadFallbackCode, ["Missing loadFallbackCode function - loadFallbackCode is required (".concat(url || 'No URL', ") add a <CodeProvider />")]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadFallbackCode, _ErrorCodeHighlighter21);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadFallbackCode);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadVariant = /*#__PURE__*/function (_ErrorCodeHighlighter22) {
+  function ErrorCodeHighlighterClientMissingLoadVariant(url) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadVariant);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadVariant, ["Missing loadVariant function - loadVariant function is required when no initial code is provided (".concat(url || 'No URL', ")")]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadVariant, _ErrorCodeHighlighter22);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadVariant);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadCodeMeta = /*#__PURE__*/function (_ErrorCodeHighlighter23) {
+  function ErrorCodeHighlighterClientMissingLoadCodeMeta(context) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMeta);
+    var message = context ? "Missing loadCodeMeta function - ".concat(context) : 'Missing loadCodeMeta function - loadCodeMeta is required';
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMeta, [message]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadCodeMeta, _ErrorCodeHighlighter23);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMeta);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode = /*#__PURE__*/function (_ErrorCodeHighlighter24) {
+  function ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode(url) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode, ["Missing loadCodeMeta function - loadCodeMeta function is required when no code is provided (".concat(url || 'No URL', ")")]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode, _ErrorCodeHighlighter24);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter25) {
+  function ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals, ["Missing loadCodeMeta function - loadCodeMeta function is required when globalsCode contains string URLs"]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals, _ErrorCodeHighlighter25);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls = /*#__PURE__*/function (_ErrorCodeHighlighter26) {
+  function ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls, ["Missing loadCodeMeta function - \"loadCodeMeta\" function is required for string URLs in globalsCode"]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls, _ErrorCodeHighlighter26);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadSource = /*#__PURE__*/function (_ErrorCodeHighlighter27) {
+  function ErrorCodeHighlighterClientMissingLoadSource(context) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadSource);
+    var message = context ? "Missing loadSource function - ".concat(context) : 'Missing loadSource function - loadSource function is required when no code is provided';
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadSource, [message]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadSource, _ErrorCodeHighlighter27);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadSource);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadSourceForNoCode = /*#__PURE__*/function (_ErrorCodeHighlighter28) {
+  function ErrorCodeHighlighterClientMissingLoadSourceForNoCode() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadSourceForNoCode);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadSourceForNoCode, ["Missing loadSource function - loadSource function is required when no code is provided"]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadSourceForNoCode, _ErrorCodeHighlighter28);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadSourceForNoCode);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls = /*#__PURE__*/function (_ErrorCodeHighlighter29) {
+  function ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls, ["Missing loadSource function - loadSource function is required when code contains unloaded URLs"]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls, _ErrorCodeHighlighter29);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls);
+}(ErrorCodeHighlighterClientProvider);
+
+// Client Validation Errors
+export var ErrorCodeHighlighterClientMissingUrl = /*#__PURE__*/function (_ErrorCodeHighlighter30) {
+  function ErrorCodeHighlighterClientMissingUrl(context) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingUrl);
+    var message = context ? "Missing URL - ".concat(context) : 'Missing URL - URL is required for loading fallback data when no initial code is provided';
+    return _callSuper(this, ErrorCodeHighlighterClientMissingUrl, [message]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingUrl, _ErrorCodeHighlighter30);
+  return _createClass(ErrorCodeHighlighterClientMissingUrl);
+}(ErrorCodeHighlighterClientValidation);
+export var ErrorCodeHighlighterClientMissingUrlForFallback = /*#__PURE__*/function (_ErrorCodeHighlighter31) {
+  function ErrorCodeHighlighterClientMissingUrlForFallback() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingUrlForFallback);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingUrlForFallback, ["Missing URL - URL is required for loading fallback data when no initial code is provided"]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingUrlForFallback, _ErrorCodeHighlighter31);
+  return _createClass(ErrorCodeHighlighterClientMissingUrlForFallback);
+}(ErrorCodeHighlighterClientValidation);
+export var ErrorCodeHighlighterClientMissingUrlForVariants = /*#__PURE__*/function (_ErrorCodeHighlighter32) {
+  function ErrorCodeHighlighterClientMissingUrlForVariants() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingUrlForVariants);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingUrlForVariants, ["Missing URL - URL is required for loading variants when no initial code is provided"]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingUrlForVariants, _ErrorCodeHighlighter32);
+  return _createClass(ErrorCodeHighlighterClientMissingUrlForVariants);
+}(ErrorCodeHighlighterClientValidation);
+export var ErrorCodeHighlighterClientMissingData = /*#__PURE__*/function (_ErrorCodeHighlighter33) {
+  function ErrorCodeHighlighterClientMissingData() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingData);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingData, ["Missing data - CodeHighlighterClient requires either `variants`, `components`, or `code` to be provided."]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingData, _ErrorCodeHighlighter33);
+  return _createClass(ErrorCodeHighlighterClientMissingData);
+}(ErrorCodeHighlighterClientValidation);
+
+// === CONSOLE ERROR CLASSES ===
+
+// Server console errors
+export var ErrorCodeHighlighterServerLoadVariantFailure = /*#__PURE__*/function (_ErrorCodeHighlighter34) {
+  function ErrorCodeHighlighterServerLoadVariantFailure(url, error) {
+    _classCallCheck(this, ErrorCodeHighlighterServerLoadVariantFailure);
+    return _callSuper(this, ErrorCodeHighlighterServerLoadVariantFailure, ["Error loading variant of ".concat(url, ": ").concat(error.message)]);
+  }
+  _inherits(ErrorCodeHighlighterServerLoadVariantFailure, _ErrorCodeHighlighter34);
+  return _createClass(ErrorCodeHighlighterServerLoadVariantFailure);
+}(ErrorCodeHighlighterServerLoader);
+
+// Client console errors
+export var ErrorCodeHighlighterClientLoadFallbackFailure = /*#__PURE__*/function (_ErrorCodeHighlighter35) {
+  function ErrorCodeHighlighterClientLoadFallbackFailure(error) {
+    _classCallCheck(this, ErrorCodeHighlighterClientLoadFallbackFailure);
+    return _callSuper(this, ErrorCodeHighlighterClientLoadFallbackFailure, ["Error loading fallback code: ".concat(error.message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientLoadFallbackFailure, _ErrorCodeHighlighter35);
+  return _createClass(ErrorCodeHighlighterClientLoadFallbackFailure);
+}(ErrorCodeHighlighterClientLoader);
+export var ErrorCodeHighlighterClientLoadVariantsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter36) {
+  function ErrorCodeHighlighterClientLoadVariantsFailure(url, errors) {
+    _classCallCheck(this, ErrorCodeHighlighterClientLoadVariantsFailure);
+    return _callSuper(this, ErrorCodeHighlighterClientLoadVariantsFailure, ["Failed to load variants:\n\n".concat(url, "\n\n").concat(errors.map(function (error) {
+      return error.message;
+    }).join('\n'))]);
+  }
+  _inherits(ErrorCodeHighlighterClientLoadVariantsFailure, _ErrorCodeHighlighter36);
+  return _createClass(ErrorCodeHighlighterClientLoadVariantsFailure);
+}(ErrorCodeHighlighterClientLoader);
+export var ErrorCodeHighlighterClientLoadAllVariantsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter37) {
+  function ErrorCodeHighlighterClientLoadAllVariantsFailure(url, error) {
+    _classCallCheck(this, ErrorCodeHighlighterClientLoadAllVariantsFailure);
+    return _callSuper(this, ErrorCodeHighlighterClientLoadAllVariantsFailure, ["Failed to load all variants\n\n".concat(url, "\n\n").concat(error.message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientLoadAllVariantsFailure, _ErrorCodeHighlighter37);
+  return _createClass(ErrorCodeHighlighterClientLoadAllVariantsFailure);
+}(ErrorCodeHighlighterClientLoader);
+export var ErrorCodeHighlighterClientMissingParseSource = /*#__PURE__*/function (_ErrorCodeHighlighter38) {
+  function ErrorCodeHighlighterClientMissingParseSource(url, isForceClient) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingParseSource);
+    var context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
+    var details = isForceClient ? 'Make sure CodeProvider is set up correctly for client-side parsing.' : 'Code highlighting requires either server-side sourceParser or a CodeProvider for client-side parsing.';
+    return _callSuper(this, ErrorCodeHighlighterClientMissingParseSource, ["".concat(context, ": parseSource function is not available. ").concat(details).concat(url ? " (".concat(url, ")") : '')]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingParseSource, _ErrorCodeHighlighter38);
+  return _createClass(ErrorCodeHighlighterClientMissingParseSource);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingParseCode = /*#__PURE__*/function (_ErrorCodeHighlighter39) {
+  function ErrorCodeHighlighterClientMissingParseCode(url, isForceClient) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingParseCode);
+    var context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
+    var details = isForceClient ? 'Make sure CodeProvider is set up correctly for client-side parsing.' : 'Code highlighting requires either server-side sourceParser or a CodeProvider for client-side parsing.';
+    return _callSuper(this, ErrorCodeHighlighterClientMissingParseCode, ["".concat(context, ": parseCode function is not available. ").concat(details).concat(url ? " (".concat(url, ")") : '')]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingParseCode, _ErrorCodeHighlighter39);
+  return _createClass(ErrorCodeHighlighterClientMissingParseCode);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientMissingParseControlledCode = /*#__PURE__*/function (_ErrorCodeHighlighter40) {
+  function ErrorCodeHighlighterClientMissingParseControlledCode(url, isForceClient) {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingParseControlledCode);
+    var context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
+    var details = isForceClient ? 'Make sure CodeProvider is set up correctly for client-side parsing.' : 'Code highlighting requires either server-side precomputed source or a CodeProvider for client-side parsing.';
+    return _callSuper(this, ErrorCodeHighlighterClientMissingParseControlledCode, ["".concat(context, ": parseControlledCode function is not available. ").concat(details).concat(url ? " (".concat(url, ")") : '')]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingParseControlledCode, _ErrorCodeHighlighter40);
+  return _createClass(ErrorCodeHighlighterClientMissingParseControlledCode);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientTransformProcessingFailure = /*#__PURE__*/function (_ErrorCodeHighlighter41) {
+  function ErrorCodeHighlighterClientTransformProcessingFailure(error) {
+    _classCallCheck(this, ErrorCodeHighlighterClientTransformProcessingFailure);
+    return _callSuper(this, ErrorCodeHighlighterClientTransformProcessingFailure, ["Failed to process transforms: ".concat(error.message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientTransformProcessingFailure, _ErrorCodeHighlighter41);
+  return _createClass(ErrorCodeHighlighterClientTransformProcessingFailure);
+}(ErrorCodeHighlighterClientLoader);
+export var ErrorCodeHighlighterClientMissingLoadVariantForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter42) {
+  function ErrorCodeHighlighterClientMissingLoadVariantForGlobals() {
+    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadVariantForGlobals);
+    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadVariantForGlobals, ["loadVariant function is required for loading missing variants in globalsCode"]);
+  }
+  _inherits(ErrorCodeHighlighterClientMissingLoadVariantForGlobals, _ErrorCodeHighlighter42);
+  return _createClass(ErrorCodeHighlighterClientMissingLoadVariantForGlobals);
+}(ErrorCodeHighlighterClientProvider);
+export var ErrorCodeHighlighterClientLoadVariantFailureForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter43) {
+  function ErrorCodeHighlighterClientLoadVariantFailureForGlobals(variantName, originalUrl, error) {
+    _classCallCheck(this, ErrorCodeHighlighterClientLoadVariantFailureForGlobals);
+    var url = originalUrl || 'No URL';
+    return _callSuper(this, ErrorCodeHighlighterClientLoadVariantFailureForGlobals, ["Failed to load variant ".concat(variantName, " for globalsCode\n\n").concat(url, "\n\n").concat((error == null ? void 0 : error.message) || 'Unknown error')]);
+  }
+  _inherits(ErrorCodeHighlighterClientLoadVariantFailureForGlobals, _ErrorCodeHighlighter43);
+  return _createClass(ErrorCodeHighlighterClientLoadVariantFailureForGlobals);
+}(ErrorCodeHighlighterClientLoader);
+export var ErrorCodeHighlighterClientLoadGlobalsCodeFailure = /*#__PURE__*/function (_ErrorCodeHighlighter44) {
+  function ErrorCodeHighlighterClientLoadGlobalsCodeFailure(url, error) {
+    _classCallCheck(this, ErrorCodeHighlighterClientLoadGlobalsCodeFailure);
+    return _callSuper(this, ErrorCodeHighlighterClientLoadGlobalsCodeFailure, ["Failed to load globalsCode:\n\n".concat(url || 'No URL', "\n\n").concat(error.message)]);
+  }
+  _inherits(ErrorCodeHighlighterClientLoadGlobalsCodeFailure, _ErrorCodeHighlighter44);
+  return _createClass(ErrorCodeHighlighterClientLoadGlobalsCodeFailure);
+}(ErrorCodeHighlighterClientLoader);

package/esm/CodeHighlighter/examineVariant.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Variant examination utility for analyzing variant structure and paths
+ */
+import type { VariantCode } from "./types.js";
+interface PathContextBase {
+  hasMetadata: boolean;
+  maxSourceBackNavigation: number;
+  urlDirectory: string[];
+  rootLevel: string;
+  pathInwardFromRoot: string;
+}
+interface PathContextWithUrl extends PathContextBase {
+  hasUrl: true;
+  actualUrl: string;
+}
+interface PathContextWithoutUrl extends PathContextBase {
+  hasUrl: false;
+  actualUrl?: undefined;
+}
+export type PathContext = PathContextWithUrl | PathContextWithoutUrl;
+/**
+ * Create path context for processing files with extended information
+ */
+export declare function createPathContext(variant: VariantCode): PathContext;
+export {};

package/esm/CodeHighlighter/examineVariant.js

@@ -0,0 +1,73 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+/**
+ * Variant examination utility for analyzing variant structure and paths
+ */
+
+import { getUrlParts, calculateMaxSourceBackNavigation } from "./pathUtils.js";
+/**
+ * Create path context for processing files with extended information
+ */
+export function createPathContext(variant) {
+  var hasMetadata = variant.extraFiles ? Object.values(variant.extraFiles).some(function (file) {
+    return _typeof(file) === 'object' && file.metadata;
+  }) : false;
+
+  // Calculate maxSourceBackNavigation based only on extraFiles structure
+  var maxSourceBackNavigation = variant.extraFiles ? calculateMaxSourceBackNavigation(variant.extraFiles) : 0;
+
+  // Parse URL to determine path structure
+  var urlDirectory = [];
+  var rootLevel = '';
+  var pathInwardFromRoot = '';
+  if (variant.url && variant.url.includes('://')) {
+    try {
+      var pathComponents = getUrlParts(variant.url);
+      if (pathComponents.length > 0) {
+        // Check if the last component looks like a filename (has an extension)
+        var lastComponent = pathComponents[pathComponents.length - 1];
+        var hasFileExtension = lastComponent.includes('.') && /\.[a-zA-Z0-9]+$/.test(lastComponent);
+
+        // If it has a file extension, exclude it from directory components
+        var directoryComponents = hasFileExtension ? pathComponents.slice(0, -1) : pathComponents;
+        urlDirectory = directoryComponents;
+        rootLevel = directoryComponents[0] || '';
+
+        // Only calculate pathInwardFromRoot if there's actual back navigation
+        if (maxSourceBackNavigation > 0 && directoryComponents.length >= maxSourceBackNavigation) {
+          // Take the last maxSourceBackNavigation components as the pathInwardFromRoot
+          var relevantComponents = directoryComponents.slice(-maxSourceBackNavigation);
+          pathInwardFromRoot = relevantComponents.join('/');
+        }
+      }
+    } catch (_unused) {
+      // If URL parsing fails, keep defaults
+      urlDirectory = [];
+      rootLevel = '';
+      pathInwardFromRoot = '';
+    }
+  }
+
+  // We keep the URL info for compatibility, but don't use it for calculations
+  var hasUrl = Boolean(variant.url);
+  var actualUrl = variant.url;
+  if (hasUrl && actualUrl) {
+    return {
+      hasUrl: true,
+      hasMetadata: hasMetadata,
+      maxSourceBackNavigation: maxSourceBackNavigation,
+      urlDirectory: urlDirectory,
+      rootLevel: rootLevel,
+      pathInwardFromRoot: pathInwardFromRoot,
+      actualUrl: actualUrl
+    };
+  }
+  return {
+    hasUrl: false,
+    hasMetadata: hasMetadata,
+    maxSourceBackNavigation: maxSourceBackNavigation,
+    urlDirectory: urlDirectory,
+    rootLevel: rootLevel,
+    pathInwardFromRoot: pathInwardFromRoot,
+    actualUrl: undefined
+  };
+}

package/esm/CodeHighlighter/hasAllVariants.d.ts

@@ -0,0 +1,27 @@
+import { Code } from "./types.js";
+/**
+ * Determines if all code variants are fully loaded and ready to render the complete content component.
+ *
+ * This function validates that we have all necessary data to transition from fallback/loading state
+ * to the full interactive code highlighter. It checks both main files and extra files for all variants.
+ *
+ * Used primarily to determine when to show the full Content component instead of ContentLoading
+ * fallback, ensuring a smooth user experience without rendering errors.
+ *
+ * @param variants - Array of variant names that must all be ready (e.g., ['javascript', 'typescript'])
+ * @param code - The code object containing variant data
+ * @param needsHighlight - Whether all sources need to be syntax highlighted (hast nodes, not strings)
+ * @returns True if all variants and their files are loaded and ready for full rendering
+ *
+ * @example
+ * ```typescript
+ * const readyForContent = hasAllVariants(['js', 'ts'], codeData, true);
+ *
+ * if (readyForContent) {
+ *   return <Content {...contentProps} />; // Full interactive component
+ * } else {
+ *   return <ContentLoading {...loadingProps} />; // Fallback state
+ * }
+ * ```
+ */
+export declare function hasAllVariants(variants: string[], code: Code, needsHighlight?: boolean): boolean;

package/esm/CodeHighlighter/hasAllVariants.js

@@ -0,0 +1,63 @@
+/**
+ * Checks if a code source is fully loaded and ready for rendering.
+ *
+ * @param code - Code object with source property
+ * @param needsHighlight - Whether the source needs to be syntax highlighted (not just a string)
+ * @returns True if the source is loaded and meets highlighting requirements
+ */
+function isSourceLoaded(code, needsHighlight) {
+  if (!code.source) {
+    return false;
+  }
+  if (typeof code.source === 'string' && needsHighlight) {
+    return false;
+  }
+
+  // if it's a hast node or hastJson, we assume it's loaded
+  return true;
+}
+
+/**
+ * Determines if all code variants are fully loaded and ready to render the complete content component.
+ *
+ * This function validates that we have all necessary data to transition from fallback/loading state
+ * to the full interactive code highlighter. It checks both main files and extra files for all variants.
+ *
+ * Used primarily to determine when to show the full Content component instead of ContentLoading
+ * fallback, ensuring a smooth user experience without rendering errors.
+ *
+ * @param variants - Array of variant names that must all be ready (e.g., ['javascript', 'typescript'])
+ * @param code - The code object containing variant data
+ * @param needsHighlight - Whether all sources need to be syntax highlighted (hast nodes, not strings)
+ * @returns True if all variants and their files are loaded and ready for full rendering
+ *
+ * @example
+ * ```typescript
+ * const readyForContent = hasAllVariants(['js', 'ts'], codeData, true);
+ *
+ * if (readyForContent) {
+ *   return <Content {...contentProps} />; // Full interactive component
+ * } else {
+ *   return <ContentLoading {...loadingProps} />; // Fallback state
+ * }
+ * ```
+ */
+export function hasAllVariants(variants, code, needsHighlight) {
+  return variants.every(function (variant) {
+    var codeVariant = code == null ? void 0 : code[variant];
+    if (!codeVariant || typeof codeVariant === 'string' || !isSourceLoaded(codeVariant, needsHighlight)) {
+      return false;
+    }
+    var extraFiles = codeVariant.extraFiles;
+    if (!extraFiles) {
+      return true;
+    }
+    return Object.keys(extraFiles).every(function (file) {
+      var extraFile = extraFiles[file];
+      if (!extraFile || typeof extraFile === 'string' || !isSourceLoaded(extraFile, needsHighlight)) {
+        return false;
+      }
+      return true;
+    });
+  });
+}

package/esm/CodeHighlighter/index.d.ts

@@ -0,0 +1 @@
+export * from "./CodeHighlighter.js";

package/esm/CodeHighlighter/index.js

@@ -0,0 +1 @@
+export * from "./CodeHighlighter.js";

package/esm/CodeHighlighter/loadFallbackCode.d.ts

@@ -0,0 +1,10 @@
+import type { Code, VariantExtraFiles, VariantSource, LoadFallbackCodeOptions } from "./types.js";
+export type FallbackVariants = {
+  code: Code;
+  initialFilename: string | undefined;
+  initialSource: VariantSource;
+  initialExtraFiles?: VariantExtraFiles;
+  allFileNames: string[];
+  processedGlobalsCode?: Array<Code>;
+};
+export declare function loadFallbackCode(url: string, initialVariant: string, loaded: Code | undefined, options?: LoadFallbackCodeOptions): Promise<FallbackVariants>;