@mui/internal-docs-infra 0.1.1-alpha.0 → 0.1.1-alpha.10

package/build/esm/CodeHighlighter/CodeHighlighterClient.js

@@ -1,399 +0,0 @@
-'use client';
-
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import * as React from 'react';
-import { useCodeContext } from "../CodeProvider/CodeContext.js";
-import { CodeHighlighterContext } from "./CodeHighlighterContext.js";
-import { maybeInitialData } from "./maybeInitialData.js";
-import { loadFallbackCode } from "./loadFallbackCode.js";
-import { hasAllVariants } from "./hasAllVariants.js";
-import { loadVariant } from "./loadVariant.js";
-import { CodeHighlighterFallbackContext } from "./CodeHighlighterFallbackContext.js";
-import { useControlledCode } from "../CodeControllerContext/index.js";
-import { codeToFallbackProps } from "./codeToFallbackProps.js";
-import { parseCode } from "./parseCode.js";
-import { applyTransforms, getAvailableTransforms } from "./transformCode.js";
-import { parseControlledCode } from "./parseControlledCode.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-var DEBUG = false; // Set to true for debugging purposes
-
-function useInitialData(_ref) {
-  var variants = _ref.variants,
-    variantName = _ref.variantName,
-    code = _ref.code,
-    setCode = _ref.setCode,
-    fileName = _ref.fileName,
-    url = _ref.url,
-    highlightAt = _ref.highlightAt,
-    fallbackUsesExtraFiles = _ref.fallbackUsesExtraFiles,
-    fallbackUsesAllVariants = _ref.fallbackUsesAllVariants,
-    isControlled = _ref.isControlled;
-  var _useCodeContext = useCodeContext(),
-    sourceParser = _useCodeContext.sourceParser,
-    loadCodeMeta = _useCodeContext.loadCodeMeta,
-    loadVariantMeta = _useCodeContext.loadVariantMeta,
-    loadSource = _useCodeContext.loadSource;
-  var _React$useMemo = React.useMemo(function () {
-      return maybeInitialData(variants, variantName, code, fileName, highlightAt === 'init', fallbackUsesExtraFiles, fallbackUsesAllVariants);
-    }, [variants, variantName, code, fileName, highlightAt, fallbackUsesExtraFiles, fallbackUsesAllVariants]),
-    initialData = _React$useMemo.initialData,
-    reason = _React$useMemo.reason;
-
-  // TODO: fallbackInitialRenderOnly option? this would mean we can't fetch fallback data on the client side
-  // Load initial data if not provided
-  React.useEffect(function () {
-    if (initialData || isControlled) {
-      return;
-    }
-
-    // TODO: abort controller
-
-    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-      var loaded;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            if (DEBUG) {
-              // eslint-disable-next-line no-console
-              console.log('Loading initial data for CodeHighlighterClient: ', reason);
-            }
-            _context.next = 3;
-            return loadFallbackCode(url, variantName, code, highlightAt === 'init', fallbackUsesExtraFiles, fallbackUsesAllVariants, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, fileName, variants)["catch"](function (error) {
-              return {
-                error: error
-              };
-            });
-          case 3:
-            loaded = _context.sent;
-            if ('error' in loaded) {
-              // TODO: handle error
-            } else {
-              setCode(loaded.code);
-            }
-          case 5:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    }))();
-  }, [initialData, reason, isControlled, variantName, code, setCode, highlightAt, url, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, fallbackUsesExtraFiles, fallbackUsesAllVariants, fileName, variants]);
-}
-function useAllVariants(_ref3) {
-  var readyForContent = _ref3.readyForContent,
-    variants = _ref3.variants,
-    isControlled = _ref3.isControlled,
-    url = _ref3.url,
-    code = _ref3.code,
-    setCode = _ref3.setCode;
-  var _useCodeContext2 = useCodeContext(),
-    loadCodeMeta = _useCodeContext2.loadCodeMeta,
-    loadVariantMeta = _useCodeContext2.loadVariantMeta,
-    loadSource = _useCodeContext2.loadSource;
-  React.useEffect(function () {
-    if (readyForContent || isControlled) {
-      return;
-    }
-
-    // TODO: abort controller
-
-    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-      var loadedCode, result, resultCode, errors, _iterator, _step, item;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            loadedCode = code;
-            if (loadedCode) {
-              _context2.next = 7;
-              break;
-            }
-            if (loadCodeMeta) {
-              _context2.next = 4;
-              break;
-            }
-            throw new Error('"loadCodeMeta" function is required when no code is provided');
-          case 4:
-            _context2.next = 6;
-            return loadCodeMeta(url);
-          case 6:
-            loadedCode = _context2.sent;
-          case 7:
-            _context2.next = 9;
-            return Promise.all(variants.map(function (name) {
-              return loadVariant(url, name, loadedCode[name], undefined,
-              // sourceParser - skip parsing
-              loadSource, loadVariantMeta, undefined,
-              // sourceTransformers - skip transforming
-              {
-                disableParsing: true,
-                disableTransforms: true
-              }).then(function (variant) {
-                return {
-                  name: name,
-                  variant: variant
-                };
-              })["catch"](function (error) {
-                return {
-                  error: error
-                };
-              });
-            }));
-          case 9:
-            result = _context2.sent;
-            resultCode = {};
-            errors = [];
-            _iterator = _createForOfIteratorHelper(result);
-            try {
-              for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                item = _step.value;
-                if ('error' in item) {
-                  errors.push(item.error);
-                } else {
-                  resultCode[item.name] = item.variant.code;
-                }
-              }
-            } catch (err) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
-            }
-            if (errors.length > 0) {
-              // TODO: handle error
-            } else {
-              setCode(resultCode);
-            }
-          case 15:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2);
-    }))();
-  }, [readyForContent, isControlled, variants, url, code, setCode, loadSource, loadVariantMeta, loadCodeMeta]);
-  return {
-    readyForContent: readyForContent
-  };
-}
-function useCodeParsing(_ref5) {
-  var code = _ref5.code,
-    readyForContent = _ref5.readyForContent;
-  var _useCodeContext3 = useCodeContext(),
-    parseSource = _useCodeContext3.parseSource;
-
-  // Parse the internal code state when ready
-  var parsedCode = React.useMemo(function () {
-    if (!code || !readyForContent || !parseSource) {
-      return undefined;
-    }
-    return parseCode(code, parseSource);
-  }, [code, readyForContent, parseSource]);
-  return {
-    parsedCode: parsedCode
-  };
-}
-function useCodeTransforms(_ref6) {
-  var parsedCode = _ref6.parsedCode,
-    variantName = _ref6.variantName;
-  var _useCodeContext4 = useCodeContext(),
-    sourceParser = _useCodeContext4.sourceParser;
-  var _React$useState = React.useState(undefined),
-    _React$useState2 = _slicedToArray(_React$useState, 2),
-    transformedCode = _React$useState2[0],
-    setTransformedCode = _React$useState2[1];
-
-  // Get available transforms from the current variant (separate memo for efficiency)
-  var availableTransforms = React.useMemo(function () {
-    return getAvailableTransforms(parsedCode, variantName);
-  }, [parsedCode, variantName]);
-
-  // Effect to compute transformations for all variants
-  React.useEffect(function () {
-    if (!parsedCode || !sourceParser) {
-      setTransformedCode(parsedCode);
-      return;
-    }
-
-    // Process transformations for all variants
-    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-      var parseSource, enhanced;
-      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-        while (1) switch (_context3.prev = _context3.next) {
-          case 0:
-            _context3.prev = 0;
-            _context3.next = 3;
-            return sourceParser;
-          case 3:
-            parseSource = _context3.sent;
-            _context3.next = 6;
-            return applyTransforms(parsedCode, parseSource);
-          case 6:
-            enhanced = _context3.sent;
-            setTransformedCode(enhanced);
-            _context3.next = 14;
-            break;
-          case 10:
-            _context3.prev = 10;
-            _context3.t0 = _context3["catch"](0);
-            console.error('Failed to process transforms:', _context3.t0);
-            setTransformedCode(parsedCode);
-          case 14:
-          case "end":
-            return _context3.stop();
-        }
-      }, _callee3, null, [[0, 10]]);
-    }))();
-  }, [parsedCode, sourceParser]);
-  return {
-    transformedCode: transformedCode,
-    availableTransforms: availableTransforms
-  };
-}
-function useControlledCodeParsing(_ref8) {
-  var controlledCode = _ref8.controlledCode;
-  var _useCodeContext5 = useCodeContext(),
-    parseSource = _useCodeContext5.parseSource;
-
-  // Parse the controlled code separately (no need to check readyForContent)
-  var parsedControlledCode = React.useMemo(function () {
-    if (!controlledCode || !parseSource) {
-      return undefined;
-    }
-    return parseControlledCode(controlledCode, parseSource);
-  }, [controlledCode, parseSource]);
-  return {
-    parsedControlledCode: parsedControlledCode
-  };
-}
-export function CodeHighlighterClient(props) {
-  var _activeCode$variantNa, _activeCode$variantNa2;
-  var _useControlledCode = useControlledCode(),
-    controlledCode = _useControlledCode.controlledCode,
-    controlledSelection = _useControlledCode.controlledSelection,
-    controlledSetCode = _useControlledCode.controlledSetCode,
-    controlledSetSelection = _useControlledCode.controlledSetSelection,
-    controlledComponents = _useControlledCode.controlledComponents;
-  var isControlled = Boolean(props.code || controlledCode);
-
-  // TODO: props.code is for controlled components, props.precompute is for precomputed code
-  // props.code should only be highlighted, but no additional fetching should be done
-  // this is the case with live demos where the code can be edited by the user
-  // then maybe props.code shouldn't allow highlighted code, only strings?
-  // this is a code highlighter afterall, why would they want to control the highlighting aspect?
-
-  // TODO: should we empty this state if controlled?
-  var _React$useState3 = React.useState(_typeof(props.precompute) === 'object' ? props.precompute : undefined),
-    _React$useState4 = _slicedToArray(_React$useState3, 2),
-    code = _React$useState4[0],
-    setCode = _React$useState4[1];
-
-  // TODO: if using props.variant, then the variant is controlled and we can't use our own state
-  // does props.variant make any sense instead of controlledSelection?.variant?
-  var _React$useState5 = React.useState({
-      variant: props.initialVariant || props.defaultVariant || 'Default'
-    }),
-    _React$useState6 = _slicedToArray(_React$useState5, 2),
-    selection = _React$useState6[0],
-    setSelection = _React$useState6[1];
-  var variantName = (controlledSelection == null ? void 0 : controlledSelection.variant) || props.variant || selection.variant;
-  var activeCode = controlledCode || props.code || code;
-  var initialFilename = _typeof(activeCode == null ? void 0 : activeCode[variantName]) === 'object' && (activeCode != null && (_activeCode$variantNa = activeCode[variantName]) != null && _activeCode$variantNa.filesOrder ? activeCode[variantName].filesOrder[0] : activeCode == null || (_activeCode$variantNa2 = activeCode[variantName]) == null ? void 0 : _activeCode$variantNa2.fileName);
-  var fileName = (controlledSelection == null ? void 0 : controlledSelection.fileName) || props.fileName || initialFilename || 'index.js';
-  var variants = props.variants || Object.keys(props.components || activeCode || {});
-  var url = props.url,
-    highlightAt = props.highlightAt,
-    fallbackUsesExtraFiles = props.fallbackUsesExtraFiles,
-    fallbackUsesAllVariants = props.fallbackUsesAllVariants;
-  useInitialData({
-    variants: variants,
-    variantName: variantName,
-    code: code,
-    setCode: setCode,
-    fileName: fileName,
-    url: url,
-    highlightAt: highlightAt,
-    fallbackUsesExtraFiles: fallbackUsesExtraFiles,
-    fallbackUsesAllVariants: fallbackUsesAllVariants,
-    isControlled: isControlled
-  });
-  var readyForContent = React.useMemo(function () {
-    if (!code) {
-      return false;
-    }
-    return hasAllVariants(variants, code);
-  }, [code, variants]);
-
-  // Separate check for activeCode to determine when to show fallback
-  var activeCodeReady = React.useMemo(function () {
-    if (!activeCode) {
-      return false;
-    }
-
-    // Controlled code is always ready since it comes from editing already-ready code
-    if (controlledCode) {
-      return true;
-    }
-
-    // For regular code, use the existing hasAllVariants function
-    var regularCode = props.code || code;
-    return regularCode ? hasAllVariants(variants, regularCode) : false;
-  }, [activeCode, controlledCode, variants, props.code, code]);
-  useAllVariants({
-    readyForContent: readyForContent,
-    variants: variants,
-    isControlled: isControlled,
-    url: url,
-    code: code,
-    setCode: setCode
-  });
-  var _useCodeParsing = useCodeParsing({
-      code: props.code || code,
-      readyForContent: readyForContent || Boolean(props.code)
-    }),
-    parsedCode = _useCodeParsing.parsedCode;
-  var _useCodeTransforms = useCodeTransforms({
-      parsedCode: parsedCode,
-      variantName: variantName
-    }),
-    transformedCode = _useCodeTransforms.transformedCode,
-    availableTransforms = _useCodeTransforms.availableTransforms;
-  var _useControlledCodePar = useControlledCodeParsing({
-      controlledCode: controlledCode
-    }),
-    parsedControlledCode = _useControlledCodePar.parsedControlledCode;
-
-  // Determine the final overlaid code (controlled takes precedence)
-  var overlaidCode = parsedControlledCode || transformedCode;
-
-  // For fallback context, use the processed code or fall back to non-controlled code
-  var codeForFallback = overlaidCode || (controlledCode ? undefined : props.code || code);
-  var fallbackContext = React.useMemo(function () {
-    return codeToFallbackProps(variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants);
-  }, [variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants]);
-  var context = React.useMemo(function () {
-    return {
-      code: overlaidCode || transformedCode,
-      // Use processed/transformed code
-      setCode: controlledSetCode,
-      selection: controlledSelection || selection,
-      setSelection: controlledSetSelection || setSelection,
-      components: controlledComponents || props.components,
-      availableTransforms: availableTransforms
-    };
-  }, [overlaidCode, transformedCode, controlledSetCode, selection, controlledSelection, controlledSetSelection, controlledComponents, props.components, availableTransforms]);
-  if (!props.variants && !props.components && !activeCode) {
-    throw new Error('CodeHighlighterClient requires either `variants`, `components`, or `code` to be provided.');
-  }
-  var fallback = props.fallback;
-  if (fallback && !props.skipFallback && !activeCodeReady) {
-    return /*#__PURE__*/_jsx(CodeHighlighterFallbackContext.Provider, {
-      value: fallbackContext,
-      children: fallback
-    });
-  }
-  return /*#__PURE__*/_jsx(CodeHighlighterContext.Provider, {
-    value: context,
-    children: props.children
-  });
-}

