@constela/start 0.4.1 → 1.1.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CompiledProgram } from '@constela/compiler';
+import { CompiledProgram, CompiledNode } from '@constela/compiler';
 import { LayoutProgram, Program, StaticPathsDefinition, DataSource } from '@constela/core';
 
 /**
@@ -357,6 +357,47 @@ declare class LayoutResolver {
     getAll(): ScannedLayout[];
 }
 
+/**
+ * MDX to Constela AST Pipeline
+ *
+ * Transforms MDX content into CompiledProgram for Constela runtime.
+ * Uses unified/remark for parsing and gray-matter for frontmatter.
+ */
+
+/**
+ * Component definition for custom MDX components
+ */
+interface ComponentDef$1 {
+    params?: Record<string, {
+        type: string;
+        required?: boolean;
+    }>;
+    view: CompiledNode;
+}
+/**
+ * Options for MDX to Constela transformation
+ */
+interface MDXToConstelaOptions {
+    components?: Record<string, ComponentDef$1>;
+}
+/**
+ * Transform MDX source to CompiledProgram
+ *
+ * @param source - MDX source string
+ * @param options - Transformation options
+ * @returns CompiledProgram
+ */
+declare function mdxToConstela(source: string, options?: MDXToConstelaOptions): Promise<CompiledProgram>;
+/**
+ * Transform MDX content (without frontmatter) to CompiledNode
+ * For use when frontmatter has already been extracted
+ *
+ * @param content - MDX content string (frontmatter already removed)
+ * @param options - Transformation options
+ * @returns CompiledNode
+ */
+declare function mdxContentToNode$1(content: string, options?: MDXToConstelaOptions): Promise<CompiledNode>;
+
 /**
  * Data Loader for Build-time Content Loading
  *
@@ -374,17 +415,35 @@ interface GlobResult {
     frontmatter?: Record<string, unknown>;
     content?: string;
 }
+interface MdxGlobResult {
+    file: string;
+    raw: string;
+    frontmatter: Record<string, unknown>;
+    content: CompiledNode;
+    slug: string;
+}
+interface ComponentDef {
+    params?: Record<string, {
+        type: string;
+        required?: boolean;
+    }>;
+    view: CompiledNode;
+}
+declare const mdxContentToNode: typeof mdxContentToNode$1;
 interface StaticPath {
     params: Record<string, string>;
     data?: unknown;
 }
 /**
- * Transform MDX content - parse frontmatter and content
+ * Load component definitions from a JSON file
  */
-declare function transformMdx(content: string): {
-    frontmatter: Record<string, unknown>;
-    content: string;
-};
+declare function loadComponentDefinitions(baseDir: string, componentsPath: string): Record<string, ComponentDef>;
+/**
+ * Transform MDX content - parse frontmatter and compile content to CompiledNode
+ */
+declare function transformMdx(content: string, file: string, options?: {
+    components?: Record<string, ComponentDef>;
+}): Promise<MdxGlobResult>;
 /**
  * Transform YAML content
  */
@@ -396,7 +455,9 @@ declare function transformCsv(content: string): Record<string, string>[];
 /**
  * Load files matching a glob pattern
  */
-declare function loadGlob(baseDir: string, pattern: string, transform?: string): Promise<GlobResult[]>;
+declare function loadGlob(baseDir: string, pattern: string, transform?: string, options?: {
+    components?: Record<string, ComponentDef>;
+}): Promise<GlobResult[] | MdxGlobResult[]>;
 /**
  * Load a single file
  */
