@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.4

package/esm/CodeHighlighter/errors.js

@@ -1,441 +1,289 @@
-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));
+export class ErrorCodeHighlighter extends Error {
+  constructor(message) {
+    super(`CodeHighlighter: ${message}`);
+    this.name = this.constructor.name;
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterServer extends ErrorCodeHighlighter {
+  constructor(message) {
+    super(`[Server] ${message}`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterClient extends ErrorCodeHighlighter {
+  constructor(message) {
+    super(`[Client] ${message}`);
+  }
+}
 
 // === 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);
+export class ErrorCodeHighlighterServerConfiguration extends ErrorCodeHighlighterServer {
+  constructor(message) {
+    super(`[Configuration] ${message}`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterServerLoader extends ErrorCodeHighlighterServer {
+  constructor(message) {
+    super(`[Loader] ${message}`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterServerValidation extends ErrorCodeHighlighterServer {
+  constructor(message) {
+    super(`[Validation] ${message}`);
+  }
+}
 
 // === 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);
+export class ErrorCodeHighlighterClientConfiguration extends ErrorCodeHighlighterClient {
+  constructor(message) {
+    super(`[Configuration] ${message}`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterClientLoader extends ErrorCodeHighlighterClient {
+  constructor(message) {
+    super(`[Loader] ${message}`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterClientValidation extends ErrorCodeHighlighterClient {
+  constructor(message) {
+    super(`[Validation] ${message}`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterClientProvider extends ErrorCodeHighlighterClient {
+  constructor(message) {
+    super(`[Provider] ${message}`);
+  }
+}
 
 // === 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 highlightAfter: init requires precomputed and parsed source code"]);
-  }
-  _inherits(ErrorCodeHighlighterServerInvalidClientMode, _ErrorCodeHighlighter17);
-  return _createClass(ErrorCodeHighlighterServerInvalidClientMode);
-}(ErrorCodeHighlighterServerValidation);
+export class ErrorCodeHighlighterServerMissingLoadCodeMeta extends ErrorCodeHighlighterServerConfiguration {
+  constructor(context) {
+    const message = context ? `Missing loadCodeMeta function - ${context}` : 'Missing loadCodeMeta function - No code provided and "loadCodeMeta" function is not defined';
+    super(message);
+  }
+}
+export class ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals extends ErrorCodeHighlighterServerConfiguration {
+  constructor() {
+    super('Missing loadCodeMeta function - loadCodeMeta function is required when globalsCode contains string URLs');
+  }
+}
+export class ErrorCodeHighlighterServerMissingUrl extends ErrorCodeHighlighterServerValidation {
+  constructor(context) {
+    const message = context ? `Missing URL - URL is required ${context}` : 'Missing URL - URL is required for loading initial source';
+    super(message);
+  }
+}
+export class ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta extends ErrorCodeHighlighterServerValidation {
+  constructor() {
+    super('Missing URL - URL is required when loading code with "loadCodeMeta"');
+  }
+}
+export class ErrorCodeHighlighterServerInvalidProps extends ErrorCodeHighlighterServerValidation {
+  constructor() {
+    super('Invalid props - Cannot provide both "children" and "code" or "precompute" props');
+  }
+}
+export class ErrorCodeHighlighterServerMissingData extends ErrorCodeHighlighterServerValidation {
+  constructor() {
+    super('Missing data - No code or components provided');
+  }
+}
+export class ErrorCodeHighlighterServerMissingVariant extends ErrorCodeHighlighterServerValidation {
+  constructor(variantName) {
+    super(`Missing variant - No code or component for variant "${variantName}"`);
+  }
+}
+export class ErrorCodeHighlighterServerMissingFileName extends ErrorCodeHighlighterServerValidation {
+  constructor(variantName) {
+    super(`Missing fileName - fileName or url is required for variant "${variantName}" when extraFiles are provided`);
+  }
+}
+export class ErrorCodeHighlighterServerMissingContentLoading extends ErrorCodeHighlighterServerConfiguration {
+  constructor() {
+    super(`Missing ContentLoading component - ContentLoading component is required for stream highlighting`);
+  }
+}
+export class ErrorCodeHighlighterServerInvalidClientMode extends ErrorCodeHighlighterServerValidation {
+  constructor() {
+    super(`Invalid client mode - Client only mode with highlightAfter: init requires precomputed and parsed source code`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterServerLoadCodeFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url, error) {
+    super(`Failed to load code from URL:\n\n${url}\n\nError:\n${JSON.stringify(error, null, 2)}`);
+  }
+}
+export class ErrorCodeHighlighterServerLoadGlobalsFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url, error) {
+    super(`Failed to load globalsCode from URL:\n\n${url}\n\nError:\n${JSON.stringify(error, null, 2)}`);
+  }
+}
+export class ErrorCodeHighlighterServerLoadVariantsFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url, errors) {
+    super(`Failed to load all variants of URL:\n\n${url}:\n\n${errors.map(error => error.message).join('\n')}`);
+  }
+}
 
 // === CLIENT SPECIFIC ERRORS ===
 
 // Client Provider Errors
-export var ErrorCodeHighlighterClientMissingLoadFallbackCode = /*#__PURE__*/function (_ErrorCodeHighlighter21) {
-  function ErrorCodeHighlighterClientMissingLoadFallbackCode(url) {
-    _classCallCheck(this, ErrorCodeHighlighterClientMissingLoadFallbackCode);
-    return _callSuper(this, ErrorCodeHighlighterClientMissingLoadFallbackCode, ["Missing loadCodeFallback function - loadCodeFallback 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 loadCodeVariant function - loadCodeVariant 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);
+export class ErrorCodeHighlighterClientMissingLoadFallbackCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url) {
+    super(`Missing loadCodeFallback function - loadCodeFallback is required (${url || 'No URL'}) add a <CodeProvider />`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadVariant extends ErrorCodeHighlighterClientProvider {
+  constructor(url) {
+    super(`Missing loadCodeVariant function - loadCodeVariant function is required when no initial code is provided (${url || 'No URL'})`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadCodeMeta extends ErrorCodeHighlighterClientProvider {
+  constructor(context) {
+    const message = context ? `Missing loadCodeMeta function - ${context}` : 'Missing loadCodeMeta function - loadCodeMeta is required';
+    super(message);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url) {
+    super(`Missing loadCodeMeta function - loadCodeMeta function is required when no code is provided (${url || 'No URL'})`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals extends ErrorCodeHighlighterClientProvider {
+  constructor() {
+    super(`Missing loadCodeMeta function - loadCodeMeta function is required when globalsCode contains string URLs`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls extends ErrorCodeHighlighterClientProvider {
+  constructor() {
+    super(`Missing loadCodeMeta function - "loadCodeMeta" function is required for string URLs in globalsCode`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadSource extends ErrorCodeHighlighterClientProvider {
+  constructor(context) {
+    const message = context ? `Missing loadSource function - ${context}` : 'Missing loadSource function - loadSource function is required when no code is provided';
+    super(message);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadSourceForNoCode extends ErrorCodeHighlighterClientProvider {
+  constructor() {
+    super(`Missing loadSource function - loadSource function is required when no code is provided`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls extends ErrorCodeHighlighterClientProvider {
+  constructor() {
+    super(`Missing loadSource function - loadSource function is required when code contains unloaded URLs`);
+  }
+}
 
 // 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);
+export class ErrorCodeHighlighterClientMissingUrl extends ErrorCodeHighlighterClientValidation {
+  constructor(context) {
+    const message = context ? `Missing URL - ${context}` : 'Missing URL - URL is required for loading fallback data when no initial code is provided';
+    super(message);
+  }
+}
+export class ErrorCodeHighlighterClientMissingUrlForFallback extends ErrorCodeHighlighterClientValidation {
+  constructor() {
+    super(`Missing URL - URL is required for loading fallback data when no initial code is provided`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingUrlForVariants extends ErrorCodeHighlighterClientValidation {
+  constructor() {
+    super(`Missing URL - URL is required for loading variants when no initial code is provided`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingData extends ErrorCodeHighlighterClientValidation {
+  constructor() {
+    super(`Missing data - CodeHighlighterClient requires either \`variants\`, \`components\`, or \`code\` to be provided.`);
+  }
+}
 
 // === 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);
+export class ErrorCodeHighlighterServerLoadVariantFailure extends ErrorCodeHighlighterServerLoader {
+  constructor(url, error) {
+    super(`Error loading variant of ${url}: ${error.message}`);
+  }
+}
 
 // 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, ["loadCodeVariant 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);
+export class ErrorCodeHighlighterClientLoadFallbackFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(error) {
+    super(`Error loading fallback code: ${error.message}`);
+  }
+}
+export class ErrorCodeHighlighterClientLoadVariantsFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(url, errors) {
+    super(`Failed to load variants:\n\n${url}\n\n${errors.map(error => error.message).join('\n')}`);
+  }
+}
+export class ErrorCodeHighlighterClientLoadAllVariantsFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(url, error) {
+    super(`Failed to load all variants\n\n${url}\n\n${error.message}`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingParseSource extends ErrorCodeHighlighterClientProvider {
+  constructor(url, isForceClient) {
+    const context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
+    const 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.';
+    super(`${context}: parseSource function is not available. ${details}${url ? ` (${url})` : ''}`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingParseCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url, isForceClient) {
+    const context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
+    const 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.';
+    super(`${context}: parseCode function is not available. ${details}${url ? ` (${url})` : ''}`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingParseControlledCode extends ErrorCodeHighlighterClientProvider {
+  constructor(url, isForceClient) {
+    const context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
+    const 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.';
+    super(`${context}: parseControlledCode function is not available. ${details}${url ? ` (${url})` : ''}`);
+  }
+}
+export class ErrorCodeHighlighterClientTransformProcessingFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(error) {
+    super(`Failed to process transforms: ${error.message}`);
+  }
+}
+export class ErrorCodeHighlighterClientMissingLoadVariantForGlobals extends ErrorCodeHighlighterClientProvider {
+  constructor() {
+    super(`loadCodeVariant function is required for loading missing variants in globalsCode`);
+  }
+}
+export class ErrorCodeHighlighterClientLoadVariantFailureForGlobals extends ErrorCodeHighlighterClientLoader {
+  constructor(variantName, originalUrl, error) {
+    const url = originalUrl || 'No URL';
+    super(`Failed to load variant ${variantName} for globalsCode\n\n${url}\n\n${error?.message || 'Unknown error'}`);
+  }
+}
+export class ErrorCodeHighlighterClientLoadGlobalsCodeFailure extends ErrorCodeHighlighterClientLoader {
+  constructor(url, error) {
+    super(`Failed to load globalsCode:\n\n${url || 'No URL'}\n\n${error.message}`);
+  }
+}