package/build/esm/CodeHighlighter/CodeHighlighterContext.d.ts

@@ -1,14 +0,0 @@
-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[];
-}
-export declare const CodeHighlighterContext: React.Context<CodeHighlighterContextType | undefined>;
-export declare function useCodeHighlighterContext(): CodeHighlighterContextType;
-export declare function useCodeHighlighterContextOptional(): CodeHighlighterContextType | undefined;

package/build/esm/CodeHighlighter/CodeHighlighterContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CodeHighlighterContext.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/CodeHighlighterContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,cAAc,GAAG,SAAS,CAAC,CAAC,CAAC;IAC3E,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,YAAY,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC7C,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,eAAO,MAAM,sBAAsB,uDAElC,CAAC;AAEF,wBAAgB,yBAAyB,+BAQxC;AAED,wBAAgB,iCAAiC,2CAEhD"}

package/build/esm/CodeHighlighter/CodeHighlighterFallbackContext.d.ts

@@ -1,7 +0,0 @@
-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/build/esm/CodeHighlighter/CodeHighlighterFallbackContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CodeHighlighterFallbackContext.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/CodeHighlighterFallbackContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,8BAA+B,SAAQ,qBAAqB;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;CACvD;AAED,eAAO,MAAM,8BAA8B,2DAE/B,CAAC;AAEb,wBAAgB,iCAAiC,mCAQhD"}