@@ -414,12 +475,19 @@ declare function generateStaticPaths(data: unknown[], staticPathsDef: StaticPath
  */
 declare class DataLoader {
     private cache;
+    private componentCache;
     private projectRoot;
     constructor(projectRoot: string);
+    /**
+     * Resolve components from string path or import reference
+     */
+    private resolveComponents;
     /**
      * Load a single data source
      */
-    loadDataSource(name: string, dataSource: DataSource): Promise<unknown>;
+    loadDataSource(name: string, dataSource: DataSource, context?: {
+        imports?: Record<string, unknown>;
+    }): Promise<unknown>;
     /**
      * Load all data sources
      */
@@ -438,4 +506,4 @@ declare class DataLoader {
     getCacheSize(): number;
 }
 
-export { type APIContext, type APIModule, type BuildOptions, type ConstelaConfig, DataLoader, type DevServerOptions, type GenerateStaticPagesOptions, type GlobResult, type LayoutInfo, LayoutResolver, type Middleware, type MiddlewareContext, type MiddlewareNext, type PageExportFunction, type PageModule, type ScannedLayout, type ScannedRoute, type StaticFileResult, type StaticPath, type StaticPathsProvider, type StaticPathsResult, build, createAPIHandler, createAdapter, createDevServer, createMiddlewareChain, filePathToPattern, generateStaticPages, generateStaticPaths, getMimeType, isPageExportFunction, isPathSafe, loadApi, loadFile, loadGlob, loadLayout, resolveLayout, resolvePageExport, resolveStaticFile, scanLayouts, scanRoutes, transformCsv, transformMdx, transformYaml };
+export { type APIContext, type APIModule, type BuildOptions, type ComponentDef$1 as ComponentDef, type ConstelaConfig, DataLoader, type DevServerOptions, type GenerateStaticPagesOptions, type GlobResult, type LayoutInfo, LayoutResolver, type MDXToConstelaOptions, type MdxGlobResult, type Middleware, type MiddlewareContext, type MiddlewareNext, type PageExportFunction, type PageModule, type ScannedLayout, type ScannedRoute, type StaticFileResult, type StaticPath, type StaticPathsProvider, type StaticPathsResult, build, createAPIHandler, createAdapter, createDevServer, createMiddlewareChain, filePathToPattern, generateStaticPages, generateStaticPaths, getMimeType, isPageExportFunction, isPathSafe, loadApi, loadComponentDefinitions, loadFile, loadGlob, loadLayout, mdxContentToNode, mdxToConstela, resolveLayout, resolvePageExport, resolveStaticFile, scanLayouts, scanRoutes, transformCsv, transformMdx, transformYaml };

package/dist/index.js

@@ -415,8 +415,408 @@ var LayoutResolver = class {
 
 // src/data/loader.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { basename as basename2, extname, join as join3 } from "path";
 import fg2 from "fast-glob";
+
+// src/build/mdx.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkMdx from "remark-mdx";
+import remarkGfm from "remark-gfm";
+import matter from "gray-matter";
+function lit(value) {
+  return { expr: "lit", value };
+}
+function textNode(value) {
+  return { kind: "text", value: lit(value) };
+}
+function elementNode(tag, props, children) {
+  const node = { kind: "element", tag };
+  if (props && Object.keys(props).length > 0) {
+    node.props = props;
+  }
+  if (children && children.length > 0) {
+    node.children = children;
+  }
+  return node;
+}
+function codeNode(language, content) {
+  return {
+    kind: "code",
+    language: lit(language),
+    content: lit(content)
+  };
+}
+function wrapNodes(nodes) {
+  if (nodes.length === 0) {
+    return elementNode("div");
+  }
+  if (nodes.length === 1 && nodes[0]) {
+    return nodes[0];
+  }
+  return elementNode("div", void 0, nodes);
+}
+function isCustomComponent(name) {
+  if (!name) return false;
+  return /^[A-Z]/.test(name);
+}
+var DISALLOWED_PATTERNS = [
+  /\bfunction\b/i,
+  /\b(eval|Function|setTimeout|setInterval)\b/,
+  /\bimport\b/,
+  /\brequire\b/,
+  /\bfetch\b/,
+  /\bwindow\b/,
+  /\bdocument\b/,
+  /\bglobal\b/,
+  /\bprocess\b/,
+  /\b__proto__\b/,
+  /\bconstructor\b/,
+  /\bprototype\b/
+];
+function isSafeLiteral(value) {
+  return !DISALLOWED_PATTERNS.some((pattern) => pattern.test(value));
+}
+function safeEvalLiteral(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+  }
+  if (!isSafeLiteral(value)) {
+    return null;
+  }
+  try {
+    const fn = new Function(`return (${value});`);
+    return fn();
+  } catch {
+    return null;
+  }
+}
+function parseAttributeValue(attr) {
+  if (attr.value === null) {
+    return lit(true);
+  }
+  if (typeof attr.value === "string") {
+    return lit(attr.value);
+  }
+  if (attr.value.type === "mdxJsxAttributeValueExpression") {
+    const exprValue = attr.value.value.trim();
+    if (exprValue === "true") return lit(true);
+    if (exprValue === "false") return lit(false);
+    if (exprValue === "null") return lit(null);
+    const num = Number(exprValue);
+    if (!Number.isNaN(num)) return lit(num);
+    if (exprValue.startsWith("[") || exprValue.startsWith("{")) {
+      const parsed = safeEvalLiteral(exprValue);
+      if (parsed !== null && parsed !== void 0) {
+        return lit(parsed);
+      }
+    }
+    return lit(exprValue);
+  }
+  return lit(null);
+}
+function transformNode(node, ctx) {
+  switch (node.type) {
+    case "heading":
+      return elementNode(
+        `h${node.depth}`,
+        void 0,
+        transformChildren(node.children, ctx)
+      );
+    case "paragraph":
+      return elementNode("p", void 0, transformChildren(node.children, ctx));
+    case "text":
+      return textNode(node.value);
+    case "emphasis":
+      return elementNode("em", void 0, transformChildren(node.children, ctx));
+    case "strong":
+      return elementNode("strong", void 0, transformChildren(node.children, ctx));
+    case "link": {
+      const props = {
+        href: lit(node.url)
+      };
+      if (node["title"]) {
+        props["title"] = lit(node["title"]);
+      }
+      return elementNode("a", props, transformChildren(node.children, ctx));
+    }
+    case "inlineCode":
+      return elementNode("code", void 0, [textNode(node.value)]);
+    case "code": {
+      const lang = node.lang || "text";
+      return codeNode(lang, node.value);
+    }
+    case "blockquote":
+      return elementNode("blockquote", void 0, transformChildren(node.children, ctx));
+    case "list": {
+      const tag = node.ordered ? "ol" : "ul";
+      return elementNode(tag, void 0, transformChildren(node.children, ctx));
+    }
+    case "listItem": {
+      const children = [];
+      for (const child of node.children) {
+        if (child.type === "paragraph") {
+          children.push(...transformChildren(child.children, ctx));
+        } else {
+          const transformed = transformNode(child, ctx);
+          if (transformed) {
+            if (Array.isArray(transformed)) {
+              children.push(...transformed);
+            } else {
+              children.push(transformed);
+            }
+          }
+        }
+      }
+      return elementNode("li", void 0, children);
+    }
+    case "thematicBreak":
+      return elementNode("hr");
+    case "break":
+      return elementNode("br");
+    case "image": {
+      const props = {
+        src: lit(node.url)
+      };
+      if (node["alt"]) {
+        props["alt"] = lit(node["alt"]);
+      }
+      if (node["title"]) {
+        props["title"] = lit(node["title"]);
+      }
+      return elementNode("img", props);
+    }
+    case "html":
+      return textNode(node.value);
+    // MDX JSX elements
+    case "mdxJsxFlowElement":
+    case "mdxJsxTextElement":
+      return transformJsxElement(node, ctx);
+    // MDX expressions
+    case "mdxFlowExpression":
+    case "mdxTextExpression": {
+      const exprNode = node;
+      const value = exprNode.value.trim();
+      if (value === "") return null;
+      if (value === "true") return textNode("true");
+      if (value === "false") return textNode("false");
+      if (value === "null") return textNode("null");
+      const num = Number(value);
+      if (!Number.isNaN(num)) return textNode(String(num));
+      return textNode(value);
+    }
+    // GFM extensions
+    case "table":
+      return elementNode("table", void 0, transformChildren(node.children, ctx));
+    case "tableRow":
+      return elementNode("tr", void 0, transformChildren(node.children, ctx));
+    case "tableCell":
+      return elementNode("td", void 0, transformChildren(node.children, ctx));
+    case "delete":
+      return elementNode("del", void 0, transformChildren(node.children, ctx));
+    default:
+      return null;
+  }
+}
+function transformJsxElement(node, ctx) {
+  const name = node.name;
+  if (!name) {
+    const children2 = transformChildren(node.children, ctx);
+    return wrapNodes(children2);
+  }
+  if (isCustomComponent(name)) {
+    const def = ctx.components[name];
+    if (!def) {
+      throw new Error(`Undefined component: ${name}`);
+    }
+    const props2 = {};
+    for (const attr of node.attributes) {
+      if (attr.type === "mdxJsxAttribute") {
+        props2[attr.name] = parseAttributeValue(attr);
+      }
+    }
+    const children2 = transformChildren(node.children, ctx);
+    return applyComponentView(def.view, props2, children2);
+  }
+  const props = {};
+  for (const attr of node.attributes) {
+    if (attr.type === "mdxJsxAttribute") {
+      props[attr.name] = parseAttributeValue(attr);
+    }
+  }
+  const children = transformChildren(node.children, ctx);
+  return elementNode(name, props, children);
+}
+function substituteExpression(expr, props) {
+  const exprAny = expr;
+  if (exprAny.expr === "param") {
+    const paramExpr = expr;
+    const propValue = props[paramExpr.name];
+    if (!propValue) {
+      return { expr: "lit", value: null };
+    }
+    if (paramExpr.path && propValue.expr === "var") {
+      const varExpr = propValue;
+      return {
+        expr: "var",
+        name: varExpr.name,
+        path: paramExpr.path
+      };
+    }
+    return propValue;
+  }
+  if (expr.expr === "bin") {
+    const binExpr = expr;
+    return {
+      expr: "bin",
+      op: binExpr.op,
+      left: substituteExpression(binExpr.left, props),
+      right: substituteExpression(binExpr.right, props)
+    };
+  }
+  if (expr.expr === "not") {
+    const notExpr = expr;
+    return {
+      expr: "not",
+      operand: substituteExpression(notExpr.operand, props)
+    };
+  }
+  if (expr.expr === "cond") {
+    const condExpr = expr;
+    return {
+      expr: "cond",
+      if: substituteExpression(condExpr.if, props),
+      then: substituteExpression(condExpr.then, props),
+      else: substituteExpression(condExpr.else, props)
+    };
+  }
+  if (expr.expr === "get") {
+    const getExpr = expr;
+    return {
+      expr: "get",
+      base: substituteExpression(getExpr.base, props),
+      path: getExpr.path
+    };
+  }
+  return expr;
+}
+function applyComponentView(view, props, children) {
+  return substituteInNode(view, props, children);
+}
+function substituteInNode(node, props, children) {
+  switch (node.kind) {
+    case "each": {
+      const eachNode = node;
+      const result = {
+        kind: "each",
+        items: substituteExpression(eachNode.items, props),
+        as: eachNode.as,
+        body: substituteInNode(eachNode.body, props, children)
+      };
+      if (eachNode.index) {
+        result.index = eachNode.index;
+      }
+      if (eachNode.key) {
+        result.key = substituteExpression(eachNode.key, props);
+      }
+      return result;
+    }
+    case "text": {
+      const textNode2 = node;
+      return {
+        kind: "text",
+        value: substituteExpression(textNode2.value, props)
+      };
+    }
+    case "if": {
+      const ifNode = node;
+      const result = {
+        kind: "if",
+        condition: substituteExpression(ifNode.condition, props),
+        then: substituteInNode(ifNode.then, props, children)
+      };
+      if (ifNode.else) {
+        result.else = substituteInNode(ifNode.else, props, children);
+      }
+      return result;
+    }
+    case "element": {
+      const elem = node;
+      const newProps = {};
+      if (elem.props) {
+        for (const [key, value] of Object.entries(elem.props)) {
+          newProps[key] = substituteExpression(value, props);
+        }
+      }
+      let newChildren;
+      if (elem.children) {
+        newChildren = [];
+        for (const child of elem.children) {
+          if (child.kind === "slot") {
+            newChildren.push(...children);
+          } else {
+            newChildren.push(substituteInNode(child, props, children));
+          }
+        }
+      }
+      return elementNode(
+        elem.tag,
+        Object.keys(newProps).length > 0 ? newProps : void 0,
+        newChildren && newChildren.length > 0 ? newChildren : void 0
+      );
+    }
+    case "markdown":
+    case "code":
+      return node;
+    default:
+      return node;
+  }
+}
+function transformChildren(children, ctx) {
+  const result = [];
+  for (const child of children) {
+    const transformed = transformNode(child, ctx);
+    if (transformed) {
+      if (Array.isArray(transformed)) {
+        result.push(...transformed);
+      } else {
+        result.push(transformed);
+      }
+    }
+  }
+  return result;
+}
+function transformRoot(root, ctx) {
+  const nodes = transformChildren(root.children, ctx);
+  return wrapNodes(nodes);
+}
+async function mdxToConstela(source, options) {
+  const { content, data: _frontmatter } = matter(source);
+  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
+  const tree = processor.parse(content);
+  const ctx = {
+    components: options?.components ?? {}
+  };
+  const view = transformRoot(tree, ctx);
+  return {
+    version: "1.0",
+    state: {},
+    actions: {},
+    view
+  };
+}
+async function mdxContentToNode(content, options) {
+  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
+  const tree = processor.parse(content);
+  const ctx = {
+    components: options?.components ?? {}
+  };
+  return transformRoot(tree, ctx);
+}
+
+// src/data/loader.ts
+var mdxContentToNode2 = mdxContentToNode;
 function parseYaml(content) {
   const result = {};
   const lines = content.split("\n");
@@ -494,13 +894,46 @@ function parseValue(value) {
   }
   return trimmed;
 }
-function transformMdx(content) {
+function loadComponentDefinitions(baseDir, componentsPath) {
+  const fullPath = join3(baseDir, componentsPath);
+  const resolvedBase = join3(baseDir, "");
+  const resolvedPath = join3(fullPath, "");
+  if (!resolvedPath.startsWith(resolvedBase)) {
+    throw new Error(`Invalid component path: path traversal detected`);
+  }
+  if (!existsSync2(fullPath)) {
+    throw new Error(`MDX components file not found: ${fullPath}`);
+  }
+  const content = readFileSync(fullPath, "utf-8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in MDX components file: ${fullPath}`);
+  }
+}
+async function transformMdx(content, file, options) {
   const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) {
-    return { frontmatter: {}, content: content.trim() };
+  let frontmatter = {};
+  let mdxContent;
+  if (match) {
+    frontmatter = parseYaml(match[1]);
+    mdxContent = match[2].trim();
+  } else {
+    mdxContent = content.trim();
   }
-  const frontmatter = parseYaml(match[1]);
-  return { frontmatter, content: match[2].trim() };
+  const compiledContent = await mdxContentToNode(
+    mdxContent,
+    options?.components ? { components: options.components } : void 0
+  );
+  const fmSlug = frontmatter["slug"];
+  const slug = typeof fmSlug === "string" ? fmSlug : basename2(file, extname(file));
+  return {
+    file,
+    raw: content,
+    frontmatter,
+    content: compiledContent,
+    slug
+  };
 }
 function transformYaml(content) {
   return parseYaml(content);
@@ -550,7 +983,7 @@ function applyTransform(content, transform, filename) {
   }
   switch (transform) {
     case "mdx":
-      return transformMdx(content);
+      throw new Error("MDX transform for single files is not supported via loadFile. Use loadGlob instead.");
     case "yaml":
       return transformYaml(content);
     case "csv":
@@ -559,26 +992,26 @@ function applyTransform(content, transform, filename) {
       return content;
   }
 }
-async function loadGlob(baseDir, pattern, transform) {
+async function loadGlob(baseDir, pattern, transform, options) {
   const files = await fg2(pattern, { cwd: baseDir });
+  if (transform === "mdx") {
+    const results2 = [];
+    for (const file of files) {
+      const fullPath = join3(baseDir, file);
+      const content = readFileSync(fullPath, "utf-8");
+      const transformed = await transformMdx(content, file, options);
+      results2.push(transformed);
+    }
+    return results2;
+  }
   const results = [];
   for (const file of files) {
     const fullPath = join3(baseDir, file);
     const content = readFileSync(fullPath, "utf-8");
-    if (transform === "mdx") {
-      const transformed = transformMdx(content);
-      results.push({
-        file,
-        raw: content,
-        frontmatter: transformed.frontmatter,
-        content: transformed.content
-      });
-    } else {
-      results.push({
-        file,
-        raw: content
-      });
-    }
+    results.push({
+      file,
+      raw: content
+    });
   }
   return results;
 }
@@ -652,24 +1085,61 @@ async function generateStaticPaths(data, staticPathsDef) {
 }
 var DataLoader = class {
   cache = /* @__PURE__ */ new Map();
+  componentCache = /* @__PURE__ */ new Map();
   projectRoot;
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
   }
+  /**
+   * Resolve components from string path or import reference
+   */
+  resolveComponents(ref, imports) {
+    if (typeof ref === "string") {
+      if (this.componentCache.has(ref)) {
+        return this.componentCache.get(ref);
+      }
+      const defs = loadComponentDefinitions(this.projectRoot, ref);
+      this.componentCache.set(ref, defs);
+      return defs;
+    }
+    if (ref.expr === "import") {
+      if (!imports) {
+        throw new Error(`Import context required for component reference "${ref.name}"`);
+      }
+      const imported = imports[ref.name];
+      if (!imported || typeof imported !== "object") {
+        throw new Error(`Component import "${ref.name}" not found or invalid`);
+      }
+      return imported;
+    }
+    return {};
+  }
   /**
    * Load a single data source
    */
-  async loadDataSource(name, dataSource) {
+  async loadDataSource(name, dataSource, context) {
     if (this.cache.has(name)) {
       return this.cache.get(name);
     }
+    let componentDefs;
+    if (dataSource.transform === "mdx" && dataSource.components) {
+      componentDefs = this.resolveComponents(
+        dataSource.components,
+        context?.imports
+      );
+    }
     let data;
     switch (dataSource.type) {
       case "glob":
         if (!dataSource.pattern) {
           throw new Error(`Glob data source '${name}' requires pattern`);
         }
-        data = await loadGlob(this.projectRoot, dataSource.pattern, dataSource.transform);
+        data = await loadGlob(
+          this.projectRoot,
+          dataSource.pattern,
+          dataSource.transform,
+          componentDefs ? { components: componentDefs } : void 0
+        );
         break;
       case "file":
         if (!dataSource.path) {
@@ -737,9 +1207,12 @@ export {
   isPageExportFunction,
   isPathSafe,
   loadApi,
+  loadComponentDefinitions,
   loadFile,
   loadGlob,
   loadLayout,
+  mdxContentToNode2 as mdxContentToNode,
+  mdxToConstela,
   resolveLayout,
   resolvePageExport,
   resolveStaticFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/start",
-  "version": "0.4.1",
+  "version": "1.1.0",
   "description": "Meta-framework for Constela applications",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,24 +30,25 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "hono": "^4.0.0",
-    "vite": "^6.0.0",
     "commander": "^12.0.0",
     "fast-glob": "^3.3.0",
-    "unified": "^11.0.0",
-    "remark-parse": "^11.0.0",
-    "remark-mdx": "^3.0.0",
-    "remark-gfm": "^4.0.0",
     "gray-matter": "^4.0.0",
-    "@constela/core": "0.6.0",
-    "@constela/router": "6.0.0",
-    "@constela/server": "2.0.0",
-    "@constela/runtime": "0.9.0",
-    "@constela/compiler": "0.6.0"
+    "hono": "^4.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-mdx": "^3.0.0",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.0",
+    "vite": "^6.0.0",
+    "@constela/compiler": "0.7.0",
+    "@constela/server": "3.0.0",
+    "@constela/runtime": "0.9.2",
+    "@constela/router": "7.0.0",
+    "@constela/core": "0.7.0"
   },
   "devDependencies": {
-    "typescript": "^5.3.0",
+    "@types/mdast": "^4.0.4",
     "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
     "vitest": "^2.0.0"
   },
   "license": "MIT",