@kubb/ast 5.0.0-beta.59 → 5.0.0-beta.60

package/dist/utils.cjs

@@ -1,133 +1,34 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils-BCtRXfhI.cjs");
-Object.defineProperty(exports, "buildGroupParam", {
-	enumerable: true,
-	get: function() {
-		return require_utils.buildGroupParam;
-	}
-});
-Object.defineProperty(exports, "buildJSDoc", {
-	enumerable: true,
-	get: function() {
-		return require_utils.buildJSDoc;
-	}
-});
-Object.defineProperty(exports, "buildList", {
-	enumerable: true,
-	get: function() {
-		return require_utils.buildList;
-	}
-});
-Object.defineProperty(exports, "buildObject", {
-	enumerable: true,
-	get: function() {
-		return require_utils.buildObject;
-	}
-});
-Object.defineProperty(exports, "buildTypeLiteral", {
-	enumerable: true,
-	get: function() {
-		return require_utils.buildTypeLiteral;
-	}
-});
-Object.defineProperty(exports, "caseParams", {
-	enumerable: true,
-	get: function() {
-		return require_utils.caseParams;
-	}
-});
+const require_response = require("./response-DS5S3IG4.cjs");
+const require_utils = require("./utils-D83JA6Xx.cjs");
+exports.buildGroupParam = require_utils.buildGroupParam;
+exports.buildJSDoc = require_utils.buildJSDoc;
+exports.buildList = require_utils.buildList;
+exports.buildObject = require_utils.buildObject;
+exports.buildTypeLiteral = require_utils.buildTypeLiteral;
+exports.caseParams = require_utils.caseParams;
 exports.childName = require_utils.childName;
-Object.defineProperty(exports, "collectUsedSchemaNames", {
-	enumerable: true,
-	get: function() {
-		return require_utils.collectUsedSchemaNames;
-	}
-});
-Object.defineProperty(exports, "containsCircularRef", {
-	enumerable: true,
-	get: function() {
-		return require_utils.containsCircularRef;
-	}
-});
-Object.defineProperty(exports, "createOperationParams", {
-	enumerable: true,
-	get: function() {
-		return require_utils.createOperationParams;
-	}
-});
+exports.collectUsedSchemaNames = require_utils.collectUsedSchemaNames;
+exports.containsCircularRef = require_utils.containsCircularRef;
+exports.createOperationParams = require_utils.createOperationParams;
 exports.enumPropName = require_utils.enumPropName;
 exports.extractRefName = require_utils.extractRefName;
-Object.defineProperty(exports, "extractStringsFromNodes", {
-	enumerable: true,
-	get: function() {
-		return require_utils.extractStringsFromNodes;
-	}
-});
-Object.defineProperty(exports, "findCircularSchemas", {
-	enumerable: true,
-	get: function() {
-		return require_utils.findCircularSchemas;
-	}
-});
-Object.defineProperty(exports, "getNestedAccessor", {
-	enumerable: true,
-	get: function() {
-		return require_utils.getNestedAccessor;
-	}
-});
+exports.extractStringsFromNodes = require_response.extractStringsFromNodes;
+exports.findCircularSchemas = require_utils.findCircularSchemas;
+exports.getNestedAccessor = require_utils.getNestedAccessor;
 exports.isStringType = require_utils.isStringType;
-Object.defineProperty(exports, "isValidVarName", {
-	enumerable: true,
-	get: function() {
-		return require_utils.isValidVarName;
-	}
-});
-Object.defineProperty(exports, "jsStringEscape", {
-	enumerable: true,
-	get: function() {
-		return require_utils.jsStringEscape;
-	}
-});
-Object.defineProperty(exports, "objectKey", {
-	enumerable: true,
-	get: function() {
-		return require_utils.objectKey;
-	}
-});
+exports.isValidVarName = require_utils.isValidVarName;
+exports.jsStringEscape = require_utils.jsStringEscape;
+exports.lazyGetter = require_utils.lazyGetter;
+exports.mapSchemaItems = require_utils.mapSchemaItems;
+exports.mapSchemaMembers = require_utils.mapSchemaMembers;
+exports.mapSchemaProperties = require_utils.mapSchemaProperties;
+exports.objectKey = require_utils.objectKey;
 exports.resolveGroupType = require_utils.resolveGroupType;
