@qualcomm-ui/mdx-vite 1.0.0

package/dist/index.js

@@ -0,0 +1,4632 @@
+import {createRequire} from "node:module";const require=createRequire(import.meta.url);
+
+// src/angular-demo-plugin/angular-demo-plugin.ts
+import { transformerRenderIndentGuides } from "@shikijs/transformers";
+import chalk from "chalk";
+import { watch } from "chokidar";
+import { glob } from "glob";
+import { existsSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import {
+  createHighlighter
+} from "shiki";
+import * as ts from "typescript";
+import {
+  quiCustomDarkTheme
+} from "@qualcomm-ui/mdx-common";
+var VIRTUAL_MODULE_ID = "\0virtual:angular-demo-registry";
+var VIRTUAL_MODULE_PREFIX = "virtual:angular-demo-registry/";
+var LOG_PREFIX = "[angular-demo]";
+var hasWatcherInitialized = false;
+function logDev(...args) {
+  if (!hasWatcherInitialized) {
+    return;
+  }
+  console.log(...args);
+}
+var demoDimensionsCache = {};
+var highlighter = null;
+var initCount = 0;
+var demoRegistry = /* @__PURE__ */ new Map();
+var hotUpdateDemoIds = [];
+function angularDemoPlugin({
+  demoPattern = "src/routes/**/demos/*.ts",
+  initialHtml,
+  routesDir = "src/routes",
+  theme = {
+    dark: quiCustomDarkTheme,
+    light: "github-light-high-contrast"
+  }
+} = {}) {
+  let watcher = null;
+  let devServer = null;
+  return {
+    async buildEnd() {
+      if (watcher) {
+        await watcher.close();
+        watcher = null;
+        hasWatcherInitialized = false;
+      }
+    },
+    async buildStart() {
+      if (initCount === 0) {
+        initCount++;
+        return;
+      }
+      if (!highlighter) {
+        try {
+          highlighter = await createHighlighter({
+            langs: ["angular-ts", "angular-html"],
+            themes: [theme.dark, theme.light]
+          });
+          logDev(`${chalk.blue.bold(LOG_PREFIX)} Shiki highlighter initialized`);
+        } catch (error) {
+          console.warn(
+            `${chalk.blue.bold(LOG_PREFIX)} Failed to initialize highlighter:`,
+            error
+          );
+        }
+      }
+      logDev(`${chalk.blue.bold(LOG_PREFIX)} Initializing Angular demo scanner`);
+      await collectAngularDemos();
+      if (process.env.NODE_ENV === "development") {
+        if (!hasWatcherInitialized) {
+          hasWatcherInitialized = true;
+          await setupAngularWatcher();
+        } else {
+          logDev(
+            `${chalk.blue.bold(LOG_PREFIX)} Watcher already initialized by another instance`
+          );
+        }
+      }
+    },
+    configureServer(server) {
+      devServer = server;
+      let dimensionUpdateTimeout = null;
+      server.ws.on(
+        "custom:store-demo-dimensions",
+        (data) => {
+          const demoId = data.demoId;
+          demoDimensionsCache[demoId] = data.dimensions;
+          if (dimensionUpdateTimeout) {
+            clearTimeout(dimensionUpdateTimeout);
+          }
+          dimensionUpdateTimeout = setTimeout(() => {
+            const module = server.moduleGraph.getModuleById(VIRTUAL_MODULE_ID);
+            if (module) {
+              server.moduleGraph.invalidateModule(module);
+            }
+          }, 50);
+        }
+      );
+      server.ws.on("custom:reset-demo-dimensions", () => {
+        demoDimensionsCache = {};
+        const module = server.moduleGraph.getModuleById(VIRTUAL_MODULE_ID);
+        if (module) {
+          server.moduleGraph.invalidateModule(module);
+          server.reloadModule(module);
+        }
+      });
+    },
+    async handleHotUpdate({ file, server }) {
+      if (!isAngularDemoFile(file)) {
+        if (isCssAsset2(file)) {
+          return server.moduleGraph.getModulesByFile(file)?.values()?.toArray();
+        } else if (file.endsWith("main.js")) {
+          const ids = [...hotUpdateDemoIds];
+          server.ws.send({
+            data: {
+              demoInfo: ids.reduce(
+                (acc, current) => {
+                  acc[current] = demoRegistry.get(current);
+                  return acc;
+                },
+                {}
+              )
+            },
+            event: "demo-bundle-updated",
+            type: "custom"
+          });
+        }
+        return [];
+      }
+      logDev(
+        `${chalk.blue.bold(LOG_PREFIX)} Processing Angular demo change: ${chalk.cyan(file)}`
+      );
+      const code = await readFile(file, "utf-8");
+      const demoInfo = await parseAngularDemo(file, code);
+      if (!demoInfo) {
+        const affectedDemos = await scanDemosForFileImport(file);
+        if (affectedDemos.length > 0) {
+          hotUpdateDemoIds = [];
+          const mainModule2 = server.moduleGraph.getModuleById(VIRTUAL_MODULE_ID);
+          if (mainModule2) {
+            server.moduleGraph.invalidateModule(mainModule2);
+            await server.reloadModule(mainModule2);
+          }
+          for (const demo of affectedDemos) {
+            hotUpdateDemoIds.push(demo.id);
+          }
+          const pageIds = new Set(affectedDemos.map((demo) => demo.pageId));
+          for (const pageId of pageIds) {
+            const pageModuleId2 = `\0${VIRTUAL_MODULE_PREFIX}${pageId}`;
+            const pageModule2 = server.moduleGraph.getModuleById(pageModuleId2);
+            if (pageModule2) {
+              server.moduleGraph.invalidateModule(pageModule2);
+              await server.reloadModule(pageModule2);
+            }
+          }
+        }
+        server.ws.send({
+          data: {
+            ids: [...hotUpdateDemoIds]
+          },
+          event: "demo-bundle-updating",
+          type: "custom"
+        });
+        return;
+      }
+      delete demoDimensionsCache[demoInfo.id];
+      demoRegistry.set(demoInfo.id, demoInfo);
+      hotUpdateDemoIds = [demoInfo.id];
+      server.ws.send({
+        data: {
+          ids: [...hotUpdateDemoIds]
+        },
+        event: "demo-bundle-updating",
+        type: "custom"
+      });
+      const mainModule = server.moduleGraph.getModuleById(VIRTUAL_MODULE_ID);
+      if (mainModule) {
+        server.moduleGraph.invalidateModule(mainModule);
+        await server.reloadModule(mainModule);
+      }
+      const pageModuleId = `\0${VIRTUAL_MODULE_PREFIX}${demoInfo.pageId}`;
+      const pageModule = server.moduleGraph.getModuleById(pageModuleId);
+      if (pageModule) {
+        server.moduleGraph.invalidateModule(pageModule);
+        await server.reloadModule(pageModule);
+      }
+      const demoModule = server.moduleGraph.getModuleById(file);
+      if (demoModule) {
+        server.moduleGraph.invalidateModule(demoModule);
+      }
+      return [];
+    },
+    async load(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return generateRegistryModule();
+      }
+      if (id.startsWith(`\0${VIRTUAL_MODULE_PREFIX}`)) {
+        const pageId = id.slice(`\0${VIRTUAL_MODULE_PREFIX}`.length);
+        return generatePageRegistryModule(pageId);
+      }
+    },
+    name: "angular-demo-plugin",
+    resolveId(id) {
+      if (id === "virtual:angular-demo-registry") {
+        return VIRTUAL_MODULE_ID;
+      }
+      if (id.startsWith(VIRTUAL_MODULE_PREFIX)) {
+        const pageId = id.slice(VIRTUAL_MODULE_PREFIX.length);
+        return `\0${VIRTUAL_MODULE_PREFIX}${pageId}`;
+      }
+    },
+    writeBundle() {
+      console.log(
+        `${chalk.blue.bold(LOG_PREFIX)} Successfully integrated ${chalk.green(demoRegistry.size)} component demos`
+      );
+    }
+  };
+  async function collectAngularDemos() {
+    if (demoRegistry.size) {
+      logDev(
+        `${chalk.magenta.bold(LOG_PREFIX)} Using cached ${chalk.cyanBright.bold(demoRegistry.size)} demos`
+      );
+      return;
+    }
+    const demoFiles = await glob(demoPattern);
+    demoRegistry.clear();
+    for (const filePath of demoFiles) {
+      const code = await readFile(filePath, "utf-8");
+      const demoInfo = await parseAngularDemo(filePath, code);
+      if (demoInfo) {
+        demoRegistry.set(demoInfo.id, demoInfo);
+      }
+    }
+  }
+  async function scanDemosForFileImport(file) {
+    const affectedDemos = [];
+    for (const [demoId, demo] of demoRegistry.entries()) {
+      if (demo.sourceCode.find((entry) => entry.filePath === file)) {
+        logDev(
+          `${chalk.blue.bold(LOG_PREFIX)} Re-parsing demo ${chalk.cyan(demoId)} due to imported file change: ${chalk.yellow(file)}`
+        );
+        const code = await readFile(demo.filePath, "utf-8");
+        const updatedDemo = await parseAngularDemo(demo.filePath, code);
+        if (updatedDemo) {
+          delete demoDimensionsCache[updatedDemo.id];
+          demoRegistry.set(updatedDemo.id, updatedDemo);
+          affectedDemos.push(updatedDemo);
+          hotUpdateDemoIds.push(updatedDemo.id);
+        }
+      }
+    }
+    return affectedDemos;
+  }
+  async function highlightCode(code, language = "angular-ts") {
+    if (!highlighter) {
+      return code;
+    }
+    try {
+      return highlighter.codeToHtml(code, {
+        defaultColor: "light-dark()",
+        lang: language,
+        themes: {
+          dark: theme.dark,
+          light: theme.light
+        },
+        transformers: [transformerRenderIndentGuides()]
+      });
+    } catch (error) {
+      console.warn(
+        `${chalk.blue.bold(LOG_PREFIX)} Failed to highlight code with ${language} language:`,
+        error
+      );
+      return code;
+    }
+  }
+  function extractAngularPreviewsAndCleanSource(code) {
+    const lines = code.split("\n");
+    const previewBlocks = [];
+    const cleanedLines = [];
+    let inPreview = false;
+    let currentBlock = [];
+    let startLine = -1;
+    let currentContext = "typescript";
+    let inTemplate = false;
+    let templateDepth = 0;
+    let omitNextLine = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmedLine = line.trim();
+      if (/template\s*:\s*[`"']/.test(line)) {
+        inTemplate = true;
+        templateDepth = 0;
+      }
+      if (inTemplate && line.includes("`")) {
+        const backticks = (line.match(/`/g) || []).length;
+        templateDepth += backticks;
+        if (templateDepth % 2 === 0 && backticks > 0) {
+          inTemplate = false;
+        }
+      }
+      if (inTemplate && /['"]\s*[,}]/.test(line)) {
+        inTemplate = false;
+      }
+      if (omitNextLine) {
+        omitNextLine = false;
+        continue;
+      }
+      if (isOmitNextLine(trimmedLine)) {
+        omitNextLine = true;
+        continue;
+      }
+      if (isPreviewLine(trimmedLine)) {
+        if (inPreview) {
+          const normalizedContent = normalizeIndentation2(currentBlock);
+          previewBlocks.push({
+            content: normalizedContent,
+            context: currentContext,
+            endLine: i - 1,
+            startLine
+          });
+          currentBlock = [];
+          inPreview = false;
+        } else {
+          inPreview = true;
+          startLine = i + 1;
+          currentContext = inTemplate ? "template" : "typescript";
+        }
+      } else {
+        cleanedLines.push(line);
+        if (inPreview) {
+          currentBlock.push(line);
+        }
+      }
+    }
+    function normalizeIndentation2(lines2) {
+      if (lines2.length === 0) {
+        return "";
+      }
+      const nonEmptyLines = lines2.filter((line) => line.trim().length > 0);
+      if (nonEmptyLines.length === 0) {
+        return lines2.join("\n");
+      }
+      let minIndent = Infinity;
+      for (const line of nonEmptyLines) {
+        const match = line.match(/^(\s*)/);
+        const indent = match ? match[1].length : 0;
+        minIndent = Math.min(minIndent, indent);
+      }
+      const normalizedLines = lines2.map((line) => {
+        if (line.trim().length === 0) {
+          return line;
+        }
+        return line.slice(minIndent);
+      });
+      return normalizedLines.join("\n");
+    }
+    const formattedPreview = previewBlocks.length ? previewBlocks.map((block) => block.content).join("\n") : "";
+    return {
+      formattedPreview,
+      previewBlocks,
+      sourceWithoutPreviews: cleanedLines.join("\n")
+    };
+  }
+  function isPreviewLine(trimmedLine) {
+    return trimmedLine === "// preview" || /^\/\*\s*preview\s*\*\/$/.test(trimmedLine) || /^<!--\s*preview\s*-->$/.test(trimmedLine);
+  }
+  async function extractRelativeImports(filePath) {
+    try {
+      let visit8 = function(node) {
+        if (ts.isImportDeclaration(node)) {
+          const moduleSpecifier = node.moduleSpecifier;
+          if (ts.isStringLiteral(moduleSpecifier)) {
+            const source = moduleSpecifier.text;
+            if (isRelativeImport2(source)) {
+              const resolvedPath = resolveRelativeImport2(source, filePath);
+              relativeImports.push({ resolvedPath, source });
+            } else if (!isNodeBuiltin2(source)) {
+              const pathAliases = loadTsConfigPaths2(filePath);
+              if (isPathAliasImport(source, pathAliases)) {
+                const resolvedPath = resolvePathAlias(source, pathAliases);
+                if (resolvedPath) {
+                  relativeImports.push({ resolvedPath, source });
+                }
+              }
+            }
+          }
+        }
+        ts.forEachChild(node, visit8);
+      };
+      var visit7 = visit8;
+      const content = await readFile(filePath, "utf-8");
+      const sourceFile = ts.createSourceFile(
+        filePath,
+        content,
+        ts.ScriptTarget.Latest,
+        true,
+        ts.ScriptKind.TS
+      );
+      const relativeImports = [];
+      visit8(sourceFile);
+      return relativeImports;
+    } catch (error) {
+      logDev(
+        `${chalk.blue.bold(LOG_PREFIX)} ${chalk.yellowBright("Failed to extract imports from")} ${chalk.cyan(filePath)}:`,
+        error
+      );
+      return [];
+    }
+  }
+  async function collectAllImports(filePath, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(filePath)) {
+      return [];
+    }
+    visited.add(filePath);
+    const directImports = await extractRelativeImports(filePath);
+    for (const { resolvedPath } of directImports) {
+      await collectAllImports(resolvedPath, visited);
+    }
+    return Array.from(visited).slice(1);
+  }
+  function stripImports(code, fileName) {
+    try {
+      let visit8 = function(node) {
+        if (ts.isImportDeclaration(node)) {
+          importRanges.push({
+            end: node.getEnd(),
+            start: node.getFullStart()
+          });
+        }
+        ts.forEachChild(node, visit8);
+      };
+      var visit7 = visit8;
+      const sourceFile = ts.createSourceFile(
+        fileName,
+        code,
+        ts.ScriptTarget.Latest,
+        true,
+        ts.ScriptKind.TS
+      );
+      const importRanges = [];
+      visit8(sourceFile);
+      const imports = importRanges.map((range) => {
+        let endPos = range.end;
+        if (code[endPos] === "\n") {
+          endPos++;
+        }
+        return code.slice(range.start, endPos).trim();
+      });
+      importRanges.sort((a, b) => b.start - a.start);
+      let strippedCode = code;
+      for (const range of importRanges) {
+        let endPos = range.end;
+        if (strippedCode[endPos] === "\n") {
+          endPos++;
+        }
+        strippedCode = strippedCode.slice(0, range.start) + strippedCode.slice(endPos);
+      }
+      strippedCode = strippedCode.trim();
+      return {
+        imports,
+        strippedCode: strippedCode.replace(/^\n+/, "")
+      };
+    } catch (error) {
+      logDev(
+        `${chalk.blue.bold(LOG_PREFIX)} ${chalk.redBright("Failed to strip imports from")} ${chalk.cyan(fileName)}:`,
+        error
+      );
+      return {
+        imports: [],
+        strippedCode: code
+      };
+    }
+  }
+  async function parseAngularDemo(filePath, code) {
+    try {
+      let visit8 = function(node) {
+        if (ts.isImportDeclaration(node)) {
+          imports.push(node.getFullText(sourceFile).trim());
+        }
+        if (ts.isClassDeclaration(node)) {
+          const decorators = node.modifiers?.filter(ts.isDecorator);
+          const componentDecorator = decorators?.find((decorator) => {
+            if (ts.isCallExpression(decorator.expression)) {
+              const expression = decorator.expression.expression;
+              return ts.isIdentifier(expression) && expression.text === "Component";
+            }
+            return false;
+          });
+          if (componentDecorator && node.name) {
+            componentClass = node.name.text;
+            if (ts.isCallExpression(componentDecorator.expression) && componentDecorator.expression.arguments[0] && ts.isObjectLiteralExpression(
+              componentDecorator.expression.arguments[0]
+            )) {
+              const properties = componentDecorator.expression.arguments[0].properties;
+              const selectorProp = properties.find(
+                (prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "selector"
+              );
+              if (selectorProp && ts.isStringLiteral(selectorProp.initializer)) {
+                selector = selectorProp.initializer.text;
+              }
+              const templateUrlProp = properties.find(
+                (prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "templateUrl"
+              );
+              if (templateUrlProp) {
+                if (ts.isStringLiteral(templateUrlProp.initializer)) {
+                  templateUrl = templateUrlProp.initializer.text;
+                } else if (ts.isNoSubstitutionTemplateLiteral(
+                  templateUrlProp.initializer
+                )) {
+                  templateUrl = templateUrlProp.initializer.text;
+                }
+              }
+              const standaloneProp = properties.find(
+                (prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "standalone"
+              );
+              if (standaloneProp) {
+                if (standaloneProp.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                  isStandalone = false;
+                }
+              }
+            }
+          }
+        }
+        if (ts.isExportAssignment(node) && !node.isExportEquals) {
+          hasDefaultExport = true;
+        }
+        ts.forEachChild(node, visit8);
+      };
+      var visit7 = visit8;
+      const { formattedPreview, sourceWithoutPreviews } = extractAngularPreviewsAndCleanSource(code);
+      const sourceFile = ts.createSourceFile(
+        filePath,
+        sourceWithoutPreviews,
+        ts.ScriptTarget.Latest,
+        true,
+        ts.ScriptKind.TS
+      );
+      let componentClass = "";
+      let selector = "";
+      let isStandalone = true;
+      let templateUrl = null;
+      const imports = [];
+      let hasDefaultExport = false;
+      visit8(sourceFile);
+      if (!componentClass || !selector) {
+        return null;
+      }
+      const demoId = componentClass;
+      const pageId = extractPageId2(filePath, routesDir);
+      const importPath = relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const fileName = basename(filePath);
+      const { strippedCode: codeWithoutImports } = stripImports(code, filePath);
+      const highlightedFull = await highlightCode(code, "angular-ts");
+      const { highlightedPreview, highlightedWithoutPreview } = extractHighlightedVariants(highlightedFull);
+      const sourceCode = [
+        {
+          fileName,
+          filePath,
+          highlighted: {
+            full: highlightedWithoutPreview,
+            preview: highlightedPreview
+          },
+          raw: {
+            full: sourceWithoutPreviews,
+            preview: formattedPreview || "",
+            withoutImports: codeWithoutImports
+          }
+        }
+      ];
+      if (templateUrl) {
+        const templatePath = resolveTemplateFile(templateUrl, filePath);
+        if (existsSync(templatePath)) {
+          try {
+            const templateCode = await readFile(templatePath, "utf-8");
+            const {
+              formattedPreview: templatePreview,
+              sourceWithoutPreviews: templateWithoutPreviews
+            } = extractAngularPreviewsAndCleanSource(templateCode);
+            const highlightedTemplate = await highlightCode(
+              templateCode,
+              "angular-html"
+            );
+            const {
+              highlightedPreview: highlightedTemplatePreview,
+              highlightedWithoutPreview: highlightedTemplateWithoutPreview
+            } = extractHighlightedVariants(highlightedTemplate);
+            sourceCode.push({
+              fileName: basename(templatePath),
+              highlighted: {
+                full: highlightedTemplateWithoutPreview,
+                preview: highlightedTemplatePreview
+              },
+              raw: {
+                full: templateWithoutPreviews,
+                preview: templatePreview || "",
+                withoutImports: templateCode
+              }
+            });
+          } catch (error) {
+            console.log(
+              `${chalk.blue.bold(LOG_PREFIX)} ${chalk.redBright("Failed to read template file:")} ${chalk.cyan(templatePath)}`,
+              error
+            );
+          }
+        }
+      }
+      const relativeImports = await collectAllImports(filePath);
+      for (const resolvedPath of relativeImports) {
+        try {
+          const importedCode = await readFile(resolvedPath, "utf-8");
+          const { strippedCode: importedCodeWithoutImports } = stripImports(
+            importedCode,
+            resolvedPath
+          );
+          const { sourceWithoutPreviews: importedSourceWithoutSnippets } = extractAngularPreviewsAndCleanSource(importedCode);
+          const importedFileName = basename(resolvedPath);
+          const highlightedImportedSource = await highlightCode(
+            importedSourceWithoutSnippets,
+            "angular-ts"
+          );
+          sourceCode.push({
+            fileName: importedFileName,
+            highlighted: {
+              full: highlightedImportedSource,
+              preview: ""
+            },
+            raw: {
+              full: importedSourceWithoutSnippets,
+              preview: "",
+              withoutImports: importedCodeWithoutImports
+            }
+          });
+        } catch (error) {
+          logDev(
+            `${chalk.blue.bold(LOG_PREFIX)} ${chalk.yellowBright("Failed to process relative import:")} ${chalk.cyan(resolvedPath)}`
+          );
+        }
+      }
+      return {
+        componentClass,
+        filePath: importPath.startsWith(".") ? importPath : `./${importPath}`,
+        hasDefaultExport,
+        id: demoId,
+        imports,
+        initialHtml: initialHtml?.[demoId] || void 0,
+        isStandalone,
+        lastModified: Date.now(),
+        pageId,
+        selector,
+        sourceCode
+      };
+    } catch (error) {
+      console.error(
+        `${chalk.blue.bold(LOG_PREFIX)} Failed to parse Angular demo ${filePath}:`,
+        error
+      );
+      return null;
+    }
+  }
+  function extractHighlightedVariants(highlightedHtml) {
+    const preMatch = highlightedHtml.match(/^<pre[^>]*><code>/)?.[0] || "";
+    const postMatch = highlightedHtml.match(/<\/code><\/pre>$/)?.[0] || "";
+    const content = highlightedHtml.slice(preMatch.length, -postMatch.length);
+    const lines = content.split("\n");
+    const previewLines = [];
+    const withoutPreviewLines = [];
+    let inPreview = false;
+    let omitNextLine = false;
+    for (const line of lines) {
+      const textContent = line.replace(/<[^>]*>/g, "").replace(/&#x3C;/g, "<").replace(/&#x3E;/g, ">").trim();
+      if (omitNextLine) {
+        omitNextLine = false;
+        continue;
+      }
+      if (textContent === "// qui-docs::omit-next-line") {
+        omitNextLine = true;
+        continue;
+      }
+      if (textContent === "// preview" || textContent === "/* preview */" || textContent === "<!-- preview -->") {
+        inPreview = !inPreview;
+        continue;
+      }
+      if (inPreview) {
+        previewLines.push(line);
+      }
+      withoutPreviewLines.push(line);
+    }
+    const normalizedPreviewLines = normalizeIndentation(previewLines);
+    const highlightedPreview = normalizedPreviewLines.length > 0 ? `${preMatch}${normalizedPreviewLines.join("\n")}${postMatch}` : "";
+    const highlightedWithoutPreview = `${preMatch}${withoutPreviewLines.join("\n")}${postMatch}`;
+    return { highlightedPreview, highlightedWithoutPreview };
+  }
+  function normalizeIndentation(lines) {
+    if (lines.length === 0) {
+      return [];
+    }
+    const nonEmptyLines = lines.filter(
+      (line) => line.replace(/<[^>]*>/g, "").trim().length > 0
+    );
+    if (nonEmptyLines.length === 0) {
+      return lines;
+    }
+    let minIndent = Infinity;
+    for (const line of nonEmptyLines) {
+      const matches = line.match(/<span class="indent">/g);
+      if (matches) {
+        minIndent = Math.min(minIndent, matches.length);
+      } else {
+        minIndent = 0;
+        break;
+      }
+    }
+    if (minIndent === 0 || minIndent === Infinity) {
+      return lines;
+    }
+    return lines.map((line) => {
+      let result = line;
+      for (let i = 0; i < minIndent; i++) {
+        result = result.replace(/<span class="indent">(\s*)<\/span>/, "");
+      }
+      return result;
+    });
+  }
+  function generateRegistryModule() {
+    const demos = Array.from(demoRegistry.values());
+    return `// Auto-generated Angular demo registry
+export const ANGULAR_DEMOS = {
+${demos.map(
+      (demo) => `  "${demo.id}": ${JSON.stringify(
+        {
+          componentClass: demo.componentClass,
+          dimensions: demoDimensionsCache[demo.id],
+          filePath: demo.filePath,
+          hasDefaultExport: demo.hasDefaultExport,
+          id: demo.id,
+          imports: demo.imports,
+          initialHtml: demo.initialHtml,
+          isStandalone: demo.isStandalone,
+          lastModified: demo.lastModified,
+          pageId: demo.pageId,
+          selector: demo.selector,
+          sourceCode: demo.sourceCode
+        },
+        null,
+        4
+      )}`
+    ).join(",\n")}
+}
+
+export function isAngularDemo(demoId) {
+  return demoId in ANGULAR_DEMOS
+}
+
+export function getAngularDemoInfo(demoId) {
+  return ANGULAR_DEMOS[demoId] || null
+}
+
+export function getAllAngularDemos() {
+  return Object.values(ANGULAR_DEMOS)
+}
+
+export const availableAngularDemos = Object.keys(ANGULAR_DEMOS)
+
+if (import.meta.hot) {
+  import.meta.hot.accept(() => {
+    console.log('[angular-demo-registry] Registry updated via HMR')
+  })
+  
+  if (typeof window !== 'undefined') {
+    import.meta.hot.on('angular-demo-update', (data) => {
+      console.log('[angular-demo-registry] Demo updated:', data.demoId)
+    })
+  }
+}`;
+  }
+  function generatePageRegistryModule(pageId) {
+    const pageDemos = Array.from(demoRegistry.values()).filter(
+      (demo) => demo.pageId === pageId
+    );
+    if (pageDemos.length === 0) {
+      return `export function getAngularDemoInfo() { return null }
+export const ANGULAR_DEMOS = {}`;
+    }
+    return `// Auto-generated Angular demo registry for ${pageId}
+export const ANGULAR_DEMOS = {
+${pageDemos.map(
+      (demo) => `  "${demo.id}": ${JSON.stringify(
+        {
+          componentClass: demo.componentClass,
+          dimensions: demoDimensionsCache[demo.id],
+          filePath: demo.filePath,
+          hasDefaultExport: demo.hasDefaultExport,
+          id: demo.id,
+          imports: demo.imports,
+          initialHtml: demo.initialHtml,
+          isStandalone: demo.isStandalone,
+          lastModified: demo.lastModified,
+          pageId: demo.pageId,
+          selector: demo.selector,
+          sourceCode: demo.sourceCode
+        },
+        null,
+        4
+      )}`
+    ).join(",\n")}
+}
+
+export function getAngularDemoInfo(demoId) {
+  return ANGULAR_DEMOS[demoId] || null
+}
+
+if (import.meta.hot) {
+  import.meta.hot.accept(() => {
+    console.log('[angular-demo-registry/${pageId}] Registry updated')
+  })
+}`;
+  }
+  function extractPageId2(filePath, routesDir2) {
+    const relativePath = relative(routesDir2, filePath);
+    const pathParts = relativePath.split("/");
+    const demoIndex = pathParts.findIndex((part) => part.includes("demos"));
+    if (demoIndex === -1) {
+      return pathParts.at(-2) || pathParts.join("/");
+    }
+    return pathParts.slice(0, demoIndex).join("/");
+  }
+  function isAngularDemoFile(filePath) {
+    return filePath.includes("/demos/") && (filePath.endsWith(".ts") || filePath.endsWith("html"));
+  }
+  function isCssAsset2(filePath) {
+    return filePath.endsWith(".css");
+  }
+  function isRelativeImport2(source) {
+    return source.startsWith("./") || source.startsWith("../");
+  }
+  function isNodeBuiltin2(source) {
+    const NODE_BUILTINS2 = [
+      "assert",
+      "buffer",
+      "child_process",
+      "cluster",
+      "crypto",
+      "dgram",
+      "dns",
+      "domain",
+      "events",
+      "fs",
+      "http",
+      "https",
+      "net",
+      "os",
+      "path",
+      "punycode",
+      "querystring",
+      "readline",
+      "stream",
+      "string_decoder",
+      "timers",
+      "tls",
+      "tty",
+      "url",
+      "util",
+      "v8",
+      "vm",
+      "zlib"
+    ];
+    return source.startsWith("node:") || NODE_BUILTINS2.includes(source);
+  }
+  function resolveRelativeImport2(source, fromFile) {
+    const fromDir = dirname(fromFile);
+    const resolved = resolve(fromDir, source);
+    const extensions = [".ts", ".tsx", ".js", ".jsx"];
+    for (const ext of extensions) {
+      const withExt = resolved + ext;
+      if (existsSync(withExt)) {
+        return withExt;
+      }
+    }
+    for (const ext of extensions) {
+      const indexFile = join(resolved, `index${ext}`);
+      if (existsSync(indexFile)) {
+        return indexFile;
+      }
+    }
+    return resolved;
+  }
+  function loadTsConfigPaths2(fromFile) {
+    let currentDir = dirname(fromFile);
+    const pathAliases = [];
+    while (currentDir !== dirname(currentDir)) {
+      const tsconfigPath = join(currentDir, "tsconfig.json");
+      if (existsSync(tsconfigPath)) {
+        try {
+          const configContent = ts.sys.readFile(tsconfigPath);
+          if (!configContent) {
+            currentDir = dirname(currentDir);
+            continue;
+          }
+          const parseResult = ts.parseConfigFileTextToJson(
+            tsconfigPath,
+            configContent
+          );
+          if (parseResult.error) {
+            currentDir = dirname(currentDir);
+            continue;
+          }
+          const paths = parseResult.config?.compilerOptions?.paths;
+          const baseUrl = parseResult.config?.compilerOptions?.baseUrl || "./";
+          const resolvedBaseUrl = resolve(currentDir, baseUrl);
+          if (paths) {
+            for (const [alias, targets] of Object.entries(paths)) {
+              if (Array.isArray(targets) && targets.length > 0) {
+                const target = targets[0];
+                const pattern = new RegExp(
+                  `^${alias.replace("*", "(.*)").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\(\\*\\)", "(.*)")}$`
+                );
+                const replacement = resolve(
+                  resolvedBaseUrl,
+                  target.replace("*", "$1")
+                );
+                pathAliases.push({ pattern, replacement });
+              }
+            }
+          }
+          const extendsPath = parseResult.config?.extends;
+          if (extendsPath) {
+            const resolvedExtends = resolve(currentDir, extendsPath);
+            const extendedAliases = loadTsConfigPathsFromFile(resolvedExtends);
+            pathAliases.push(...extendedAliases);
+          }
+          return pathAliases;
+        } catch (error) {
+          currentDir = dirname(currentDir);
+          continue;
+        }
+      }
+      currentDir = dirname(currentDir);
+    }
+    return pathAliases;
+  }
+  async function setupAngularWatcher() {
+    watcher = watch(routesDir, {
+      ignoreInitial: true,
+      persistent: true
+    });
+    watcher.on("ready", () => {
+      logDev(
+        `${chalk.blue.bold(LOG_PREFIX)} Registered ${chalk.green(demoRegistry.size)} demo files. Watching for file changes...`
+      );
+    });
+    watcher.on("add", async (filePath) => {
+      const fileStats = await stat(filePath);
+      if (fileStats.size === 0) {
+        return;
+      }
+      if (isAngularDemoFile(filePath)) {
+        logDev(
+          `${chalk.blue.bold(LOG_PREFIX)} New Angular demo: ${chalk.green(filePath)}`
+        );
+        await handleAngularDemoUpdate(filePath);
+        triggerRegistryUpdate();
+      }
+    });
+    watcher.on("unlink", (filePath) => {
+      if (isAngularDemoFile(filePath)) {
+        const demoEntry = Array.from(demoRegistry.entries()).find(
+          ([, info]) => info.filePath === filePath
+        );
+        if (demoEntry) {
+          const [demoId] = demoEntry;
+          demoRegistry.delete(demoId);
+          logDev(
+            `${chalk.blue.bold(LOG_PREFIX)} Removed demo: ${chalk.red(demoId)}`
+          );
+          triggerRegistryUpdate();
+        }
+      }
+    });
+  }
+  async function handleAngularDemoUpdate(filePath) {
+    const code = await readFile(filePath, "utf-8");
+    const demoInfo = await parseAngularDemo(filePath, code);
+    if (demoInfo) {
+      demoRegistry.set(demoInfo.id, demoInfo);
+    }
+  }
+  function triggerRegistryUpdate() {
+    if (devServer) {
+      const mainModule = devServer.moduleGraph.getModuleById(VIRTUAL_MODULE_ID);
+      if (mainModule) {
+        devServer.moduleGraph.invalidateModule(mainModule);
+        mainModule.lastHMRTimestamp = Date.now();
+        devServer.reloadModule(mainModule);
+      }
+      const pageIds = new Set(
+        Array.from(demoRegistry.values()).map((demo) => demo.pageId)
+      );
+      for (const pageId of pageIds) {
+        const pageModuleId = `\0${VIRTUAL_MODULE_PREFIX}${pageId}`;
+        const pageModule = devServer.moduleGraph.getModuleById(pageModuleId);
+        if (pageModule) {
+          devServer.moduleGraph.invalidateModule(pageModule);
+          pageModule.lastHMRTimestamp = Date.now();
+          devServer.reloadModule(pageModule);
+        }
+      }
+    }
+  }
+}
+function loadTsConfigPathsFromFile(tsconfigPath) {
+  const pathAliases = [];
+  const configDir = dirname(tsconfigPath);
+  try {
+    const configContent = ts.sys.readFile(tsconfigPath);
+    if (!configContent) {
+      return pathAliases;
+    }
+    const parseResult = ts.parseConfigFileTextToJson(
+      tsconfigPath,
+      configContent
+    );
+    if (parseResult.error) {
+      return pathAliases;
+    }
+    const paths = parseResult.config?.compilerOptions?.paths;
+    const baseUrl = parseResult.config?.compilerOptions?.baseUrl || "./";
+    const resolvedBaseUrl = resolve(configDir, baseUrl);
+    if (paths) {
+      for (const [alias, targets] of Object.entries(paths)) {
+        if (Array.isArray(targets) && targets.length > 0) {
+          const target = targets[0];
+          const pattern = new RegExp(
+            `^${alias.replace("*", "(.*)").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\(\\*\\)", "(.*)")}$`
+          );
+          const replacement = resolve(
+            resolvedBaseUrl,
+            target.replace("*", "$1")
+          );
+          pathAliases.push({ pattern, replacement });
+        }
+      }
+    }
+    const extendsPath = parseResult.config?.extends;
+    if (extendsPath) {
+      let resolvedExtends = resolve(configDir, extendsPath);
+      if (!resolvedExtends.endsWith(".json")) {
+        resolvedExtends += ".json";
+      }
+      if (existsSync(resolvedExtends)) {
+        const extendedAliases = loadTsConfigPathsFromFile(resolvedExtends);
+        pathAliases.push(...extendedAliases);
+      }
+    }
+  } catch (error) {
+    return pathAliases;
+  }
+  return pathAliases;
+}
+function isPathAliasImport(source, pathAliases) {
+  return pathAliases.some((alias) => alias.pattern.test(source));
+}
+function resolvePathAlias(source, pathAliases) {
+  for (const alias of pathAliases) {
+    if (alias.pattern.test(source)) {
+      const resolvedPath = source.replace(alias.pattern, alias.replacement);
+      const extensions = [".ts", ".tsx", ".js", ".jsx"];
+      for (const ext of extensions) {
+        const withExt = resolvedPath + ext;
+        if (existsSync(withExt)) {
+          return withExt;
+        }
+      }
+      for (const ext of extensions) {
+        const indexFile = join(resolvedPath, `index${ext}`);
+        if (existsSync(indexFile)) {
+          return indexFile;
+        }
+      }
+      return resolvedPath;
+    }
+  }
+  return null;
+}
+function resolveTemplateFile(templateUrl, fromFile) {
+  const fromDir = dirname(fromFile);
+  const resolved = resolve(fromDir, templateUrl);
+  if (existsSync(resolved)) {
+    return resolved;
+  }
+  if (!resolved.endsWith(".html")) {
+    const withHtml = `${resolved}.html`;
+    if (existsSync(withHtml)) {
+      return withHtml;
+    }
+  }
+  return resolved;
+}
+function isOmitNextLine(trimmedLine) {
+  return trimmedLine === "// qui-docs::omit-next-line";
+}
+
+// src/docs-plugin/docs-plugin.ts
+import chalk4 from "chalk";
+import chokidar from "chokidar";
+import { glob as glob2 } from "glob";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import prettyMilliseconds from "pretty-ms";
+
+// src/docs-plugin/internal/config-loader.ts
+import { cosmiconfigSync } from "cosmiconfig";
+
+// src/docs-plugin/internal/config-schema.ts
+import { z as z2 } from "zod";
+
+// src/docs-plugin/internal/zod.ts
+import { z } from "zod";
+function implement() {
+  return {
+    with: (schema) => z.object(schema)
+  };
+}
+
+// src/docs-plugin/internal/config-schema.ts
+var navMetaSchema = implement().with({
+  id: z2.never().optional(),
+  sectionTitle: z2.string().optional(),
+  separator: z2.boolean().optional()
+});
+var routeMetaSchema = implement().with({
+  children: z2.array(z2.lazy(() => routeMetaSchema)).optional(),
+  expanded: z2.boolean().optional(),
+  group: z2.string().optional(),
+  groupOrder: z2.string().array().optional(),
+  hidden: z2.boolean().optional(),
+  hideBreadcrumbs: z2.boolean().optional(),
+  hideFromSearch: z2.boolean().optional(),
+  hidePageLinks: z2.boolean().optional(),
+  hideSideNav: z2.boolean().optional(),
+  hideToc: z2.boolean().optional(),
+  id: z2.string(),
+  ignoreRouteMetaOrder: z2.boolean().optional(),
+  restricted: z2.boolean().optional(),
+  sectionTitle: z2.never().optional(),
+  separator: z2.never().optional(),
+  sideNavTitle: z2.string().optional(),
+  title: z2.string().optional()
+});
+var typeDocPropsSchema = implement().with({
+  includeInSearchIndex: z2.boolean().optional()
+});
+var configSchema = implement().with({
+  appDirectory: z2.string().optional(),
+  disableCache: z2.boolean().optional(),
+  headings: z2.array(
+    z2.union([
+      z2.literal("h1"),
+      z2.literal("h2"),
+      z2.literal("h3"),
+      z2.literal("h4"),
+      z2.literal("h5"),
+      z2.literal("h6")
+    ])
+  ).optional(),
+  hotUpdateIgnore: z2.instanceof(RegExp).optional(),
+  navConfig: z2.array(z2.union([routeMetaSchema, navMetaSchema])).optional(),
+  pageDirectory: z2.string().optional(),
+  routingStrategy: z2.union([
+    z2.literal("vite-generouted"),
+    z2.function(z2.tuple([z2.string()]), z2.array(z2.string()))
+  ]).optional(),
+  typeDocProps: z2.string().optional(),
+  typeDocPropsOptions: typeDocPropsSchema.optional()
+});
+
+// src/docs-plugin/internal/utils.ts
+import { z as z3 } from "zod";
+function defined(value) {
+  return typeof value !== "undefined" && value !== null;
+}
+var frontmatterSchema = implement().with({
+  categories: z3.string().array().optional(),
+  group: z3.string().optional(),
+  hidden: z3.boolean().optional(),
+  hideBreadcrumbs: z3.boolean().optional(),
+  hideFromSearch: z3.boolean().optional(),
+  hidePageLinks: z3.boolean().optional(),
+  hideSideNav: z3.boolean().optional(),
+  hideToc: z3.boolean().optional(),
+  id: z3.string().optional(),
+  restricted: z3.boolean().optional(),
+  sideNavTitle: z3.string().optional(),
+  title: z3.string()
+});
+function fixPath(str) {
+  return str.replaceAll("\\", "/");
+}
+function removeTrailingSlash(str) {
+  return str.endsWith("/") ? str.substring(0, str.length - 1) : str;
+}
+
+// src/docs-plugin/internal/config-loader.ts
+var ConfigLoader = class {
+  options;
+  constructor(options) {
+    this.options = options;
+    return this;
+  }
+  getCosmiconfig() {
+    const explorer = cosmiconfigSync("qui-docs");
+    const result = this.options.configFile ? explorer.load(this.options.configFile) : explorer.search();
+    if (!result) {
+      throw new Error(
+        "Config file not found. Please consult the docs at https://docs.qui.qualcomm.com/guide/page-setup#config"
+      );
+    }
+    return result;
+  }
+  resolveConfigFromCosmiconfig(config) {
+    const parsed = configSchema.safeParse(config.config);
+    if (!parsed.success) {
+      console.dir(parsed.error.issues, { depth: 10 });
+      throw new Error("Failed to parse config file.");
+    }
+    const conf = parsed.data;
+    return {
+      ...conf,
+      appDirectory: conf.appDirectory || "app",
+      filePath: config.filepath,
+      pageDirectory: conf.pageDirectory ? removeTrailingSlash(conf.pageDirectory) : "routes"
+    };
+  }
+  loadConfig() {
+    const config = this.getCosmiconfig();
+    return this.resolveConfigFromCosmiconfig(config);
+  }
+};
+
+// src/docs-plugin/internal/search-indexer.ts
+import chalk3 from "chalk";
+
+// src/docs-plugin/internal/services/doc-props/doc-props-indexer.ts
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+import {
+  UniqueIdService
+} from "@qualcomm-ui/mdx-common";
+function extractPickPropsRecord(node) {
+  if (node.name !== "unionWithPick" || !node.value || typeof node.value === "string") {
+    return null;
+  }
+  const estree = node.value.data?.estree;
+  if (!estree?.body?.[0] || estree.body[0].type !== "ExpressionStatement") {
+    return null;
+  }
+  const expression = estree.body[0].expression;
+  if (expression.type !== "ObjectExpression") {
+    return null;
+  }
+  const result = {};
+  for (const property of expression.properties) {
+    if (property.type !== "Property" || property.key.type !== "Identifier") {
+      continue;
+    }
+    if (property.value.type !== "ArrayExpression") {
+      continue;
+    }
+    const key = property.key.name;
+    const values = [];
+    for (const element of property.value.elements) {
+      if (element?.type === "Literal" && typeof element.value === "string") {
+        values.push(element.value);
+      }
+    }
+    result[key] = values;
+  }
+  return result;
+}
+var targetMdxElements = [
+  "TypeDocProps",
+  "TypeDocAttributes",
+  "TypeDocAngularAttributes"
+];
+var DocPropsIndexer = class {
+  docPropsEntries = [];
+  idService = new UniqueIdService();
+  props;
+  pageDocProps = {};
+  constructor(props) {
+    this.props = props;
+  }
+  reset() {
+    this.idService.reset();
+    this.docPropsEntries = [];
+  }
+  extractNamesFromAttribute(attr) {
+    if (!attr.value) {
+      return [];
+    }
+    if (typeof attr.value === "string") {
+      return [attr.value];
+    }
+    if (attr.value.type === "mdxJsxAttributeValueExpression") {
+      const estree = attr.value.data?.estree;
+      if (!estree?.body?.[0] || estree.body[0].type !== "ExpressionStatement") {
+        return [];
+      }
+      const expression = estree.body[0].expression;
+      if (expression.type === "ArrayExpression") {
+        const names = [];
+        for (const element of expression.elements) {
+          if (element?.type === "Literal" && typeof element.value === "string") {
+            names.push(element.value);
+          }
+        }
+        return names;
+      }
+      if (expression.type === "Literal" && typeof expression.value === "string") {
+        return [expression.value];
+      }
+    }
+    return [];
+  }
+  /**
+   * Finds all JSX `<TypeDocProps />` nodes on the current page and adds their names
+   * to an array. Once all nodes have been collected, we process them into
+   * `PageSection` entries for the search index.
+   */
+  getTypeDocPropsNodes = () => {
+    return (tree, _file, done) => {
+      visit(tree, "mdxJsxFlowElement", (node) => {
+        if (node && "name" in node && targetMdxElements.includes(node.name)) {
+          const nameAttr = node.attributes?.find(
+            (attr) => attr.name === "name"
+          );
+          const omitFromAttr = node.attributes?.find(
+            (attr) => attr.name === "omitFrom"
+          );
+          const omitFrom = omitFromAttr ? this.extractNamesFromAttribute(omitFromAttr) : void 0;
+          if (nameAttr) {
+            const names = this.extractNamesFromAttribute(nameAttr);
+            for (const name of names) {
+              this.docPropsEntries.push({ name, omitFrom });
+              if (name.endsWith("Props")) {
+                this.docPropsEntries.push({ name: name.slice(0, -5), omitFrom });
+              }
+            }
+          }
+          const unionWithPickAttr = node.attributes?.find(
+            (attr) => attr.name === "unionWithPick"
+          );
+          if (unionWithPickAttr) {
+            try {
+              const unionWithPick = extractPickPropsRecord(unionWithPickAttr);
+              if (unionWithPick) {
+                this.docPropsEntries.push(
+                  ...Object.keys(unionWithPick).map((entry) => ({
+                    name: entry,
+                    omitFrom
+                  }))
+                );
+              }
+            } catch (e) {
+            }
+          }
+        }
+      });
+      done();
+    };
+  };
+  build(fileContents, toc) {
+    unified().use(remarkMdx).use(this.getTypeDocPropsNodes).use(remarkParse).use(remarkStringify).processSync(fileContents);
+    if (!this.docPropsEntries.length) {
+      return null;
+    }
+    for (const item of toc) {
+      this.idService.add(item.id);
+    }
+    return this.docPropsEntries.map((entry) => {
+      const propTypes = this.props[entry.name];
+      if (!propTypes) {
+        return [];
+      }
+      const omittedProps = new Set(
+        (entry.omitFrom ?? []).map((entry2) => {
+          const propTypes2 = this.props[entry2];
+          if (!propTypes2) {
+            return [];
+          }
+          return [
+            propTypes2.props,
+            propTypes2.input,
+            propTypes2.output,
+            propTypes2.publicMethods
+          ].reduce((acc, current) => {
+            if (current) {
+              acc.push(...current.map((prop) => prop.name));
+            }
+            return acc;
+          }, []);
+        }).flat(1).filter(Boolean)
+      );
+      const sections = [];
+      const assembleProps = (propsInput) => {
+        if (!propsInput) {
+          return void 0;
+        }
+        const props = [];
+        for (const prop of propsInput) {
+          if (omittedProps.has(prop.name)) {
+            continue;
+          }
+          const id = this.idService.add(prop.name);
+          props.push({ ...prop, id });
+          sections.push(this.assembleProp(prop, id));
+        }
+        return props;
+      };
+      this.pageDocProps[entry.name] = {
+        ...this.props[entry.name],
+        input: assembleProps(propTypes.input),
+        output: assembleProps(propTypes.output),
+        props: assembleProps(propTypes.props),
+        publicMethods: assembleProps(propTypes.publicMethods)
+      };
+      return sections;
+    }).flat();
+  }
+  getDocProps() {
+    return this.docPropsEntries.reduce((acc, entry) => {
+      const propTypes = this.pageDocProps[entry.name];
+      if (propTypes) {
+        acc[entry.name] = propTypes;
+      }
+      return acc;
+    }, {});
+  }
+  assembleProp(prop, id) {
+    const name = prop.name;
+    const heading2 = {
+      headingLevel: 4,
+      id,
+      tagName: "a",
+      textContent: name
+    };
+    const comment = prop.comment;
+    if (!comment) {
+      return { content: [], heading: heading2 };
+    }
+    const content = {
+      tagName: "p",
+      text: [
+        comment.summary.map((entry) => entry.text.replaceAll("\n", " ")).join("")
+      ]
+    };
+    return { content: [content], heading: heading2 };
+  }
+};
+
+// src/docs-plugin/internal/services/markdown/markdown-file-reader.ts
+import chalk2 from "chalk";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkParse2 from "remark-parse";
+import remarkParseFrontmatter from "remark-parse-frontmatter";
+import remarkStringify2 from "remark-stringify";
+import { unified as unified2 } from "unified";
+var MarkdownFileReader = class {
+  constructor(enabled) {
+    this.enabled = enabled;
+  }
+  cachedFileCount = 0;
+  logWarnings = true;
+  mdxCache = {};
+  hash(input) {
+    return createHash("md5").update(input).digest("hex");
+  }
+  reset() {
+    this.cachedFileCount = 0;
+  }
+  checkCache(filepath, fileContents) {
+    if (!this.enabled) {
+      return;
+    }
+    const fileMd5 = this.hash(fileContents);
+    const cached = this.mdxCache[filepath];
+    if (cached?.md5 !== fileMd5) {
+      return;
+    }
+    this.cachedFileCount++;
+    return {
+      frontmatter: cached.frontmatter,
+      page: cached.page,
+      pageDocProps: cached.pageDocProps,
+      pageDocPropSections: cached.pageDocPropSections
+    };
+  }
+  readFile(filepath) {
+    const fileContents = readFileSync(filepath, "utf-8");
+    const cached = this.checkCache(filepath, fileContents);
+    let file;
+    if (cached?.frontmatter) {
+      file = { data: { frontmatter: cached.frontmatter } };
+    } else {
+      const yamlSection = fileContents.substring(
+        0,
+        fileContents.indexOf("\n---") + 4
+      );
+      file = unified2().use(remarkParse2).use(remarkFrontmatter, ["yaml"]).use(remarkParseFrontmatter).use(remarkStringify2).processSync(yamlSection);
+    }
+    const frontmatter = file.data.frontmatter ?? { title: "" };
+    if (!frontmatter.title) {
+      const lines = fileContents.split("\n");
+      const fallbackTitle = lines.find((line) => line.startsWith("# "));
+      if (fallbackTitle) {
+        frontmatter.title = fallbackTitle.substring(2).trim();
+      }
+    }
+    if (!frontmatter.title && this.logWarnings) {
+      console.debug(chalk2.red.bold("Missing title:"), filepath);
+    }
+    const parsedFrontmatter = frontmatterSchema.safeParse(frontmatter);
+    if (!parsedFrontmatter.success) {
+      console.debug(
+        `${chalk2.redBright.bold("Invalid frontmatter detected for file")}: ${filepath}
+`
+      );
+      console.debug(chalk2.redBright.bold("Please check the following fields:"));
+      parsedFrontmatter.error.issues.map((issue) => {
+        console.debug(`- ${issue.path.join(".")}`);
+      });
+    }
+    return { cached, fileContents, frontmatter };
+  }
+  updateCache(filepath, fileContents, cacheData) {
+    if (this.enabled) {
+      this.mdxCache[filepath] = { ...cacheData, md5: this.hash(fileContents) };
+    }
+  }
+};
+
+// src/docs-plugin/internal/services/markdown/markdown-indexer.ts
+import { fromHtml } from "hast-util-from-html";
+import { toText } from "hast-util-to-text";
+import { clone, size } from "lodash-es";
+import rehypeParse from "rehype-parse";
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkMdx2 from "remark-mdx";
+import remarkParse3 from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified as unified3 } from "unified";
+
+// src/docs-plugin/rehype/rehype-slug.ts
+import { headingRank } from "hast-util-heading-rank";
+import { toString } from "hast-util-to-string";
+import { visit as visit2 } from "unist-util-visit";
+var emptyOptions = {};
+var rehypeSlug = (options) => {
+  const settings = options || emptyOptions;
+  const prefix = settings.prefix || "";
+  const allowedHeadings = new Set(
+    settings.allowedHeadings || ["h2", "h3", "h4"]
+  );
+  const seenIds = /* @__PURE__ */ new Map();
+  function createSlug(text) {
+    const cleaned = text.replace(/[<>]/g, "").replace(/[^\w\s-]/g, "").trim();
+    let slug;
+    if (cleaned.includes(" ")) {
+      slug = cleaned.toLowerCase().replace(/\s+/g, "-").replace(/^-+|-+$/g, "");
+    } else if ((cleaned.match(/[A-Z]/g) || []).length >= 2) {
+      slug = cleaned.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+    } else {
+      slug = cleaned.toLowerCase();
+    }
+    const count = seenIds.get(slug) || 0;
+    seenIds.set(slug, count + 1);
+    return count > 0 ? `${slug}-${count}` : slug;
+  }
+  return (tree) => {
+    seenIds.clear();
+    visit2(tree, "element", function(node) {
+      if (headingRank(node) && !node.properties.id && allowedHeadings.has(node.tagName)) {
+        node.properties.id = prefix + createSlug(toString(node));
+      }
+    });
+  };
+};
+
+// src/docs-plugin/remark/remark-alerts.ts
+import { visit as visit3 } from "unist-util-visit";
+var alertLegacyRegex = /^\[!(NOTE|TIP|SUCCESS|WARNING|CAUTION)(\/.*)?\]/i;
+var remarkAlerts = () => {
+  return (tree) => {
+    visit3(tree, "blockquote", (node) => {
+      let alertType = "";
+      let title = "";
+      let isNext = true;
+      const child = node.children.map((item) => {
+        if (isNext && item.type === "paragraph") {
+          const firstNode = item.children[0];
+          const text = firstNode.type === "text" ? firstNode.value : "";
+          const reg = alertLegacyRegex;
+          const match = text.match(reg);
+          if (match) {
+            isNext = false;
+            alertType = match[1].toLocaleLowerCase();
+            title = match[2] || alertType.toLocaleUpperCase();
+            if (text.includes("\n")) {
+              item.children[0] = {
+                type: "text",
+                value: text.replace(reg, "").replace(/^\n+/, "")
+              };
+            }
+            if (!text.includes("\n")) {
+              const itemChild = [];
+              item.children.forEach((item2, idx) => {
+                if (idx === 0) {
+                  return;
+                }
+                if (idx === 1 && item2.type === "break") {
+                  return;
+                }
+                itemChild.push(item2);
+              });
+              item.children = [...itemChild];
+            }
+          }
+        }
+        return item;
+      });
+      title = title.replace(/^\//, "");
+      if (!!alertType) {
+        node.data = {
+          hName: "div",
+          hProperties: {
+            class: `qui-notification__root`,
+            "data-emphasis": alertToEmphasis[alertType] || "neutral",
+            "data-orientation": "vertical",
+            dir: "auto"
+          }
+        };
+        node.children = [
+          {
+            children: [getAlertIcon(alertType)],
+            data: {
+              hProperties: {
+                class: "qui-notification__icon",
+                "data-part": "status-icon",
+                "data-scope": "inline-notification"
+              }
+            },
+            type: "paragraph"
+          },
+          {
+            children: [
+              {
+                type: "text",
+                value: title
+              }
+            ],
+            data: {
+              hProperties: {
+                class: "qui-notification__label",
+                dir: "auto"
+              }
+            },
+            type: "paragraph"
+          },
+          {
+            children: child,
+            data: {
+              hName: "div",
+              hProperties: {
+                class: `qui-notification__description`,
+                dir: "auto"
+              }
+            },
+            type: "blockquote"
+          }
+        ];
+      }
+    });
+  };
+};
+function getAlertIcon(type) {
+  const svgChildren = svgData[type] ?? [];
+  return {
+    children: svgChildren,
+    data: {
+      hName: "svg",
+      hProperties: {
+        ariaHidden: "true",
+        class: "lucide",
+        fill: "transparent",
+        height: "20",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "2",
+        viewBox: "0 0 24 24",
+        width: "20"
+      }
+    },
+    type: "emphasis"
+  };
+}
+var svgData = {
+  caution: [
+    {
+      children: [],
+      data: {
+        hName: "polygon",
+        hProperties: {
+          points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "line",
+        hProperties: {
+          x1: "12",
+          x2: "12",
+          y1: "8",
+          y2: "12"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "line",
+        hProperties: {
+          x1: "12",
+          x2: "12.01",
+          y1: "16",
+          y2: "16"
+        }
+      },
+      type: "emphasis"
+    }
+  ],
+  note: [
+    {
+      children: [],
+      data: {
+        hName: "circle",
+        hProperties: {
+          cx: "12",
+          cy: "12",
+          r: "10"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M12 16v-4"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M12 8h.01"
+        }
+      },
+      type: "emphasis"
+    }
+  ],
+  success: [
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M20 6 9 17l-5-5"
+        }
+      },
+      type: "emphasis"
+    }
+  ],
+  tip: [
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M9 18h6"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M10 22h4"
+        }
+      },
+      type: "emphasis"
+    }
+  ],
+  warning: [
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M12 9v4"
+        }
+      },
+      type: "emphasis"
+    },
+    {
+      children: [],
+      data: {
+        hName: "path",
+        hProperties: {
+          d: "M12 17h.01"
+        }
+      },
+      type: "emphasis"
+    }
+  ]
+};
+var alertToEmphasis = {
+  caution: "danger",
+  note: "neutral",
+  success: "success",
+  tip: "info",
+  warning: "warning"
+};
+
+// src/docs-plugin/internal/services/markdown/remark-remove-code-blocks.ts
+import { remove } from "unist-util-remove";
+var remarkRemoveMermaidCodeBlocks = () => {
+  return (tree, _file, done) => {
+    remove(tree, (node) => node.type === "code" && node.lang === "mermaid");
+    done();
+  };
+};
+
+// src/docs-plugin/internal/services/markdown/remark-remove-jsx.ts
+import { remove as remove2 } from "unist-util-remove";
+var remarkRemoveJsx = () => {
+  return (tree, _file, done) => {
+    remove2(tree, "mdxjsEsm");
+    remove2(tree, "mdxJsxFlowElement");
+    done();
+  };
+};
+
+// src/docs-plugin/internal/services/markdown/markdown-indexer.ts
+var MarkdownIndexer = class {
+  sections = [];
+  currentSection;
+  headingLevels;
+  reset() {
+    this.sections = [];
+    this._toc = [];
+    this.resetSection();
+  }
+  resetSection() {
+    this.currentSection = {
+      content: [],
+      heading: null
+    };
+  }
+  get toc() {
+    return this._toc;
+  }
+  _toc = [];
+  constructor(headingLevels) {
+    this.resetSection();
+    this.headingLevels = headingLevels;
+  }
+  appendTocItem(heading2) {
+    this._toc.push(heading2);
+  }
+  warn(...data) {
+    if (process.env.DEBUG) {
+      console.warn(...data);
+    }
+    console.warn(...data);
+  }
+  isHeading(element) {
+    return this.headingLevels.has(element.tagName);
+  }
+  isRootHeading(element) {
+    return element.tagName === "h1";
+  }
+  /**
+   * Parses a heading Element node into the indexed heading data structure.
+   */
+  parseHeading(headingElement) {
+    const id = headingElement.properties.id;
+    const text = toText(headingElement);
+    return {
+      headingLevel: parseInt(headingElement.tagName.charAt(1)),
+      id: id ? `${id}` : "",
+      tagName: headingElement.tagName,
+      textContent: text
+    };
+  }
+  parseElementNode(element) {
+    const isRootHeading = this.isRootHeading(element);
+    if (this.isHeading(element) || isRootHeading) {
+      const currentSection = this.currentSection;
+      if (currentSection.heading) {
+        this.sections.push(clone(this.currentSection));
+        this.resetSection();
+      }
+      const heading2 = this.parseHeading(element);
+      if (!isRootHeading) {
+        this.appendTocItem(heading2);
+      }
+      this.currentSection.heading = heading2;
+      return;
+    }
+    const text = toText(element, { whitespace: "pre-wrap" }).replaceAll("\n", "	").split("	").filter(size);
+    if (text.length) {
+      this.currentSection.content.push({
+        tagName: element.tagName,
+        text
+      });
+    }
+  }
+  parseMarkdown(fileContents, frontmatter) {
+    const file = unified3().use(remarkMdx2).use(remarkRemoveJsx).use(remarkRemoveMermaidCodeBlocks).use(remarkParse3).use(remarkGfm).use(remarkAlerts).use(remarkRehype).use(rehypeStringify).processSync(fileContents);
+    let contents = file.toString();
+    contents = contents.substring(contents.indexOf("<h1>"));
+    for (const [key, value] of Object.entries(frontmatter)) {
+      if (typeof value === "string" || typeof value === "number") {
+        contents = contents.replaceAll(`frontmatter.${key}`, `${value}`);
+      }
+    }
+    const htmlAst = unified3().data("settings", { fragment: true }).use(rehypeParse).use(rehypeStringify).use(rehypeSlug).processSync(contents);
+    contents = htmlAst.toString();
+    return this.build(contents);
+  }
+  build(html) {
+    const tree = fromHtml(html, { fragment: true });
+    for (const child of tree.children) {
+      if (child.type === "element") {
+        this.parseElementNode(child);
+      }
+    }
+    if (this.currentSection.heading?.textContent) {
+      this.sections.push(clone(this.currentSection));
+    }
+    return {
+      sections: this.sections,
+      toc: this.toc
+    };
+  }
+};
+
+// src/docs-plugin/internal/services/nav-builder/get-route-meta.ts
+function getRouteMeta(pathSegments, metaJson) {
+  const routeMeta = metaJson[pathSegments[0]];
+  if (!routeMeta) {
+    return void 0;
+  }
+  if (pathSegments.length === 1) {
+    return routeMeta;
+  }
+  return pathSegments.slice(1).reduce((acc, segment) => {
+    return acc?.children?.[segment];
+  }, routeMeta);
+}
+
+// src/docs-plugin/internal/services/nav-builder/nav-builder.ts
+import { capitalCase } from "change-case";
+import { sortBy } from "lodash-es";
+import { v4 as uuidv4 } from "uuid";
+var NavBuilder = class {
+  initialRoutes = [];
+  flatNavItems = [];
+  get navItems() {
+    return this._navItems;
+  }
+  _navItems = [];
+  metaJson;
+  navMeta;
+  constructor(metaJson, navMeta) {
+    this.navMeta = navMeta;
+    this.metaJson = metaJson;
+  }
+  add(pageSection, pageFrontmatter, routeMeta) {
+    this.initialRoutes.push({ pageFrontmatter, pageSection, routeMeta });
+  }
+  reset() {
+    this.initialRoutes = [];
+    this.flatNavItems = [];
+    this._navItems = [];
+  }
+  /**
+   * Sorts nav items. Nav items with an order defined take precedence over nav items
+   * without an order. Nav items with the same order are sorted alphabetically by
+   * title.
+   */
+  navItemSort(a, b, groupOrder) {
+    if (a.depth !== b.depth) {
+      return a.depth - b.depth;
+    }
+    if (a.order && !b.order) {
+      return -1;
+    }
+    if (!a.order && b.order) {
+      return 1;
+    } else if (a.order && b.order && a.order !== b.order) {
+      return a.order - b.order;
+    }
+    if (groupOrder && a.group && b.group) {
+      const aIndex = a.group ? groupOrder.indexOf(a.group) : -1;
+      const bIndex = b.group ? groupOrder.indexOf(b.group) : -1;
+      if (aIndex === bIndex) {
+      } else if (aIndex !== -1 && bIndex !== -1) {
+        return aIndex - bIndex;
+      } else if (aIndex !== -1) {
+        return -1;
+      } else if (bIndex !== -1) {
+        return 1;
+      }
+    }
+    if (a.group !== b.group) {
+      if (!a.group && b.group) {
+        return -1;
+      }
+      if (a.group && !b.group) {
+        return 1;
+      }
+      if (a.group && b.group) {
+        return a.group.localeCompare(b.group);
+      }
+    }
+    return a.title.localeCompare(b.title);
+  }
+  resolveSideNavTitle(frontmatter, routeMeta, fallback) {
+    return (defined(routeMeta.sideNavTitle) ? routeMeta.sideNavTitle || "" : frontmatter.sideNavTitle || "") || fallback;
+  }
+  /**
+   * Builds a flat list of nav items from the MDX pages and _meta.json. If a page
+   * does not exist, it is not added to the side nav (even if it has an entry in
+   * _meta.json).
+   */
+  buildNavItem({
+    pageFrontmatter,
+    pageSection: { pathname, pathSegments, title },
+    routeMeta: routeMetaParam
+  }) {
+    const id = pageFrontmatter?.id || "";
+    if (!pathSegments.length && pathname === "/") {
+      const routeMeta = routeMetaParam || getRouteMeta(id ? [id] : [], this.metaJson);
+      if (!routeMeta) {
+        return;
+      }
+      this.flatNavItems.push({
+        depth: 1,
+        expanded: routeMeta?.expanded || false,
+        id: `/`,
+        order: routeMeta?.order,
+        pathname,
+        pathSegments: [],
+        title: this.resolveSideNavTitle(
+          pageFrontmatter,
+          routeMeta,
+          routeMeta?.title || title
+        )
+      });
+    }
+    pathSegments.forEach((segment, index) => {
+      const depth = index + 1;
+      const navItem = this.flatNavItems.find(
+        (item) => pathSegments.slice(0, depth).every((value, i) => value === item.pathSegments[i])
+      );
+      if (!navItem) {
+        const isPage = index === pathSegments.length - 1;
+        const adjustedSegments = pathSegments.slice(0, depth);
+        const routeMeta = getRouteMeta(
+          isPage ? pathSegments : adjustedSegments,
+          this.metaJson
+        ) ?? {};
+        this.flatNavItems.push({
+          depth,
+          expanded: routeMeta?.expanded || false,
+          group: isPage ? routeMeta.group || pageFrontmatter.group : routeMeta.group,
+          id: `/${adjustedSegments.join("/")}`,
+          items: [],
+          order: routeMeta?.order,
+          pathname: isPage ? pathname : void 0,
+          pathSegments: adjustedSegments,
+          title: this.resolveSideNavTitle(
+            pageFrontmatter,
+            routeMeta,
+            routeMeta?.title ? routeMeta.title : isPage ? title : capitalCase(segment)
+          )
+        });
+      }
+    });
+  }
+  /**
+   * Iterates through a nav item's path segments and ensures that all of its parent
+   * elements exist in the recursive structure.
+   */
+  ensureParent(navItem) {
+    const segments = navItem.pathSegments;
+    let items = this.navItems;
+    let item;
+    let prevItem = void 0;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const segment = segments[i];
+      item = items?.find((entry) => entry.pathSegments[i] === segment);
+      if (item) {
+        items = item.items ?? [];
+        prevItem = item;
+        continue;
+      }
+      if (prevItem) {
+        const pathSegments = segments.slice(0, i + 1);
+        const routeMeta = getRouteMeta(pathSegments, this.metaJson);
+        items = [];
+        const base = {
+          depth: pathSegments.length,
+          id: `/routes/${pathSegments.join("/")}`,
+          items,
+          pathSegments,
+          title: segment
+        };
+        const newItem = routeMeta ? {
+          ...base,
+          expanded: routeMeta.expanded,
+          order: routeMeta.order,
+          restricted: routeMeta.restricted,
+          title: routeMeta.title ?? segment
+        } : base;
+        prevItem.items = prevItem.items ? [...prevItem.items, newItem] : [newItem];
+      }
+      prevItem = item;
+    }
+  }
+  /**
+   * Deeply inserts a nav item into the array, iterating through parent routes
+   * (based on the pathSegments) and adding them if they don't exist.
+   *
+   * For example, given a leaf node 4 path segments deep, this function will create
+   * all parent nav items as nested children of the top-most nav item.
+   */
+  nestedInsert(item, pathSegments, items) {
+    const segment = pathSegments[0];
+    const parentItem = items.find(
+      (parent) => parent.pathSegments[parent.pathSegments.length - 1] === segment
+    );
+    if (parentItem) {
+      this.nestedInsert(item, pathSegments.slice(1), parentItem.items ?? []);
+    } else if (pathSegments.length === 1) {
+      items.push(item);
+    }
+  }
+  buildNestedNavItems() {
+    for (let i = 0; i < this.flatNavItems.length; i++) {
+      const navItem = this.flatNavItems[i];
+      if (navItem.depth === 1) {
+        this.navItems.push(navItem);
+        continue;
+      }
+      this.ensureParent(navItem);
+      this.nestedInsert(navItem, navItem.pathSegments, this.navItems);
+    }
+  }
+  sortNestedNavItems(items, groupOrder) {
+    items.sort((a, b) => this.navItemSort(a, b, groupOrder));
+    items.forEach((item) => {
+      if (item.items?.length) {
+        const meta = getRouteMeta(item.pathSegments, this.metaJson);
+        this.sortNestedNavItems(item.items, meta?.groupOrder);
+      }
+    });
+  }
+  /**
+   * To be called after every mdx page route has been added through the {@link add}
+   * function.
+   */
+  build() {
+    sortBy(
+      this.initialRoutes,
+      (item) => item.pageSection.pathSegments.length
+    ).map((r) => this.buildNavItem(r));
+    this.buildNestedNavItems();
+    const rootMeta = getRouteMeta([], this.metaJson);
+    this.sortNestedNavItems(this.navItems, rootMeta?.groupOrder);
+    if (this.navMeta) {
+      Object.entries(this.navMeta).forEach(([index, value]) => {
+        this._navItems.splice(parseInt(index), 0, {
+          depth: 1,
+          id: uuidv4(),
+          pathSegments: [],
+          sectionTitle: value.sectionTitle,
+          separator: value.separator,
+          title: ""
+        });
+      });
+    }
+    this._navItems = this.groupNavItems(this.navItems);
+    this._navItems = this.buildSearchMeta(this.navItems, []);
+    return this.navItems;
+  }
+  groupNavItems(items) {
+    const result = [];
+    const seenGroups = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      if (item.group && !seenGroups.has(item.group)) {
+        seenGroups.add(item.group);
+        result.push({
+          depth: item.depth,
+          group: item.group,
+          id: uuidv4(),
+          pathSegments: [],
+          sectionTitle: item.group,
+          title: ""
+        });
+      }
+      result.push({
+        ...item,
+        items: item.items ? this.groupNavItems(item.items) : void 0
+      });
+    }
+    return result;
+  }
+  /**
+   * Walks over the tree and builds search metadata using the nearest sectionTitle.
+   */
+  buildSearchMeta(items, meta) {
+    let sectionTitle = "";
+    const results = [];
+    for (const ogItem of items) {
+      const item = { ...ogItem };
+      if (item.sectionTitle) {
+        sectionTitle = item.sectionTitle;
+      } else if (item.separator) {
+        sectionTitle = "";
+      }
+      if (!item.separator) {
+        const currentMeta = sectionTitle ? [...meta, sectionTitle] : [...meta];
+        const nextMeta = [...item.searchMeta || [], ...currentMeta];
+        if (nextMeta.length) {
+          item.searchMeta = [...nextMeta];
+        }
+        if (item.items) {
+          item.items = this.buildSearchMeta(item.items, currentMeta);
+        }
+      }
+      results.push(item);
+    }
+    return results;
+  }
+};
+
+// src/docs-plugin/internal/services/nav-builder/page-map.ts
+import { capitalCase as capitalCase2 } from "change-case";
+import { join as join2 } from "node:path";
+function getPathnameFromPathSegments(segments) {
+  return `/${segments.join("/")}`;
+}
+function getCategoriesFromPathSegments(segments, metaJson, frontmatterTitle) {
+  return segments.reduce((acc, segment, index) => {
+    const pathSegments = segments.slice(0, index + 1);
+    if (index === segments.length - 1) {
+      acc.push(frontmatterTitle);
+      return acc;
+    }
+    const meta = getRouteMeta(pathSegments, metaJson);
+    if (meta?.title) {
+      acc.push(meta.title);
+    } else {
+      acc.push(pathSegmentToCategory(segment));
+    }
+    return acc;
+  }, []);
+}
+function pathSegmentToCategory(segment) {
+  return segment.split("-").map(
+    (segment2) => /\b(a|an|and|but|or|in|on|at)\b/.test(segment2) ? segment2 : capitalCase2(segment2)
+  ).join(" ");
+}
+function getGeneroutedPathSegments(filePath) {
+  const extension = filePath.endsWith("mdx") ? "mdx" : "tsx";
+  const segments = filePath.substring(0, filePath.lastIndexOf(`.${extension}`)).split("/");
+  if (segments[segments.length - 1] === "index") {
+    return segments.slice(0, segments.length - 1);
+  }
+  return segments;
+}
+var pathSeparatorRegex = /[\/\\.]/;
+function isPathSeparator(char) {
+  return pathSeparatorRegex.test(char);
+}
+var indexRouteRegex = /((^|[.]|[+]\/)(index|_index))(\/[^\/]+)?$|(\/_?index\/)/;
+function getRemixFlatRoutesSegments(name, index, paramPrefixChar = "$") {
+  let routeSegments = [];
+  let i = 0;
+  let routeSegment = "";
+  let state2 = "START";
+  let subState = "NORMAL";
+  let hasPlus = false;
+  if (name.endsWith("_layout")) {
+    return [];
+  }
+  if (/\+\/_\./.test(name)) {
+    name = name.replace(/\+\/_\./g, "_+/");
+  }
+  if (/\+\//.test(name)) {
+    name = name.replace(/\+\//g, ".");
+    hasPlus = true;
+  }
+  const hasFolder = /\//.test(name);
+  if ((hasPlus && hasFolder || !hasPlus) && !(name.endsWith(".route") || name.endsWith(".index"))) {
+    const last = name.lastIndexOf("/");
+    if (last >= 0) {
+      name = name.substring(0, last);
+    }
+  }
+  const pushRouteSegment = (routeSegment2) => {
+    if (routeSegment2) {
+      routeSegments.push(routeSegment2);
+    }
+  };
+  while (i < name.length) {
+    const char = name[i];
+    switch (state2) {
+      case "START":
+        if (routeSegment.includes(paramPrefixChar) && !(routeSegment.startsWith(paramPrefixChar) || routeSegment.startsWith(`(${paramPrefixChar}`))) {
+          throw new Error(
+            `Route params must start with prefix char ${paramPrefixChar}: ${routeSegment}`
+          );
+        }
+        if (routeSegment.includes("(") && !routeSegment.startsWith("(") && !routeSegment.endsWith(")")) {
+          throw new Error(
+            `Optional routes must start and end with parentheses: ${routeSegment}`
+          );
+        }
+        pushRouteSegment(routeSegment);
+        routeSegment = "";
+        state2 = "PATH";
+        continue;
+      // restart without advancing index
+      case "PATH":
+        if (isPathSeparator(char) && subState === "NORMAL") {
+          state2 = "START";
+          break;
+        } else if (char === "[") {
+          subState = "ESCAPE";
+          break;
+        } else if (char === "]") {
+          subState = "NORMAL";
+          break;
+        }
+        routeSegment += char;
+        break;
+    }
+    i++;
+  }
+  pushRouteSegment(routeSegment);
+  if (routeSegments.at(-1) === "route" || routeSegments.at(-1) === "index" || routeSegments.at(-1) === "_index" || routeSegments.at(-1) === "_route") {
+    routeSegments = routeSegments.slice(0, -1);
+  }
+  if (!index && hasPlus && routeSegments.at(-1)?.startsWith("_")) {
+    routeSegments = routeSegments.slice(0, -1);
+  }
+  return routeSegments;
+}
+function getRemixHybridRoutesPathSegments(filePath) {
+  const routeWithoutExtension = filePath.substring(0, filePath.lastIndexOf("."));
+  return getRemixFlatRoutesSegments(
+    routeWithoutExtension,
+    indexRouteRegex.test(routeWithoutExtension)
+  );
+}
+function getPathSegmentsFromFileName(filePath, pageDirectory, strategy) {
+  const filePathWithoutPageDirectory = filePath.substring(
+    filePath.indexOf(pageDirectory) + pageDirectory.length + 1
+  );
+  if (typeof strategy === "function") {
+    return strategy(filePathWithoutPageDirectory);
+  }
+  switch (strategy) {
+    case "vite-generouted":
+      return getGeneroutedPathSegments(filePathWithoutPageDirectory);
+    default:
+      return getRemixHybridRoutesPathSegments(filePathWithoutPageDirectory);
+  }
+}
+function filterFileGlob(fileGlob, ext, srcDir, router) {
+  if (typeof router === "string" && router === "vite-generouted") {
+    const restrictedPattern = /(\(.*\))|(\[.*\])/;
+    const relativeGlobs = fileGlob.map((file) => file.replace(srcDir, ""));
+    return relativeGlobs.filter(
+      (file) => file.endsWith(`.${ext}`) && !file.includes("/_") && !file.includes("/+")
+    ).map(
+      (file) => file.split("/").filter((segment) => !restrictedPattern.test(segment)).join("/")
+    ).map((file) => join2(srcDir, file));
+  }
+  return fileGlob.filter((file) => file.endsWith(ext) && !file.includes("$"));
+}
+
+// src/docs-plugin/internal/transform-route-meta-array.ts
+function transformRouteMetaArray(meta, routeMetaNav) {
+  let ignoringOrder = 0;
+  return meta.reduce((acc, item, index) => {
+    if (!("id" in item)) {
+      if ("separator" in item || "sectionTitle" in item) {
+        routeMetaNav[index - ignoringOrder] = item;
+      }
+      return acc;
+    }
+    const current = item;
+    if (current.ignoreRouteMetaOrder || current.hidden) {
+      ignoringOrder++;
+    }
+    acc[current.id] = {
+      children: current.children ? transformRouteMetaArray(current.children, routeMetaNav) : void 0,
+      expanded: current.expanded,
+      group: current.group,
+      groupOrder: current.groupOrder,
+      hidden: current.hidden,
+      hideBreadcrumbs: current.hideBreadcrumbs,
+      hideFromSearch: current.hideFromSearch,
+      hidePageLinks: current.hidePageLinks,
+      hideSideNav: current.hideSideNav,
+      hideToc: current.hideToc,
+      order: current.ignoreRouteMetaOrder ? void 0 : index + 1,
+      restricted: current.restricted,
+      title: current.title
+    };
+    return acc;
+  }, {});
+}
+
+// src/docs-plugin/internal/search-indexer.ts
+var SearchIndexer = class {
+  constructor(config, logWarnings = true, addons = {}) {
+    this.config = config;
+    this.logWarnings = logWarnings;
+    this.allowedHeadings = new Set(
+      Array.from(config?.headings || ["h2", "h3", "h4"])
+    );
+    this.metaJson = transformRouteMetaArray(
+      this.config.navConfig ?? [],
+      this.routeMetaNav
+    );
+    this.markdownIndexer = addons.markdownIndexer || new MarkdownIndexer(this.allowedHeadings);
+    this.navBuilder = addons.navBuilder || new NavBuilder(this.metaJson, this.routeMetaNav);
+    this.docPropsIndexer = addons.docPropsIndexer || new DocPropsIndexer(this.config.typeDocProps ?? {});
+    this.fileCache = addons.fileCache || new MarkdownFileReader(
+      process.env.NODE_ENV === "development" && !this.config.disableCache
+    );
+  }
+  docPropsIndexer;
+  markdownIndexer;
+  navBuilder;
+  fileCache;
+  allowedHeadings;
+  metaJson;
+  routeMetaNav = {};
+  get cachedFileCount() {
+    return this.fileCache.cachedFileCount;
+  }
+  get pageDocProps() {
+    return this._pageDocProps;
+  }
+  _pageDocProps = {};
+  get mdxFileCount() {
+    return this._mdxFileCount;
+  }
+  _mdxFileCount = 0;
+  get navItems() {
+    return this.navBuilder.navItems;
+  }
+  get pageMap() {
+    return this._pageMap;
+  }
+  _pageMap = {};
+  get searchIndex() {
+    return this._searchIndex;
+  }
+  _searchIndex = [];
+  reset() {
+    this.fileCache.reset();
+    this._pageMap = {};
+    this._searchIndex = [];
+  }
+  /**
+   * Resolves a page's properties from the combined frontmatter and RouteMeta.
+   * RouteMeta properties take precedence.
+   */
+  getPageEntry(filepath, frontmatter) {
+    const pagePath = filepath.replace(this.config.srcDir, "");
+    const pathSegments = getPathSegmentsFromFileName(
+      pagePath,
+      this.config.pageDirectory,
+      this.config.routingStrategy
+    );
+    const pathname = getPathnameFromPathSegments(pathSegments);
+    const routeMeta = getRouteMeta(
+      pathSegments.length === 0 ? frontmatter.id ? [frontmatter.id] : ["_index"] : pathSegments,
+      this.metaJson
+    ) ?? {};
+    return {
+      categories: frontmatter.categories ?? getCategoriesFromPathSegments(
+        pathSegments,
+        this.metaJson,
+        routeMeta?.title || frontmatter.title || ""
+      ),
+      hidden: defined(routeMeta.hidden) ? routeMeta.hidden : frontmatter.hidden,
+      hideBreadcrumbs: defined(routeMeta.hideBreadcrumbs) ? routeMeta.hideBreadcrumbs : frontmatter.hideBreadcrumbs,
+      hideFromSearch: defined(routeMeta.hideFromSearch) ? routeMeta.hideFromSearch : frontmatter.hideFromSearch,
+      hidePageLinks: defined(routeMeta.hidePageLinks) ? routeMeta.hidePageLinks : frontmatter.hidePageLinks,
+      hideSideNav: defined(routeMeta.hideSideNav) ? routeMeta.hideSideNav : frontmatter.hideSideNav,
+      hideToc: defined(routeMeta.hideToc) ? routeMeta.hideToc : frontmatter.hideToc,
+      id: pagePath,
+      pathname,
+      pathSegments,
+      restricted: defined(routeMeta.restricted) ? routeMeta.restricted : frontmatter.restricted,
+      title: defined(routeMeta.title) ? routeMeta.title || "" : frontmatter.title || ""
+    };
+  }
+  /**
+   * Parses an MDX file to extract the site data for the nav items, doc props,
+   * breadcrumbs, and search index.
+   */
+  compileMdxFile(filepath) {
+    const { cached, fileContents, frontmatter } = this.fileCache.readFile(filepath);
+    this.docPropsIndexer.reset();
+    this.markdownIndexer.reset();
+    const defaultSection = this.getPageEntry(filepath, frontmatter);
+    if (!defaultSection.categories.length && defaultSection.title) {
+      defaultSection.categories = [defaultSection.title];
+    }
+    if (!defaultSection.hidden) {
+      this.navBuilder.add(defaultSection, frontmatter);
+    }
+    this._pageMap[defaultSection.pathname] = defaultSection;
+    let indexedPage;
+    try {
+      indexedPage = cached?.page ? cached.page : this.markdownIndexer.parseMarkdown(fileContents, frontmatter);
+    } catch (error) {
+      console.debug(
+        `${chalk3.yellowBright.bold(
+          "Failed to parse mdx page content."
+        )} ${chalk3.blueBright.bold(filepath)}`
+      );
+      return [defaultSection];
+    }
+    const { sections, toc } = indexedPage;
+    if (toc.length) {
+      this._pageMap[defaultSection.pathname].toc = toc;
+    }
+    let docPropSections = [];
+    let docProps = {};
+    if (this.config.typeDocProps) {
+      docPropSections = cached?.pageDocPropSections || (this.docPropsIndexer.build(fileContents, toc) ?? []);
+      docProps = cached?.pageDocProps || this.docPropsIndexer.getDocProps();
+    }
+    if (docPropSections.length) {
+      this._pageDocProps[defaultSection.pathname] = docProps;
+    }
+    this.fileCache.updateCache(filepath, fileContents, {
+      frontmatter,
+      page: indexedPage,
+      pageDocProps: docProps,
+      pageDocPropSections: docPropSections
+    });
+    if (frontmatter.hideFromSearch) {
+      return [defaultSection];
+    }
+    if (!sections.length && !docPropSections.length) {
+      return [defaultSection];
+    }
+    const sectionReturn = [
+      ...this.formatSections(sections, defaultSection, false)
+    ];
+    if (this.config.typeDocPropsOptions?.includeInSearchIndex) {
+      sectionReturn.push(
+        ...this.formatSections(docPropSections, defaultSection, true)
+      );
+    }
+    return sectionReturn;
+  }
+  formatSections(sections, { toc: _toc, ...defaultSection }, isDocProp) {
+    return sections.map((section, index) => {
+      const content = section.content.map((c) => c.text.join(" ")).join(" ");
+      return {
+        ...defaultSection,
+        content: content || void 0,
+        heading: section.heading?.textContent ?? defaultSection.title,
+        headingLevel: section.heading?.headingLevel,
+        href: section.heading && (this.allowedHeadings.has(section.heading.tagName) || isDocProp) ? `${defaultSection.pathname}#${section.heading.id}` : defaultSection.pathname,
+        id: `${defaultSection.id}-${index}${isDocProp ? "-prop" : ""}`,
+        isDocProp: isDocProp || void 0
+      };
+    });
+  }
+  compileTsxFile(filepath) {
+    const entry = this.getPageEntry(filepath, {});
+    const routeMeta = getRouteMeta(
+      entry.pathSegments.length === 0 ? ["_index"] : entry.pathSegments,
+      this.metaJson
+    );
+    if (!routeMeta) {
+      return null;
+    }
+    if (!entry.hidden) {
+      this.navBuilder.add(entry, {}, routeMeta);
+    }
+    this._pageMap[entry.pathname] = entry;
+    return entry;
+  }
+  buildIndex(inputFileGlob, logWarnings = true) {
+    this.logWarnings = logWarnings;
+    this.fileCache.logWarnings = logWarnings;
+    const fileGlob = inputFileGlob.map(fixPath);
+    this.navBuilder.reset();
+    this.reset();
+    const mdxFileGlob = filterFileGlob(
+      fileGlob,
+      "mdx",
+      this.config.srcDir,
+      this.config.routingStrategy
+    );
+    this._mdxFileCount = mdxFileGlob.length;
+    const mdxIndex = mdxFileGlob.map((file) => this.compileMdxFile(file)).flat();
+    filterFileGlob(
+      fileGlob,
+      "tsx",
+      this.config.srcDir,
+      this.config.routingStrategy
+    ).map((file) => this.compileTsxFile(file));
+    this._searchIndex.push(...mdxIndex.filter((entry) => !entry.hideFromSearch));
+    this.navBuilder.build();
+  }
+};
+
+// src/docs-plugin/docs-plugin.ts
+var isDev = process.env.NODE_ENV === "development";
+var PluginState = class {
+  buildCount = 0;
+  configFilePath = "";
+  docPropsFilePath = "";
+  indexer;
+  configLoader = null;
+  routesDir;
+  servers = [];
+  timeout = void 0;
+  watching = false;
+  resolvedVirtualModuleId;
+  virtualModuleId = "@qualcomm-ui/mdx-vite-plugin";
+  cwd;
+  constructor() {
+    this.resolvedVirtualModuleId = `\0${this.virtualModuleId}`;
+  }
+  init(cwd) {
+    this.cwd = cwd;
+  }
+  get docPropsDirectory() {
+    if (!this.docPropsFilePath) {
+      return "";
+    }
+    return this.docPropsFilePath.substring(
+      0,
+      this.docPropsFilePath.lastIndexOf("/")
+    );
+  }
+  resolveDocProps() {
+    if (!this.docPropsFilePath) {
+      return {};
+    }
+    try {
+      return JSON.parse(readFileSync2(this.docPropsFilePath, "utf-8"))?.props;
+    } catch (e) {
+      console.debug(
+        "Invalid doc props file. Unable to parse JSON. Please check the file"
+      );
+      return {};
+    }
+  }
+  createIndexer(config) {
+    this.configFilePath = config.filePath;
+    this.docPropsFilePath = config.typeDocProps ? fixPath(resolve2(this.cwd, config.typeDocProps)) : "";
+    this.routesDir = fixPath(resolve2(config.appDirectory, config.pageDirectory));
+    this.indexer = new SearchIndexer({
+      ...config,
+      srcDir: fixPath(resolve2(this.cwd, config.appDirectory)),
+      typeDocProps: this.resolveDocProps()
+    });
+  }
+  buildIndex(shouldLog) {
+    const files = glob2.sync(
+      [`${this.routesDir}/**/*.mdx`, `${this.routesDir}/**/*.tsx`],
+      {
+        absolute: true,
+        cwd: this.cwd
+      }
+    );
+    if (!files.length) {
+      return;
+    }
+    const startTime = Date.now();
+    this.indexer.buildIndex(files, shouldLog);
+    if (isDev && shouldLog) {
+      console.debug(
+        `${chalk4.magenta.bold(`@qualcomm-ui/mdx-vite/docs-plugin:`)} Compiled search index in: ${chalk4.blueBright.bold(prettyMilliseconds(Date.now() - startTime))}${state.indexer.cachedFileCount ? chalk4.greenBright.bold(` (${state.indexer.cachedFileCount}/${state.indexer.mdxFileCount} files cached)`) : ""}`
+      );
+    }
+  }
+  /**
+   * When the user edits MDX content or modifies the plugin config, we re-index the
+   * site. This function handles module invalidation so that virtual file imports
+   * are refreshed as expected by the consumer's dev server.
+   */
+  sendUpdate() {
+    for (const server of this.servers) {
+      const virtualModule = server.moduleGraph.getModuleById(
+        this.resolvedVirtualModuleId
+      );
+      if (virtualModule) {
+        server.moduleGraph.invalidateModule(virtualModule);
+        server.reloadModule(virtualModule);
+      }
+    }
+  }
+  handleChange(callback) {
+    clearTimeout(this.timeout);
+    this.timeout = setTimeout(() => {
+      this.buildIndex(true);
+      this.sendUpdate();
+      callback?.();
+    }, 300);
+  }
+  initWatchers(configFile) {
+    if (this.watching) {
+      return;
+    }
+    this.initConfigWatcher(configFile);
+    this.watching = true;
+  }
+  initConfigWatcher(configFile) {
+    const paths = [this.configFilePath];
+    if (this.docPropsFilePath) {
+      paths.push(this.docPropsFilePath);
+    }
+    chokidar.watch(paths, {
+      cwd: this.cwd
+    }).on("change", () => {
+      console.debug(`qui-docs config changed, reloading plugin`);
+      this.configLoader = new ConfigLoader({ configFile });
+      const resolvedConfig = this.configLoader.loadConfig();
+      this.configFilePath = resolvedConfig.filePath;
+      this.createIndexer(resolvedConfig);
+      this.handleChange();
+    });
+  }
+};
+var state = new PluginState();
+function quiDocsPlugin(opts) {
+  state.init(fixPath(opts?.cwd ?? process.cwd()));
+  const configLoader = new ConfigLoader(opts || {});
+  const config = configLoader.loadConfig();
+  state.createIndexer(config);
+  return {
+    buildStart: async () => {
+      state.buildIndex(state.buildCount > 0);
+      state.buildCount++;
+    },
+    configureServer: (server) => {
+      if (!isDev) {
+        return;
+      }
+      state.initWatchers(opts?.configFile);
+      server.watcher.on("add", (path) => {
+        if (path.endsWith(".mdx")) {
+          state.handleChange(() => {
+            server.ws.send({ type: "full-reload" });
+          });
+        }
+      });
+      server.watcher.on("unlink", (path) => {
+        if (path.endsWith(".mdx")) {
+          state.handleChange(() => {
+            server.ws.send({ type: "full-reload" });
+          });
+        }
+      });
+      state.servers.push(server);
+    },
+    handleHotUpdate: async ({ file: updateFile }) => {
+      const file = fixPath(updateFile);
+      if ((!config.hotUpdateIgnore || !config.hotUpdateIgnore.test(file)) && // ignore watched files. We watch for these separately.
+      file !== state.configFilePath) {
+        if (state.docPropsDirectory && file.startsWith(state.docPropsFilePath)) {
+          return [];
+        }
+        state.handleChange();
+      }
+      return [];
+    },
+    load: (id) => {
+      if (id === state.resolvedVirtualModuleId) {
+        return `export const siteData = ${JSON.stringify({ navItems: state.indexer.navItems, pageDocProps: state.indexer.pageDocProps, pageMap: state.indexer.pageMap, searchIndex: state.indexer.searchIndex })}`;
+      }
+      return void 0;
+    },
+    name: "qui-mdx-vite-plugin",
+    resolveId: (id) => {
+      if (id === state.virtualModuleId) {
+        return state.resolvedVirtualModuleId;
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/docs-plugin/mdx-plugins.ts
+import rehypeShiki from "@shikijs/rehype";
+import { quiCustomDarkTheme as quiCustomDarkTheme2 } from "@qualcomm-ui/mdx-common";
+
+// src/exports.ts
+import rehypeMdxCodeProps from "rehype-mdx-code-props";
+import remarkFrontmatter2 from "remark-frontmatter";
+import remarkGfm2 from "remark-gfm";
+import remarkMdxFrontmatter from "remark-mdx-frontmatter";
+
+// src/docs-plugin/rehype/rehype-sectionize.ts
+import { heading } from "hast-util-heading";
+import { headingRank as headingRank2 } from "hast-util-heading-rank";
+var defaultOptions = {
+  enableRootSection: false,
+  idPropertyName: "ariaLabelledby",
+  properties: {},
+  rankPropertyName: "dataHeadingRank"
+};
+var wrappingRank = (rootContent, rankPropertyName) => {
+  if (rootContent == null || rankPropertyName == null || !("properties" in rootContent)) {
+    throw new Error("rootContent and rankPropertyName must have value");
+  }
+  const rank = rootContent.properties?.[rankPropertyName];
+  if (typeof rank !== "number") {
+    throw new Error(`rankPropertyName(${rankPropertyName}) must be number`);
+  }
+  return rank;
+};
+var createElement = (rank, options, children = []) => {
+  const { idPropertyName, properties, rankPropertyName } = options;
+  if (properties != null && rankPropertyName != null && rankPropertyName in properties) {
+    throw new Error(
+      `rankPropertyName(${rankPropertyName}) dataHeadingRank must exist`
+    );
+  }
+  const id = children.at(0)?.properties?.id;
+  const element = {
+    children,
+    properties: {
+      className: ["heading"],
+      ...rankPropertyName ? { [rankPropertyName]: rank } : {},
+      ...idPropertyName && typeof id === "string" ? { [idPropertyName]: id } : {},
+      ...properties ? properties : {}
+    },
+    tagName: "section",
+    type: "element"
+  };
+  return element;
+};
+var rehypeSectionize = (options = defaultOptions) => {
+  const { enableRootSection, ...rest } = {
+    enableRootSection: options.enableRootSection ?? defaultOptions.enableRootSection,
+    idPropertyName: options.idPropertyName ?? defaultOptions.idPropertyName,
+    properties: options.properties ?? defaultOptions.properties,
+    rankPropertyName: options.rankPropertyName ?? defaultOptions.rankPropertyName
+  };
+  return (root) => {
+    const rootWrapper = createElement(0, rest);
+    const wrapperStack = [];
+    wrapperStack.push(rootWrapper);
+    const lastStackItem = () => {
+      const last = wrapperStack.at(-1);
+      if (last == null || last.type !== "element") {
+        throw new Error("lastStackItem must be Element");
+      }
+      return wrapperStack.at(-1);
+    };
+    for (const rootContent of root.children) {
+      if (heading(rootContent)) {
+        const rank = headingRank2(rootContent);
+        if (rank == null) {
+          throw new Error("heading or headingRank is not working");
+        }
+        if (rank > wrappingRank(lastStackItem(), rest.rankPropertyName)) {
+          const childWrapper = createElement(rank, rest, [rootContent]);
+          lastStackItem().children.push(childWrapper);
+          wrapperStack.push(childWrapper);
+        } else if (rank <= wrappingRank(lastStackItem(), rest.rankPropertyName)) {
+          while (rank <= wrappingRank(lastStackItem(), rest.rankPropertyName)) {
+            wrapperStack.pop();
+          }
+          const siblingWrapper = createElement(rank, rest, [rootContent]);
+          lastStackItem().children.push(siblingWrapper);
+          wrapperStack.push(siblingWrapper);
+        }
+      } else {
+        if (rootContent.type === "doctype") {
+          throw new Error("must be used in a fragment");
+        }
+        lastStackItem().children.push(rootContent);
+      }
+    }
+    return {
+      ...root,
+      children: enableRootSection ? [rootWrapper] : rootWrapper.children
+    };
+  };
+};
+
+// src/docs-plugin/remark/remark-code-tabs.ts
+import { visit as visit4 } from "unist-util-visit";
+function parseTabAttributes(meta) {
+  if (!meta) {
+    return { label: null, remainingMeta: "", tabsGroup: null };
+  }
+  const tabsMatch = meta.match(/tabs=["']([^"']+)["']|tabs=(\S+)/);
+  const labelMatch = meta.match(/label=["']([^"']+)["']|label=(\S+)/);
+  const tabsGroup = tabsMatch ? tabsMatch[1] || tabsMatch[2] : null;
+  const label = labelMatch ? labelMatch[1] || labelMatch[2] : null;
+  const remainingMeta = meta.replace(/\s*tabs=["']([^"']+)["']/g, "").replace(/\s*tabs=(\S+)/g, "").replace(/\s*label=["']([^"']+)["']/g, "").replace(/\s*label=(\S+)/g, "").trim();
+  return { label, remainingMeta, tabsGroup };
+}
+function findConsecutiveTabs(startIndex, parent, targetTabsGroup) {
+  const tabs = [];
+  let currentIndex = startIndex;
+  while (currentIndex < parent.children.length) {
+    const currentNode = parent.children[currentIndex];
+    if (!currentNode || currentNode.type !== "code") {
+      break;
+    }
+    const codeNode = currentNode;
+    if (!codeNode.meta) {
+      break;
+    }
+    const { label, remainingMeta, tabsGroup } = parseTabAttributes(codeNode.meta);
+    if (!tabsGroup || !label || tabsGroup !== targetTabsGroup) {
+      break;
+    }
+    codeNode.meta = remainingMeta || void 0;
+    tabs.push({
+      index: currentIndex,
+      label,
+      meta: remainingMeta || void 0,
+      tabsGroup
+    });
+    if (remainingMeta && remainingMeta.includes("end")) {
+      break;
+    }
+    currentIndex++;
+  }
+  return tabs;
+}
+function renderTabs(tabs, parent) {
+  const tabsContainer = {
+    attributes: [],
+    children: [],
+    name: "CodeTabs",
+    type: "mdxJsxFlowElement"
+  };
+  tabs.forEach((tab) => {
+    const codeNode = parent.children[tab.index];
+    const tabAttributes = [
+      {
+        name: "label",
+        type: "mdxJsxAttribute",
+        value: tab.label
+      }
+    ];
+    if (tab.meta) {
+      tabAttributes.push({
+        name: "meta",
+        type: "mdxJsxAttribute",
+        value: tab.meta
+      });
+    }
+    const tabElement = {
+      attributes: tabAttributes,
+      children: [
+        {
+          lang: codeNode.lang,
+          meta: codeNode.meta,
+          // This is now clean
+          type: "code",
+          value: codeNode.value
+        }
+      ],
+      name: "CodeTab",
+      type: "mdxJsxFlowElement"
+    };
+    tabsContainer.children.push(tabElement);
+  });
+  return [tabsContainer];
+}
+var remarkCodeTabs = () => {
+  return (tree) => {
+    const transformations = [];
+    visit4(
+      tree,
+      "code",
+      (node, index, parent) => {
+        if (!node.meta || !parent || index === void 0) {
+          return;
+        }
+        const { label, tabsGroup } = parseTabAttributes(node.meta);
+        if (!tabsGroup || !label) {
+          return;
+        }
+        const alreadyProcessed = transformations.some(
+          (t) => t.parent === parent && index >= t.startIndex && index < t.endIndex
+        );
+        if (alreadyProcessed) {
+          return;
+        }
+        const tabs = findConsecutiveTabs(index, parent, tabsGroup);
+        if (tabs.length > 1) {
+          const startIndex = tabs[0].index;
+          const endIndex = tabs[tabs.length - 1].index + 1;
+          const newChildren = renderTabs(tabs, parent);
+          transformations.push({
+            endIndex,
+            parent,
+            replacement: newChildren,
+            startIndex
+          });
+        }
+      }
+    );
+    transformations.sort((a, b) => b.startIndex - a.startIndex).forEach((transformation) => {
+      transformation.parent.children.splice(
+        transformation.startIndex,
+        transformation.endIndex - transformation.startIndex,
+        ...transformation.replacement
+      );
+    });
+  };
+};
+
+// src/docs-plugin/remark/remark-self-link-headings.ts
+import { toString as toString2 } from "mdast-util-to-string";
+import { visit as visit5 } from "unist-util-visit";
+var emptyOptions2 = {};
+function remarkSelfLinkHeadings(baseUrl = "", options) {
+  if (!baseUrl) {
+    return () => {
+    };
+  }
+  return () => {
+    const settings = options || emptyOptions2;
+    const prefix = settings.prefix || "";
+    const allowedLevels = new Set(settings.allowedLevels || [2, 3, 4]);
+    const seenIds = /* @__PURE__ */ new Map();
+    function createSlug(text) {
+      const cleaned = text.replace(/[<>]/g, "").replace(/[^\w\s-]/g, "").trim();
+      let slug;
+      if (cleaned.includes(" ")) {
+        slug = cleaned.toLowerCase().replace(/\s+/g, "-").replace(/^-+|-+$/g, "");
+      } else if ((cleaned.match(/[A-Z]/g) || []).length >= 2) {
+        slug = cleaned.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+      } else {
+        slug = cleaned.toLowerCase();
+      }
+      const count = seenIds.get(slug) || 0;
+      seenIds.set(slug, count + 1);
+      return count > 0 ? `${slug}-${count}` : slug;
+    }
+    return (tree) => {
+      seenIds.clear();
+      visit5(tree, "heading", (node) => {
+        if (allowedLevels.has(node.depth)) {
+          const text = toString2(node);
+          const slug = prefix + createSlug(text);
+          const linkNode = {
+            children: node.children,
+            type: "link",
+            url: `${baseUrl}#${slug}`
+          };
+          node.children = [linkNode];
+        }
+      });
+    };
+  };
+}
+
+// src/docs-plugin/remark/remark-spoilers.ts
+import { visit as visit6 } from "unist-util-visit";
+var remarkSpoilers = (options = {}) => {
+  const {
+    defaultSummary = "Open spoiler",
+    detailsClassName = [],
+    summaryClassName = []
+  } = options;
+  return (tree) => {
+    visit6(tree, "paragraph", (node, index, parent) => {
+      if (!parent || index === void 0) {
+        return;
+      }
+      const firstChild = node.children[0];
+      if (firstChild?.type !== "text") {
+        return;
+      }
+      const match = firstChild.value.match(/^:::\s*spoiler\s*(.*)$/);
+      if (!match) {
+        return;
+      }
+      const summary = match[1].trim() || defaultSummary;
+      let endIndex = index + 1;
+      const contentNodes = [];
+      while (endIndex < parent.children.length) {
+        const child = parent.children[endIndex];
+        if (child.type === "paragraph") {
+          const firstText = child.children[0];
+          if (firstText?.type === "text" && firstText.value.trim() === ":::") {
+            break;
+          }
+        }
+        contentNodes.push(child);
+        endIndex++;
+      }
+      if (endIndex >= parent.children.length) {
+        return;
+      }
+      const summaryNode = {
+        attributes: summaryClassName.length ? [
+          {
+            name: "className",
+            type: "mdxJsxAttribute",
+            value: summaryClassName.join(" ")
+          }
+        ] : [],
+        children: [
+          {
+            children: [{ type: "text", value: summary }],
+            type: "paragraph"
+          }
+        ],
+        name: "SpoilerSummary",
+        type: "mdxJsxFlowElement"
+      };
+      const contentNode = {
+        attributes: [],
+        children: contentNodes,
+        name: "SpoilerContent",
+        type: "mdxJsxFlowElement"
+      };
+      const detailsNode = {
+        attributes: detailsClassName.length ? [
+          {
+            name: "className",
+            type: "mdxJsxAttribute",
+            value: detailsClassName.join(" ")
+          }
+        ] : [],
+        children: [summaryNode, contentNode],
+        name: "SpoilerRoot",
+        type: "mdxJsxFlowElement"
+      };
+      parent.children.splice(index, endIndex - index + 1, detailsNode);
+    });
+  };
+};
+
+// src/docs-plugin/mdx-plugins.ts
+var quiRehypePlugins = [rehypeSectionize, rehypeSlug];
+function getRehypePlugins(options = {}) {
+  const config = new ConfigLoader(options).loadConfig();
+  return [
+    rehypeMdxCodeProps,
+    [
+      rehypeSlug,
+      { allowedHeadings: config.headings }
+    ],
+    rehypeSectionize,
+    [
+      rehypeShiki,
+      {
+        defaultColor: "light-dark()",
+        themes: {
+          dark: quiCustomDarkTheme2,
+          light: "github-light-high-contrast"
+        },
+        ...options.rehypeShikiOptions
+      }
+    ]
+  ];
+}
+var quiRemarkPlugins = [remarkAlerts, remarkCodeTabs];
+function getRemarkPlugins() {
+  return [
+    remarkFrontmatter2,
+    remarkMdxFrontmatter,
+    remarkGfm2,
+    remarkAlerts,
+    remarkCodeTabs,
+    remarkSpoilers
+  ];
+}
+
+// src/react-demo-plugin/demo-plugin-constants.ts
+var VIRTUAL_MODULE_IDS = {
+  AUTO: "\0virtual:qui-demo-scope/auto",
+  CONFIG: "\0virtual:qui-demo-scope/config",
+  PAGE_PREFIX: "\0virtual:qui-demo-scope/page:"
+};
+var LOG_PREFIX2 = "@qualcomm-ui/mdx-vite/react-demo-plugin:";
+var REACT_IMPORTS = [
+  "useState",
+  "useEffect",
+  "useMemo",
+  "useCallback",
+  "useRef",
+  "useContext",
+  "createContext",
+  "forwardRef",
+  "memo",
+  "lazy",
+  "Suspense",
+  "Fragment"
+];
+var NODE_BUILTINS = [
+  "fs",
+  "path",
+  "url",
+  "util",
+  "os",
+  "crypto",
+  "events",
+  "stream",
+  "buffer"
+];
+
+// src/react-demo-plugin/demo-plugin-utils.ts
+import chalk5 from "chalk";
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join3, relative as relative2, resolve as resolve3, sep } from "node:path";
+import * as ts2 from "typescript";
+import { pascalCase } from "@qualcomm-ui/utils/change-case";
+function createDemoName(filePath) {
+  const separatorChar = filePath.includes("/") ? "/" : "\\";
+  const fileName = filePath.substring(
+    filePath.lastIndexOf(separatorChar),
+    filePath.lastIndexOf(".")
+  );
+  if (!fileName) {
+    throw new Error(`Failed to create demo name for ${filePath}`);
+  }
+  return pascalCase(fileName);
+}
+async function extractFileImports(filePath) {
+  try {
+    const content = await readFile2(filePath, "utf-8");
+    return extractImports(content, filePath);
+  } catch (error) {
+    console.log(
+      `${chalk5.magenta.bold(LOG_PREFIX2)} ${chalk5.yellowBright("Failed to parse")} ${chalk5.blueBright.bold(filePath)}:`,
+      error
+    );
+    return null;
+  }
+}
+function mergeImports(importMap, imports) {
+  for (const { source, specifiers } of imports) {
+    if (isNodeBuiltin(source)) {
+      continue;
+    }
+    let sourceSpecifiers = importMap.get(source);
+    if (!sourceSpecifiers) {
+      sourceSpecifiers = /* @__PURE__ */ new Set();
+      importMap.set(source, sourceSpecifiers);
+    }
+    for (const spec of specifiers) {
+      sourceSpecifiers.add(spec);
+    }
+  }
+}
+function extractImports(code, fileName) {
+  const sourceFile = ts2.createSourceFile(
+    fileName,
+    code,
+    ts2.ScriptTarget.Latest,
+    true,
+    getScriptKind(fileName)
+  );
+  const thirdPartyImports = [];
+  const relativeImports = [];
+  function visit7(node) {
+    if (ts2.isImportDeclaration(node)) {
+      const importSpec = parseImportDeclaration(node, fileName);
+      if (importSpec) {
+        if (importSpec.type === "relative") {
+          relativeImports.push(importSpec);
+        } else {
+          thirdPartyImports.push(importSpec);
+        }
+      }
+    }
+    ts2.forEachChild(node, visit7);
+  }
+  visit7(sourceFile);
+  return { relativeImports, thirdPartyImports };
+}
+function getScriptKind(fileName) {
+  return fileName.endsWith(".tsx") || fileName.endsWith(".jsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS;
+}
+function parseImportDeclaration(node, fileName) {
+  const moduleSpecifier = node.moduleSpecifier;
+  if (!ts2.isStringLiteral(moduleSpecifier)) {
+    return null;
+  }
+  const source = moduleSpecifier.text;
+  if (node.importClause?.isTypeOnly) {
+    return null;
+  }
+  const specifiers = extractSpecifiers(node.importClause);
+  if (specifiers.length === 0) {
+    return null;
+  }
+  if (isRelativeImport(source)) {
+    const resolvedPath = resolveRelativeImport(source, fileName);
+    return {
+      resolvedPath,
+      source,
+      specifiers,
+      type: "relative"
+    };
+  }
+  if (isNodeBuiltin(source)) {
+    return null;
+  }
+  const pathAliases = loadTsConfigPaths(fileName);
+  if (isPathAliasImport2(source, pathAliases)) {
+    const resolvedPath = resolvePathAlias2(source, pathAliases);
+    if (resolvedPath) {
+      return {
+        resolvedPath,
+        source,
+        specifiers,
+        type: "relative"
+      };
+    }
+  }
+  return {
+    source,
+    specifiers,
+    type: "thirdParty"
+  };
+}
+function extractSpecifiers(importClause) {
+  if (!importClause) {
+    return [];
+  }
+  const specifiers = [];
+  if (importClause.name) {
+    specifiers.push({ imported: "default", local: "default" });
+  }
+  if (importClause.namedBindings) {
+    if (ts2.isNamespaceImport(importClause.namedBindings)) {
+      specifiers.push({ imported: "*", local: "*" });
+    } else if (ts2.isNamedImports(importClause.namedBindings)) {
+      importClause.namedBindings.elements.forEach((element) => {
+        if (!element.isTypeOnly) {
+          const imported = element.propertyName ? element.propertyName.text : element.name.text;
+          const local = element.name.text;
+          specifiers.push({ imported, local });
+        }
+      });
+    }
+  }
+  return specifiers;
+}
+function resolveRelativeImport(source, fromFile) {
+  const fromDir = dirname2(fromFile);
+  const resolved = resolve3(fromDir, source);
+  const extensions = [".ts", ".tsx", ".js", ".jsx"];
+  for (const ext of extensions) {
+    const withExt = resolved + ext;
+    if (existsSync2(withExt)) {
+      return withExt;
+    }
+  }
+  for (const ext of extensions) {
+    const indexFile = join3(resolved, `index${ext}`);
+    if (existsSync2(indexFile)) {
+      return indexFile;
+    }
+  }
+  return resolved;
+}
+async function extractAllImports(files) {
+  const importMap = /* @__PURE__ */ new Map();
+  const relativeImports = [];
+  for (const filePath of files) {
+    const result = await extractFileImports(filePath);
+    if (result) {
+      mergeImports(importMap, result.thirdPartyImports);
+      relativeImports.push(...result.relativeImports);
+    }
+  }
+  return { importMap, relativeImports };
+}
+function isRelativeImport(source) {
+  return source.startsWith("./") || source.startsWith("../");
+}
+function isNodeBuiltin(source) {
+  return source.startsWith("node:") || NODE_BUILTINS.includes(source);
+}
+function loadTsConfigPaths(fromFile) {
+  let currentDir = dirname2(fromFile);
+  const pathAliases = [];
+  while (currentDir !== dirname2(currentDir)) {
+    const tsconfigPath = join3(currentDir, "tsconfig.json");
+    if (existsSync2(tsconfigPath)) {
+      try {
+        const configContent = ts2.sys.readFile(tsconfigPath);
+        if (!configContent) {
+          currentDir = dirname2(currentDir);
+          continue;
+        }
+        const parseResult = ts2.parseConfigFileTextToJson(
+          tsconfigPath,
+          configContent
+        );
+        if (parseResult.error) {
+          currentDir = dirname2(currentDir);
+          continue;
+        }
+        const paths = parseResult.config?.compilerOptions?.paths;
+        const baseUrl = parseResult.config?.compilerOptions?.baseUrl || "./";
+        const resolvedBaseUrl = resolve3(currentDir, baseUrl);
+        if (paths) {
+          for (const [alias, targets] of Object.entries(paths)) {
+            if (Array.isArray(targets) && targets.length > 0) {
+              const target = targets[0];
+              const pattern = new RegExp(
+                `^${alias.replace("*", "(.*)").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\(\\*\\)", "(.*)")}$`
+              );
+              const replacement = resolve3(
+                resolvedBaseUrl,
+                target.replace("*", "$1")
+              );
+              pathAliases.push({ pattern, replacement });
+            }
+          }
+        }
+        const extendsPath = parseResult.config?.extends;
+        if (extendsPath) {
+          const resolvedExtends = resolve3(currentDir, extendsPath);
+          const extendedAliases = loadTsConfigPathsFromFile2(resolvedExtends);
+          pathAliases.push(...extendedAliases);
+        }
+        return pathAliases;
+      } catch (error) {
+        currentDir = dirname2(currentDir);
+        continue;
+      }
+    }
+    currentDir = dirname2(currentDir);
+  }
+  return pathAliases;
+}
+function loadTsConfigPathsFromFile2(tsconfigPath) {
+  const pathAliases = [];
+  const configDir = dirname2(tsconfigPath);
+  try {
+    const configContent = ts2.sys.readFile(tsconfigPath);
+    if (!configContent) {
+      return pathAliases;
+    }
+    const parseResult = ts2.parseConfigFileTextToJson(
+      tsconfigPath,
+      configContent
+    );
+    if (parseResult.error) {
+      return pathAliases;
+    }
+    const paths = parseResult.config?.compilerOptions?.paths;
+    const baseUrl = parseResult.config?.compilerOptions?.baseUrl || "./";
+    const resolvedBaseUrl = resolve3(configDir, baseUrl);
+    if (paths) {
+      for (const [alias, targets] of Object.entries(paths)) {
+        if (Array.isArray(targets) && targets.length > 0) {
+          const target = targets[0];
+          const pattern = new RegExp(
+            `^${alias.replace("*", "(.*)").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\(\\*\\)", "(.*)")}$`
+          );
+          const replacement = resolve3(
+            resolvedBaseUrl,
+            target.replace("*", "$1")
+          );
+          pathAliases.push({ pattern, replacement });
+        }
+      }
+    }
+    const extendsPath = parseResult.config?.extends;
+    if (extendsPath) {
+      let resolvedExtends = resolve3(configDir, extendsPath);
+      if (!resolvedExtends.endsWith(".json")) {
+        resolvedExtends += ".json";
+      }
+      if (existsSync2(resolvedExtends)) {
+        const extendedAliases = loadTsConfigPathsFromFile2(resolvedExtends);
+        pathAliases.push(...extendedAliases);
+      }
+    }
+  } catch (error) {
+    return pathAliases;
+  }
+  return pathAliases;
+}
+function isPathAliasImport2(source, pathAliases) {
+  return pathAliases.some((alias) => alias.pattern.test(source));
+}
+function resolvePathAlias2(source, pathAliases) {
+  for (const alias of pathAliases) {
+    if (alias.pattern.test(source)) {
+      const resolvedPath = source.replace(alias.pattern, alias.replacement);
+      const extensions = [".ts", ".tsx", ".js", ".jsx"];
+      for (const ext of extensions) {
+        const withExt = resolvedPath + ext;
+        if (existsSync2(withExt)) {
+          return withExt;
+        }
+      }
+      for (const ext of extensions) {
+        const indexFile = join3(resolvedPath, `index${ext}`);
+        if (existsSync2(indexFile)) {
+          return indexFile;
+        }
+      }
+      return resolvedPath;
+    }
+  }
+  return null;
+}
+function sanitizeSourceName(source) {
+  return source.replace(/@/g, "at_").replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+function sanitizeIdentifier(str) {
+  return str.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function createUniqueModuleName(source) {
+  const hash = createHash2("sha256").update(source).digest("hex").substring(0, 8);
+  const baseName = source.split("/").pop()?.replace(/[^a-zA-Z0-9]/g, "_")?.replace(/^_+|_+$/g, "")?.replace(/^(\d)/, "_$1") || "module";
+  return `mod_${baseName}_${hash}`;
+}
+function addReactImports(imports, scopeEntries) {
+  imports.push(`import React from "react"`);
+  imports.push(`import {
+    ${REACT_IMPORTS.join(", ")}
+  } from "react"`);
+  scopeEntries.push("React", ...REACT_IMPORTS);
+}
+function addThirdPartyImports(importMap, imports, scopeEntries) {
+  const sortedImports = Array.from(importMap.entries()).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const usedNames = /* @__PURE__ */ new Set(["React", ...REACT_IMPORTS]);
+  for (const [source, specifiers] of sortedImports) {
+    const moduleName = createUniqueModuleName(source);
+    imports.push(`import * as ${moduleName} from "${source}"`);
+    addModuleToScope(source, specifiers, moduleName, scopeEntries, usedNames);
+  }
+}
+function addThirdPartyImportsNamespaced(importMap, imports, scopeEntries, demoName) {
+  const sortedImports = Array.from(importMap.entries()).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const usedNames = /* @__PURE__ */ new Set(["React", ...REACT_IMPORTS]);
+  for (const [source, specifiers] of sortedImports) {
+    const moduleName = `${sanitizeIdentifier(demoName)}_${createUniqueModuleName(source)}`;
+    imports.push(`import * as ${moduleName} from "${source}"`);
+    addModuleToScope(source, specifiers, moduleName, scopeEntries, usedNames);
+  }
+}
+function addRelativeImportsNamespaced(relativeImports, imports, scopeEntries, demoName) {
+  const processedPaths = /* @__PURE__ */ new Set();
+  for (const { resolvedPath, specifiers } of relativeImports) {
+    if (processedPaths.has(resolvedPath)) {
+      continue;
+    }
+    processedPaths.add(resolvedPath);
+    const moduleName = `${sanitizeIdentifier(demoName)}_${createUniqueModuleName(resolvedPath)}`;
+    imports.push(`import * as ${moduleName} from "${resolvedPath}"`);
+    for (const { imported, local } of specifiers) {
+      if (imported === "default") {
+        scopeEntries.push(`${local}: ${moduleName}.default`);
+      } else if (imported === "*") {
+        scopeEntries.push(`...${moduleName}`);
+      } else {
+        scopeEntries.push(`${local}: ${moduleName}.${imported}`);
+      }
+    }
+  }
+}
+function addModuleToScope(source, specifiers, moduleName, scopeEntries, usedNames) {
+  const specArray = Array.from(specifiers);
+  const hasDefault = specArray.some((spec) => spec.imported === "default");
+  const hasNamespace = specArray.some((spec) => spec.imported === "*");
+  const namedImports = specArray.filter(
+    (spec) => spec.imported !== "default" && spec.imported !== "*"
+  );
+  if (hasNamespace) {
+    scopeEntries.push(`...${moduleName}`);
+    return;
+  }
+  const sanitizedSource = sanitizeSourceName(source);
+  if (hasDefault) {
+    scopeEntries.push(`"${sanitizedSource}__default": ${moduleName}.default`);
+  }
+  for (const { imported, local } of namedImports) {
+    const sanitizedKey = `${sanitizedSource}__${imported}`;
+    scopeEntries.push(`"${sanitizedKey}": ${moduleName}.${imported}`);
+    if (!usedNames.has(local)) {
+      scopeEntries.push(`${local}: ${moduleName}.${imported}`);
+      usedNames.add(local);
+    }
+  }
+}
+function extractPageId(filePath, routesDir) {
+  const relativePath = relative2(routesDir, filePath);
+  const pathParts = relativePath.split(sep);
+  if (pathParts.includes("demos")) {
+    const demosIndex = pathParts.indexOf("demos");
+    return pathParts.slice(0, demosIndex).join(sep);
+  }
+  return dirname2(relativePath);
+}
+function isCssAsset(filePath) {
+  return filePath.endsWith(".css");
+}
+function isDemoFile(filePath) {
+  try {
+    return filePath.includes("/demos/") && filePath.endsWith(".tsx") && // could also be in a comment, probably need to use TS parser
+    readFileSync3(filePath, "utf-8").includes("export default");
+  } catch (error) {
+    return false;
+  }
+}
+function createEmptyScopeModule() {
+  return "export const createDemoScope = () => ({})";
+}
+
+// src/react-demo-plugin/react-demo-plugin.ts
+import { transformerRenderIndentGuides as transformerRenderIndentGuides2 } from "@shikijs/transformers";
+import chalk6 from "chalk";
+import { watch as watch2 } from "chokidar";
+import { glob as glob3 } from "glob";
+import { readFile as readFile3 } from "node:fs/promises";
+import { basename as basename2, resolve as resolve4 } from "node:path";
+import { createHighlighter as createHighlighter2 } from "shiki";
+import * as ts3 from "typescript";
+import { quiCustomDarkTheme as quiCustomDarkTheme3 } from "@qualcomm-ui/mdx-common";
+import { dedent } from "@qualcomm-ui/utils/dedent";
+import { debounce } from "@qualcomm-ui/utils/functions";
+var isDev2 = process.env.NODE_ENV === "development";
+var highlighter2 = null;
+var initCount2 = 0;
+var hmrState = {
+  windowScrollY: 0
+};
+var demoRegistry2 = /* @__PURE__ */ new Map();
+var pageScopes = /* @__PURE__ */ new Map();
+var pageFiles = /* @__PURE__ */ new Map();
+var relativeImportDependents = /* @__PURE__ */ new Map();
+var hasWatcherInitialized2 = false;
+function logDev2(...args) {
+  if (!hasWatcherInitialized2) {
+    return;
+  }
+  console.log(...args);
+}
+function reactDemoPlugin({
+  demoPattern = "src/routes/**/demos/*.tsx",
+  lazyLoadDevModules = true,
+  routesDir = "src/routes",
+  theme = {
+    dark: quiCustomDarkTheme3,
+    light: "github-light-high-contrast"
+  },
+  transformers = [],
+  transformLine
+} = {}) {
+  let watcher = null;
+  return {
+    async buildEnd() {
+      if (watcher) {
+        await watcher.close();
+        watcher = null;
+        hasWatcherInitialized2 = false;
+      }
+    },
+    async buildStart() {
+      if (initCount2 === 0) {
+        initCount2++;
+        return;
+      }
+      if (!highlighter2) {
+        try {
+          highlighter2 = await createHighlighter2({
+            langs: ["tsx", "typescript"],
+            themes: [theme.dark, theme.light]
+          });
+          console.log(
+            `${chalk6.magenta.bold(LOG_PREFIX2)} Shiki highlighter initialized`
+          );
+        } catch (error) {
+          console.warn(
+            `${chalk6.magenta.bold(LOG_PREFIX2)} Failed to initialize highlighter:`,
+            error
+          );
+        }
+      }
+      try {
+        await collectReactDemos();
+        if (isDev2 && !hasWatcherInitialized2) {
+          hasWatcherInitialized2 = true;
+          await setupFileWatcher();
+        } else if (isDev2) {
+          logDev2(
+            `${chalk6.magenta.bold(LOG_PREFIX2)} skipping watch: watcher already initialized by another instance`
+          );
+        }
+      } catch (error) {
+        if (watcher) {
+          await watcher.close();
+          watcher = null;
+          hasWatcherInitialized2 = false;
+        }
+        throw error;
+      }
+    },
+    configureServer(server) {
+      const debouncedRestore = debounce((data) => {
+        hmrState.windowScrollY = data.scrollY;
+      }, 100);
+      server.ws.on("custom:store-scroll-position", debouncedRestore);
+      server.ws.on("custom:request-scroll-position", () => {
+        server.ws.send({
+          data: hmrState.windowScrollY,
+          event: "custom:restore-scroll-position",
+          type: "custom"
+        });
+      });
+    },
+    async handleHotUpdate({ file, server }) {
+      if (isCssAsset(file)) {
+        return server.moduleGraph.getModulesByFile(file)?.values()?.toArray();
+      }
+      if (!lazyLoadDevModules) {
+        let shouldUpdate = false;
+        if (isDemoFile(file)) {
+          await handleFileAdditionOrUpdate(file, false);
+          shouldUpdate = true;
+        }
+        const normalizedFile = resolve4(file);
+        const dependents = relativeImportDependents.get(normalizedFile);
+        if (dependents) {
+          shouldUpdate = true;
+        }
+        if (shouldUpdate) {
+          const autoModule = server.moduleGraph.getModuleById(
+            VIRTUAL_MODULE_IDS.AUTO
+          );
+          if (autoModule) {
+            server.moduleGraph.invalidateModule(autoModule);
+            await server.reloadModule(autoModule);
+          }
+          return [];
+        }
+      }
+      if (isDemoFile(file)) {
+        logDev2(
+          `${chalk6.magenta.bold(LOG_PREFIX2)} Processing change: ${chalk6.blueBright.bold(file)}`
+        );
+        const pageId = extractPageId(file, routesDir);
+        const demoName = createDemoName(file);
+        const wasNew = !demoRegistry2.has(demoName);
+        await handleFileAdditionOrUpdate(file, false);
+        const pageModule = server.moduleGraph.getModuleById(
+          `${VIRTUAL_MODULE_IDS.PAGE_PREFIX}${pageId}`
+        );
+        if (pageModule) {
+          console.debug(
+            "invalidating:",
+            `virtual:qui-demo-scope/page:${pageId}`
+          );
+          server.moduleGraph.invalidateModule(pageModule);
+          await server.reloadModule(pageModule);
+        }
+        if (wasNew) {
+          const autoModule = server.moduleGraph.getModuleById(
+            VIRTUAL_MODULE_IDS.AUTO
+          );
+          if (autoModule) {
+            server.moduleGraph.invalidateModule(autoModule);
+            await server.reloadModule(autoModule);
+          }
+        }
+        server.ws.send({
+          data: demoRegistry2.get(createDemoName(file)),
+          event: "qui-demo-update",
+          type: "custom"
+        });
+      } else {
+        const normalizedFile = resolve4(file);
+        const dependents = relativeImportDependents.get(normalizedFile);
+        if (dependents) {
+          for (const demoName of dependents) {
+            server.ws.send({
+              data: { demoName },
+              event: "react-demo-updating",
+              type: "custom"
+            });
+          }
+        }
+      }
+      return [];
+    },
+    async load(id) {
+      if (id === VIRTUAL_MODULE_IDS.AUTO) {
+        return generateAutoScopeModule();
+      }
+      if (id.startsWith(VIRTUAL_MODULE_IDS.PAGE_PREFIX)) {
+        const pageId = id.replace(VIRTUAL_MODULE_IDS.PAGE_PREFIX, "");
+        return pageScopes.get(pageId) || createEmptyScopeModule();
+      }
+      if (id === VIRTUAL_MODULE_IDS.CONFIG) {
+        return generateConfigModule();
+      }
+    },
+    name: "auto-demo-scope",
+    resolveId(id) {
+      if (id === "virtual:qui-demo-scope/auto") {
+        return VIRTUAL_MODULE_IDS.AUTO;
+      }
+      if (id.startsWith("virtual:qui-demo-scope/page:")) {
+        return `\0${id}`;
+      }
+      if (id === "virtual:qui-demo-scope/config") {
+        return VIRTUAL_MODULE_IDS.CONFIG;
+      }
+    },
+    writeBundle() {
+      console.log(
+        `${chalk6.blue.bold(LOG_PREFIX2)} Successfully integrated ${chalk6.green(demoRegistry2.size)} component demos`
+      );
+    }
+  };
+  async function setupFileWatcher() {
+    watcher = watch2(routesDir, {
+      ignoreInitial: true,
+      persistent: true
+    });
+    watcher.on("ready", () => {
+      logDev2(
+        `${chalk6.blue.bold(LOG_PREFIX2)} Registered ${chalk6.green(demoRegistry2.size)} demo files. Watching for file changes...`
+      );
+    });
+    watcher.on("addDir", (dirPath) => {
+      if (dirPath.endsWith("/demos")) {
+        logDev2(
+          `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.greenBright("New demo directory detected:")} ${chalk6.blueBright.bold(dirPath)}`
+        );
+      }
+    });
+    watcher.on("unlink", async (filePath) => {
+      if (isDemoFile(filePath)) {
+        logDev2(
+          `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.redBright("Demo file deleted:")} ${chalk6.blueBright.bold(filePath)}`
+        );
+        await handleFileDeletion(filePath);
+      }
+    });
+    watcher.on("add", async (filePath) => {
+      if (isDemoFile(filePath)) {
+        logDev2(
+          `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.greenBright("Demo file added:")} ${chalk6.blueBright.bold(filePath)}`
+        );
+        await handleFileAdditionOrUpdate(filePath, true).catch(() => {
+          console.debug("failed to add file", filePath);
+        });
+      }
+    });
+  }
+  async function handleFileAdditionOrUpdate(filePath, isAdd) {
+    const pageId = extractPageId(filePath, routesDir);
+    const demoName = createDemoName(filePath);
+    const existingFiles = pageFiles.get(pageId) ?? [];
+    if (!existingFiles.includes(filePath)) {
+      existingFiles.push(filePath);
+      pageFiles.set(pageId, existingFiles);
+    }
+    const fileData = await extractFileData(filePath);
+    if (fileData) {
+      demoRegistry2.set(demoName, {
+        ...fileData,
+        demoName,
+        pageId
+      });
+      const fileImports = await extractFileImports(filePath);
+      if (fileImports) {
+        for (const relativeImport of fileImports.relativeImports) {
+          const dependents = relativeImportDependents.get(relativeImport.resolvedPath) ?? /* @__PURE__ */ new Set();
+          dependents.add(demoName);
+          relativeImportDependents.set(relativeImport.resolvedPath, dependents);
+        }
+      }
+    }
+    const previousScope = pageScopes.get(pageId);
+    const allPageFiles = pageFiles.get(pageId);
+    const scope = await generateScopeForPage(pageId, allPageFiles);
+    pageScopes.set(pageId, scope);
+    logDev2(
+      `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.greenBright(isAdd ? "Added demo:" : "Updated demo:")} ${chalk6.greenBright.bold(demoName)}`
+    );
+    return previousScope !== scope;
+  }
+  async function handleFileDeletion(deletedFile) {
+    const demoName = createDemoName(deletedFile);
+    const pageId = extractPageId(deletedFile, routesDir);
+    demoRegistry2.delete(demoName);
+    for (const [importPath, dependents] of relativeImportDependents.entries()) {
+      dependents.delete(demoName);
+      if (dependents.size === 0) {
+        relativeImportDependents.delete(importPath);
+      }
+    }
+    const files = pageFiles.get(pageId);
+    if (files) {
+      const updatedFiles = files.filter((f) => f !== deletedFile);
+      if (updatedFiles.length === 0) {
+        pageFiles.delete(pageId);
+        pageScopes.delete(pageId);
+        logDev2(
+          `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.redBright("Removed empty page:")} ${chalk6.blueBright.bold(pageId)}`
+        );
+      } else {
+        pageFiles.set(pageId, updatedFiles);
+        const scope = await generateScopeForPage(pageId, updatedFiles);
+        pageScopes.set(pageId, scope);
+      }
+    }
+    logDev2(
+      `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.redBright("Cleaned up deleted file:")} ${chalk6.blueBright.bold(deletedFile)}`
+    );
+  }
+  function isPreviewLine(trimmedLine) {
+    return trimmedLine === "// preview" || /^\{\s*\/\*\s*preview\s*\*\/\s*\}$/.test(trimmedLine);
+  }
+  function extractPreviewsAndCleanSource(code) {
+    const lines = code.split("\n");
+    const previewBlocks = [];
+    const cleanedLines = [];
+    let inPreview = false;
+    let currentBlock = [];
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (isPreviewLine(trimmedLine)) {
+        if (inPreview) {
+          previewBlocks.push(currentBlock.join("\n"));
+          currentBlock = [];
+          inPreview = false;
+        } else {
+          inPreview = true;
+        }
+        continue;
+      }
+      cleanedLines.push(line);
+      if (inPreview) {
+        currentBlock.push(line);
+      }
+    }
+    const joined = previewBlocks.join("\n");
+    const split = joined.split("\n");
+    if (!split.at(-1)?.trim()) {
+      split.pop();
+    }
+    return {
+      formattedPreview: dedent(split.join("\n")).trim(),
+      sourceWithoutSnippetComments: cleanedLines.join("\n")
+    };
+  }
+  async function highlightCode(code) {
+    if (!highlighter2) {
+      return code;
+    }
+    try {
+      return highlighter2.codeToHtml(code, {
+        defaultColor: "light-dark()",
+        lang: "tsx",
+        themes: {
+          dark: theme.dark,
+          light: theme.light
+        },
+        transformers: [transformerRenderIndentGuides2(), ...transformers]
+      });
+    } catch (error) {
+      console.warn(
+        `${chalk6.magenta.bold(LOG_PREFIX2)} Failed to highlight code:`,
+        error
+      );
+      return code;
+    }
+  }
+  async function collectReactDemos() {
+    if (demoRegistry2.size && pageScopes.size && pageFiles.size) {
+      logDev2(
+        `${chalk6.magenta.bold(LOG_PREFIX2)} Using cached ${chalk6.cyanBright.bold(demoRegistry2.size)} demos`
+      );
+      return;
+    }
+    const demoFiles = (await glob3(demoPattern)).filter(isDemoFile);
+    for (const filePath of demoFiles) {
+      const pageId = extractPageId(filePath, routesDir);
+      const existingFiles = pageFiles.get(pageId) ?? [];
+      existingFiles.push(filePath);
+      pageFiles.set(pageId, existingFiles);
+      const fileData = await extractFileData(filePath);
+      if (fileData) {
+        const demoName = createDemoName(filePath);
+        demoRegistry2.set(demoName, {
+          ...fileData,
+          pageId
+        });
+      }
+      const fileImports = await extractFileImports(filePath);
+      if (fileImports) {
+        for (const relativeImport of fileImports.relativeImports) {
+          const demoName = createDemoName(filePath);
+          const dependents = relativeImportDependents.get(relativeImport.resolvedPath) ?? /* @__PURE__ */ new Set();
+          dependents.add(demoName);
+          relativeImportDependents.set(relativeImport.resolvedPath, dependents);
+        }
+      }
+    }
+    for (const [pageId, files] of pageFiles.entries()) {
+      const scope = await generateScopeForPage(pageId, files);
+      pageScopes.set(pageId, scope);
+    }
+  }
+  async function generateScopeForPage(pageId, files) {
+    const demosData = [];
+    const allThirdPartyImports = /* @__PURE__ */ new Map();
+    const allRelativeImports = [];
+    const demoImportData = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const demoName = createDemoName(file);
+      const demo = demoRegistry2.get(demoName);
+      if (!demo) {
+        continue;
+      }
+      demosData.push({
+        demoName,
+        fileName: demo.fileName,
+        imports: demo.imports,
+        pageId: demo.pageId,
+        sourceCode: demo.sourceCode
+      });
+      const { importMap, relativeImports } = await extractAllImports([file]);
+      demoImportData.set(demoName, {
+        relative: relativeImports.map((r) => ({
+          resolvedPath: r.resolvedPath,
+          specifiers: r.specifiers
+        })),
+        thirdParty: Array.from(importMap.entries()).map(([source, specs]) => ({
+          source,
+          specifiers: Array.from(specs)
+        }))
+      });
+      for (const [source, specifiers] of importMap) {
+        if (!allThirdPartyImports.has(source)) {
+          allThirdPartyImports.set(source, /* @__PURE__ */ new Set());
+        }
+        for (const spec of specifiers) {
+          allThirdPartyImports.get(source).add(spec);
+        }
+      }
+      for (const relImport of relativeImports) {
+        if (!allRelativeImports.some(
+          (r) => r.resolvedPath === relImport.resolvedPath
+        )) {
+          allRelativeImports.push(relImport);
+        }
+      }
+    }
+    const pageImports = [];
+    const reactScopeEntries = [];
+    addReactImports(pageImports, reactScopeEntries);
+    const moduleNames = /* @__PURE__ */ new Map();
+    const moduleRegistryEntries = [];
+    for (const [source] of Array.from(allThirdPartyImports.entries()).sort(
+      ([a], [b]) => a.localeCompare(b)
+    )) {
+      const moduleName = createUniqueModuleName(source);
+      moduleNames.set(source, moduleName);
+      pageImports.push(`import * as ${moduleName} from "${source}"`);
+      moduleRegistryEntries.push(`  "${source}": ${moduleName}`);
+    }
+    for (const { resolvedPath } of allRelativeImports) {
+      const moduleName = createUniqueModuleName(resolvedPath);
+      moduleNames.set(resolvedPath, moduleName);
+      pageImports.push(`import * as ${moduleName} from "${resolvedPath}"`);
+      moduleRegistryEntries.push(`  "${resolvedPath}": ${moduleName}`);
+    }
+    const demosJson = JSON.stringify(demosData);
+    const demoImportDataJson = JSON.stringify(
+      Array.from(demoImportData.entries())
+    );
+    const reactScopeEntriesCode = reactScopeEntries.map((e) => `  ${e}`).join(",\n");
+    return `// Auto-generated page scope for ${pageId}
+${pageImports.join("\n")}
+
+const modules = {
+${moduleRegistryEntries.join(",\n")}
+}
+
+const demosData = ${demosJson}
+const demoImportData = new Map(${demoImportDataJson})
+
+const reactScope = {
+${reactScopeEntriesCode}
+}
+
+const scopeCache = new Map()
+
+function createScope(demoName) {
+  if (scopeCache.has(demoName)) {
+    return scopeCache.get(demoName)
+  }
+  
+  const imports = demoImportData.get(demoName)
+  if (!imports) return {}
+  
+  const scope = {...reactScope}
+  
+  for (const {source, specifiers} of imports.thirdParty) {
+    const mod = modules[source]
+    if (!mod) continue
+    
+    for (const {imported, local} of specifiers) {
+      if (imported === 'default') {
+        scope[local] = mod.default
+      } else if (imported === '*') {
+        Object.assign(scope, mod)
+      } else {
+        scope[local] = mod[imported]
+      }
+    }
+  }
+  
+  for (const {resolvedPath, specifiers} of imports.relative) {
+    const mod = modules[resolvedPath]
+    if (!mod) continue
+    
+    for (const {imported, local} of specifiers) {
+      if (imported === 'default') {
+        scope[local] = mod.default
+      } else if (imported === '*') {
+        Object.assign(scope, mod)
+      } else {
+        scope[local] = mod[imported]
+      }
+    }
+  }
+  
+  scopeCache.set(demoName, scope)
+  return scope
+}
+
+export function getDemo(demoName) {
+  const demo = demosData.find(d => d.demoName === demoName)
+  if (!demo) return null
+  return {
+    ...demo,
+    scope: createScope(demoName)
+  }
+}
+
+export function getDemos() {
+  return demosData.map(demo => ({
+    ...demo,
+    scope: createScope(demo.demoName)
+  }))
+}
+`;
+  }
+  async function generateAutoScopeModule() {
+    if (isDev2 && lazyLoadDevModules) {
+      return [
+        "// Auto-generated demo scope resolver (DEV MODE - Lazy by Page)",
+        generateLazyPageLoaders(),
+        generateDemoToPageMap(),
+        generateDevGetDemo()
+      ].join("\n\n");
+    }
+    const registryCode = generateDemoRegistry(demoRegistry2);
+    return [
+      "// Auto-generated demo scope resolver (PROD MODE)",
+      generatePageImports(),
+      generateScopeMap(),
+      registryCode,
+      generateExportedFunctions()
+    ].join("\n\n");
+  }
+  function generateConfigModule() {
+    return dedent`
+      export function getReactDemoConfig() {
+        return {lazyLoadDevModules: ${lazyLoadDevModules}}
+      }
+    `;
+  }
+  function generateLazyPageLoaders() {
+    const pageIds = Array.from(pageFiles.keys()).sort();
+    if (pageIds.length === 0) {
+      return "export const lazyDemoLoader = {}";
+    }
+    const entries = pageIds.map((pageId) => {
+      return `  "${pageId}": () => import("virtual:qui-demo-scope/page:${pageId}")`;
+    }).join(",\n");
+    return `export const lazyDemoLoader = {
+${entries}
+}`;
+  }
+  function generateDemoToPageMap() {
+    const entries = Array.from(demoRegistry2.entries()).map(([demoName, { pageId }]) => {
+      return `  "${demoName}": "${pageId}"`;
+    }).join(",\n");
+    return `const demoToPageMap = {
+${entries}
+}`;
+  }
+  function generateDevGetDemo() {
+    return dedent`
+    export async function getDemo(demoName) {
+      const pageId = demoToPageMap[demoName]
+      if (!pageId) {
+        return {
+          fileName: "",
+          imports: [],
+          errorMessage: \`Demo "\${demoName}" not found.\`,
+          scope: {},
+          pageId: "",
+          sourceCode: [],
+        }
+      }
+      
+      const loader = lazyDemoLoader[pageId]
+      if (!loader) {
+        return {
+          fileName: "",
+          imports: [],
+          errorMessage: \`Page "\${pageId}" not found.\`,
+          scope: {},
+          pageId: "",
+          sourceCode: [],
+        }
+      }
+      
+      const pageModule = await loader()
+      const demo = pageModule.getDemo(demoName)
+      
+      return demo || {
+        fileName: "",
+        imports: [],
+        errorMessage: \`Demo "\${demoName}" not found in page.\`,
+        scope: {},
+        pageId: "",
+        sourceCode: [],
+      }
+    }
+  `;
+  }
+  function extractHighlightedVariants(highlightedHtml) {
+    const preMatch = highlightedHtml.match(/^<pre[^>]*><code>/)?.[0] || "";
+    const postMatch = highlightedHtml.match(/<\/code><\/pre>$/)?.[0] || "";
+    const content = highlightedHtml.slice(preMatch.length, -postMatch.length);
+    const lines = content.split("\n");
+    const previewLines = [];
+    const withoutPreviewLines = [];
+    let inPreview = false;
+    for (const line of lines) {
+      const textContent = line.replace(/<[^>]*>/g, "").replace(/&#x3C;/g, "<").replace(/&#x3E;/g, ">").trim();
+      if (textContent === "// preview" || textContent === "{/* preview */}") {
+        inPreview = !inPreview;
+        continue;
+      }
+      if (inPreview) {
+        previewLines.push(line);
+      }
+      withoutPreviewLines.push(line);
+    }
+    const normalizedPreviewLines = normalizeIndentation(previewLines);
+    const highlightedPreview = normalizedPreviewLines.length > 0 ? `${preMatch}${normalizedPreviewLines.join("\n")}${postMatch}` : "";
+    const highlightedWithoutPreview = `${preMatch}${withoutPreviewLines.join("\n")}${postMatch}`;
+    return { highlightedPreview, highlightedWithoutPreview };
+  }
+  function normalizeIndentation(lines) {
+    if (lines.length === 0) {
+      return [];
+    }
+    const nonEmptyLines = lines.filter(
+      (line) => line.replace(/<[^>]*>/g, "").trim().length > 0
+    );
+    if (nonEmptyLines.length === 0) {
+      return lines;
+    }
+    let minIndent = Infinity;
+    for (const line of nonEmptyLines) {
+      const matches = line.match(/<span class="indent">/g);
+      if (matches) {
+        minIndent = Math.min(minIndent, matches.length);
+      } else {
+        minIndent = 0;
+        break;
+      }
+    }
+    if (minIndent === 0 || minIndent === Infinity) {
+      return lines;
+    }
+    return lines.map((line) => {
+      let result = line;
+      for (let i = 0; i < minIndent; i++) {
+        result = result.replace(/<span class="indent">(\s*)<\/span>/, "");
+      }
+      return result;
+    });
+  }
+  function transformLines(code) {
+    if (!transformLine) {
+      return code;
+    }
+    const result = [];
+    for (const line of code.split("\n")) {
+      if (line.trim()) {
+        const transformed = transformLine(line);
+        if (transformed) {
+          result.push(transformed);
+        }
+      } else {
+        result.push(line);
+      }
+    }
+    return result.join("\n");
+  }
+  async function extractFileData(filePath) {
+    try {
+      const code = await readFile3(filePath, "utf-8").then(transformLines);
+      const { imports, strippedCode: codeWithoutImports } = stripImports(
+        code,
+        filePath
+      );
+      const fileName = basename2(filePath);
+      const { formattedPreview, sourceWithoutSnippetComments } = extractPreviewsAndCleanSource(code);
+      const highlightedFull = await highlightCode(code);
+      const { highlightedPreview, highlightedWithoutPreview } = extractHighlightedVariants(highlightedFull);
+      const sourceCode = [
+        {
+          fileName,
+          highlighted: {
+            full: highlightedWithoutPreview,
+            preview: highlightedPreview
+          },
+          raw: {
+            full: sourceWithoutSnippetComments,
+            preview: formattedPreview,
+            withoutImports: codeWithoutImports
+          }
+        }
+      ];
+      const fileImports = await extractFileImports(filePath);
+      if (fileImports) {
+        for (const relativeImport of fileImports.relativeImports) {
+          try {
+            const importedCode = await readFile3(
+              relativeImport.resolvedPath,
+              "utf-8"
+            ).then(transformLines);
+            const { strippedCode: importedCodeWithoutImports } = stripImports(
+              importedCode,
+              relativeImport.resolvedPath
+            );
+            const {
+              sourceWithoutSnippetComments: importedSourceWithoutSnippets
+            } = extractPreviewsAndCleanSource(importedCode);
+            const importedFileName = basename2(relativeImport.resolvedPath);
+            const highlightedImportedSource = await highlightCode(
+              importedSourceWithoutSnippets
+            );
+            sourceCode.push({
+              fileName: importedFileName,
+              highlighted: {
+                full: highlightedImportedSource,
+                preview: ""
+              },
+              raw: {
+                full: importedSourceWithoutSnippets,
+                preview: "",
+                withoutImports: importedCodeWithoutImports
+              }
+            });
+          } catch (error) {
+            logDev2(
+              `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.yellowBright("Failed to process relative import:")} ${chalk6.blueBright.bold(relativeImport.resolvedPath)}`
+            );
+          }
+        }
+      }
+      return {
+        demoName: createDemoName(filePath),
+        fileName,
+        imports,
+        sourceCode
+      };
+    } catch (e) {
+      logDev2(
+        `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.yellowBright("Failed to parse")} ${chalk6.blueBright.bold(filePath)}. ${chalk6.yellowBright("Removing from registry")}`
+      );
+      return null;
+    }
+  }
+  function stripImports(code, fileName) {
+    try {
+      let visit8 = function(node) {
+        if (ts3.isImportDeclaration(node)) {
+          importRanges.push({
+            end: node.getEnd(),
+            start: node.getFullStart()
+          });
+        }
+        ts3.forEachChild(node, visit8);
+      };
+      var visit7 = visit8;
+      const sourceFile = ts3.createSourceFile(
+        fileName,
+        code,
+        ts3.ScriptTarget.Latest,
+        true,
+        getScriptKind(fileName)
+      );
+      const importRanges = [];
+      visit8(sourceFile);
+      const imports = importRanges.map((range) => {
+        let endPos = range.end;
+        if (code[endPos] === "\n") {
+          endPos++;
+        }
+        return code.slice(range.start, endPos).trim();
+      });
+      importRanges.sort((a, b) => b.start - a.start);
+      let strippedCode = code;
+      for (const range of importRanges) {
+        let endPos = range.end;
+        if (strippedCode[endPos] === "\n") {
+          endPos++;
+        }
+        strippedCode = strippedCode.slice(0, range.start) + strippedCode.slice(endPos);
+      }
+      strippedCode = strippedCode.trim();
+      return {
+        imports,
+        strippedCode: strippedCode.replace(/^\n+/, "")
+      };
+    } catch (error) {
+      logDev2(
+        `${chalk6.magenta.bold(LOG_PREFIX2)} ${chalk6.redBright("Failed to strip imports from")} ${chalk6.blueBright.bold(fileName)}:`,
+        error
+      );
+      return {
+        imports: [],
+        strippedCode: code
+      };
+    }
+  }
+  function generatePageImports() {
+    const pageIds = Array.from(pageScopes.keys());
+    return pageIds.map((pageId) => {
+      const safeName = sanitizeIdentifier(pageId);
+      return `import * as page_${safeName} from "virtual:qui-demo-scope/page:${pageId}"`;
+    }).join("\n");
+  }
+  function generateScopeMap() {
+    const pageIds = Array.from(pageScopes.keys());
+    if (pageIds.length === 0) {
+      return "const pageModules = {}";
+    }
+    const entries = pageIds.map((pageId) => {
+      const safeName = sanitizeIdentifier(pageId);
+      return `  "${pageId}": page_${safeName}`;
+    }).join(",\n");
+    return `const pageModules = {
+${entries}
+}`;
+  }
+  function generateDemoRegistry(registry) {
+    const entries = Array.from(registry.entries()).map(([demoName, { fileName, imports, pageId, sourceCode }]) => {
+      return `  ["${demoName}", { fileName: "${fileName}", imports: ${JSON.stringify(imports)}, pageId: "${pageId}", sourceCode: ${JSON.stringify(sourceCode)}, demoName: "${demoName}" }]`;
+    }).join(",\n");
+    return `const demoRegistry = new Map([
+${entries}
+])`;
+  }
+  function generateExportedFunctions() {
+    return dedent`
+    export function getDemo(demoName) {
+      const demo = demoRegistry.get(demoName)
+      if (!demo) {
+        return {
+          fileName: "",
+          imports: [],
+          errorMessage: \`Demo "\${demoName}" not found.\`,
+          scope: {},
+          pageId: "",
+          sourceCode: [],
+        }
+      }
+      
+      const pageModule = pageModules[demo.pageId]
+      if (!pageModule) {
+        return {
+          fileName: "",
+          imports: [],
+          errorMessage: \`Page module not found.\`,
+          scope: {},
+          pageId: demo.pageId,
+          sourceCode: [],
+        }
+      }
+      
+      return pageModule.getDemo(demoName) || {
+        fileName: demo.fileName,
+        imports: demo.imports,
+        scope: {},
+        pageId: demo.pageId,
+        sourceCode: demo.sourceCode,
+      }
+    }
+  `;
+  }
+}
+export {
+  LOG_PREFIX2 as LOG_PREFIX,
+  NODE_BUILTINS,
+  REACT_IMPORTS,
+  VIRTUAL_MODULE_IDS,
+  addReactImports,
+  addRelativeImportsNamespaced,
+  addThirdPartyImports,
+  addThirdPartyImportsNamespaced,
+  angularDemoPlugin,
+  createDemoName,
+  createEmptyScopeModule,
+  createUniqueModuleName,
+  extractAllImports,
+  extractFileImports,
+  extractPageId,
+  getAlertIcon,
+  getRehypePlugins,
+  getRemarkPlugins,
+  getScriptKind,
+  isCssAsset,
+  isDemoFile,
+  quiDocsPlugin,
+  quiRehypePlugins,
+  quiRemarkPlugins,
+  reactDemoPlugin,
+  rehypeMdxCodeProps,
+  rehypeSectionize,
+  rehypeSlug,
+  remarkAlerts,
+  remarkCodeTabs,
+  remarkFrontmatter2 as remarkFrontmatter,
+  remarkGfm2 as remarkGfm,
+  remarkMdxFrontmatter,
+  remarkSelfLinkHeadings,
+  remarkSpoilers,
+  sanitizeIdentifier,
+  sanitizeSourceName
+};
+//# sourceMappingURL=index.js.map