@xyd-js/cli 0.1.0-xyd.1 → 0.1.0-xyd.11

package/.cli/{host/node_modules/.vite/deps/gray-matter.js → index.js}

@@ -1,14 +1,1600 @@
-import {
-  require_fs
-} from "./chunk-IVP26VTC.js";
-import {
-  __commonJS,
-  __require
-} from "./chunk-2TUXWMP5.js";
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require3() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports2, module2) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module2.exports = createColors();
+    module2.exports.createColors = createColors;
+  }
+});
 
-// ../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js
-var require_kind_of = __commonJS({
-  "../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"(exports2, module2) {
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@xyd-js/cli",
+      version: "0.1.0-xyd.10",
+      keywords: [],
+      author: "",
+      description: "",
+      type: "module",
+      files: [
+        ".cli",
+        "postinstall.js"
+      ],
+      scripts: {
+        build: "tsup",
+        postinstall: "node postinstall.js"
+      },
+      dependencies: {
+        "@graphql-markdown/core": "^1.12.0",
+        "@graphql-markdown/graphql": "^1.1.4",
+        "@graphql-markdown/types": "^1.4.0",
+        "@react-router/dev": "^7.1.1",
+        "@react-router/node": "^7.1.1",
+        "@react-router/serve": "^7.1.1",
+        "@readme/oas-to-snippet": "^26.0.1",
+        "@xyd-js/documan-host": "file:.cli",
+        "@xyd-js/react-router-dev": "7.1.1-xyd.3",
+        arg: "^5.0.2",
+        codehike: "^1.0.3",
+        colors: "^1.4.0",
+        compression: "^1.7.5",
+        express: "^4.21.1",
+        "get-port": "^7.1.0",
+        "graphql-config": "^5.1.2",
+        "gray-matter": "^4.0.3",
+        isbot: "^5.1.17",
+        "js-yaml": "^4.1.0",
+        "json-schema-ref-parser": "^9.0.9",
+        "json-to-graphql-query": "^2.3.0",
+        lightningcss: "^1.27.0",
+        morgan: "^1.10.0",
+        oas: "^25.0.3",
+        "openapi-sampler": "^1.5.1",
+        "openapi-types": "^12.1.3",
+        react: "^18.3.1",
+        "react-dom": "^18.3.1",
+        "react-router": "^7.1.1",
+        remark: "^15.0.1",
+        "remark-frontmatter": "^5.0.0",
+        "remark-gfm": "^4.0.0",
+        "remark-mdx-frontmatter": "^5.0.0",
+        "remark-stringify": "^11.0.0",
+        semver: "^7.6.3",
+        "source-map-support": "^0.5.21",
+        typescript: "^5.6.3",
+        "unist-builder": "^4.0.0",
+        "unist-util-visit": "^5.0.0",
+        vfile: "^6.0.3",
+        "vite-tsconfig-paths": "^5.1.4",
+        yaml: "^2.6.0"
+      },
+      devDependencies: {
+        "@xyd-js/documan": "0.1.0-xyd.15",
+        arg: "^5.0.2",
+        colors: "^1.4.0",
+        semver: "^7.6.3",
+        tsup: "^8.3.0",
+        "vite-tsconfig-paths": "^5.1.4"
+      }
+    };
+  }
+});
+
+// src/run.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import arg from "arg";
+import semver from "semver";
+
+// node_modules/@xyd-js/documan/dist/index.js
+import path4 from "node:path";
+import fs4 from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { execSync } from "child_process";
+import { build as viteBuild } from "vite";
+import tsconfigPaths from "vite-tsconfig-paths";
+import { reactRouter } from "@xyd-js/react-router-dev/vite";
+
+// node_modules/@xyd-js/content/dist/index.js
+import { VFile } from "vfile";
+import { compile as mdxCompile } from "@mdx-js/mdx";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkMdxFrontmatter from "remark-mdx-frontmatter";
+import remarkGfm from "remark-gfm";
+import { visit } from "unist-util-visit";
+import { visit as visit2 } from "unist-util-visit";
+import { visit as visit3 } from "unist-util-visit";
+import mdx from "@mdx-js/rollup";
+var remarkMdxToc = (options2) => () => async (ast) => {
+  const { visit: visit4 } = await import("unist-util-visit");
+  const { toString } = await import("mdast-util-to-string");
+  const { valueToEstree } = await import("estree-util-value-to-estree");
+  const { name: isIdentifierName } = await import("estree-util-is-identifier-name");
+  const mdast = ast;
+  const name = options2.name ?? "toc";
+  if (!isIdentifierName(name)) {
+    throw new Error(`Invalid name for an identifier: ${name}`);
+  }
+  const toc = [];
+  const flatToc = [];
+  const createEntry = (node, depth) => {
+    let attributes = node.data || {};
+    if (node.type === "mdxJsxFlowElement") {
+      attributes = Object.fromEntries(
+        node.attributes.filter((attribute) => attribute.type === "mdxJsxAttribute" && typeof attribute.value === "string").map((attribute) => [attribute.name, attribute.value])
+      );
+    }
+    return {
+      depth,
+      value: toString(node, { includeImageAlt: false }),
+      attributes,
+      children: []
+    };
+  };
+  visit4(mdast, ["heading", "mdxJsxFlowElement"], (node) => {
+    let depth = 0;
+    if (node.type === "mdxJsxFlowElement") {
+      let valid = false;
+      if (/^h[1-6]$/.test(node.name || "")) {
+        valid = true;
+        depth = parseInt(node.name.substring(1));
+      } else if (options2.customTags) {
+        for (const tag of options2.customTags) {
+          if (tag.name.test(node.name || "")) {
+            valid = true;
+            depth = tag.depth(node.name || "");
+            break;
+          }
+        }
+      }
+      if (!valid) {
+        return;
+      }
+    } else if (node.type === "heading") {
+      depth = node.depth;
+    } else {
+      return;
+    }
+    if (depth && ((options2 == null ? void 0 : options2.minDepth) && options2.minDepth > depth)) {
+      return;
+    }
+    const entry = createEntry(node, depth);
+    flatToc.push(entry);
+    let parent = toc;
+    for (let i = flatToc.length - 1; i >= 0; --i) {
+      const current = flatToc[i];
+      if (current.depth < entry.depth) {
+        parent = current.children;
+        break;
+      }
+    }
+    parent.push(entry);
+  });
+  const tocExport = {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "const",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: valueToEstree(toc)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+  mdast.children.unshift(tocExport);
+};
+function remarkInjectCodeMeta() {
+  return (tree) => {
+    visit(tree, "code", (node) => {
+      if (node.meta) {
+        node.data = node.data || {};
+        node.data.hProperties = {
+          ...node.data.hProperties || {},
+          meta: node.meta
+        };
+      }
+    });
+  };
+}
+var extractThemeSettings = () => {
+  return (tree) => {
+    visit2(tree, "exportNamedDeclaration", (node) => {
+      const declaration = node.declaration;
+      if (declaration && declaration.declarations) {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.name === "themeSettings") {
+            global.themeSettings = decl.init;
+          }
+        });
+      }
+    });
+  };
+};
+var extractPage = () => {
+  return (tree) => {
+    visit3(tree, "exportNamedDeclaration", (node) => {
+      const declaration = node.declaration;
+      if (declaration && declaration.declarations) {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.name === "page") {
+            global.page = decl.init;
+          }
+        });
+      }
+    });
+  };
+};
+function mdxOptions(toc) {
+  return {
+    remarkPlugins: [
+      remarkFrontmatter,
+      remarkMdxFrontmatter,
+      remarkGfm,
+      remarkInjectCodeMeta,
+      remarkMdxToc(toc),
+      extractThemeSettings,
+      extractPage
+    ],
+    rehypePlugins: []
+  };
+}
+function vitePlugins(options2) {
+  return [
+    mdx(mdxOptions(options2.toc))
+  ];
+}
+
+// node_modules/@xyd-js/plugin-zero/dist/index.js
+import { promises as fs2 } from "fs";
+import path22 from "node:path";
+import { createServer as createServer2 } from "vite";
+import { route } from "@react-router/dev/routes";
+import fs3 from "fs/promises";
+import path3 from "node:path";
+import { createServer } from "vite";
+import { fileURLToPath } from "node:url";
+
+// node_modules/@xyd-js/gql/dist/index.js
+import { getDocumentLoaders, loadSchema } from "@graphql-markdown/graphql";
+
+// node_modules/@xyd-js/uniform/dist/index.js
+import path from "path";
+import matter from "gray-matter";
+function uniform(references, config) {
+  const response = {
+    references,
+    out: {}
+  };
+  const finishCallbacks = /* @__PURE__ */ new Set();
+  config.plugins.forEach((plugin) => {
+    const call = plugin((cb) => {
+      finishCallbacks.add(cb);
+    });
+    references.forEach((ref) => {
+      call(ref);
+    });
+  });
+  finishCallbacks.forEach((cb) => {
+    if (typeof cb === "function") {
+      const resp = cb();
+      if (typeof resp !== "object") {
+        throw new Error(`Invalid callback return type: ${typeof resp}`);
+      }
+      response.out = {
+        ...response.out,
+        ...resp
+      };
+    } else {
+      throw new Error(`Invalid callback type: ${typeof cb}`);
+    }
+  });
+  return response;
+}
+function pluginNavigation(options2) {
+  if (!options2.urlPrefix) {
+    throw new Error("urlPrefix is required");
+  }
+  return function pluginNavigationInner(cb) {
+    const pageFrontMatter = {};
+    const groupMaps = {};
+    cb(() => {
+      return {
+        pageFrontMatter,
+        sidebar: convertGroupMapsToNavigations(groupMaps)
+      };
+    });
+    return (ref) => {
+      var _a;
+      const content = matter(ref.description || "");
+      if (content.data) {
+        const data = content.data;
+        const pagePath = path.join(options2.urlPrefix, ref.canonical);
+        if (data.title) {
+          pageFrontMatter[pagePath] = {
+            title: data.title
+          };
+        }
+        if (data.group) {
+          if (typeof ((_a = content == null ? void 0 : content.data) == null ? void 0 : _a.group) === "string") {
+            throw new Error("group as string is not supported yet");
+          }
+          content.data.group.reduce((groups, group, i) => {
+            if (!groups[group]) {
+              groups[group] = {
+                __groups: {},
+                pages: /* @__PURE__ */ new Set()
+              };
+            }
+            if (i === content.data.group.length - 1) {
+              groups[group].pages.add(pagePath);
+            }
+            return groups[group].__groups;
+          }, groupMaps);
+        }
+        ref.description = content.content;
+      }
+    };
+  };
+}
+function convertGroupMapsToNavigations(groupMaps) {
+  const nav = [];
+  Object.keys(groupMaps).map((groupName) => {
+    const current = groupMaps[groupName];
+    const pages = [];
+    current.pages.forEach((page) => {
+      pages.push(page);
+    });
+    if (Object.keys(current.__groups).length) {
+      const subNav = {
+        group: groupName,
+        pages: convertGroupMapsToNavigations(current.__groups)
+      };
+      nav.push(subNav);
+    } else {
+      nav.push({
+        group: groupName,
+        pages
+      });
+    }
+  });
+  return nav;
+}
+var ReferenceCategory = /* @__PURE__ */ ((ReferenceCategory22) => {
+  ReferenceCategory22["COMPONENTS"] = "components";
+  ReferenceCategory22["HOOKS"] = "hooks";
+  ReferenceCategory22["REST"] = "rest";
+  ReferenceCategory22["GRAPHQL"] = "graphql";
+  ReferenceCategory22["FUNCTIONS"] = "functions";
+  return ReferenceCategory22;
+})(ReferenceCategory || {});
+var ReferenceType = /* @__PURE__ */ ((ReferenceType22) => {
+  ReferenceType22["COMPONENT"] = "component";
+  ReferenceType22["HOOK"] = "hook";
+  ReferenceType22["REST_HTTP_GET"] = "rest_get";
+  ReferenceType22["REST_HTTP_POST"] = "rest_post";
+  ReferenceType22["REST_HTTP_PUT"] = "rest_put";
+  ReferenceType22["REST_HTTP_PATCH"] = "rest_patch";
+  ReferenceType22["REST_HTTP_DELETE"] = "rest_delete";
+  ReferenceType22["GRAPHQL_QUERY"] = "graphql_query";
+  ReferenceType22["GRAPHQL_MUTATION"] = "graphql_mutation";
+  ReferenceType22["FUNCTION_JS"] = "function_js";
+  return ReferenceType22;
+})(ReferenceType || {});
+
+// node_modules/@xyd-js/gql/dist/index.js
+import { jsonToGraphQLQuery, VariableType } from "json-to-graphql-query";
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS2 = (cb, mod) => function __require3() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var require_ast = __commonJS2({
+  "node_modules/graphql/language/ast.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    exports2.Token = exports2.QueryDocumentKeys = exports2.OperationTypeNode = exports2.Location = void 0;
+    exports2.isNode = isNode;
+    var Location = class {
+      /**
+       * The character offset at which this Node begins.
+       */
+      /**
+       * The character offset at which this Node ends.
+       */
+      /**
+       * The Token at which this Node begins.
+       */
+      /**
+       * The Token at which this Node ends.
+       */
+      /**
+       * The Source document the AST represents.
+       */
+      constructor(startToken, endToken, source) {
+        this.start = startToken.start;
+        this.end = endToken.end;
+        this.startToken = startToken;
+        this.endToken = endToken;
+        this.source = source;
+      }
+      get [Symbol.toStringTag]() {
+        return "Location";
+      }
+      toJSON() {
+        return {
+          start: this.start,
+          end: this.end
+        };
+      }
+    };
+    exports2.Location = Location;
+    var Token = class {
+      /**
+       * The kind of Token.
+       */
+      /**
+       * The character offset at which this Node begins.
+       */
+      /**
+       * The character offset at which this Node ends.
+       */
+      /**
+       * The 1-indexed line number on which this Token appears.
+       */
+      /**
+       * The 1-indexed column number at which this Token begins.
+       */
+      /**
+       * For non-punctuation tokens, represents the interpreted value of the token.
+       *
+       * Note: is undefined for punctuation tokens, but typed as string for
+       * convenience in the parser.
+       */
+      /**
+       * Tokens exist as nodes in a double-linked-list amongst all tokens
+       * including ignored tokens. <SOF> is always the first node and <EOF>
+       * the last.
+       */
+      constructor(kind, start2, end, line, column, value) {
+        this.kind = kind;
+        this.start = start2;
+        this.end = end;
+        this.line = line;
+        this.column = column;
+        this.value = value;
+        this.prev = null;
+        this.next = null;
+      }
+      get [Symbol.toStringTag]() {
+        return "Token";
+      }
+      toJSON() {
+        return {
+          kind: this.kind,
+          value: this.value,
+          line: this.line,
+          column: this.column
+        };
+      }
+    };
+    exports2.Token = Token;
+    var QueryDocumentKeys = {
+      Name: [],
+      Document: ["definitions"],
+      OperationDefinition: [
+        "name",
+        "variableDefinitions",
+        "directives",
+        "selectionSet"
+      ],
+      VariableDefinition: ["variable", "type", "defaultValue", "directives"],
+      Variable: ["name"],
+      SelectionSet: ["selections"],
+      Field: ["alias", "name", "arguments", "directives", "selectionSet"],
+      Argument: ["name", "value"],
+      FragmentSpread: ["name", "directives"],
+      InlineFragment: ["typeCondition", "directives", "selectionSet"],
+      FragmentDefinition: [
+        "name",
+        // Note: fragment variable definitions are deprecated and will removed in v17.0.0
+        "variableDefinitions",
+        "typeCondition",
+        "directives",
+        "selectionSet"
+      ],
+      IntValue: [],
+      FloatValue: [],
+      StringValue: [],
+      BooleanValue: [],
+      NullValue: [],
+      EnumValue: [],
+      ListValue: ["values"],
+      ObjectValue: ["fields"],
+      ObjectField: ["name", "value"],
+      Directive: ["name", "arguments"],
+      NamedType: ["name"],
+      ListType: ["type"],
+      NonNullType: ["type"],
+      SchemaDefinition: ["description", "directives", "operationTypes"],
+      OperationTypeDefinition: ["type"],
+      ScalarTypeDefinition: ["description", "name", "directives"],
+      ObjectTypeDefinition: [
+        "description",
+        "name",
+        "interfaces",
+        "directives",
+        "fields"
+      ],
+      FieldDefinition: ["description", "name", "arguments", "type", "directives"],
+      InputValueDefinition: [
+        "description",
+        "name",
+        "type",
+        "defaultValue",
+        "directives"
+      ],
+      InterfaceTypeDefinition: [
+        "description",
+        "name",
+        "interfaces",
+        "directives",
+        "fields"
+      ],
+      UnionTypeDefinition: ["description", "name", "directives", "types"],
+      EnumTypeDefinition: ["description", "name", "directives", "values"],
+      EnumValueDefinition: ["description", "name", "directives"],
+      InputObjectTypeDefinition: ["description", "name", "directives", "fields"],
+      DirectiveDefinition: ["description", "name", "arguments", "locations"],
+      SchemaExtension: ["directives", "operationTypes"],
+      ScalarTypeExtension: ["name", "directives"],
+      ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
+      InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
+      UnionTypeExtension: ["name", "directives", "types"],
+      EnumTypeExtension: ["name", "directives", "values"],
+      InputObjectTypeExtension: ["name", "directives", "fields"]
+    };
+    exports2.QueryDocumentKeys = QueryDocumentKeys;
+    var kindValues = new Set(Object.keys(QueryDocumentKeys));
+    function isNode(maybeNode) {
+      const maybeKind = maybeNode === null || maybeNode === void 0 ? void 0 : maybeNode.kind;
+      return typeof maybeKind === "string" && kindValues.has(maybeKind);
+    }
+    var OperationTypeNode2;
+    exports2.OperationTypeNode = OperationTypeNode2;
+    (function(OperationTypeNode3) {
+      OperationTypeNode3["QUERY"] = "query";
+      OperationTypeNode3["MUTATION"] = "mutation";
+      OperationTypeNode3["SUBSCRIPTION"] = "subscription";
+    })(OperationTypeNode2 || (exports2.OperationTypeNode = OperationTypeNode2 = {}));
+  }
+});
+var import_ast = __toESM2(require_ast(), 1);
+function fieldIntoDefinitionProperty(fieldName, field) {
+  let properties2;
+  if ("ofType" in field.type) {
+    switch (field.type.constructor.name) {
+      case "GraphQLList": {
+        switch (field.type.ofType.constructor.name) {
+          case "GraphQLObjectType": {
+            const objectType = field.type.ofType;
+            properties2 = nestedProperties(objectType);
+            break;
+          }
+          case "GraphQLInputObjectType": {
+            const inputObjectType = field.type.ofType;
+            properties2 = nestedProperties(inputObjectType);
+            break;
+          }
+          case "GraphQLScalarType": {
+            properties2 = definitionPropsFromNestedObj(field) || [];
+            break;
+          }
+          case "GraphQLNonNull": {
+            properties2 = definitionPropsFromNestedObj(field) || [];
+            break;
+          }
+          default: {
+            console.error("unsupported ofType list", field.type.ofType.constructor.name);
+            break;
+          }
+        }
+        break;
+      }
+      case "GraphQLNonNull": {
+        properties2 = definitionPropsFromNestedObj(field) || [];
+        break;
+      }
+      default: {
+        console.error("unsupported ofType", field.type.constructor.name);
+        break;
+      }
+    }
+  } else if (field.type.constructor.name === "GraphQLObjectType") {
+    const objectType = field.type;
+    properties2 = nestedProperties(objectType);
+  } else if (field.type.constructor.name === "GraphQLInputObjectType") {
+    const objectType = field.type;
+    properties2 = nestedProperties(objectType);
+  }
+  return {
+    name: fieldName,
+    type: field.type.toJSON(),
+    description: field.description || "",
+    properties: properties2
+  };
+}
+function definitionPropsFromNestedObj(obj) {
+  if (!obj) {
+    return null;
+  }
+  if (obj.getFields) {
+    return nestedProperties(obj);
+  }
+  if (obj.ofType) {
+    return definitionPropsFromNestedObj(obj.ofType);
+  }
+  if (obj.type) {
+    return definitionPropsFromNestedObj(obj.type);
+  }
+  return null;
+}
+function deepFieldMap(fieldsMap) {
+  const properties2 = [];
+  for (const [name, field] of Object.entries(fieldsMap)) {
+    const prop = fieldIntoDefinitionProperty(
+      name,
+      field
+    );
+    if (prop) {
+      properties2.push(prop);
+    }
+  }
+  return properties2;
+}
+function nestedProperties(objectType) {
+  var _a;
+  const nestedFields = (_a = objectType == null ? void 0 : objectType.getFields) == null ? void 0 : _a.call(objectType);
+  return deepFieldMap(nestedFields);
+}
+function argumentsIntoDefinitionProperty(args) {
+  const resp = [];
+  args.forEach((arg2) => {
+    var _a;
+    if (arg2.type.constructor.name === "GraphQLInputObjectType") {
+      const inputObjectType = arg2.type;
+      const inputFields = (_a = inputObjectType.getFields) == null ? void 0 : _a.call(inputObjectType);
+      const nestedProps = [];
+      const nestedDefinitionProperty = {
+        name: arg2.name,
+        type: arg2.type.toJSON(),
+        description: arg2.description || "",
+        properties: nestedProps
+      };
+      for (const [name, inputField] of Object.entries(inputFields)) {
+        const prop = fieldIntoDefinitionProperty(
+          name,
+          inputField
+        );
+        if (prop) {
+          nestedProps.push(prop);
+        }
+      }
+      resp.push(nestedDefinitionProperty);
+    } else {
+      const prop = {
+        name: arg2.name,
+        type: arg2.type.toJSON(),
+        description: arg2.description || "",
+        properties: []
+      };
+      resp.push(prop);
+    }
+  });
+  return resp;
+}
+function simpleGraphqlExample(operationType, operationName, args, returns) {
+  let obj = {};
+  switch (operationType) {
+    case ReferenceType.GRAPHQL_QUERY: {
+      const exampleReturnProps = exampleReturns(returns);
+      obj = {
+        query: {
+          __name: operationName,
+          [operationName]: exampleReturnProps
+        }
+      };
+      break;
+    }
+    case ReferenceType.GRAPHQL_MUTATION: {
+      const exampleReturnProps = exampleReturns(returns);
+      const vars = exampleVariables(args);
+      const argumen = exampleArguments(args);
+      obj = {
+        mutation: {
+          __name: operationName,
+          __variables: vars,
+          [operationName]: {
+            ...exampleReturnProps,
+            __args: argumen
+          }
+        }
+      };
+      break;
+    }
+  }
+  return jsonToGraphQLQuery(obj, { pretty: true });
+}
+function exampleReturns(properties2, obj = {}) {
+  properties2.forEach((property) => {
+    var _a;
+    obj[property.name] = true;
+    if ((_a = property == null ? void 0 : property.properties) == null ? void 0 : _a.length) {
+      obj[property.name] = {};
+      exampleReturns(property.properties, obj[property.name]);
+    }
+  });
+  return obj;
+}
+function exampleArguments(properties2, obj = {}) {
+  properties2.forEach((property) => {
+    obj[property.name] = new VariableType(property.name);
+  });
+  return obj;
+}
+function exampleVariables(properties2, obj = {}) {
+  properties2.forEach((property) => {
+    obj[property.name] = property.type;
+  });
+  return obj;
+}
+function graphqlOperationReferences(operationType, fieldsMap) {
+  const references = [];
+  for (const [operationName, operationField] of Object.entries(fieldsMap)) {
+    const definitions2 = [];
+    const args = argumentsIntoDefinitionProperty(operationField.args);
+    const returns = fieldIntoDefinitionProperty(operationName, operationField);
+    const returnProperties = returns.properties || [];
+    definitions2.push({
+      title: "Arguments",
+      properties: args
+    });
+    definitions2.push({
+      title: "Returns",
+      properties: returnProperties
+    });
+    const exampleQuery = simpleGraphqlExample(
+      operationType,
+      operationName,
+      args,
+      returnProperties
+    );
+    const examples2 = [
+      {
+        codeblock: {
+          tabs: [
+            {
+              title: "graphql",
+              language: "graphql",
+              code: exampleQuery
+            }
+          ]
+        }
+      }
+    ];
+    const exampleGroup = {
+      description: "Example request",
+      examples: examples2
+    };
+    let description = operationField.description || "";
+    references.push(graphqlReference(
+      operationType,
+      operationName,
+      operationName,
+      description,
+      [exampleGroup],
+      definitions2
+    ));
+  }
+  return references;
+}
+function graphqlReference(operationType, title, canonical, description, examples2, definitions2) {
+  return {
+    title,
+    canonical,
+    description,
+    category: ReferenceCategory.GRAPHQL,
+    type: operationType,
+    examples: {
+      groups: examples2
+    },
+    definitions: definitions2
+  };
+}
+async function gqlSchemaToReferences(schemaLocation) {
+  var _a, _b;
+  const loadersList = {
+    ["GraphQLFileLoader"]: "@graphql-tools/graphql-file-loader"
+  };
+  const loaders = await getDocumentLoaders(loadersList);
+  const schema = await loadSchema(schemaLocation, loaders);
+  const references = [];
+  const queries = schema.getRootType(import_ast.OperationTypeNode.QUERY);
+  const queryFields = (_a = queries == null ? void 0 : queries.getFields) == null ? void 0 : _a.call(queries);
+  if (queryFields) {
+    references.push(...graphqlOperationReferences(
+      ReferenceType.GRAPHQL_QUERY,
+      queryFields
+    ));
+  }
+  const mutations = schema.getRootType(import_ast.OperationTypeNode.MUTATION);
+  const mutationFields = (_b = mutations == null ? void 0 : mutations.getFields) == null ? void 0 : _b.call(mutations);
+  if (mutationFields) {
+    references.push(...graphqlOperationReferences(
+      ReferenceType.GRAPHQL_MUTATION,
+      mutationFields
+    ));
+  }
+  return references;
+}
+
+// node_modules/@xyd-js/plugin-zero/dist/index.js
+import path32 from "path";
+import { promises as fs32 } from "fs";
+import { route as route2 } from "@react-router/dev/routes";
+
+// node_modules/@xyd-js/uniform/dist/markdown.js
+import { remark } from "remark";
+import remarkStringify from "remark-stringify";
+import { u } from "unist-builder";
+var START_DEPTH_LEVEL = 2;
+function root(ast) {
+  return u("root", ast);
+}
+function heading(title, canonical, description, refCategory, refType, refContext) {
+  const uTitle = u(
+    "heading",
+    { depth: START_DEPTH_LEVEL },
+    [u("text", `!!references ${title}`)]
+  );
+  const uCanonical = u(
+    "heading",
+    { depth: uTitle.depth + 1 },
+    [u("text", `!canonical ${canonical}`)]
+  );
+  let uDesc = [
+    u(
+      "heading",
+      { depth: START_DEPTH_LEVEL },
+      [u("text", `!description`)]
+    ),
+    u("paragraph", [u("text", description)])
+  ];
+  let uRefCategory;
+  if (refCategory) {
+    uRefCategory = u(
+      "heading",
+      { depth: uTitle.depth + 1 },
+      [u("text", `!category ${refCategory}`)]
+    );
+  }
+  let uRefType;
+  if (refType) {
+    uRefType = u(
+      "heading",
+      { depth: uTitle.depth + 1 },
+      [u("text", `!type ${refType}`)]
+    );
+  }
+  let uContext = [];
+  if (refContext && Object.keys(refContext)) {
+    uContext.push(u(
+      "heading",
+      { depth: uTitle.depth + 1 },
+      [
+        u("text", `!context`)
+      ]
+    ));
+    for (const [key, value] of Object.entries(refContext)) {
+      uContext.push(
+        u(
+          "heading",
+          { depth: uContext[0].depth + 1 },
+          [u("text", `!${key} ${value}`)]
+        )
+      );
+    }
+  }
+  return {
+    title: uTitle,
+    canonical: uCanonical,
+    description: uDesc,
+    category: uRefCategory || null,
+    type: uRefType || null,
+    context: uContext || null
+  };
+}
+function examples(examples2) {
+  const md = [];
+  const uExampleRoot = u(
+    "heading",
+    { depth: START_DEPTH_LEVEL + 1 },
+    [u("text", `!examples`)]
+  );
+  md.push(uExampleRoot);
+  examples2.groups.forEach((group) => {
+    const uExampleGroups = u(
+      "heading",
+      { depth: uExampleRoot.depth + 1 },
+      [u("text", `!!groups`)]
+    );
+    md.push(uExampleGroups);
+    const uGroupDescription = u(
+      "heading",
+      { depth: uExampleGroups.depth + 1 },
+      [u("text", `!description ${group.description}`)]
+    );
+    md.push(uGroupDescription);
+    group.examples.forEach((example) => {
+      const uExamples = u(
+        "heading",
+        { depth: uExampleGroups.depth + 1 },
+        [u("text", `!!examples`)]
+      );
+      md.push(uExamples);
+      const codeBlock = u(
+        "heading",
+        { depth: uExamples.depth + 1 },
+        [u("text", `!codeblock`)]
+      );
+      md.push(codeBlock);
+      const codeBlockTitle = u(
+        "heading",
+        { depth: codeBlock.depth + 1 },
+        [u("text", `!title ${example.codeblock.title}`)]
+      );
+      md.push(codeBlockTitle);
+      const tabs = u(
+        "heading",
+        { depth: codeBlock.depth + 1 },
+        [u("text", `!!tabs`)]
+      );
+      md.push(tabs);
+      example.codeblock.tabs.forEach((tab) => {
+        const code = u("code", {
+          lang: tab.language,
+          meta: `!code ${tab.title}`
+        }, tab.code);
+        md.push(code);
+      });
+    });
+  });
+  return md;
+}
+function definitions(definitions2) {
+  const md = [];
+  definitions2.forEach((definition) => {
+    const uDefinition = u(
+      "heading",
+      { depth: START_DEPTH_LEVEL + 1 },
+      [u("text", `!!definitions`)]
+    );
+    md.push(uDefinition);
+    md.push(u(
+      "heading",
+      { depth: uDefinition.depth + 1 },
+      [u("text", `!title ${definition.title}`)]
+    ));
+    definition.properties.forEach((prop) => {
+      properties(
+        uDefinition.depth + 1,
+        {
+          name: prop.name,
+          type: prop.type,
+          description: prop.description,
+          properties: prop.properties
+          // TODO: fix ts
+        },
+        md
+      );
+    });
+  });
+  return md;
+}
+function properties(depth, props, output = []) {
+  const paramName = props.name;
+  const propTitle = `!!properties ${paramName}`;
+  const uPropTitle = u("heading", { depth }, [u("text", propTitle)]);
+  const uPropName = u("paragraph", { depth }, [u("text", `!name ${paramName}`)]);
+  const uPropType = u("paragraph", { depth }, [u("text", `!type ${props.type}`)]);
+  const uPropDesc = u("paragraph", { depth }, [u("text", props.description || "")]);
+  output.push(
+    uPropTitle,
+    uPropName,
+    uPropType,
+    uPropDesc
+  );
+  if (props.properties) {
+    const deepDepth = depth + 1;
+    for (const prop of props.properties) {
+      properties(deepDepth, prop, output);
+    }
+  }
+}
+function compile(ast) {
+  return remark().use(remarkStringify, {
+    bullet: "-",
+    fences: true,
+    listItemIndent: "one",
+    incrementListMarker: false,
+    handlers: {
+      heading(node) {
+        return `${"#".repeat(node.depth)} ${node.children[0].value}`;
+      }
+    }
+  }).stringify(root(ast));
+}
+function referenceAST(ref) {
+  var _a, _b;
+  const md = [];
+  const mdHeading = heading(
+    ref.title,
+    ref.canonical,
+    ref.description,
+    ref.category,
+    ref.type,
+    ref.context
+  );
+  if ((_a = mdHeading == null ? void 0 : mdHeading.description) == null ? void 0 : _a.length) {
+    md.push(...mdHeading.description);
+  }
+  md.push(
+    mdHeading.title,
+    mdHeading.canonical
+  );
+  if (mdHeading.category) {
+    md.push(mdHeading.category);
+  }
+  if (mdHeading.type) {
+    md.push(mdHeading.type);
+  }
+  if ((_b = mdHeading == null ? void 0 : mdHeading.context) == null ? void 0 : _b.length) {
+    md.push(...mdHeading.context);
+  }
+  const mdExamples = examples(ref.examples);
+  const mdDefinitions = definitions(ref.definitions);
+  md.push(...mdExamples, ...mdDefinitions);
+  return md;
+}
+
+// node_modules/@xyd-js/openapi/dist/index.js
+import Oas from "oas";
+
+// node_modules/@xyd-js/openapi/node_modules/@xyd-js/uniform/dist/index.js
+import matter2 from "gray-matter";
+var ReferenceCategory2 = /* @__PURE__ */ ((ReferenceCategory22) => {
+  ReferenceCategory22["COMPONENTS"] = "components";
+  ReferenceCategory22["HOOKS"] = "hooks";
+  ReferenceCategory22["REST"] = "rest";
+  ReferenceCategory22["GRAPHQL"] = "graphql";
+  ReferenceCategory22["FUNCTIONS"] = "functions";
+  return ReferenceCategory22;
+})(ReferenceCategory2 || {});
+var ReferenceType2 = /* @__PURE__ */ ((ReferenceType22) => {
+  ReferenceType22["COMPONENT"] = "component";
+  ReferenceType22["HOOK"] = "hook";
+  ReferenceType22["REST_HTTP_GET"] = "rest_get";
+  ReferenceType22["REST_HTTP_POST"] = "rest_post";
+  ReferenceType22["REST_HTTP_PUT"] = "rest_put";
+  ReferenceType22["REST_HTTP_PATCH"] = "rest_patch";
+  ReferenceType22["REST_HTTP_DELETE"] = "rest_delete";
+  ReferenceType22["GRAPHQL_QUERY"] = "graphql_query";
+  ReferenceType22["GRAPHQL_MUTATION"] = "graphql_mutation";
+  ReferenceType22["FUNCTION_JS"] = "function_js";
+  return ReferenceType22;
+})(ReferenceType2 || {});
+
+// node_modules/@xyd-js/openapi/dist/index.js
+import path2 from "path";
+import fs from "fs";
+import yaml2 from "js-yaml";
+import $refParser from "json-schema-ref-parser";
+import oasToSnippet from "@readme/oas-to-snippet";
+import OpenAPISampler from "openapi-sampler";
+var SUPPORTED_HTTP_METHODS = [
+  "get",
+  "put",
+  "patch",
+  "post",
+  "delete"
+  // 'options',
+  // 'head',
+  // 'trace'
+];
+function oapParametersToDefinitionProperties(parameters) {
+  const parameterIn = {};
+  parameters.forEach((param) => {
+    if (!parameterIn[param.in]) {
+      parameterIn[param.in] = [];
+    }
+    const schema = param.schema;
+    const property = {
+      name: param.name,
+      type: schema.type || "",
+      description: param.description || ""
+    };
+    parameterIn[param.in].push(property);
+  });
+  return parameterIn;
+}
+function schemaObjectToDefinitionProperties(v) {
+  return Object.entries(v.properties || {}).map(([name, prop]) => {
+    let objProp = prop;
+    let merged = [];
+    if (objProp.allOf) {
+      merged = objProp.allOf.reduce((acc, of) => {
+        return [
+          ...acc,
+          ...schemaObjectToDefinitionProperties(of)
+        ];
+      }, []);
+    }
+    return {
+      name,
+      type: objProp.type || "",
+      description: objProp.description || "",
+      properties: (merged == null ? void 0 : merged.length) ? merged : objProp.properties ? schemaObjectToDefinitionProperties(objProp) : []
+    };
+  });
+}
+function oapRequestBodyToDefinitionProperties(reqBody) {
+  const schema = reqBody.content["application/json"].schema;
+  let schemaObject;
+  if (schema.allOf) {
+    return schema.allOf.reduce((acc, of) => {
+      const fakeBody = {
+        content: {
+          "application/json": {
+            schema: of
+          }
+        }
+      };
+      return [
+        ...acc,
+        ...oapRequestBodyToDefinitionProperties(fakeBody) || []
+      ];
+    }, []);
+  }
+  switch (schema.type) {
+    case "object": {
+      schemaObject = schema;
+      break;
+    }
+    case "array": {
+      const arrSchema = schema;
+      const items = arrSchema.items;
+      schemaObject = items;
+      break;
+    }
+    default:
+      break;
+  }
+  if (!schemaObject) {
+    return null;
+  }
+  return schemaObjectToDefinitionProperties(schemaObject);
+}
+function oapResponseToDefinitionProperties(responses) {
+  var _a, _b, _c, _d;
+  let schemaObject;
+  if (responses["default"]) {
+    const w = responses["default"];
+    schemaObject = (_b = (_a = w == null ? void 0 : w.content) == null ? void 0 : _a["application/json"]) == null ? void 0 : _b.schema;
+  } else if (responses["200"]) {
+    const w = responses["200"];
+    schemaObject = (_d = (_c = w == null ? void 0 : w.content) == null ? void 0 : _c["application/json"]) == null ? void 0 : _d.schema;
+  }
+  if (!schemaObject) {
+    return null;
+  }
+  switch (schemaObject.type) {
+    case "array":
+      const arrSchema = schemaObject;
+      const items = arrSchema.items;
+      schemaObject = items;
+      break;
+    default:
+      break;
+  }
+  return schemaObjectToDefinitionProperties(schemaObject);
+}
+function toPascalCase(str2) {
+  return str2.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function readOpenApiSpec(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  const content = fs.readFileSync(filePath, "utf-8");
+  if (ext === ".yaml" || ext === ".yml") {
+    return yaml2.load(content);
+  } else if (ext === ".json") {
+    return JSON.parse(content);
+  } else {
+    throw new Error("Unsupported file format. Use JSON or YAML.");
+  }
+}
+async function deferencedOpenAPI(openApiPath) {
+  const openApiSpec = readOpenApiSpec(openApiPath);
+  await $refParser.dereference(openApiSpec);
+  return openApiSpec;
+}
+function httpMethodToUniformMethod(method) {
+  switch (method) {
+    case "get":
+      return ReferenceType2.REST_HTTP_GET;
+    case "put":
+      return ReferenceType2.REST_HTTP_PUT;
+    case "patch":
+      return ReferenceType2.REST_HTTP_PATCH;
+    case "post":
+      return ReferenceType2.REST_HTTP_POST;
+    case "delete":
+      return ReferenceType2.REST_HTTP_DELETE;
+    // case 'options':
+    //     return ReferenceType.REST_HTTP_OPTIONS
+    // case 'head':
+    //     return ReferenceType.REST_HTTP_HEAD
+    // case 'trace':
+    //     return ReferenceType.REST_HTTP_TRACE
+    default:
+      return null;
+  }
+}
+function oapPathToReference(httpMethod, path24, oapPath) {
+  const mType = httpMethodToUniformMethod(httpMethod);
+  if (!mType) {
+    console.error(`Unsupported method: ${httpMethod}`);
+    return null;
+  }
+  const definitions2 = [];
+  const exampleGroups = [];
+  const oapMethod = oapPath == null ? void 0 : oapPath[httpMethod];
+  if (!oapMethod) {
+    return null;
+  }
+  const endpointRef = {
+    title: (oapMethod == null ? void 0 : oapMethod.summary) || "",
+    canonical: toPascalCase((oapMethod == null ? void 0 : oapMethod.summary) || ""),
+    description: (oapMethod == null ? void 0 : oapMethod.description) || "",
+    category: ReferenceCategory2.REST,
+    type: mType,
+    context: {
+      method: httpMethod,
+      path: path24
+    },
+    examples: {
+      groups: exampleGroups
+    },
+    definitions: definitions2
+  };
+  if (oapMethod.parameters) {
+    const parameters = oapMethod.parameters;
+    const paramtersMap = oapParametersToDefinitionProperties(parameters);
+    Object.entries(paramtersMap).forEach(([key, definitionProperties]) => {
+      let title;
+      switch (key) {
+        case "path":
+          title = "Paths";
+          break;
+        case "query":
+          title = "Query";
+          break;
+        case "header":
+          title = "Header";
+          break;
+        default:
+          console.error(`Unsupported parameter type: ${key} for ${httpMethod} ${path24}`);
+          return;
+      }
+      definitions2.push({
+        title,
+        properties: definitionProperties
+      });
+    });
+  }
+  if (oapMethod.requestBody) {
+    const reqBody = oapMethod.requestBody;
+    definitions2.push({
+      title: "Request body",
+      properties: oapRequestBodyToDefinitionProperties(reqBody) || []
+    });
+  }
+  if (oapMethod.responses) {
+    const responses = oapMethod.responses;
+    definitions2.push({
+      title: "Response",
+      properties: oapResponseToDefinitionProperties(responses) || []
+    });
+  }
+  return endpointRef;
+}
+function oapExamples(oas, operation) {
+  const exampleGroups = [];
+  if (operation.schema.requestBody) {
+    const body = operation.schema.requestBody;
+    const schema = fixAllOfBug(
+      body.content["application/json"].schema
+    );
+    if (!schema) {
+      return exampleGroups;
+    }
+    const fakeData = OpenAPISampler.sample(schema);
+    const { code } = oasToSnippet(oas, operation, {
+      body: fakeData
+    }, null, "shell");
+    const examples2 = [];
+    examples2.push({
+      codeblock: {
+        tabs: [{
+          title: "curl",
+          language: "curl",
+          code: code || ""
+        }]
+      }
+    });
+    exampleGroups.push({
+      description: "Example request",
+      examples: examples2
+    });
+  }
+  if (operation.schema.responses) {
+    const responses = operation.schema.responses;
+    const examples2 = [];
+    Object.entries(responses).forEach(([status, r]) => {
+      var _a;
+      const response = r;
+      const schema = (_a = response == null ? void 0 : response.content) == null ? void 0 : _a["application/json"].schema;
+      if (!schema) {
+        return;
+      }
+      const fakeData = OpenAPISampler.sample(schema);
+      examples2.push({
+        codeblock: {
+          title: status,
+          tabs: [{
+            title: "json",
+            language: "json",
+            code: JSON.stringify(fakeData, null, 2) || ""
+          }]
+        }
+      });
+    });
+    exampleGroups.push({
+      description: "Response",
+      examples: examples2
+    });
+  }
+  return exampleGroups;
+}
+function fixAllOfBug(schema) {
+  const modifiedSchema = { ...schema };
+  if (schema.allOf) {
+    schema.allOf.forEach((prop, i) => {
+      var _a;
+      const propObj = prop;
+      if ("properties" in propObj && !propObj["properties"]) {
+        (_a = modifiedSchema.allOf) == null ? true : delete _a[i];
+      }
+    });
+  }
+  return modifiedSchema;
+}
+function oapSchemaToReferences(schema) {
+  const references = [];
+  const oas = new Oas(schema);
+  Object.entries(schema.paths).forEach(([path24, oapPath]) => {
+    let type;
+    SUPPORTED_HTTP_METHODS.forEach((eachMethod) => {
+      const httpMethod = eachMethod.toLowerCase();
+      switch (httpMethod) {
+        case "get":
+          break;
+        case "put":
+          break;
+        case "post":
+          break;
+        case "delete":
+          break;
+        default:
+          console.error(`Unsupported method: ${httpMethod}`);
+          return;
+      }
+      const reference = oapPathToReference(
+        httpMethod,
+        path24,
+        oapPath
+      );
+      if (reference) {
+        const operation = oas.operation(path24, httpMethod);
+        reference.examples.groups = oapExamples(oas, operation);
+        references.push(reference);
+      }
+    });
+  });
+  return references;
+}
+
+// node_modules/@xyd-js/plugin-zero/dist/index.js
+var __create3 = Object.create;
+var __defProp3 = Object.defineProperty;
+var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames3 = Object.getOwnPropertyNames;
+var __getProtoOf3 = Object.getPrototypeOf;
+var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS3 = (cb, mod) => function __require22() {
+  return mod || (0, cb[__getOwnPropNames3(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps3 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames3(from))
+      if (!__hasOwnProp3.call(to, key) && key !== except)
+        __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps3(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var require_kind_of = __commonJS3({
+  "../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"(exports2, module2) {
     var toString = Object.prototype.toString;
     module2.exports = function kindOf(val) {
       if (val === void 0) return "undefined";
@@ -32,6 +1618,7 @@ var require_kind_of = __commonJS({
           return "symbol";
         case "Promise":
           return "promise";
+        // Set, Map, WeakSet, WeakMap
         case "WeakMap":
           return "weakmap";
         case "WeakSet":
@@ -40,16 +1627,19 @@ var require_kind_of = __commonJS({
           return "map";
         case "Set":
           return "set";
+        // 8-bit typed arrays
         case "Int8Array":
           return "int8array";
         case "Uint8Array":
           return "uint8array";
         case "Uint8ClampedArray":
           return "uint8clampedarray";
+        // 16-bit typed arrays
         case "Int16Array":
           return "int16array";
         case "Uint16Array":
           return "uint16array";
+        // 32-bit typed arrays
         case "Int32Array":
           return "int32array";
         case "Uint32Array":
@@ -66,6 +1656,7 @@ var require_kind_of = __commonJS({
       switch (type) {
         case "[object Object]":
           return "object";
+        // iterators
         case "[object Map Iterator]":
           return "mapiterator";
         case "[object Set Iterator]":
@@ -121,158 +1712,40 @@ var require_kind_of = __commonJS({
     }
   }
 });
-
-// ../node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js
-var require_is_extendable = __commonJS({
-  "../node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js"(exports2, module2) {
+var require_engine = __commonJS3({
+  "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js"(exports2, module2) {
     "use strict";
-    module2.exports = function isExtendable(val) {
-      return typeof val !== "undefined" && val !== null && (typeof val === "object" || typeof val === "function");
-    };
-  }
-});
-
-// ../node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js
-var require_extend_shallow = __commonJS({
-  "../node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js"(exports2, module2) {
-    "use strict";
-    var isObject = require_is_extendable();
-    module2.exports = function extend(o) {
-      if (!isObject(o)) {
-        o = {};
+    module2.exports = function(name, options2) {
+      let engine = options2.engines[name] || options2.engines[aliase(name)];
+      if (typeof engine === "undefined") {
+        throw new Error('gray-matter engine "' + name + '" is not registered');
       }
-      var len = arguments.length;
-      for (var i = 1; i < len; i++) {
-        var obj = arguments[i];
-        if (isObject(obj)) {
-          assign(o, obj);
-        }
+      if (typeof engine === "function") {
+        engine = { parse: engine };
       }
-      return o;
+      return engine;
     };
-    function assign(a, b) {
-      for (var key in b) {
-        if (hasOwn(b, key)) {
-          a[key] = b[key];
-        }
-      }
-    }
-    function hasOwn(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-    }
-  }
-});
-
-// ../node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js
-var require_section_matter = __commonJS({
-  "../node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js"(exports2, module2) {
-    "use strict";
-    var typeOf = require_kind_of();
-    var extend = require_extend_shallow();
-    module2.exports = function(input, options2) {
-      if (typeof options2 === "function") {
-        options2 = { parse: options2 };
-      }
-      var file = toObject(input);
-      var defaults = { section_delimiter: "---", parse: identity };
-      var opts = extend({}, defaults, options2);
-      var delim = opts.section_delimiter;
-      var lines = file.content.split(/\r?\n/);
-      var sections = null;
-      var section = createSection();
-      var content = [];
-      var stack = [];
-      function initSections(val) {
-        file.content = val;
-        sections = [];
-        content = [];
-      }
-      function closeSection(val) {
-        if (stack.length) {
-          section.key = getKey(stack[0], delim);
-          section.content = val;
-          opts.parse(section, sections);
-          sections.push(section);
-          section = createSection();
-          content = [];
-          stack = [];
-        }
-      }
-      for (var i = 0; i < lines.length; i++) {
-        var line = lines[i];
-        var len = stack.length;
-        var ln = line.trim();
-        if (isDelimiter(ln, delim)) {
-          if (ln.length === 3 && i !== 0) {
-            if (len === 0 || len === 2) {
-              content.push(line);
-              continue;
-            }
-            stack.push(ln);
-            section.data = content.join("\n");
-            content = [];
-            continue;
-          }
-          if (sections === null) {
-            initSections(content.join("\n"));
-          }
-          if (len === 2) {
-            closeSection(content.join("\n"));
-          }
-          stack.push(ln);
-          continue;
+    function aliase(name) {
+      switch (name.toLowerCase()) {
+        case "js":
+        case "javascript":
+          return "javascript";
+        case "coffee":
+        case "coffeescript":
+        case "cson":
+          return "coffee";
+        case "yaml":
+        case "yml":
+          return "yaml";
+        default: {
+          return name;
         }
-        content.push(line);
-      }
-      if (sections === null) {
-        initSections(content.join("\n"));
-      } else {
-        closeSection(content.join("\n"));
-      }
-      file.sections = sections;
-      return file;
-    };
-    function isDelimiter(line, delim) {
-      if (line.slice(0, delim.length) !== delim) {
-        return false;
-      }
-      if (line.charAt(delim.length + 1) === delim.slice(-1)) {
-        return false;
-      }
-      return true;
-    }
-    function toObject(input) {
-      if (typeOf(input) !== "object") {
-        input = { content: input };
-      }
-      if (typeof input.content !== "string" && !isBuffer(input.content)) {
-        throw new TypeError("expected a buffer or string");
-      }
-      input.content = input.content.toString();
-      input.sections = [];
-      return input;
-    }
-    function getKey(val, delim) {
-      return val ? val.slice(delim.length).trim() : "";
-    }
-    function createSection() {
-      return { key: "", data: "", content: "" };
-    }
-    function identity(val) {
-      return val;
-    }
-    function isBuffer(val) {
-      if (val && val.constructor && typeof val.constructor.isBuffer === "function") {
-        return val.constructor.isBuffer(val);
       }
-      return false;
     }
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/common.js
-var require_common = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/common.js"(exports2, module2) {
+var require_common = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/common.js"(exports2, module2) {
     "use strict";
     function isNothing(subject) {
       return typeof subject === "undefined" || subject === null;
@@ -314,10 +1787,8 @@ var require_common = __commonJS({
     module2.exports.extend = extend;
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/exception.js
-var require_exception = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/exception.js"(exports2, module2) {
+var require_exception = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/exception.js"(exports2, module2) {
     "use strict";
     function YAMLException(reason, mark) {
       Error.call(this);
@@ -344,10 +1815,8 @@ var require_exception = __commonJS({
     module2.exports = YAMLException;
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/mark.js
-var require_mark = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/mark.js"(exports2, module2) {
+var require_mark = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/mark.js"(exports2, module2) {
     "use strict";
     var common = require_common();
     function Mark(name, buffer, position, line, column) {
@@ -358,23 +1827,23 @@ var require_mark = __commonJS({
       this.column = column;
     }
     Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
-      var head, start, tail, end, snippet;
+      var head, start2, tail, end, snippet;
       if (!this.buffer) return null;
       indent = indent || 4;
       maxLength = maxLength || 75;
       head = "";
-      start = this.position;
-      while (start > 0 && "\0\r\n…\u2028\u2029".indexOf(this.buffer.charAt(start - 1)) === -1) {
-        start -= 1;
-        if (this.position - start > maxLength / 2 - 1) {
+      start2 = this.position;
+      while (start2 > 0 && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(start2 - 1)) === -1) {
+        start2 -= 1;
+        if (this.position - start2 > maxLength / 2 - 1) {
           head = " ... ";
-          start += 5;
+          start2 += 5;
           break;
         }
       }
       tail = "";
       end = this.position;
-      while (end < this.buffer.length && "\0\r\n…\u2028\u2029".indexOf(this.buffer.charAt(end)) === -1) {
+      while (end < this.buffer.length && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(end)) === -1) {
         end += 1;
         if (end - this.position > maxLength / 2 - 1) {
           tail = " ... ";
@@ -382,8 +1851,8 @@ var require_mark = __commonJS({
           break;
         }
       }
-      snippet = this.buffer.slice(start, end);
-      return common.repeat(" ", indent) + head + snippet + tail + "\n" + common.repeat(" ", indent + this.position - start + head.length) + "^";
+      snippet = this.buffer.slice(start2, end);
+      return common.repeat(" ", indent) + head + snippet + tail + "\n" + common.repeat(" ", indent + this.position - start2 + head.length) + "^";
     };
     Mark.prototype.toString = function toString(compact) {
       var snippet, where = "";
@@ -402,10 +1871,8 @@ var require_mark = __commonJS({
     module2.exports = Mark;
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type.js
-var require_type = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type.js"(exports2, module2) {
+var require_type = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type.js"(exports2, module2) {
     "use strict";
     var YAMLException = require_exception();
     var TYPE_CONSTRUCTOR_OPTIONS = [
@@ -461,10 +1928,8 @@ var require_type = __commonJS({
     module2.exports = Type;
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema.js
-var require_schema = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema.js"(exports2, module2) {
+var require_schema = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema.js"(exports2, module2) {
     "use strict";
     var common = require_common();
     var YAMLException = require_exception();
@@ -549,10 +2014,8 @@ var require_schema = __commonJS({
     module2.exports = Schema;
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/str.js
-var require_str = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/str.js"(exports2, module2) {
+var require_str = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/str.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     module2.exports = new Type("tag:yaml.org,2002:str", {
@@ -563,10 +2026,8 @@ var require_str = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/seq.js
-var require_seq = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/seq.js"(exports2, module2) {
+var require_seq = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/seq.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     module2.exports = new Type("tag:yaml.org,2002:seq", {
@@ -577,10 +2038,8 @@ var require_seq = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/map.js
-var require_map = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/map.js"(exports2, module2) {
+var require_map = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/map.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     module2.exports = new Type("tag:yaml.org,2002:map", {
@@ -591,10 +2050,8 @@ var require_map = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js
-var require_failsafe = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js"(exports2, module2) {
+var require_failsafe = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js"(exports2, module2) {
     "use strict";
     var Schema = require_schema();
     module2.exports = new Schema({
@@ -606,10 +2063,8 @@ var require_failsafe = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/null.js
-var require_null = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/null.js"(exports2, module2) {
+var require_null = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/null.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     function resolveYamlNull(data) {
@@ -646,10 +2101,8 @@ var require_null = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/bool.js
-var require_bool = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/bool.js"(exports2, module2) {
+var require_bool = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/bool.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     function resolveYamlBoolean(data) {
@@ -683,10 +2136,8 @@ var require_bool = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/int.js
-var require_int = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/int.js"(exports2, module2) {
+var require_int = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/int.js"(exports2, module2) {
     "use strict";
     var common = require_common();
     var Type = require_type();
@@ -816,10 +2267,8 @@ var require_int = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/float.js
-var require_float = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/float.js"(exports2, module2) {
+var require_float = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/float.js"(exports2, module2) {
     "use strict";
     var common = require_common();
     var Type = require_type();
@@ -911,10 +2360,8 @@ var require_float = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/json.js
-var require_json = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/json.js"(exports2, module2) {
+var require_json = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/json.js"(exports2, module2) {
     "use strict";
     var Schema = require_schema();
     module2.exports = new Schema({
@@ -930,10 +2377,8 @@ var require_json = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/core.js
-var require_core = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/core.js"(exports2, module2) {
+var require_core = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/core.js"(exports2, module2) {
     "use strict";
     var Schema = require_schema();
     module2.exports = new Schema({
@@ -943,10 +2388,8 @@ var require_core = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/timestamp.js
-var require_timestamp = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/timestamp.js"(exports2, module2) {
+var require_timestamp = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/timestamp.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     var YAML_DATE_REGEXP = new RegExp(
@@ -1004,10 +2447,8 @@ var require_timestamp = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/merge.js
-var require_merge = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/merge.js"(exports2, module2) {
+var require_merge = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/merge.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     function resolveYamlMerge(data) {
@@ -1019,14 +2460,12 @@ var require_merge = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/binary.js
-var require_binary = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/binary.js"(exports2, module2) {
+var require_binary = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/binary.js"(exports2, module2) {
     "use strict";
     var NodeBuffer;
     try {
-      _require = __require;
+      _require = __require2;
       NodeBuffer = _require("buffer").Buffer;
     } catch (__) {
     }
@@ -1112,10 +2551,8 @@ var require_binary = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/omap.js
-var require_omap = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/omap.js"(exports2, module2) {
+var require_omap = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/omap.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     var _hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -1149,10 +2586,8 @@ var require_omap = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/pairs.js
-var require_pairs = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/pairs.js"(exports2, module2) {
+var require_pairs = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/pairs.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     var _toString = Object.prototype.toString;
@@ -1187,10 +2622,8 @@ var require_pairs = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/set.js
-var require_set = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/set.js"(exports2, module2) {
+var require_set = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/set.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     var _hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -1214,10 +2647,8 @@ var require_set = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js
-var require_default_safe = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js"(exports2, module2) {
+var require_default_safe = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js"(exports2, module2) {
     "use strict";
     var Schema = require_schema();
     module2.exports = new Schema({
@@ -1237,10 +2668,8 @@ var require_default_safe = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js
-var require_undefined = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js"(exports2, module2) {
+var require_undefined = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     function resolveJavascriptUndefined() {
@@ -1264,10 +2693,8 @@ var require_undefined = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js
-var require_regexp = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js"(exports2, module2) {
+var require_regexp = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js"(exports2, module2) {
     "use strict";
     var Type = require_type();
     function resolveJavascriptRegExp(data) {
@@ -1308,14 +2735,12 @@ var require_regexp = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/function.js
-var require_function = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/function.js"(exports2, module2) {
+var require_function = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/function.js"(exports2, module2) {
     "use strict";
     var esprima;
     try {
-      _require = __require;
+      _require = __require2;
       esprima = _require("esprima");
     } catch (_) {
       if (typeof window !== "undefined") esprima = window.esprima;
@@ -1363,10 +2788,8 @@ var require_function = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_full.js
-var require_default_full = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_full.js"(exports2, module2) {
+var require_default_full = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_full.js"(exports2, module2) {
     "use strict";
     var Schema = require_schema();
     module2.exports = Schema.DEFAULT = new Schema({
@@ -1381,10 +2804,8 @@ var require_default_full = __commonJS({
     });
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/loader.js
-var require_loader = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/loader.js"(exports2, module2) {
+var require_loader = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/loader.js"(exports2, module2) {
     "use strict";
     var common = require_common();
     var YAMLException = require_exception();
@@ -1449,7 +2870,7 @@ var require_loader = __commonJS({
       return -1;
     }
     function simpleEscapeSequence(c) {
-      return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? "	" : c === 9 ? "	" : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "…" : c === 95 ? " " : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
+      return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? "	" : c === 9 ? "	" : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
     }
     function charFromCodepoint(c) {
       if (c <= 65535) {
@@ -1541,10 +2962,10 @@ var require_loader = __commonJS({
         state.tagMap[handle] = prefix;
       }
     };
-    function captureSegment(state, start, end, checkJson) {
+    function captureSegment(state, start2, end, checkJson) {
       var _position, _length, _character, _result;
-      if (start < end) {
-        _result = state.input.slice(start, end);
+      if (start2 < end) {
+        _result = state.input.slice(start2, end);
         if (checkJson) {
           for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
             _character = _result.charCodeAt(_position);
@@ -2488,10 +3909,8 @@ var require_loader = __commonJS({
     module2.exports.safeLoad = safeLoad;
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/dumper.js
-var require_dumper = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/dumper.js"(exports2, module2) {
+var require_dumper = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/dumper.js"(exports2, module2) {
     "use strict";
     var common = require_common();
     var YAMLException = require_exception();
@@ -2771,22 +4190,22 @@ var require_dumper = __commonJS({
       if (line === "" || line[0] === " ") return line;
       var breakRe = / [^ ]/g;
       var match;
-      var start = 0, end, curr = 0, next = 0;
+      var start2 = 0, end, curr = 0, next = 0;
       var result = "";
       while (match = breakRe.exec(line)) {
         next = match.index;
-        if (next - start > width) {
-          end = curr > start ? curr : next;
-          result += "\n" + line.slice(start, end);
-          start = end + 1;
+        if (next - start2 > width) {
+          end = curr > start2 ? curr : next;
+          result += "\n" + line.slice(start2, end);
+          start2 = end + 1;
         }
         curr = next;
       }
       result += "\n";
-      if (line.length - start > width && curr > start) {
-        result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
+      if (line.length - start2 > width && curr > start2) {
+        result += line.slice(start2, curr) + "\n" + line.slice(curr + 1);
       } else {
-        result += line.slice(start);
+        result += line.slice(start2);
       }
       return result.slice(1);
     }
@@ -3036,10 +4455,8 @@ var require_dumper = __commonJS({
     module2.exports.safeDump = safeDump;
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml.js
-var require_js_yaml = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml.js"(exports2, module2) {
+var require_js_yaml = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml.js"(exports2, module2) {
     "use strict";
     var loader = require_loader();
     var dumper = require_dumper();
@@ -3071,19 +4488,15 @@ var require_js_yaml = __commonJS({
     module2.exports.addConstructor = deprecated("addConstructor");
   }
 });
-
-// ../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/index.js
-var require_js_yaml2 = __commonJS({
-  "../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/index.js"(exports2, module2) {
+var require_js_yaml2 = __commonJS3({
+  "../../node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/index.js"(exports2, module2) {
     "use strict";
-    var yaml2 = require_js_yaml();
-    module2.exports = yaml2;
+    var yaml22 = require_js_yaml();
+    module2.exports = yaml22;
   }
 });
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js
-var require_engines = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js"(exports, module) {
+var require_engines = __commonJS3({
+  "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js"(exports, module) {
     "use strict";
     var yaml = require_js_yaml2();
     var engines = exports = module.exports;
@@ -3118,10 +4531,8 @@ var require_engines = __commonJS({
     };
   }
 });
-
-// ../node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js
-var require_strip_bom_string = __commonJS({
-  "../node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js"(exports2, module2) {
+var require_strip_bom_string = __commonJS3({
+  "../../node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js"(exports2, module2) {
     "use strict";
     module2.exports = function(str2) {
       if (typeof str2 === "string" && str2.charAt(0) === "\uFEFF") {
@@ -3131,10 +4542,8 @@ var require_strip_bom_string = __commonJS({
     };
   }
 });
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js
-var require_utils = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js"(exports2) {
+var require_utils = __commonJS3({
+  "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js"(exports2) {
     "use strict";
     var stripBom = require_strip_bom_string();
     var typeOf = require_kind_of();
@@ -3171,10 +4580,8 @@ var require_utils = __commonJS({
     };
   }
 });
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js
-var require_defaults = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js"(exports2, module2) {
+var require_defaults = __commonJS3({
+  "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js"(exports2, module2) {
     "use strict";
     var engines2 = require_engines();
     var utils = require_utils();
@@ -3190,44 +4597,8 @@ var require_defaults = __commonJS({
     };
   }
 });
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js
-var require_engine = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function(name, options2) {
-      let engine = options2.engines[name] || options2.engines[aliase(name)];
-      if (typeof engine === "undefined") {
-        throw new Error('gray-matter engine "' + name + '" is not registered');
-      }
-      if (typeof engine === "function") {
-        engine = { parse: engine };
-      }
-      return engine;
-    };
-    function aliase(name) {
-      switch (name.toLowerCase()) {
-        case "js":
-        case "javascript":
-          return "javascript";
-        case "coffee":
-        case "coffeescript":
-        case "cson":
-          return "coffee";
-        case "yaml":
-        case "yml":
-          return "yaml";
-        default: {
-          return name;
-        }
-      }
-    }
-  }
-});
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js
-var require_stringify = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js"(exports2, module2) {
+var require_stringify = __commonJS3({
+  "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js"(exports2, module2) {
     "use strict";
     var typeOf = require_kind_of();
     var getEngine = require_engine();
@@ -3260,10 +4631,10 @@ var require_stringify = __commonJS({
       data = Object.assign({}, file.data, data);
       const open = opts.delimiters[0];
       const close = opts.delimiters[1];
-      const matter = engine.stringify(data, options2).trim();
+      const matter3 = engine.stringify(data, options2).trim();
       let buf = "";
-      if (matter !== "{}") {
-        buf = newline(open) + newline(matter) + newline(close);
+      if (matter3 !== "{}") {
+        buf = newline(open) + newline(matter3) + newline(close);
       }
       if (typeof file.excerpt === "string" && file.excerpt !== "") {
         if (str2.indexOf(file.excerpt.trim()) === -1) {
@@ -3277,216 +4648,1027 @@ var require_stringify = __commonJS({
     }
   }
 });
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js
-var require_excerpt = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js"(exports2, module2) {
-    "use strict";
-    var defaults = require_defaults();
-    module2.exports = function(file, options2) {
-      const opts = defaults(options2);
-      if (file.data == null) {
-        file.data = {};
+var extensions = ["tsx", "jsx", "js", "ts", "json"];
+async function readSettings() {
+  const dirPath = process.cwd();
+  const baseFileName = "settings";
+  let settingsFilePath = "";
+  let reactSettings = false;
+  try {
+    const files = await fs3.readdir(dirPath);
+    const settingsFile = files.find((file) => {
+      const ext = path3.extname(file).slice(1);
+      return file.startsWith(baseFileName) && extensions.includes(ext);
+    });
+    if (settingsFile) {
+      settingsFilePath = path3.join(dirPath, settingsFile);
+      reactSettings = path3.extname(settingsFile) !== ".json";
+    } else {
+      console.error("No settings file found");
+      return null;
+    }
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+  if (reactSettings) {
+    const settingsPreview = await createServer({
+      optimizeDeps: {
+        include: ["react/jsx-runtime"]
+      }
+    });
+    const config = await settingsPreview.ssrLoadModule(settingsFilePath);
+    return config.default;
+  } else {
+    const rawJsonSettings = await fs3.readFile(settingsFilePath, "utf-8");
+    return JSON.parse(rawJsonSettings);
+  }
+}
+async function loadModule(filePath) {
+  const server = await createServer2({
+    optimizeDeps: {
+      include: ["react/jsx-runtime"]
+    }
+  });
+  try {
+    const module2 = await server.ssrLoadModule(filePath);
+    return module2.default;
+  } finally {
+    await server.close();
+  }
+}
+function preinstall() {
+  return async function docsPluginInner(_, data) {
+    const root2 = process.cwd();
+    const settings = await readSettings();
+    let themeRoutesExists = false;
+    try {
+      await fs2.access(path22.join(root2, ".xyd/theme/routes.ts"));
+      themeRoutesExists = true;
+    } catch (_2) {
+    }
+    if (themeRoutesExists) {
+      const routeMod = await loadModule(path22.join(root2, ".xyd/theme/routes.ts"));
+      const routes = routeMod((routePath, routeFile, routeOptions) => {
+        return route(routePath, path22.join(root2, ".xyd/theme", routeFile), routeOptions);
+      });
+      data.routes.push(...routes);
+    }
+    return {
+      settings
+    };
+  };
+}
+function vitePluginSettings() {
+  return async function({ preinstall: preinstall3 }) {
+    return {
+      name: "virtual:xyd-settings",
+      resolveId(id) {
+        if (id === "virtual:xyd-settings") {
+          return id + ".jsx";
+        }
+        return null;
+      },
+      async load(id) {
+        if (id === "virtual:xyd-settings.jsx") {
+          if (typeof preinstall3.settings === "string") {
+            return preinstall3.settings;
+          }
+          return `export default ${JSON.stringify(preinstall3.settings)};`;
+        }
+        return null;
       }
-      if (typeof opts.excerpt === "function") {
-        return opts.excerpt(file, opts);
+    };
+  };
+}
+function vitePluginThemeCSS() {
+  return async function({ preinstall: preinstall3 }) {
+    return {
+      name: "virtual:xyd-theme-css",
+      resolveId(source) {
+        if (source === "virtual:xyd-theme/index.css") {
+          let basePath = "";
+          if (process.env.XYD_CLI) {
+            const __filename3 = fileURLToPath(import.meta.url);
+            const __dirname23 = path22.dirname(__filename3);
+            basePath = __dirname23 + "/";
+          } else {
+            basePath = import.meta.url.split("xyd/packages")[0] += "xyd/";
+          }
+          switch (preinstall3.settings.styling?.theme) {
+            // TODO: support another themes + custom themes
+            case "gusto": {
+              const gustoCss = basePath += "node_modules/@xyd-js/theme-gusto/dist/index.css";
+              return gustoCss.replace("file://", "");
+            }
+            case "poetry": {
+              const poetryCss = basePath += "node_modules/@xyd-js/theme-poetry/dist/index.css";
+              return poetryCss.replace("file://", "");
+            }
+            default: {
+              const fableCss = basePath += "node_modules/@xyd-js/fable-wiki/dist/theme.css";
+              return fableCss.replace("file://", "");
+            }
+          }
+        }
+        return null;
       }
-      const sep = file.data.excerpt_separator || opts.excerpt_separator;
-      if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {
-        return file;
+    };
+  };
+}
+function vitePluginThemeOverrideCSS() {
+  return async function({ preinstall: preinstall3 }) {
+    return {
+      name: "virtual:xyd-theme-override-css",
+      async resolveId(id) {
+        if (id === "virtual:xyd-theme-override/index.css") {
+          const root2 = process.cwd();
+          const filePath = path22.join(root2, ".xyd/theme/index.css");
+          try {
+            await fs2.access(filePath);
+            return filePath;
+          } catch {
+            return "virtual:xyd-theme-override/empty.css";
+          }
+        }
+        return null;
+      },
+      async load(id) {
+        if (id === "virtual:xyd-theme-override/empty.css") {
+          return "";
+        }
+        return null;
       }
-      const delimiter = typeof opts.excerpt === "string" ? opts.excerpt : sep || opts.delimiters[0];
-      const idx = file.content.indexOf(delimiter);
-      if (idx !== -1) {
-        file.excerpt = file.content.slice(0, idx);
+    };
+  };
+}
+function vitePluginTheme() {
+  return async function({
+    preinstall: preinstall3
+  }) {
+    return {
+      name: "virtual:xyd-theme",
+      resolveId(id) {
+        if (id === "virtual:xyd-theme") {
+          return id;
+        }
+        return null;
+      },
+      async load(id) {
+        if (id === "virtual:xyd-theme") {
+          switch (preinstall3.settings.styling?.theme) {
+            // TODO: support another themes + custom themes
+            case "gusto": {
+              return `import Theme from '@xyd-js/theme-gusto'; export default Theme;`;
+            }
+            case "poetry": {
+              return `import Theme from '@xyd-js/theme-poetry'; export default Theme;`;
+            }
+            default: {
+              return `import Theme from '@xyd-js/fable-wiki/theme'; export default Theme;`;
+            }
+          }
+        }
+        return null;
       }
-      return file;
     };
+  };
+}
+function preset(settings, options2) {
+  const __filename3 = fileURLToPath(import.meta.url);
+  const __dirname23 = path22.dirname(__filename3);
+  let basePath = "";
+  if (process.env.XYD_CLI) {
+    basePath = path22.join(__dirname23, "./plugins/xyd-plugin-zero");
+  } else {
+    basePath = "../../../xyd-plugin-zero";
   }
-});
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js
-var require_to_file = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js"(exports2, module2) {
-    "use strict";
-    var typeOf = require_kind_of();
-    var stringify = require_stringify();
-    var utils = require_utils();
-    module2.exports = function(file) {
-      if (typeOf(file) !== "object") {
-        file = { content: file };
+  return {
+    preinstall: [
+      preinstall
+    ],
+    routes: [
+      route("", path22.join(basePath, "src/pages/docs.tsx")),
+      // TODO: custom routes
+      route(options2.urlPrefix ? `${options2.urlPrefix}/*` : "*", path22.join(basePath, "src/pages/docs.tsx"), {
+        // TODO: absolute paths does not works
+        id: "xyd-plugin-zero/docs"
+      })
+    ],
+    vitePlugins: [
+      vitePluginSettings,
+      vitePluginTheme,
+      vitePluginThemeCSS,
+      vitePluginThemeOverrideCSS
+    ]
+  };
+}
+var docsPreset = preset;
+var import_stringify = __toESM3(require_stringify(), 1);
+function flatPages(sidebar, groups, resp = []) {
+  sidebar.map(async (side) => {
+    if ("match" in side) {
+      side.items.map((item) => {
+        return flatPages([item], groups, resp);
+      });
+      return;
+    }
+    if (groups[side.group || ""]) {
+      const link = groups[side.group || ""];
+      resp.push(link);
+    }
+    side?.pages?.map(async (page) => {
+      if (typeof page === "string") {
+        resp.push(page);
+        return;
+      }
+      return flatPages([page], groups, resp);
+    });
+  });
+  return resp;
+}
+function flatGroups(sidebar, resp = {}) {
+  sidebar.map(async (side) => {
+    if ("match" in side) {
+      side.items.map((item) => {
+        return flatGroups([item], resp);
+      });
+      return;
+    }
+    if (side.group) {
+      if (resp[side.group]) {
+        console.error("group already exists", side.group);
+      }
+      const first = side?.pages?.[0];
+      if (first && typeof first === "string") {
+        const chunks = first.split("/");
+        chunks[chunks.length - 1] = side.group || "";
+        const groupLink = chunks.join("/");
+        resp[side.group] = groupLink;
+      }
+    }
+    side?.pages?.map(async (page) => {
+      if (typeof page === "string") {
+        return;
       }
-      if (typeOf(file.data) !== "object") {
-        file.data = {};
+      return flatGroups([page], resp);
+    });
+  });
+  return resp;
+}
+function uniformSidebarLevelMap(pages) {
+  const out = {};
+  let level = 0;
+  function recursive(items) {
+    for (const item of items) {
+      out[item] = level++;
+    }
+  }
+  recursive(pages);
+  return out;
+}
+async function uniformResolver(root2, matchRoute, apiFile, uniformApiResolver, sidebar, options2) {
+  let urlPrefix = "";
+  if (matchRoute && sidebar) {
+    sidebar.forEach((sidebar2) => {
+      if ("match" in sidebar2) {
+        if (sidebar2.match === matchRoute) {
+          if (urlPrefix) {
+            throw new Error("multiple sidebars found for apiFile match");
+          }
+          urlPrefix = sidebar2.match;
+        }
       }
-      if (file.contents && file.content == null) {
-        file.content = file.contents;
+    });
+  }
+  if (!urlPrefix && options2?.urlPrefix) {
+    urlPrefix = options2.urlPrefix;
+  }
+  if (!urlPrefix) {
+    throw new Error("urlPrefix not found");
+  }
+  const apiFilePath = path32.join(root2, apiFile);
+  const uniformRefs = await uniformApiResolver(apiFilePath);
+  const uniformWithNavigation = uniform(uniformRefs, {
+    plugins: [pluginNavigation({
+      urlPrefix
+    })]
+  });
+  let pageLevels = {};
+  const uniformData = {
+    slugs: {},
+    data: [],
+    // TODO: fix any
+    i: 0,
+    set: (slug, content, options3 = {}) => {
+      if (uniformData.slugs[slug]) {
+        console.error("slug already exists", slug);
+      }
+      const level = pageLevels[slug];
+      uniformData.data[level] = {
+        slug,
+        content,
+        options: options3
+      };
+    }
+  };
+  const uniformSidebars = [];
+  if (sidebar && matchRoute) {
+    sidebar.forEach((sidebar2) => {
+      if ("match" in sidebar2) {
+        if (sidebar2.match === matchRoute) {
+          uniformSidebars.push(sidebar2);
+        }
       }
-      utils.define(file, "orig", utils.toBuffer(file.content));
-      utils.define(file, "language", file.language || "");
-      utils.define(file, "matter", file.matter || "");
-      utils.define(file, "stringify", function(data, options2) {
-        if (options2 && options2.language) {
-          file.language = options2.language;
+    });
+    if (uniformSidebars.length > 1) {
+      throw new Error("multiple sidebars found for uniform match");
+    }
+  }
+  {
+    const otherUniformPages = flatPages(uniformSidebars, {});
+    const groups = flatGroups(uniformWithNavigation.out.sidebar);
+    const flatUniformPages = [
+      ...otherUniformPages,
+      ...flatPages(
+        uniformWithNavigation.out.sidebar,
+        groups
+        // TODO: we dont need groups - because it comes to structured page levels
+      )
+    ];
+    pageLevels = uniformSidebarLevelMap(flatUniformPages);
+    {
+      await Promise.all(otherUniformPages.map(async (page) => {
+        const content = await fs32.readFile(path32.join(root2, page + ".mdx"), "utf-8");
+        uniformData.set(page, content + "\n");
+      }));
+      await Promise.all(Object.keys(groups).map(async (group) => {
+        try {
+          const page = groups[group];
+          const content = await fs32.readFile(path32.join(root2, page + ".mdx"), "utf-8");
+          uniformData.set(page, content + "\n");
+        } catch (e) {
         }
-        return stringify(file, data, options2);
+      }));
+    }
+  }
+  await Promise.all(
+    uniformWithNavigation.references.map(async (ref) => {
+      const ast = referenceAST(ref);
+      const md = compile(ast);
+      const byCanonical = path32.join(urlPrefix, ref.canonical);
+      const mdPath = path32.join(root2, byCanonical + ".md");
+      const frontmatter = uniformWithNavigation.out.pageFrontMatter[byCanonical];
+      if (!frontmatter) {
+        console.error("frontmatter not found", byCanonical);
+        return;
+      }
+      const content = (0, import_stringify.default)({ content: md }, {
+        title: frontmatter.title
       });
-      file.content = utils.toString(file.content);
-      file.isEmpty = false;
-      file.excerpt = "";
-      return file;
+      await fs32.writeFile(mdPath, content);
+      uniformData.set(byCanonical, md + "\n");
+    })
+  );
+  if (!sidebar) {
+    return {
+      sidebar: uniformWithNavigation.out.sidebar,
+      data: uniformData.data
     };
   }
-});
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js
-var require_parse = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js"(exports2, module2) {
-    "use strict";
-    var getEngine = require_engine();
-    var defaults = require_defaults();
-    module2.exports = function(language, str2, options2) {
-      const opts = defaults(options2);
-      const engine = getEngine(language, opts);
-      if (typeof engine.parse !== "function") {
-        throw new TypeError('expected "' + language + '.parse" to be a function');
-      }
-      return engine.parse(str2, opts);
+  if (matchRoute) {
+    uniformSidebars[0].items.push(...uniformWithNavigation.out.sidebar);
+    return {
+      data: uniformData.data
     };
   }
-});
-
-// ../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js
-var require_gray_matter = __commonJS({
-  "../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js"(exports2, module2) {
-    var fs = require_fs();
-    var sections = require_section_matter();
-    var defaults = require_defaults();
-    var stringify = require_stringify();
-    var excerpt = require_excerpt();
-    var engines2 = require_engines();
-    var toFile = require_to_file();
-    var parse2 = require_parse();
-    var utils = require_utils();
-    function matter(input, options2) {
-      if (input === "") {
-        return { data: {}, content: input, excerpt: "", orig: input };
+  sidebar.push(...uniformWithNavigation.out.sidebar);
+  return {
+    data: uniformData.data
+  };
+}
+function preinstall2(id, uniformApiResolver, apiFile) {
+  return function preinstallInner(options2) {
+    return async function uniformPluginInner(settings, data) {
+      const root2 = options2.root ?? process.cwd();
+      if (!apiFile) {
+        return;
       }
-      let file = toFile(input);
-      const cached = matter.cache[file.content];
-      if (!options2) {
-        if (cached) {
-          file = Object.assign({}, cached);
-          file.orig = cached.orig;
-          return file;
+      const resp = [];
+      if (typeof apiFile === "string") {
+        const routeMatch = settings.api?.match?.[id] || "";
+        const resolved = await uniformResolver(
+          root2,
+          routeMatch,
+          apiFile,
+          uniformApiResolver,
+          settings?.structure?.sidebar,
+          options2
+        );
+        if (resolved.sidebar) {
+          settings.structure = {
+            ...settings?.structure,
+            sidebar: !settings.structure?.sidebar ? resolved.sidebar : [
+              ...!settings.structure?.sidebar || [],
+              ...resolved.sidebar
+            ]
+          };
         }
-        matter.cache[file.content] = file;
-      }
-      return parseMatter(file, options2);
-    }
-    function parseMatter(file, options2) {
-      const opts = defaults(options2);
-      const open = opts.delimiters[0];
-      const close = "\n" + opts.delimiters[1];
-      let str2 = file.content;
-      if (opts.language) {
-        file.language = opts.language;
-      }
-      const openLen = open.length;
-      if (!utils.startsWith(str2, open, openLen)) {
-        excerpt(file, opts);
-        return file;
-      }
-      if (str2.charAt(openLen) === open.slice(-1)) {
-        return file;
-      }
-      str2 = str2.slice(openLen);
-      const len = str2.length;
-      const language = matter.language(str2, opts);
-      if (language.name) {
-        file.language = language.name;
-        str2 = str2.slice(language.raw.length);
-      }
-      let closeIndex = str2.indexOf(close);
-      if (closeIndex === -1) {
-        closeIndex = len;
-      }
-      file.matter = str2.slice(0, closeIndex);
-      const block = file.matter.replace(/^\s*#[^\n]+/gm, "").trim();
-      if (block === "") {
-        file.isEmpty = true;
-        file.empty = file.content;
-        file.data = {};
+        resp.push({
+          urlPrefix: routeMatch.startsWith("/") ? routeMatch : `/${routeMatch}`,
+          data: resolved.data
+        });
       } else {
-        file.data = parse2(file.language, file.matter, opts);
+        for (const openapiKey in apiFile) {
+          const uniform2 = apiFile?.[openapiKey];
+          const routeMatch = settings.api?.match?.[id]?.[openapiKey] || "";
+          if (!routeMatch) {
+            throw new Error(`route match not found for ${openapiKey}`);
+          }
+          if (!uniform2) {
+            throw new Error(`uniform not found for ${openapiKey}`);
+          }
+          const resolved = await uniformResolver(
+            root2,
+            routeMatch,
+            uniform2,
+            uniformApiResolver,
+            settings?.structure?.sidebar
+          );
+          if (resolved.sidebar) {
+            settings.structure = {
+              ...settings?.structure,
+              sidebar: !settings.structure?.sidebar ? resolved.sidebar : [
+                ...!settings.structure?.sidebar || [],
+                ...resolved.sidebar
+              ]
+            };
+          }
+          resp.push({
+            urlPrefix: routeMatch.startsWith("/") ? routeMatch : `/${routeMatch}`,
+            data: resolved.data
+          });
+        }
       }
-      if (closeIndex === len) {
-        file.content = "";
-      } else {
-        file.content = str2.slice(closeIndex + close.length);
-        if (file.content[0] === "\r") {
-          file.content = file.content.slice(1);
+      return resp;
+    };
+  };
+}
+function vitePluginUniformContent(pluginId) {
+  return function vitePluginUniformContentInner() {
+    return async function({
+      preinstall: preinstall3
+    }) {
+      return {
+        name: `virtual:xyd-plugin-zero/${pluginId}`,
+        // TODO: unique name per plugin ?
+        resolveId(id) {
+          if (id == `virtual:xyd-plugin-zero/${pluginId}`) {
+            return id;
+          }
+        },
+        async load(id) {
+          if (id === `virtual:xyd-plugin-zero/${pluginId}`) {
+            if (!preinstall3.data) {
+              return `export default ${JSON.stringify(preinstall3)}`;
+            }
+            return `export default ${JSON.stringify(preinstall3.data)}`;
+          }
         }
-        if (file.content[0] === "\n") {
-          file.content = file.content.slice(1);
+      };
+    };
+  };
+}
+function uniformPreset(id, apiFile, sidebar, options2, uniformApiResolver) {
+  return function(settings) {
+    const routeMatches = [];
+    if (apiFile) {
+      sidebar.forEach((sidebar2) => {
+        if ("match" in sidebar2) {
+          if (typeof apiFile === "string") {
+            const routeMatch = settings?.api?.match?.[id];
+            if (sidebar2.match === routeMatch) {
+              routeMatches.push(routeMatch);
+            }
+            return;
+          }
+          if (typeof apiFile === "object" && !Array.isArray(apiFile)) {
+            for (const routeMatchKey in apiFile) {
+              const routeMatch = settings?.api?.match?.[id]?.[routeMatchKey];
+              if (sidebar2.match === routeMatch) {
+                routeMatches.push(routeMatch);
+              }
+            }
+          }
+          return;
         }
+      });
+    } else {
+      if (!options2.urlPrefix) {
+        throw new Error("urlPrefix not found");
       }
-      excerpt(file, opts);
-      if (opts.sections === true || typeof opts.section === "function") {
-        sections(file, opts.section);
-      }
-      return file;
+      routeMatches.push(`${options2.urlPrefix}/*`);
     }
-    matter.engines = engines2;
-    matter.stringify = function(file, data, options2) {
-      if (typeof file === "string") file = matter(file, options2);
-      return stringify(file, data, options2);
-    };
-    matter.read = function(filepath, options2) {
-      const str2 = fs.readFileSync(filepath, "utf8");
-      const file = matter(str2, options2);
-      file.path = filepath;
-      return file;
+    let basePath = "";
+    if (process.env.XYD_CLI) {
+      basePath = path32.join(__dirname, "./plugins/xyd-plugin-zero");
+    } else {
+      basePath = "../../../xyd-plugin-zero";
+    }
+    return {
+      preinstall: [
+        preinstall2(id, uniformApiResolver, apiFile)
+      ],
+      routes: routeMatches.map(
+        (routeMatch, i) => route2(
+          `${routeMatch}/*`,
+          path32.join(basePath, "src/pages/api-reference.tsx"),
+          {
+            id: `xyd-plugin-zero/${id}-${i}`
+          }
+        )
+      ),
+      vitePlugins: [
+        vitePluginUniformContent(id)
+      ]
     };
-    matter.test = function(str2, options2) {
-      return utils.startsWith(str2, defaults(options2).delimiters[0]);
+  };
+}
+function preset2(settings, options2) {
+  return uniformPreset(
+    "graphql",
+    settings?.api?.graphql || "",
+    settings?.structure?.sidebar || [],
+    {
+      root: options2.root,
+      urlPrefix: options2.urlPrefix
+    },
+    async (gqlPath) => {
+      return await gqlSchemaToReferences(gqlPath);
+    }
+  )(settings);
+}
+var graphqlPreset = preset2;
+function preset3(settings, options2) {
+  return uniformPreset(
+    "openapi",
+    settings?.api?.openapi || "",
+    settings?.structure?.sidebar || [],
+    {
+      root: options2.root,
+      urlPrefix: options2.urlPrefix
+    },
+    async (openApiPath) => {
+      const schema = await deferencedOpenAPI(openApiPath);
+      return oapSchemaToReferences(schema);
+    }
+  )(settings);
+}
+var openapiPreset = preset3;
+async function pluginZero() {
+  let settings = null;
+  const vitePlugins2 = [];
+  const routes = [];
+  {
+    const options2 = {
+      urlPrefix: ""
+      // TODO: configurable
     };
-    matter.language = function(str2, options2) {
-      const opts = defaults(options2);
-      const open = opts.delimiters[0];
-      if (matter.test(str2)) {
-        str2 = str2.slice(open.length);
+    const docs = docsPreset(void 0, options2);
+    docs.preinstall = docs.preinstall || [];
+    let preinstallMerge = {};
+    for (const preinstall3 of docs.preinstall) {
+      const resp = await preinstall3()({}, {
+        routes: docs.routes
+      });
+      if (resp && typeof resp === "object") {
+        preinstallMerge = {
+          ...preinstallMerge,
+          ...resp
+        };
       }
-      const language = str2.slice(0, str2.search(/\r?\n/));
-      return {
-        raw: language,
-        name: language ? language.trim() : ""
-      };
-    };
-    matter.cache = {};
-    matter.clearCache = function() {
-      matter.cache = {};
+    }
+    docs.vitePlugins = docs.vitePlugins || [];
+    for (const vitePlugin of docs.vitePlugins) {
+      const vitePlug = await vitePlugin()({
+        preinstall: preinstallMerge
+      });
+      vitePlugins2.push(vitePlug);
+    }
+    if ("settings" in preinstallMerge) {
+      settings = preinstallMerge.settings;
+    }
+    docs.routes = docs.routes || [];
+    routes.push(...docs.routes);
+  }
+  if (!settings) {
+    throw new Error("settings not found");
+  }
+  if (settings?.api?.graphql) {
+    const options2 = {};
+    const gql = graphqlPreset(settings, options2);
+    gql.preinstall = gql.preinstall || [];
+    let preinstallMerge = {};
+    for (const preinstall3 of gql.preinstall) {
+      const resp = await preinstall3(options2)(settings, {
+        routes: gql.routes
+      });
+      if (resp && typeof resp === "object") {
+        preinstallMerge = {
+          ...preinstallMerge,
+          ...resp
+        };
+      }
+    }
+    gql.vitePlugins = gql.vitePlugins || [];
+    for (const vitePlugin of gql.vitePlugins) {
+      const vitePlug = await vitePlugin()({
+        preinstall: preinstallMerge
+      });
+      vitePlugins2.push(vitePlug);
+    }
+    gql.routes = gql.routes || [];
+    routes.push(...gql.routes);
+  }
+  if (settings?.api?.openapi) {
+    const options2 = {};
+    const oap = openapiPreset(settings, options2);
+    oap.preinstall = oap.preinstall || [];
+    let preinstallMerge = {};
+    for (const preinstall3 of oap.preinstall) {
+      const resp = await preinstall3(options2)(settings, {
+        routes: oap.routes
+      });
+      if (resp && typeof resp === "object") {
+        preinstallMerge = {
+          ...preinstallMerge,
+          ...resp
+        };
+      }
+    }
+    oap.vitePlugins = oap.vitePlugins || [];
+    for (const vitePlugin of oap.vitePlugins) {
+      const vitePlug = await vitePlugin()({
+        preinstall: preinstallMerge
+      });
+      vitePlugins2.push(vitePlug);
+    }
+    oap.routes = oap.routes || [];
+    routes.push(...oap.routes);
+  }
+  return {
+    vitePlugins: vitePlugins2,
+    settings,
+    routes
+  };
+}
+
+// node_modules/@xyd-js/documan/dist/index.js
+import path23 from "node:path";
+import { fileURLToPath as fileURLToPath22 } from "node:url";
+import { createServer as createServer3, searchForWorkspaceRoot } from "vite";
+import { reactRouter as reactRouter2 } from "@xyd-js/react-router-dev/vite";
+import fs22 from "node:fs";
+import os from "node:os";
+import path33 from "node:path";
+import url from "node:url";
+import { createRequestHandler } from "@react-router/express";
+import compression from "compression";
+import express from "express";
+import morgan from "morgan";
+import sourceMapSupport from "source-map-support";
+import getPort from "get-port";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname2 = path4.dirname(__filename);
+async function build() {
+  const resp = await pluginZero();
+  if (!resp) {
+    throw new Error("PluginZero not found");
+  }
+  const buildDir = path4.join(process.cwd(), ".xyd/build");
+  {
+    const packageJsonPath = path4.join(buildDir, "package.json");
+    const packageJsonContent = {
+      type: "module",
+      scripts: {},
+      dependencies: {
+        // TODO: better
+        "@xyd-js/content": "latest",
+        "@xyd-js/components": "latest",
+        "@xyd-js/framework": "latest",
+        "@xyd-js/theme-poetry": "latest",
+        "@react-router/node": "^7.1.1",
+        "isbot": "^5"
+      },
+      devDependencies: {}
     };
-    module2.exports = matter;
+    if (!fs4.existsSync(buildDir)) {
+      fs4.mkdirSync(buildDir, { recursive: true });
+    }
+    fs4.writeFileSync(packageJsonPath, JSON.stringify(packageJsonContent, null, 2), "utf8");
+    console.log("Installing dependencies...");
+    execSync("npm install", { cwd: buildDir, stdio: "inherit" });
   }
-});
-export default require_gray_matter();
-/*! Bundled license information:
+  try {
+    await viteBuild({
+      root: process.env.XYD_CLI ? __dirname2 : process.env.XYD_DOCUMAN_HOST || path4.join(__dirname2, "../host"),
+      // @ts-ignore
+      plugins: [
+        ...vitePlugins({
+          toc: {
+            minDepth: 2
+          }
+        }),
+        reactRouter({
+          outDir: buildDir,
+          routes: resp.routes
+        }),
+        tsconfigPaths(),
+        ...resp.vitePlugins
+      ],
+      optimizeDeps: {
+        include: ["react/jsx-runtime"]
+      }
+    });
+    await viteBuild({
+      root: process.env.XYD_CLI ? __dirname2 : process.env.XYD_DOCUMAN_HOST || path4.join(__dirname2, "../host"),
+      build: {
+        ssr: true
+      },
+      // @ts-ignore
+      plugins: [
+        ...vitePlugins({
+          toc: {
+            minDepth: 2
+          }
+        }),
+        reactRouter({
+          outDir: buildDir,
+          routes: resp.routes
+        }),
+        tsconfigPaths(),
+        ...resp.vitePlugins
+      ],
+      optimizeDeps: {
+        include: ["react/jsx-runtime"]
+      }
+    });
+    console.log("Build completed successfully.");
+  } catch (error) {
+    console.error("Build failed:", error);
+  }
+}
+var __filename2 = fileURLToPath22(import.meta.url);
+var __dirname22 = path23.dirname(__filename2);
+var port = process.env.XYD_PORT ? parseInt(process.env.XYD_PORT) : 5175;
+async function dev() {
+  const resp = await pluginZero();
+  if (!resp) {
+    throw new Error("PluginZero not found");
+  }
+  const allowCwd = searchForWorkspaceRoot(process.cwd());
+  const preview = await createServer3({
+    // any valid user config options, plus `mode` and `configFile`
+    // configFile: path.join(__dirname, "../src/vite/empty-config.ts"), // TODO: bundler??
+    // configFile: path.join(__dirname, "../"), // TODO: bundler??
+    // root: path.join(__dirname, "../"), // TODO: bundler?
+    root: process.env.XYD_CLI ? __dirname22 : process.env.XYD_DOCUMAN_HOST || path23.join(__dirname22, "../host"),
+    // TODO: bundler?
+    server: {
+      port,
+      fs: {
+        allow: [
+          allowCwd,
+          process.env.XYD_CLI ? path23.join(__dirname22, "../../") : ""
+          // path.join(__dirname, "../node_modules") // Ensure node_modules from xyd-documan is included
+        ]
+      }
+    },
+    build: {
+      rollupOptions: {
+        // Exclude package `B` from the client-side bundle
+        external: ["@xyd-js/uniform", "@xyd-js/uniform/content", "@xyd-js/plugin-zero"]
+      }
+    },
+    ssr: {
+      external: ["@xyd-js/uniform", "@xyd-js/uniform/content", "@xyd-js/plugin-zero"]
+      // noExternal: [
+      //     "@xyd-js/uniform",
+      //     "@xyd-js/uniform/content",
+      //     "@xyd-js/plugin-zero"
+      // ],
+    },
+    optimizeDeps: {
+      include: ["react/jsx-runtime"]
+    },
+    // @ts-ignore
+    plugins: [
+      // TODO: fix plugin ts
+      ...vitePlugins({
+        toc: {
+          minDepth: 2
+        }
+      }),
+      reactRouter2({
+        routes: resp.routes
+      }),
+      ...resp.vitePlugins
+    ]
+  });
+  await preview.listen(port);
+  preview.printUrls();
+  preview.bindCLIShortcuts({ print: true });
+}
+function parseNumber(raw) {
+  if (raw === void 0) return void 0;
+  let maybe = Number(raw);
+  if (Number.isNaN(maybe)) return void 0;
+  return maybe;
+}
+async function serve() {
+  process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
+  sourceMapSupport.install({
+    retrieveSourceMap: function(source) {
+      let match = source.startsWith("file://");
+      if (match) {
+        let filePath = url.fileURLToPath(source);
+        let sourceMapPath = `${filePath}.map`;
+        if (fs22.existsSync(sourceMapPath)) {
+          return {
+            url: source,
+            map: fs22.readFileSync(sourceMapPath, "utf8")
+          };
+        }
+      }
+      return null;
+    }
+  });
+  let port2 = parseNumber(process.env.PORT) ?? await getPort({ port: 3e3 });
+  let buildPathArg = path33.join(process.cwd(), ".xyd/build/server/index.js");
+  if (!buildPathArg) {
+    console.error(`
+  Usage: react-router-serve <server-build-path> - e.g. react-router-serve build/server/index.js`);
+    process.exit(1);
+  }
+  let buildPath = path33.resolve(buildPathArg);
+  let build22 = await import(url.pathToFileURL(buildPath).href);
+  let onListen = () => {
+    let address = process.env.HOST || Object.values(os.networkInterfaces()).flat().find((ip) => String(ip?.family).includes("4") && !ip?.internal)?.address;
+    if (!address) {
+      console.log(`[xyd-serve] http://localhost:${port2}`);
+    } else {
+      console.log(
+        `[xyd-serve] http://localhost:${port2} (http://${address}:${port2})`
+      );
+    }
+  };
+  build22 = {
+    ...build22,
+    assetsBuildDirectory: path33.join(process.cwd(), ".xyd/build/client")
+  };
+  let app = express();
+  app.disable("x-powered-by");
+  app.use(compression());
+  app.use(
+    path33.posix.join(build22.publicPath, "assets"),
+    express.static(path33.join(build22.assetsBuildDirectory, "assets"), {
+      immutable: true,
+      maxAge: "1y"
+    })
+  );
+  app.use(build22.publicPath, express.static(build22.assetsBuildDirectory));
+  app.use(express.static("public", { maxAge: "1h" }));
+  app.use(morgan("tiny"));
+  app.all(
+    "*",
+    createRequestHandler({
+      build: build22,
+      mode: process.env.NODE_ENV
+    })
+  );
+  let server = process.env.HOST ? app.listen(port2, process.env.HOST, onListen) : app.listen(port2, onListen);
+  ["SIGTERM", "SIGINT"].forEach((signal) => {
+    process.once(signal, () => server?.close(console.error));
+  });
+}
 
-is-extendable/index.js:
-  (*!
-   * is-extendable <https://github.com/jonschlinkert/is-extendable>
-   *
-   * Copyright (c) 2015, Jon Schlinkert.
-   * Licensed under the MIT License.
-   *)
+// src/commands.ts
+async function build2(root2, options2 = {}) {
+  await build();
+}
+async function start(root2, options2 = {}) {
+  await serve();
+  await new Promise(() => {
+  });
+}
+async function dev2(root2, options2 = {}) {
+  await dev();
+  await new Promise(() => {
+  });
+}
+
+// src/run.ts
+var helpText = `
+${import_picocolors.default.blueBright("xyd")}
+
+  ${import_picocolors.default.underline("Usage")}:
+    $ xyd build [${import_picocolors.default.yellowBright("projectDir")}]
+    $ xyd start [${import_picocolors.default.yellowBright("projectDir")}]
+    $ xyd dev [${import_picocolors.default.yellowBright("projectDir")}]
+
+  ${import_picocolors.default.underline("Options")}:
+    --help, -h          Print this help message and exit
+    --version, -v       Print the CLI version and exit
+
+  ${import_picocolors.default.underline("Build your project")}:
+
+    $ xyd build
+
+
+ ${import_picocolors.default.underline("Start your production server")}:
+ 
+    $ xyd start
+    
+  ${import_picocolors.default.underline("Run your project locally in development")}:
+
+    $ xyd dev
+`;
+async function run(argv = process.argv.slice(2)) {
+  process.env.XYD_CLI = "true";
+  let versions = process.versions;
+  let MINIMUM_NODE_VERSION = 20;
+  if (versions && versions.node && semver.major(versions.node) < MINIMUM_NODE_VERSION) {
+    console.warn(
+      `\uFE0F\u26A0\uFE0F Oops, Node v${versions.node} detected. xyd requires a Node version greater than ${MINIMUM_NODE_VERSION}.`
+    );
+  }
+  let args = arg(
+    {
+      "--help": Boolean,
+      "-h": "--help",
+      "--version": Boolean,
+      "-v": "--version",
+      "--port": Number,
+      "-p": "--port",
+      "--logLevel": String,
+      "-l": "--logLevel"
+    },
+    {
+      argv
+    }
+  );
+  let input = args._;
+  let flags = Object.entries(args).reduce((acc, [key, value]) => {
+    key = key.replace(/^--/, "");
+    acc[key] = value;
+    return acc;
+  }, {});
+  if (flags.help) {
+    console.log(helpText);
+    return;
+  }
+  if (flags.version) {
+    let version = require_package().version;
+    console.log(version);
+    return;
+  }
+  let command = input[0];
+  switch (command) {
+    case "build":
+      await build2(input[1], flags);
+      break;
+    case "start":
+      await start(input[1], flags);
+      break;
+    case "dev":
+      await dev2(input[1], flags);
+      break;
+    default:
+      await dev2(input[0], flags);
+  }
+}
+
+// index.ts
+run().then(
+  () => {
+    process.exit(0);
+  },
+  (error) => {
+    if (error) console.error(error);
+    process.exit(1);
+  }
+);
+/*! Bundled license information:
 
-strip-bom-string/index.js:
-  (*!
-   * strip-bom-string <https://github.com/jonschlinkert/strip-bom-string>
-   *
-   * Copyright (c) 2015, 2017, Jon Schlinkert.
-   * Released under the MIT License.
-   *)
+@xyd-js/plugin-zero/dist/index.js:
+  (*! Bundled license information:
+  
+  strip-bom-string/index.js:
+    (*!
+     * strip-bom-string <https://github.com/jonschlinkert/strip-bom-string>
+     *
+     * Copyright (c) 2015, 2017, Jon Schlinkert.
+     * Released under the MIT License.
+     *)
+  *)
 */
-//# sourceMappingURL=gray-matter.js.map