@kubb/ast 5.0.0-beta.68 → 5.0.0-beta.69

package/dist/{defineMacro-DoMJxLWT.cjs → defineMacro-Bh5E_Il6.cjs}

@@ -1,4 +1,4 @@
-const require_refs = require("./refs-DLBwxlrG.cjs");
+const require_visitor = require("./visitor-CLLDwBvv.cjs");
 //#region src/defineMacro.ts
 /**
 * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
@@ -57,7 +57,7 @@ function chain({ macros, key, node, context }) {
 function composeMacros(macros) {
 	const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce));
 	const visitor = {};
-	for (const key of require_refs.visitorKeys) {
+	for (const key of require_visitor.visitorKeys) {
 		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
 		const callback = (node, context) => chain({
 			macros: ordered,
@@ -86,7 +86,7 @@ function composeMacros(macros) {
 */
 function applyMacros(root, macros, options) {
 	if (macros.length === 0) return root;
-	return require_refs.transform(root, {
+	return require_visitor.transform(root, {
 		...composeMacros(macros),
 		...options
 	});
@@ -111,4 +111,4 @@ Object.defineProperty(exports, "defineMacro", {
 	}
 });
 
-//# sourceMappingURL=defineMacro-DoMJxLWT.cjs.map
+//# sourceMappingURL=defineMacro-Bh5E_Il6.cjs.map

package/dist/{defineMacro-DoMJxLWT.cjs.map → defineMacro-Bh5E_Il6.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"defineMacro-DoMJxLWT.cjs","names":["visitorKeys","transform"],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAOA,aAAAA,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAOC,aAAAA,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}
+{"version":3,"file":"defineMacro-Bh5E_Il6.cjs","names":["visitorKeys","transform"],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAOA,gBAAAA,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAOC,gBAAAA,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}

package/dist/{defineMacro-_xJf504Y.js → defineMacro-CVrU3ajV.js}

@@ -1,5 +1,5 @@
 import "./rolldown-runtime-CNktS9qV.js";
-import { pt as visitorKeys, u as transform } from "./refs-CQNBUfBU.js";
+import { r as transform, st as visitorKeys } from "./visitor-DG5ROqRx.js";
 //#region src/defineMacro.ts
 /**
 * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
@@ -95,4 +95,4 @@ function applyMacros(root, macros, options) {
 //#endregion
 export { composeMacros as n, defineMacro as r, applyMacros as t };
 
-//# sourceMappingURL=defineMacro-_xJf504Y.js.map
+//# sourceMappingURL=defineMacro-CVrU3ajV.js.map

package/dist/{defineMacro-_xJf504Y.js.map → defineMacro-CVrU3ajV.js.map}

@@ -1 +1 @@
-{"version":3,"file":"defineMacro-_xJf504Y.js","names":[],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAO,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAO,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}
+{"version":3,"file":"defineMacro-CVrU3ajV.js","names":[],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAO,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAO,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}

package/dist/index.cjs

@@ -1,8 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_refs = require("./refs-DLBwxlrG.cjs");
-require("./utils-BjyHu4VI.cjs");
-const require_defineMacro = require("./defineMacro-DoMJxLWT.cjs");
-let node_crypto = require("node:crypto");
+const require_visitor = require("./visitor-CLLDwBvv.cjs");
+const require_defineMacro = require("./defineMacro-Bh5E_Il6.cjs");
 //#region src/defineDialect.ts
 /**
 * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
@@ -19,7 +17,6 @@ let node_crypto = require("node:crypto");
 *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
 *     resolveRef,
 *   },
-*   dedupe: { plan },
 * })
 * ```
 */
@@ -87,285 +84,33 @@ function createPrinter(build) {
 	};
 }
 //#endregion
-//#region src/signature.ts
-/**
-* The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
-*/
-function flagsDescriptor(node) {
-	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 0}`;
-}
-function refTargetName(node) {
-	if (node.ref) return require_refs.extractRefName(node.ref);
-	return node.name ?? "";
-}
-const arrayTupleFields = [
-	{
-		kind: "children",
-		key: "items",
-		prefix: "i"
-	},
-	{
-		kind: "child",
-		key: "rest",
-		prefix: "r"
-	},
-	{
-		kind: "scalar",
-		key: "min",
-		prefix: "mn"
-	},
-	{
-		kind: "scalar",
-		key: "max",
-		prefix: "mx"
-	},
-	{
-		kind: "bool",
-		key: "unique",
-		prefix: "u"
-	}
-];
-const numericFields = [
-	{
-		kind: "scalar",
-		key: "min",
-		prefix: "mn"
-	},
-	{
-		kind: "scalar",
-		key: "max",
-		prefix: "mx"
-	},
-	{
-		kind: "scalar",
-		key: "exclusiveMinimum",
-		prefix: "emn"
-	},
-	{
-		kind: "scalar",
-		key: "exclusiveMaximum",
-		prefix: "emx"
-	},
-	{
-		kind: "scalar",
-		key: "multipleOf",
-		prefix: "mo"
-	}
-];
-const rangeFields = [{
-	kind: "scalar",
-	key: "min",
-	prefix: "mn"
-}, {
-	kind: "scalar",
-	key: "max",
-	prefix: "mx"
-}];
-/**
-* Maps each node `type` to its ordered shape-contributing fields. Types absent from the map
-* (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.
-*/
-const SHAPE_KEYS = {
-	object: [
-		{ kind: "objectProps" },
-		{ kind: "additionalProps" },
-		{ kind: "patternProps" },
-		{
-			kind: "scalar",
-			key: "minProperties",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "maxProperties",
-			prefix: "mx"
-		}
-	],
-	array: arrayTupleFields,
-	tuple: arrayTupleFields,
-	union: [
-		{
-			kind: "scalar",
-			key: "strategy",
-			prefix: "s"
-		},
-		{
-			kind: "scalar",
-			key: "discriminatorPropertyName",
-			prefix: "d"
-		},
-		{
-			kind: "children",
-			key: "members",
-			prefix: "m"
-		}
-	],
-	intersection: [{
-		kind: "children",
-		key: "members",
-		prefix: "m"
-	}],
-	enum: [{ kind: "enumValues" }],
-	ref: [{ kind: "refTarget" }],
-	string: [
-		{
-			kind: "scalar",
-			key: "min",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "max",
-			prefix: "mx"
-		},
-		{
-			kind: "scalar",
-			key: "pattern",
-			prefix: "pt"
-		}
-	],
-	number: numericFields,
-	integer: numericFields,
-	bigint: numericFields,
-	url: [
-		{
-			kind: "scalar",
-			key: "path",
-			prefix: "path"
-		},
-		{
-			kind: "scalar",
-			key: "min",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "max",
-			prefix: "mx"
-		}
-	],
-	uuid: rangeFields,
-	email: rangeFields,
-	datetime: [{
-		kind: "bool",
-		key: "offset",
-		prefix: "o"
-	}, {
-		kind: "bool",
-		key: "local",
-		prefix: "l"
-	}],
-	date: [{
-		kind: "scalar",
-		key: "representation",
-		prefix: "rep"
-	}],
-	time: [{
-		kind: "scalar",
-		key: "representation",
-		prefix: "rep"
-	}]
-};
-function serializeShapeField(field, node, record) {
-	switch (field.kind) {
-		case "scalar": return `${field.prefix}:${record[field.key] ?? ""}`;
-		case "bool": return `${field.prefix}:${record[field.key] ? 1 : 0}`;
-		case "child": {
-			const child = record[field.key];
-			return `${field.prefix}:${child ? signatureOf(child) : ""}`;
-		}
-		case "children": {
-			const children = record[field.key] ?? [];
-			return `${field.prefix}[${children.map((c) => signatureOf(c)).join(",")}]`;
-		}
-		case "objectProps": return `p[${(node.properties ?? []).map((prop) => `${prop.name}${prop.required ? "!" : "?"}${signatureOf(prop.schema)}`).join(",")}]`;
-		case "additionalProps": {
-			const obj = node;
-			if (typeof obj.additionalProperties === "boolean") return `ab:${obj.additionalProperties}`;
-			if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`;
-			return "";
-		}
-		case "patternProps": {
-			const obj = node;
-			return `pp[${obj.patternProperties ? Object.keys(obj.patternProperties).sort().map((key) => `${key}=${signatureOf(obj.patternProperties[key])}`).join(",") : ""}]`;
-		}
-		case "enumValues": {
-			const en = node;
-			let values = "";
-			if (en.namedEnumValues?.length) values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(",");
-			else if (en.enumValues?.length) values = en.enumValues.map((value) => `${value === null ? "null" : typeof value}:${String(value)}`).join(",");
-			return `v[${values}]`;
-		}
-		case "refTarget": return `->${refTargetName(node)}`;
-	}
-}
-/**
-* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
-* constraints, and its children's signatures.
-*/
-function describeShape(node) {
-	const flags = flagsDescriptor(node);
-	const fields = SHAPE_KEYS[node.type];
-	if (!fields) return `${node.type}|${flags}`;
-	const record = node;
-	const parts = [`${node.type}|${flags}`];
-	for (const field of fields) parts.push(serializeShapeField(field, node, record));
-	return parts.join("|");
-}
-/**
-* Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so
-* a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.
-* Reuse is safe because a signature depends only on content, and nodes are immutable once created.
-*/
-const signatureCache = /* @__PURE__ */ new WeakMap();
-/**
-* Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
-* share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
-* `description`, `examples`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
-* `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
-* nodes compare by target name, which also terminates on circular shapes.
-*
-* @example Two enums with different descriptions share a signature
-* ```ts
-* signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
-*   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
-* ```
-*/
-function signatureOf(node) {
-	const cached = signatureCache.get(node);
-	if (cached !== void 0) return cached;
-	const signature = (0, node_crypto.hash)("sha256", describeShape(node), "hex");
-	signatureCache.set(node, signature);
-	return signature;
-}
-//#endregion
 //#region src/factory.ts