-Object.defineProperty(exports, "resolveParamType", {
-	enumerable: true,
-	get: function() {
-		return require_utils.resolveParamType;
-	}
-});
-Object.defineProperty(exports, "stringify", {
-	enumerable: true,
-	get: function() {
-		return require_utils.stringify;
-	}
-});
-Object.defineProperty(exports, "stringifyObject", {
-	enumerable: true,
-	get: function() {
-		return require_utils.stringifyObject;
-	}
-});
-Object.defineProperty(exports, "syncSchemaRef", {
-	enumerable: true,
-	get: function() {
-		return require_utils.syncSchemaRef;
-	}
-});
-Object.defineProperty(exports, "toRegExpString", {
-	enumerable: true,
-	get: function() {
-		return require_utils.toRegExpString;
-	}
-});
-Object.defineProperty(exports, "trimQuotes", {
-	enumerable: true,
-	get: function() {
-		return require_utils.trimQuotes;
-	}
-});
+exports.resolveParamType = require_utils.resolveParamType;
+exports.resolveRefName = require_utils.resolveRefName;
+exports.stringify = require_utils.stringify;
+exports.stringifyObject = require_utils.stringifyObject;
+exports.syncSchemaRef = require_utils.syncSchemaRef;
+exports.toRegExpString = require_utils.toRegExpString;
+exports.trimQuotes = require_utils.trimQuotes;

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import { n as __name } from "./chunk-CNktS9qV.js";
-import { _t as SchemaNode, f as OperationNode, w as ParameterNode } from "./index-BzjwdK2M.js";
+import { Et as PropertyNode, St as UnionSchemaNode, _t as SchemaNode, f as OperationNode, ft as ObjectSchemaNode, ot as ArraySchemaNode, ut as IntersectionSchemaNode, w as ParameterNode } from "./index-BzjwdK2M.js";
 import { a as buildTypeLiteral, c as resolveParamType, i as buildGroupParam, n as OperationParamsResolver, o as caseParams, r as ParamGroupType, s as createOperationParams, t as BuildGroupArgs } from "./operationParams-BZ07xDm0.js";
 import { o as syncSchemaRef, t as extractStringsFromNodes } from "./extractStringsFromNodes-WMYJ8nQL.js";
 
