@kubb/renderer-jsx 5.10.1 → 5.10.3

package/dist/index.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./rolldown-runtime-ClG-MNz_.cjs");
 const require_jsx_runtime = require("./jsx-runtime.cjs");
 let yaml = require("yaml");
 let _kubb_ast = require("@kubb/ast");

package/dist/index.d.cts

@@ -0,0 +1,487 @@
+import { i as KubbReactNode, n as Key, r as KubbReactElement, t as JSDoc } from "./types-BQObETlT.cjs";
+import { ast } from "@kubb/ast";
+//#region src/components/md/Callout.d.ts
+declare const CALLOUT_LABEL: {
+  readonly tip: "TIP";
+  readonly note: "NOTE";
+  readonly important: "IMPORTANT";
+  readonly warning: "WARNING";
+  readonly caution: "CAUTION";
+};
+type CalloutType = keyof typeof CALLOUT_LABEL;
+type Props$7 = {
+  key?: Key;
+  /**
+   * Callout kind. Maps to the uppercase label inside the `> [!TYPE]` marker.
+   */
+  type: CalloutType;
+  /**
+   * Optional title rendered on the same line as the marker.
+   */
+  title?: string | null;
+  /**
+   * Body text. Each line is quoted with `> ` so multi-line content stays
+   * inside the callout block.
+   */
+  children: string;
+};
+/**
+ * Renders a GitHub-style alert callout using the `> [!TYPE]` blockquote syntax.
+ *
+ * Emits a `<File.Source>` block containing `> [!TYPE] Title` followed by the
+ * body with every line prefixed by `> `.
+ *
+ * @example
+ * ```tsx
+ * <Callout type="tip">Run `kubb start --watch` to keep the generator hot.</Callout>
+ * // > [!TIP]
+ * // > Run `kubb start --watch` to keep the generator hot.
+ *
+ * <Callout type="warning" title="Heads up">Breaking change in v6.</Callout>
+ * // > [!WARNING] Heads up
+ * // > Breaking change in v6.
+ * ```
+ */
+export declare function Callout({ type, title, children }: Props$7): KubbReactElement;
+//#endregion
+//#region src/components/js/Const.d.ts
+type ConstProps = Omit<ast.ConstNode, 'kind' | 'nodes'> & {
+  key?: Key;
+  /**
+   * Child nodes rendered as the initializer expression of the constant.
+   */
+  children?: KubbReactNode;
+};
+/**
+ * Generates a TypeScript constant declaration.
+ *
+ * @example Named export with type annotation
+ * ```tsx
+ * <Const export name="petSchema" type="z.ZodType<Pet>">
+ *   {`z.object({ id: z.number() })`}
+ * </Const>
+ * // export const petSchema: z.ZodType<Pet> = z.object({ id: z.number() })
+ * ```
+ *
+ * @example With JSDoc and const assertion
+ * ```tsx
+ * <Const name="HTTP_METHODS" asConst JSDoc={{ comments: ['@description Supported HTTP methods.'] }}>
+ *   {`['GET', 'POST', 'PUT', 'DELETE']`}
+ * </Const>
+ * ```
+ */
+export declare function Const({ children, ...props }: ConstProps): KubbReactElement;
+//#endregion
+//#region src/components/File.d.ts
+type BasePropsWithBaseName = {
+  /**
+   * Base file name including extension, derived from the input path.
+   * Based on UNIX basename convention: `${name}${extname}`.
+   *
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   *
+   * @example
+   * `baseName: 'petStore.ts'`
+   */
+  baseName: `${string}.${string}`;
+  /**
+   * Fully qualified path to the generated file.
+   *
+   * @example
+   * `path: 'src/models/petStore.ts'`
+   */
+  path: string;
+};
+type BasePropsWithoutBaseName = {
+  baseName?: never;
+  /**
+   * Fully qualified path to the generated file.
+   * Optional when `baseName` is omitted, the component renders its children inline.
+   */
+  path?: string | null;
+};
+type BaseProps = BasePropsWithBaseName | BasePropsWithoutBaseName;
+type Props$6<TMeta> = BaseProps & {
+  key?: Key;
+  /**
+   * Arbitrary metadata attached to the file node for plugins to read.
+   */
+  meta?: TMeta | null;
+  /**
+   * Text prepended to the generated file content before any source blocks.
+   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
+   */
+  banner?: string | null;
+  /**
+   * Text appended to the generated file content after all source blocks.
+   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
+   */
+  footer?: string | null;
+  /**
+   * Absolute on-disk path to copy into the output, through the parser's `copy` hook when it has
+   * one. Use to emit a real source file shipped inside a package (a template) into the generated
+   * folder. Child source blocks are ignored for output but still drive barrel generation.
+   */
+  copy?: string | null;
+  /**
+   * Child nodes rendered as the content of this file (source blocks, imports, exports).
+   */
+  children?: KubbReactNode;
+};
+/**
+ * Declares a generated file entry to be collected by the renderer.
+ *
+ * When both `baseName` and `path` are provided, the component registers a new
+ * `FileNode` and passes its children through as source blocks.
+ * When either is omitted the children are rendered inline without creating a file entry.
+ *
+ * @example Basic file with a source block
+ * ```tsx
+ * <File baseName="petStore.ts" path="src/models/petStore.ts">
+ *   <File.Source name="Pet" isExportable isIndexable>
+ *     {`export type Pet = { id: number; name: string }`}
+ *   </File.Source>
+ * </File>
+ * ```
+ */
+export declare function File<TMeta extends object = object>({ children, ...props }: Props$6<TMeta>): KubbReactElement;
+export declare namespace File {
+  var Export: typeof FileExport;
+  var Import: typeof FileImport;
+  var Source: typeof FileSource;
+}
+type FileSourceProps = Omit<ast.SourceNode, 'kind' | 'value'> & {
+  key?: Key;
+  /**
+   * Child nodes rendered as the source content of this block.
+   */
+  children?: KubbReactNode;
+};
+/**
+ * Marks a block of source text to be associated with the enclosing {@link File}.
+ *
+ * Children are treated as the source string. `isExportable` prepends the `export` keyword,
+ * `isIndexable` includes the source in barrel/index generation, and `name` keys deduplication.
+ *
+ * @example Exportable, indexable source block
+ * ```tsx
+ * <File.Source name="Pet" isExportable isIndexable>
+ *   {`export type Pet = { id: number; name: string }`}
+ * </File.Source>
+ * ```
+ *
+ * @example Type-only source block
+ * ```tsx
+ * <File.Source name="PetId" isTypeOnly isExportable>
+ *   {`export type PetId = string`}
+ * </File.Source>
+ * ```
+ */
+declare function FileSource({ children, ...props }: FileSourceProps): KubbReactElement;
+type FileExportProps = Omit<ast.ExportNode, 'kind'> & {
+  key?: Key;
+};
+/**
+ * Declares an export entry for the enclosing {@link File}.
+ *
+ * The export is collected by the renderer and emitted at the top of the generated file.
+ *
+ * @example Named export
+ * ```tsx
+ * <File.Export name={['Pet']} path="./models/petStore" />
+ * // export { Pet } from './models/petStore'
+ * ```
+ *
+ * @example Type-only wildcard export
+ * ```tsx
+ * <File.Export path="./models/petStore" isTypeOnly />
+ * // export type * from './models/petStore'
+ * ```
+ */
+declare function FileExport(props: FileExportProps): KubbReactElement;
+type FileImportProps = Omit<ast.ImportNode, 'kind'> & {
+  key?: Key;
+};
+/**
+ * Declares an import entry for the enclosing {@link File}.
+ *
+ * The import is collected by the renderer and emitted at the top of the generated file.
+ *
+ * @example Named import
+ * ```tsx
+ * <File.Import name={['useState']} path="react" />
+ * // import { useState } from 'react'
+ * ```
+ *
+ * @example Type-only import
+ * ```tsx
+ * <File.Import name={['Pet']} path="./models" isTypeOnly />
+ * // import type { Pet } from './models'
+ * ```
+ *
+ * @example Namespace import
+ * ```tsx
+ * <File.Import name="z" path="zod" isNameSpace />
+ * // import * as z from 'zod'
+ * ```
+ */
+declare function FileImport(props: FileImportProps): KubbReactElement;
+//#endregion
+//#region src/components/md/Frontmatter.d.ts
+type Props$5 = {
+  key?: Key;
+  /**
+   * Plain object serialized as YAML between `---` fences.
+   *
+   * @example
+   * `{ title: 'Pets', layout: 'doc' }`
+   */
+  data: Record<string, unknown>;
+};
+/**
+ * Emits a YAML frontmatter envelope at the top of a generated markdown file.
+ *
+ * Renders a `<File.Source>` block containing `---\n<yaml>\n---`. Place it as
+ * the first child of `<File>` so it appears at the top of the output. Pair with
+ * `parserMd` to write `.md` files whose frontmatter downstream tooling can read.
+ *
+ * @example Page frontmatter at the top of a generated markdown file
+ * ```tsx
+ * <File baseName="pets.md" path="src/pets.md">
+ *   <Frontmatter data={{ title: 'Pets', layout: 'doc' }} />
+ *   <File.Source>
+ *     {'# Pets\n\nList of pets.'}
+ *   </File.Source>
+ * </File>
+ * ```
+ */
+export declare function Frontmatter({ data }: Props$5): KubbReactElement;
+//#endregion
+//#region src/components/js/Function.d.ts
+type Props$4 = Omit<ast.FunctionNode, 'kind' | 'nodes'> & {
+  key?: Key;
+  /**
+   * Child nodes rendered as the body of the function.
+   */
+  children?: KubbReactNode;
+};
+/**
+ * Generates a TypeScript function declaration.
+ *
+ * @example Async exported function with generics
+ * ```tsx
+ * <Function export async name="getPet" generics={['TData = Pet']} params="petId: string" returnType="TData">
+ *   {`return client.get(\`/pets/\${petId}\`)`}
+ * </Function>
+ * // export async function getPet<TData = Pet>(petId: string): Promise<TData> {
+ * //   return client.get(`/pets/${petId}`)
+ * // }
+ * ```
+ */
+export declare function Function({ children, ...props }: Props$4): KubbReactElement;
+export declare namespace Function {
+  var Arrow: typeof ArrowFunction;
+}
+type ArrowFunctionProps = Omit<ast.ArrowFunctionNode, 'kind' | 'nodes'> & {
+  key?: Key;
+  /**
+   * Child nodes rendered as the body of the function.
+   */
+  children?: KubbReactNode;
+};
+/**
+ * Generates an arrow function expression assigned to a `const`.
+ * Supports the same flags as {@link Function}.
+ * Use `singleLine` to render the body as a concise expression rather than a block.
+ *
+ * @example Single-line arrow function
+ * ```tsx
+ * <Function.Arrow export name="double" params="n: number" returnType="number" singleLine>
+ *   {`n * 2`}
+ * </Function.Arrow>
+ * // export const double = (n: number): number => n * 2
+ * ```
+ */
+declare function ArrowFunction({ children, ...props }: ArrowFunctionProps): KubbReactElement;
+//#endregion
+//#region src/components/md/Heading.d.ts
+type Level = 1 | 2 | 3 | 4 | 5 | 6;
+type Props$3 = {
+  key?: Key;
+  /**
+   * Heading depth, `1` through `6`. Matches the number of `#` characters
+   * prefixed to the heading text.
+   */
+  level: Level;
+  /**
+   * Heading text. Inline markdown (links, emphasis) is passed through verbatim.
+   */
+  children: string;
+};
+/**
+ * Renders an ATX-style markdown heading.
+ *
+ * Emits a `<File.Source>` block containing `${'#'.repeat(level)} ${children}`.
+ * Use inside a `<File>` rendered by `parserMd`.
+ *
+ * @example
+ * ```tsx
+ * <Heading level={2}>Installation</Heading>
+ * // ## Installation
+ * ```
+ */
+export declare function Heading({ level, children }: Props$3): KubbReactElement;
+//#endregion
+//#region src/components/jsx/Jsx.d.ts
+type Props$2 = {
+  key?: Key;
+  /**
+   * Raw JSX string embedded verbatim in the generated code, including
+   * fragments (`<>…</>`).
+   *
+   * @example
+   * ```tsx
+   * <Jsx>{'<>\n  <a href={href}>Open</a>\n</>'}</Jsx>
+   * ```
+   */
+  children?: string;
+};
+/**
+ * Embeds a raw JSX string verbatim in the generated source code.
+ *
+ * Use this component to include JSX markup (including fragments `<>…</>`) in the
+ * body of a generated function or component. The `children` prop must be a plain
+ * string. Write expression attributes that reference runtime values as template
+ * literals.
+ *
+ * @example
+ * ```tsx
+ * <Function name="MyComponent" export>
+ *   <Jsx>{'return (\n  <>\n    <div>Hello</div>\n  </>\n)'}</Jsx>
+ * </Function>
+ * ```
+ */
+export declare function Jsx({ children }: Props$2): KubbReactElement;
+//#endregion
+//#region src/components/md/List.d.ts
+type Props$1 = {
+  key?: Key;
+  /**
+   * When `true`, emits a numbered list (`1. …`). When `false` or omitted,
+   * emits a bullet list (`- …`).
+   *
+   * @default false
+   */
+  ordered?: boolean | null;
+  /**
+   * One entry per line. Inline markdown is passed through verbatim.
+   */
+  items: ReadonlyArray<string>;
+};
+/**
+ * Renders a markdown list.
+ *
+ * Emits a `<File.Source>` block containing one entry per line, prefixed with
+ * `1.` / `2.` … when `ordered`, or `-` otherwise.
+ *
+ * @example
+ * ```tsx
+ * <List items={['Add the parser', 'Render the page']} />
+ * // - Add the parser
+ * // - Render the page
+ *
+ * <List ordered items={['First', 'Second']} />
+ * // 1. First
+ * // 2. Second
+ * ```
+ */
+export declare function List({ ordered, items }: Props$1): KubbReactElement;
+//#endregion
+//#region src/components/md/Paragraph.d.ts
+type Props = {
+  key?: Key;
+  /**
+   * Paragraph text. Inline markdown (links, emphasis, code spans) is passed
+   * through verbatim.
+   */
+  children: string;
+};
+/**
+ * Renders a markdown paragraph.
+ *
+ * Emits a `<File.Source>` block containing the text as-is. Paragraphs are
+ * separated from surrounding blocks by blank lines via the parser's source
+ * joining.
+ *
+ * @example
+ * ```tsx
+ * <Paragraph>{'A pet object with `id` and `name` fields.'}</Paragraph>
+ * ```
+ */
+export declare function Paragraph({ children }: Props): KubbReactElement;
+//#endregion
+//#region src/components/js/Type.d.ts
+type TypeProps = Omit<ast.TypeNode, 'kind' | 'nodes'> & {
+  key?: Key;
+  /**
+   * Child nodes rendered as the type expression on the right-hand side of the alias.
+   */
+  children?: KubbReactNode;
+};
+/**
+ * Generates a TypeScript type alias declaration.
+ *
+ * Throws if `name` does not start with an uppercase letter. TypeScript type aliases
+ * should follow PascalCase naming conventions.
+ *
+ * @example Simple exported type alias
+ * ```tsx
+ * <Type export name="PetId">
+ *   {`string | number`}
+ * </Type>
+ * // export type PetId = string | number
+ * ```
+ *
+ * @example Type alias with JSDoc
+ * ```tsx
+ * <Type export name="Pet" JSDoc={{ comments: ['@description A pet in the store.'] }}>
+ *   {`{ id: number; name: string }`}
+ * </Type>
+ * ```
+ */
+export declare function Type({ children, ...props }: TypeProps): KubbReactElement;
+//#endregion
+//#region src/jsxRenderer.d.ts
+/**
+ * Factory for a renderer that walks the JSX tree in a single recursive pass,
+ * with no React reconciler or scheduler. Pass it as the `renderer` property on
+ * `defineGenerator`. Kubb core calls the factory once per render cycle and stays
+ * generic, with no hard dependency on `@kubb/renderer-jsx`. Every component must be a pure
+ * function. Hooks, suspense and class components are not supported.
+ *
+ * @example Wire up a JSX generator
+ * ```tsx
+ * import { defineGenerator } from '@kubb/core'
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ *
+ * export const myGenerator = defineGenerator<PluginTs>({
+ *   name: 'types',
+ *   renderer: jsxRenderer,
+ *   schema(node, ctx) {
+ *     return (
+ *       <File baseName="output.ts" path={`${ctx.root}/output.ts`}>
+ *         <Type node={node} resolver={ctx.resolver} />
+ *       </File>
+ *     )
+ *   },
+ * })
+ * ```
+ */
+export declare const jsxRenderer: () => {
+  render(element: KubbReactElement): Promise<void>;
+  readonly files: ast.FileNode[];
+  [Symbol.dispose](): void;
+};
+//#endregion
+export type { JSDoc, Key, KubbReactElement, KubbReactNode };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { i as KubbReactNode, n as Key, r as KubbReactElement, t as JSDoc } from "./types-CVtBr_H8.js";
+import { i as KubbReactNode, n as Key, r as KubbReactElement, t as JSDoc } from "./types-BQObETlT.js";
 import { ast } from "@kubb/ast";
 //#region src/components/md/Callout.d.ts
 declare const CALLOUT_LABEL: {

package/dist/jsx-dev-runtime.d.cts

@@ -0,0 +1,2 @@
+import { Fragment, JSX, jsxDEV } from "./jsx-runtime.cjs";
+export { Fragment, type JSX, jsxDEV };

package/dist/jsx-runtime.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./rolldown-runtime-ClG-MNz_.cjs");
 //#region src/jsx-runtime.ts
 const KUBB_ELEMENT = Symbol.for("kubb.element");
 /**

package/dist/jsx-runtime.d.cts

@@ -0,0 +1,81 @@
+import { i as KubbReactNode, n as Key, r as KubbReactElement } from "./types-BQObETlT.cjs";
+import { ast } from "@kubb/ast";
+//#region src/jsx-namespace.d.ts
+/**
+ * JSX contract for `@kubb/renderer-jsx`, resolved through `jsxImportSource`.
+ *
+ * It is self-contained and does not extend `React.JSX`. The renderer only emits
+ * the custom `kubb-*` hosts plus `br`, and supports pure function components, so
+ * the HTML element and class-component machinery from `@types/react` is not needed.
+ */
+declare namespace JSX {
+  type ElementType = string | ((props: never) => KubbReactNode);
+  type Element = KubbReactElement;
+  interface ElementChildrenAttribute {
+    children: {};
+  }
+  interface IntrinsicAttributes {
+    key?: Key | null;
+  }
+  interface IntrinsicElements {
+    ['kubb-jsx']: {
+      children?: string;
+    };
+    ['kubb-file']: {
+      id?: string | null;
+      children?: KubbReactNode;
+      baseName: ast.FileNode['baseName'];
+      path: string;
+      banner?: string | null;
+      footer?: string | null;
+      /**
+       * Absolute on-disk path to copy into the output, through the parser's `copy` hook when it has
+       * one. Use to emit a real source file shipped inside a package (a template) into the generated folder.
+       */
+      copy?: string | null;
+      meta?: ast.FileNode['meta'] | null;
+    };
+    ['kubb-source']: Omit<ast.SourceNode, 'kind'> & {
+      children?: KubbReactNode;
+    };
+    ['kubb-import']: Omit<ast.ImportNode, 'kind'> & {};
+    ['kubb-export']: Omit<ast.ExportNode, 'kind'> & {};
+    ['kubb-function']: Omit<ast.FunctionNode, 'kind'> & {
+      children?: KubbReactNode;
+    };
+    ['kubb-arrow-function']: Omit<ast.ArrowFunctionNode, 'kind'> & {
+      children?: KubbReactNode;
+    };
+    ['kubb-const']: Omit<ast.ConstNode, 'kind'> & {
+      children?: KubbReactNode;
+    };
+    ['kubb-type']: Omit<ast.TypeNode, 'kind'> & {
+      children?: KubbReactNode;
+    };
+    br: {};
+  }
+}
+//#endregion
+//#region src/jsx-runtime.d.ts
+/**
+ * Fragment marker. A `<>…</>` compiles to `jsx(Fragment, …)`, and the renderer
+ * unwraps it while walking the tree.
+ */
+export declare const Fragment: unique symbol;
+/**
+ * Create a Kubb JSX element. The automatic JSX runtime calls this for every tag,
+ * so the renderer never depends on React at runtime. The `type` is a host
+ * string, a function component, or `Fragment`, and children are folded into
+ * `props`.
+ */
+declare function createElement(type: unknown, props: Record<string, unknown> | null, key?: Key | null): KubbReactElement;
+/**
+ * Returns `true` when `value` is an element this runtime created.
+ */
+export declare function isKubbElement(value: unknown): value is KubbReactElement;
+export declare const jsx: typeof createElement;
+export declare const jsxs: typeof createElement;
+export declare const jsxDEV: typeof createElement;
+//#endregion
+export type { JSX };
+//# sourceMappingURL=jsx-runtime.d.cts.map

package/dist/jsx-runtime.d.ts

@@ -1,5 +1,4 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { i as KubbReactNode, n as Key, r as KubbReactElement } from "./types-CVtBr_H8.js";
+import { i as KubbReactNode, n as Key, r as KubbReactElement } from "./types-BQObETlT.js";
 import { ast } from "@kubb/ast";
 //#region src/jsx-namespace.d.ts
 /**

package/dist/{types-CVtBr_H8.d.ts → types-BQObETlT.d.cts}

@@ -1,4 +1,3 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { ast } from "@kubb/ast";
 //#region src/types.d.ts
 /**
@@ -35,4 +34,4 @@ type KubbReactNode = KubbReactElement | string | number | bigint | boolean | nul
 type JSDoc = ast.JSDocNode;
 //#endregion
 export { KubbReactNode as i, Key as n, KubbReactElement as r, JSDoc as t };
-//# sourceMappingURL=types-CVtBr_H8.d.ts.map
+//# sourceMappingURL=types-BQObETlT.d.cts.map

package/dist/types-BQObETlT.d.ts

@@ -0,0 +1,37 @@
+import { ast } from "@kubb/ast";
+//#region src/types.d.ts
+/**
+ * Unique key for a Kubb JSX element in lists or conditional renders.
+ */
+type Key = string | number | bigint;
+/**
+ * Element produced by a Kubb JSX component. The renderer walks these at runtime,
+ * so the fields stay opaque to type-checking.
+ */
+type KubbReactElement = {
+  /**
+   * Brand set by the JSX runtime, so the renderer only walks elements it created.
+   */
+  $$typeof: symbol;
+  type: unknown;
+  props: unknown;
+  key: Key | null;
+};
+/**
+ * Anything a Kubb JSX component accepts as children: an element, a primitive
+ * rendered as text, a nullish value that is skipped, or an array of nodes.
+ */
+type KubbReactNode = KubbReactElement | string | number | bigint | boolean | null | undefined | ReadonlyArray<KubbReactNode>;
+/**
+ * JSDoc comment block to attach to a generated declaration.
+ * Each string in `comments` becomes one line inside the `/** … *\/` block.
+ *
+ * @example
+ * ```ts
+ * { comments: ['@description A pet object.', '@deprecated Use PetV2 instead.'] }
+ * ```
+ */
+type JSDoc = ast.JSDocNode;
+//#endregion
+export { KubbReactNode as i, Key as n, KubbReactElement as r, JSDoc as t };
+//# sourceMappingURL=types-BQObETlT.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/renderer-jsx",
-  "version": "5.10.1",
+  "version": "5.10.3",
   "description": "Self-contained synchronous JSX renderer for Kubb. Turns JSX into FileNodes with built-in components (File, Function, Type, Const). An alternative for the ast.factory syntax.",
   "keywords": [
     "codegen",
@@ -58,19 +58,34 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./jsx-dev-runtime": {
-      "types": "./dist/jsx-dev-runtime.d.ts",
-      "import": "./dist/jsx-dev-runtime.js",
-      "require": "./dist/jsx-dev-runtime.cjs"
+      "import": {
+        "types": "./dist/jsx-dev-runtime.d.ts",
+        "default": "./dist/jsx-dev-runtime.js"
+      },
+      "require": {
+        "types": "./dist/jsx-dev-runtime.d.cts",
+        "default": "./dist/jsx-dev-runtime.cjs"
+      }
     },
     "./jsx-runtime": {
-      "types": "./dist/jsx-runtime.d.ts",
-      "import": "./dist/jsx-runtime.js",
-      "require": "./dist/jsx-runtime.cjs"
+      "import": {
+        "types": "./dist/jsx-runtime.d.ts",
+        "default": "./dist/jsx-runtime.js"
+      },
+      "require": {
+        "types": "./dist/jsx-runtime.d.cts",
+        "default": "./dist/jsx-runtime.cjs"
+      }
     },
     "./package.json": "./package.json"
   },
@@ -79,7 +94,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.10.1",
+    "@kubb/ast": "5.10.3",
     "yaml": "^2.9.1"
   },
   "engines": {