-var factory_exports = /* @__PURE__ */ require_refs.__exportAll({
-	createArrowFunction: () => require_refs.createArrowFunction,
-	createBreak: () => require_refs.createBreak,
-	createConst: () => require_refs.createConst,
-	createContent: () => require_refs.createContent,
-	createExport: () => require_refs.createExport,
-	createFile: () => require_refs.createFile,
-	createFunction: () => require_refs.createFunction,
-	createFunctionParameter: () => require_refs.createFunctionParameter,
-	createFunctionParameters: () => require_refs.createFunctionParameters,
-	createImport: () => require_refs.createImport,
-	createIndexedAccessType: () => require_refs.createIndexedAccessType,
-	createInput: () => require_refs.createInput,
-	createJsx: () => require_refs.createJsx,
-	createObjectBindingPattern: () => require_refs.createObjectBindingPattern,
-	createOperation: () => require_refs.createOperation,
-	createOutput: () => require_refs.createOutput,
-	createParameter: () => require_refs.createParameter,
-	createProperty: () => require_refs.createProperty,
-	createRequestBody: () => require_refs.createRequestBody,
-	createResponse: () => require_refs.createResponse,
-	createSchema: () => require_refs.createSchema,
-	createSource: () => require_refs.createSource,
-	createText: () => require_refs.createText,
-	createType: () => require_refs.createType,
-	createTypeLiteral: () => require_refs.createTypeLiteral,
+var factory_exports = /* @__PURE__ */ require_visitor.__exportAll({
+	createArrowFunction: () => require_visitor.createArrowFunction,
+	createBreak: () => require_visitor.createBreak,
+	createConst: () => require_visitor.createConst,
+	createContent: () => require_visitor.createContent,
+	createExport: () => require_visitor.createExport,
+	createFile: () => require_visitor.createFile,
+	createFunction: () => require_visitor.createFunction,
+	createFunctionParameter: () => require_visitor.createFunctionParameter,
+	createFunctionParameters: () => require_visitor.createFunctionParameters,
+	createImport: () => require_visitor.createImport,
+	createIndexedAccessType: () => require_visitor.createIndexedAccessType,
+	createInput: () => require_visitor.createInput,
+	createJsx: () => require_visitor.createJsx,
+	createObjectBindingPattern: () => require_visitor.createObjectBindingPattern,
+	createOperation: () => require_visitor.createOperation,
+	createOutput: () => require_visitor.createOutput,
+	createParameter: () => require_visitor.createParameter,
+	createProperty: () => require_visitor.createProperty,
+	createRequestBody: () => require_visitor.createRequestBody,
+	createResponse: () => require_visitor.createResponse,
+	createSchema: () => require_visitor.createSchema,
+	createSource: () => require_visitor.createSource,
+	createText: () => require_visitor.createText,
+	createType: () => require_visitor.createType,
+	createTypeLiteral: () => require_visitor.createTypeLiteral,
 	update: () => update
 });
 /**
@@ -393,101 +138,99 @@ function update(node, changes) {
 }
 //#endregion
 //#region src/exports.ts
-var exports_exports = /* @__PURE__ */ require_refs.__exportAll({
+var exports_exports = /* @__PURE__ */ require_visitor.__exportAll({
 	applyMacros: () => require_defineMacro.applyMacros,
-	arrowFunctionDef: () => require_refs.arrowFunctionDef,
-	breakDef: () => require_refs.breakDef,
-	collect: () => require_refs.collect,
+	arrowFunctionDef: () => require_visitor.arrowFunctionDef,
+	breakDef: () => require_visitor.breakDef,
+	collect: () => require_visitor.collect,
 	composeMacros: () => require_defineMacro.composeMacros,
-	constDef: () => require_refs.constDef,
-	contentDef: () => require_refs.contentDef,
+	constDef: () => require_visitor.constDef,
+	contentDef: () => require_visitor.contentDef,
 	createPrinter: () => createPrinter,
 	defineDialect: () => defineDialect,
 	defineMacro: () => require_defineMacro.defineMacro,
-	defineNode: () => require_refs.defineNode,
-	exportDef: () => require_refs.exportDef,
+	defineNode: () => require_visitor.defineNode,
+	exportDef: () => require_visitor.exportDef,
 	factory: () => factory_exports,
-	fileDef: () => require_refs.fileDef,
-	functionDef: () => require_refs.functionDef,
-	functionParameterDef: () => require_refs.functionParameterDef,
-	functionParametersDef: () => require_refs.functionParametersDef,
-	importDef: () => require_refs.importDef,
-	indexedAccessTypeDef: () => require_refs.indexedAccessTypeDef,
-	inputDef: () => require_refs.inputDef,
-	isHttpOperationNode: () => require_refs.isHttpOperationNode,
-	jsxDef: () => require_refs.jsxDef,
-	narrowSchema: () => require_refs.narrowSchema,
-	nodeDefs: () => require_refs.nodeDefs,
-	objectBindingPatternDef: () => require_refs.objectBindingPatternDef,
-	operationDef: () => require_refs.operationDef,
-	optionality: () => require_refs.optionality,
-	outputDef: () => require_refs.outputDef,
-	parameterDef: () => require_refs.parameterDef,
-	propertyDef: () => require_refs.propertyDef,
-	requestBodyDef: () => require_refs.requestBodyDef,
-	responseDef: () => require_refs.responseDef,
-	schemaDef: () => require_refs.schemaDef,
-	schemaTypes: () => require_refs.schemaTypes,
-	signatureOf: () => signatureOf,
-	sourceDef: () => require_refs.sourceDef,
-	textDef: () => require_refs.textDef,
-	transform: () => require_refs.transform,
-	typeDef: () => require_refs.typeDef,
-	typeLiteralDef: () => require_refs.typeLiteralDef,
-	walk: () => require_refs.walk
+	fileDef: () => require_visitor.fileDef,
+	functionDef: () => require_visitor.functionDef,
+	functionParameterDef: () => require_visitor.functionParameterDef,
+	functionParametersDef: () => require_visitor.functionParametersDef,
+	importDef: () => require_visitor.importDef,
+	indexedAccessTypeDef: () => require_visitor.indexedAccessTypeDef,
+	inputDef: () => require_visitor.inputDef,
+	isHttpOperationNode: () => require_visitor.isHttpOperationNode,
+	jsxDef: () => require_visitor.jsxDef,
+	narrowSchema: () => require_visitor.narrowSchema,
+	nodeDefs: () => require_visitor.nodeDefs,
+	objectBindingPatternDef: () => require_visitor.objectBindingPatternDef,
+	operationDef: () => require_visitor.operationDef,
+	optionality: () => require_visitor.optionality,
+	outputDef: () => require_visitor.outputDef,
+	parameterDef: () => require_visitor.parameterDef,
+	propertyDef: () => require_visitor.propertyDef,
+	requestBodyDef: () => require_visitor.requestBodyDef,
+	responseDef: () => require_visitor.responseDef,
+	schemaDef: () => require_visitor.schemaDef,
+	schemaTypes: () => require_visitor.schemaTypes,
+	sourceDef: () => require_visitor.sourceDef,
+	textDef: () => require_visitor.textDef,
+	transform: () => require_visitor.transform,
+	typeDef: () => require_visitor.typeDef,
+	typeLiteralDef: () => require_visitor.typeLiteralDef,
+	walk: () => require_visitor.walk
 });
 //#endregion
 exports.applyMacros = require_defineMacro.applyMacros;
-exports.arrowFunctionDef = require_refs.arrowFunctionDef;
+exports.arrowFunctionDef = require_visitor.arrowFunctionDef;
 Object.defineProperty(exports, "ast", {
 	enumerable: true,
 	get: function() {
 		return exports_exports;
 	}
 });
-exports.breakDef = require_refs.breakDef;
-exports.collect = require_refs.collect;
+exports.breakDef = require_visitor.breakDef;
+exports.collect = require_visitor.collect;
 exports.composeMacros = require_defineMacro.composeMacros;
-exports.constDef = require_refs.constDef;
-exports.contentDef = require_refs.contentDef;
+exports.constDef = require_visitor.constDef;
+exports.contentDef = require_visitor.contentDef;
 exports.createPrinter = createPrinter;
 exports.defineDialect = defineDialect;
 exports.defineMacro = require_defineMacro.defineMacro;
-exports.defineNode = require_refs.defineNode;
-exports.exportDef = require_refs.exportDef;
+exports.defineNode = require_visitor.defineNode;
+exports.exportDef = require_visitor.exportDef;
 Object.defineProperty(exports, "factory", {
 	enumerable: true,
 	get: function() {
 		return factory_exports;
 	}
 });
-exports.fileDef = require_refs.fileDef;
-exports.functionDef = require_refs.functionDef;
-exports.functionParameterDef = require_refs.functionParameterDef;
-exports.functionParametersDef = require_refs.functionParametersDef;
-exports.importDef = require_refs.importDef;
-exports.indexedAccessTypeDef = require_refs.indexedAccessTypeDef;
-exports.inputDef = require_refs.inputDef;
-exports.isHttpOperationNode = require_refs.isHttpOperationNode;
-exports.jsxDef = require_refs.jsxDef;
-exports.narrowSchema = require_refs.narrowSchema;
-exports.nodeDefs = require_refs.nodeDefs;
-exports.objectBindingPatternDef = require_refs.objectBindingPatternDef;
-exports.operationDef = require_refs.operationDef;
-exports.optionality = require_refs.optionality;
-exports.outputDef = require_refs.outputDef;
-exports.parameterDef = require_refs.parameterDef;
-exports.propertyDef = require_refs.propertyDef;
-exports.requestBodyDef = require_refs.requestBodyDef;
-exports.responseDef = require_refs.responseDef;
-exports.schemaDef = require_refs.schemaDef;
-exports.schemaTypes = require_refs.schemaTypes;
-exports.signatureOf = signatureOf;
-exports.sourceDef = require_refs.sourceDef;
-exports.textDef = require_refs.textDef;
-exports.transform = require_refs.transform;
-exports.typeDef = require_refs.typeDef;
-exports.typeLiteralDef = require_refs.typeLiteralDef;
-exports.walk = require_refs.walk;
+exports.fileDef = require_visitor.fileDef;
+exports.functionDef = require_visitor.functionDef;
+exports.functionParameterDef = require_visitor.functionParameterDef;
+exports.functionParametersDef = require_visitor.functionParametersDef;
+exports.importDef = require_visitor.importDef;
+exports.indexedAccessTypeDef = require_visitor.indexedAccessTypeDef;
+exports.inputDef = require_visitor.inputDef;
+exports.isHttpOperationNode = require_visitor.isHttpOperationNode;
+exports.jsxDef = require_visitor.jsxDef;
+exports.narrowSchema = require_visitor.narrowSchema;
+exports.nodeDefs = require_visitor.nodeDefs;
+exports.objectBindingPatternDef = require_visitor.objectBindingPatternDef;
+exports.operationDef = require_visitor.operationDef;
+exports.optionality = require_visitor.optionality;
+exports.outputDef = require_visitor.outputDef;
+exports.parameterDef = require_visitor.parameterDef;
+exports.propertyDef = require_visitor.propertyDef;
+exports.requestBodyDef = require_visitor.requestBodyDef;
+exports.responseDef = require_visitor.responseDef;
+exports.schemaDef = require_visitor.schemaDef;
+exports.schemaTypes = require_visitor.schemaTypes;
+exports.sourceDef = require_visitor.sourceDef;
+exports.textDef = require_visitor.textDef;
+exports.transform = require_visitor.transform;
+exports.typeDef = require_visitor.typeDef;
+exports.typeLiteralDef = require_visitor.typeLiteralDef;
+exports.walk = require_visitor.walk;
 
 //# sourceMappingURL=index.cjs.map