package/build/esm/CodeHighlighter/applyTransform.d.ts

@@ -1,19 +0,0 @@
-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/build/esm/CodeHighlighter/applyTransform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"applyTransform.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/applyTransform.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,GACnB,aAAa,CA0Cf;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EAAE,GACtB,aAAa,CAQf"}

package/build/esm/CodeHighlighter/codeToFallbackProps.d.ts

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

package/build/esm/CodeHighlighter/codeToFallbackProps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codeToFallbackProps.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/codeToFallbackProps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAsC,MAAM,SAAS,CAAC;AAexF,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,IAAI,EACX,QAAQ,CAAC,EAAE,MAAM,EACjB,aAAa,UAAQ,EACrB,gBAAgB,UAAQ,GACvB,mBAAmB,CAyDrB"}

package/build/esm/CodeHighlighter/hasAllVariants.d.ts

@@ -1,2 +0,0 @@
-import { Code } from "./types.js";
-export declare function hasAllVariants(variants: string[], code: Code, needsHighlight?: boolean): boolean;

package/build/esm/CodeHighlighter/hasAllVariants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hasAllVariants.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/hasAllVariants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiB,MAAM,SAAS,CAAC;AAgB9C,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,EAAE,OAAO,WA6BtF"}

package/build/esm/CodeHighlighter/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./CodeHighlighter.js";
-export * from "./CodeHighlighterClient.js";
-export * from "./types.js";
-export * from "./applyTransform.js";