@@ -92,6 +92,18 @@ declare function buildList(items: Array<string>, brackets?: [open: string, close
  * ```
  */
 declare function extractRefName(ref: string): string;
+/**
+ * Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
+ *
+ * Returns `null` for non-ref nodes or when no name resolves.
+ *
+ * @example
+ * ```ts
+ * resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
+ * // => 'Pet'
+ * ```
+ */
+declare function resolveRefName(node: SchemaNode | undefined): string | null;
 /**
  * Builds a PascalCase child schema name by joining a parent name and property name.
  * Returns `null` when there is no parent to nest under.
@@ -239,5 +251,82 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-export { type BuildGroupArgs, type ParamGroupType, buildGroupParam, buildJSDoc, buildList, buildObject, buildTypeLiteral, caseParams, childName, collectUsedSchemaNames, containsCircularRef, createOperationParams, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, getNestedAccessor, isStringType, isValidVarName, jsStringEscape, objectKey, resolveGroupType, resolveParamType, stringify, stringifyObject, syncSchemaRef, toRegExpString, trimQuotes };
+//#region src/utils/schemaTraversal.d.ts
+/**
+ * Converts a child schema to printer output. Plugins instantiate it with their own output type:
+ * `string` for the zod and faker printers, `ts.TypeNode` for the TypeScript printer. A printer's
+ * `this.transform` fits directly, so its `null` for an empty result carries through to `output`.
+ */
+type SchemaTransform<TOutput> = (schema: SchemaNode) => TOutput;
+/**
+ * A union or intersection member, or an array or tuple item, paired with its transformed output.
+ */
+type MappedSchema<TOutput> = {
+  /**
+   * The original child schema, kept so the printer can read its metadata for leaf formatting.
+   */
+  schema: SchemaNode;
+  /**
+   * The child schema after being run through the transform.
+   */
+  output: TOutput;
+};
+/**
+ * An object property paired with its transformed output.
+ */
+type MappedProperty<TOutput> = {
+  /**
+   * The property name as written on the schema, before any identifier quoting.
+   */
+  name: string;
+  /**
+   * The original property node, kept so the printer can read `required`, `schema`, and metadata.
+   */
+  property: PropertyNode;
+  /**
+   * The property schema after being run through the transform.
+   */
+  output: TOutput;
+};
+/**
+ * Maps each property of an object schema to its transformed output. Pairs every result with the
+ * original property so the printer keeps full control over modifiers, getters, and key syntax.
+ *
+ * @example
+ * ```ts
+ * const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+ * // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+ * ```
+ */
+declare function mapSchemaProperties<TOutput>(node: ObjectSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedProperty<TOutput>>;
+/**
+ * Maps each member of a union or intersection schema to its transformed output, pairing every
+ * result with the original member.
+ */
+declare function mapSchemaMembers<TOutput>(node: UnionSchemaNode | IntersectionSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>>;
+/**
+ * Maps each item of an array or tuple schema to its transformed output, pairing every result with
+ * the original item.
+ */
+declare function mapSchemaItems<TOutput>(node: ArraySchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>>;
+/**
+ * Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+ * is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+ * of a recursive schema until first access.
+ *
+ * @example
+ * ```ts
+ * lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+ * // "get parent() { return z.lazy(() => Pet) }"
+ * ```
+ */
+declare function lazyGetter({
+  name,
+  body
+}: {
+  name: string;
+  body: string;
+}): string;
+//#endregion
+export { type BuildGroupArgs, type MappedProperty, type MappedSchema, type ParamGroupType, type SchemaTransform, buildGroupParam, buildJSDoc, buildList, buildObject, buildTypeLiteral, caseParams, childName, collectUsedSchemaNames, containsCircularRef, createOperationParams, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, getNestedAccessor, isStringType, isValidVarName, jsStringEscape, lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, objectKey, resolveGroupType, resolveParamType, resolveRefName, stringify, stringifyObject, syncSchemaRef, toRegExpString, trimQuotes };
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,3 +1,3 @@
-import { D as extractRefName, E as enumPropName, F as objectKey, I as isValidVarName, M as buildJSDoc, N as buildList, O as isStringType, P as buildObject, T as childName, _ as stringifyObject, a as resolveParamType, c as findCircularSchemas, g as stringify, h as jsStringEscape, i as createOperationParams, k as resolveGroupType, m as getNestedAccessor, n as buildTypeLiteral, o as collectUsedSchemaNames, r as caseParams, s as containsCircularRef, t as buildGroupParam, v as toRegExpString, w as syncSchemaRef, y as trimQuotes } from "./utils-SdZU0F3H.js";
+import { A as enumPropName, B as objectKey, C as trimQuotes, L as buildJSDoc, M as isStringType, N as resolveGroupType, O as syncSchemaRef, P as resolveRefName, R as buildList, S as toRegExpString, V as isValidVarName, a as resolveParamType, b as stringify, c as mapSchemaMembers, d as containsCircularRef, f as findCircularSchemas, i as createOperationParams, j as extractRefName, k as childName, l as mapSchemaProperties, n as buildTypeLiteral, o as lazyGetter, r as caseParams, s as mapSchemaItems, t as buildGroupParam, u as collectUsedSchemaNames, v as getNestedAccessor, x as stringifyObject, y as jsStringEscape, z as buildObject } from "./utils-Dj_KoXMv.js";
 import { J as extractStringsFromNodes } from "./response-DKxTr522.js";
-export { buildGroupParam, buildJSDoc, buildList, buildObject, buildTypeLiteral, caseParams, childName, collectUsedSchemaNames, containsCircularRef, createOperationParams, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, getNestedAccessor, isStringType, isValidVarName, jsStringEscape, objectKey, resolveGroupType, resolveParamType, stringify, stringifyObject, syncSchemaRef, toRegExpString, trimQuotes };
+export { buildGroupParam, buildJSDoc, buildList, buildObject, buildTypeLiteral, caseParams, childName, collectUsedSchemaNames, containsCircularRef, createOperationParams, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, getNestedAccessor, isStringType, isValidVarName, jsStringEscape, lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, objectKey, resolveGroupType, resolveParamType, resolveRefName, stringify, stringifyObject, syncSchemaRef, toRegExpString, trimQuotes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-beta.59",
+  "version": "5.0.0-beta.60",
   "description": "Spec-agnostic AST layer for Kubb. Defines the node tree, visitor pattern, factory functions, and type guards used across all code generation plugins.",
   "keywords": [
     "ast",
@@ -23,7 +23,6 @@
     "!/**/__snapshots__/**"
   ],
   "type": "module",
-  "sideEffects": false,
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/utils/index.ts

@@ -1,9 +1,11 @@
 export { isValidVarName } from '@internals/utils'
 export { buildJSDoc, buildList, buildObject, objectKey } from './codegen.ts'
 export { extractStringsFromNodes } from './extractStringsFromNodes.ts'
-export { childName, enumPropName, extractRefName, isStringType, resolveGroupType } from './refs.ts'
+export { childName, enumPropName, extractRefName, isStringType, resolveGroupType, resolveRefName } from './refs.ts'
 export { syncSchemaRef } from '../transformers.ts'
 export { getNestedAccessor, jsStringEscape, stringify, stringifyObject, toRegExpString, trimQuotes } from './strings.ts'
 export { collectUsedSchemaNames, containsCircularRef, findCircularSchemas } from './schemaGraph.ts'
+export { lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties } from './schemaTraversal.ts'
+export type { MappedProperty, MappedSchema, SchemaTransform } from './schemaTraversal.ts'
 export { buildGroupParam, buildTypeLiteral, caseParams, createOperationParams, resolveParamType } from './operationParams.ts'
 export type { BuildGroupArgs, ParamGroupType } from './operationParams.ts'

package/src/utils/schemaTraversal.ts

@@ -0,0 +1,86 @@
+import type { ArraySchemaNode, IntersectionSchemaNode, ObjectSchemaNode, PropertyNode, SchemaNode, UnionSchemaNode } from '../nodes/index.ts'
+import { objectKey } from './codegen.ts'
+
+/**
+ * Converts a child schema to printer output. Plugins instantiate it with their own output type:
+ * `string` for the zod and faker printers, `ts.TypeNode` for the TypeScript printer. A printer's
+ * `this.transform` fits directly, so its `null` for an empty result carries through to `output`.
+ */
+export type SchemaTransform<TOutput> = (schema: SchemaNode) => TOutput
+
+/**
+ * A union or intersection member, or an array or tuple item, paired with its transformed output.
+ */
+export type MappedSchema<TOutput> = {
+  /**
+   * The original child schema, kept so the printer can read its metadata for leaf formatting.
+   */
+  schema: SchemaNode
+  /**
+   * The child schema after being run through the transform.
+   */
+  output: TOutput
+}
+
+/**
+ * An object property paired with its transformed output.
+ */
+export type MappedProperty<TOutput> = {
+  /**
+   * The property name as written on the schema, before any identifier quoting.
+   */
+  name: string
+  /**
+   * The original property node, kept so the printer can read `required`, `schema`, and metadata.
+   */
+  property: PropertyNode
+  /**
+   * The property schema after being run through the transform.
+   */
+  output: TOutput
+}
+
+/**
+ * Maps each property of an object schema to its transformed output. Pairs every result with the
+ * original property so the printer keeps full control over modifiers, getters, and key syntax.
+ *
+ * @example
+ * ```ts
+ * const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+ * // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+ * ```
+ */
+export function mapSchemaProperties<TOutput>(node: ObjectSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedProperty<TOutput>> {
+  return node.properties.map((property) => ({ name: property.name, property, output: transform(property.schema) }))
+}
+
+/**
+ * Maps each member of a union or intersection schema to its transformed output, pairing every
+ * result with the original member.
+ */
+export function mapSchemaMembers<TOutput>(node: UnionSchemaNode | IntersectionSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {
+  return (node.members ?? []).map((schema) => ({ schema, output: transform(schema) }))
+}
+
+/**
+ * Maps each item of an array or tuple schema to its transformed output, pairing every result with
+ * the original item.
+ */
+export function mapSchemaItems<TOutput>(node: ArraySchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {
+  return (node.items ?? []).map((schema) => ({ schema, output: transform(schema) }))
+}
+
+/**
+ * Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+ * is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+ * of a recursive schema until first access.
+ *
+ * @example
+ * ```ts
+ * lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+ * // "get parent() { return z.lazy(() => Pet) }"
+ * ```
+ */
+export function lazyGetter({ name, body }: { name: string; body: string }): string {
+  return `get ${objectKey(name)}() { return ${body} }`
+}

package/dist/casing-BE2R1RXg.cjs

@@ -1,88 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Converts `text` to PascalCase.
-*
-* @example Word boundaries
-* `pascalCase('hello-world') // 'HelloWorld'`
-*
-* @example With a suffix
-* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
-*/
-function pascalCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
-Object.defineProperty(exports, "__exportAll", {
-	enumerable: true,
-	get: function() {
-		return __exportAll;
-	}
-});
-Object.defineProperty(exports, "__name", {
-	enumerable: true,
-	get: function() {
-		return __name;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
-Object.defineProperty(exports, "pascalCase", {
-	enumerable: true,
-	get: function() {
-		return pascalCase;
-	}
-});
-
-//# sourceMappingURL=casing-BE2R1RXg.cjs.map

package/dist/casing-BE2R1RXg.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"casing-BE2R1RXg.cjs","names":[],"sources":["../../../internals/utils/src/casing.ts"],"sourcesContent":["type Options = {\n  /**\n   * Text prepended before casing is applied.\n   */\n  prefix?: string\n  /**\n   * Text appended before casing is applied.\n   */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  return text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n    .split(/[\\s\\-_./\\\\:]+/)\n    .filter(Boolean)\n    .map((word, i) => {\n      if (word.length > 1 && word === word.toUpperCase()) return word\n      const head = i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()\n      return head + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n/**\n * Converts `text` to camelCase.\n *\n * @example Word boundaries\n * `camelCase('hello-world') // 'helloWorld'`\n *\n * @example With a prefix\n * `camelCase('tag', { prefix: 'create' }) // 'createTag'`\n */\nexport function camelCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n *\n * @example Word boundaries\n * `pascalCase('hello-world') // 'HelloWorld'`\n *\n * @example With a suffix\n * `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`\n */\nexport function pascalCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAS,gBAAgB,MAAc,QAAyB;CAC9D,OAAO,KACJ,KAAK,CAAC,CACN,QAAQ,qBAAqB,OAAO,CAAC,CACrC,QAAQ,yBAAyB,OAAO,CAAC,CACzC,QAAQ,gBAAgB,OAAO,CAAC,CAChC,MAAM,eAAe,CAAC,CACtB,OAAO,OAAO,CAAC,CACf,KAAK,MAAM,MAAM;EAChB,IAAI,KAAK,SAAS,KAAK,SAAS,KAAK,YAAY,GAAG,OAAO;EAE3D,QADa,MAAM,KAAK,CAAC,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,KAC9E,KAAK,MAAM,CAAC;CAC5B,CAAC,CAAC,CACD,KAAK,EAAE,CAAC,CACR,QAAQ,iBAAiB,EAAE;AAChC;;;;;;;;;;AAwBA,SAAgB,WAAW,MAAc,EAAE,SAAS,IAAI,SAAS,OAAgB,CAAC,GAAW;CAC3F,OAAO,gBAAgB,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,IAAI;AAC5D"}