package/build/esm/CodeHighlighter/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC"}

package/build/esm/CodeHighlighter/loadFallbackCode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadFallbackCode.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/loadFallbackCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,eAAe,EACf,aAAa,EACb,YAAY,EAEb,MAAM,SAAS,CAAC;AAuCjB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,IAAI,GAAG,SAAS,EACxB,eAAe,CAAC,EAAE,OAAO,EACzB,sBAAsB,CAAC,EAAE,OAAO,EAChC,uBAAuB,CAAC,EAAE,OAAO,EACjC,YAAY,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EACnC,UAAU,CAAC,EAAE,UAAU,EACvB,eAAe,CAAC,EAAE,eAAe,EACjC,YAAY,CAAC,EAAE,YAAY,EAC3B,eAAe,CAAC,EAAE,MAAM,EACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAmS3B"}

package/build/esm/CodeHighlighter/loadVariant.d.ts

@@ -1,11 +0,0 @@
-import type { VariantCode, ParseSource, LoadSource, LoadVariantMeta, SourceTransformers, LoadFileOptions } from "./types.js";
-/**
- * Loads a variant with support for recursive extra file loading.
- * The loadSource function can now return extraFiles that will be loaded recursively.
- * Supports both relative and absolute paths for extra files.
- * Uses Promise.all for efficient parallel loading of extra files.
- */
-export declare function loadVariant(url: string, variantName: string, variant: VariantCode | string | undefined, sourceParser?: Promise<ParseSource>, loadSource?: LoadSource, loadVariantMeta?: LoadVariantMeta, sourceTransformers?: SourceTransformers, options?: LoadFileOptions): Promise<{
-  code: VariantCode;
-  dependencies: string[];
-}>;

package/build/esm/CodeHighlighter/loadVariant.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadVariant.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/loadVariant.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,WAAW,EAIX,WAAW,EACX,UAAU,EACV,eAAe,EACf,kBAAkB,EAClB,eAAe,EAChB,MAAM,SAAS,CAAC;AA4ajB;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,EACzC,YAAY,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EACnC,UAAU,CAAC,EAAE,UAAU,EACvB,eAAe,CAAC,EAAE,eAAe,EACjC,kBAAkB,CAAC,EAAE,kBAAkB,EACvC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAiHxD"}