@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/to-constant-case.d.cts

@@ -1,3 +1,31 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toConstantCase } from "./to-constant-case-Bobbz_hT.cjs";
-export { toConstantCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-constant-case.d.ts
+
+/**
+ * Convert a string to constant case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toConstantCase(str)
+ * @example
+ *   toConstantCase('test'); // => 'TEST'
+ *   toConstantCase('test string'); // => 'TEST_STRING'
+ *   toConstantCase('test string', { delimiter: '$' }); // => 'TEST$STRING'
+ *   toConstantCase('testV2', { separateNumbers: true }); // => 'TEST_V_2'
+ *   toConstantCase('__typename', { prefixCharacters: '_' }); // => '__TYPENAME'
+ *   toConstantCase('type__', { suffixCharacters: '_' }); // => 'TYPE__'
+ * @category String
+ */
+declare function toConstantCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toConstantCase };
+//# sourceMappingURL=to-constant-case.d.cts.map

package/dist/to-constant-case.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-constant-case.d.cts","names":[],"sources":["../src/to-constant-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,0BAAwC"}

package/dist/to-constant-case.d.ts

@@ -1,3 +1,31 @@
-import "./case.types-DegX_-fY.js";
-import { toConstantCase } from "./to-constant-case-DlZZVrYx.js";
-export { toConstantCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-constant-case.d.ts
+
+/**
+ * Convert a string to constant case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toConstantCase(str)
+ * @example
+ *   toConstantCase('test'); // => 'TEST'
+ *   toConstantCase('test string'); // => 'TEST_STRING'
+ *   toConstantCase('test string', { delimiter: '$' }); // => 'TEST$STRING'
+ *   toConstantCase('testV2', { separateNumbers: true }); // => 'TEST_V_2'
+ *   toConstantCase('__typename', { prefixCharacters: '_' }); // => '__TYPENAME'
+ *   toConstantCase('type__', { suffixCharacters: '_' }); // => 'TYPE__'
+ * @category String
+ */
+declare function toConstantCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toConstantCase };
+//# sourceMappingURL=to-constant-case.d.ts.map

package/dist/to-constant-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-constant-case.d.ts","names":[],"sources":["../src/to-constant-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,0BAAwC"}

package/dist/to-constant-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import{toConstantCase as e}from"./to-constant-case-Bs1J4UNN.js";export{e as toConstantCase};
+import{r as e}from"./case.transform-CCMWrBmz.js";function t(t,n){let[r,i,a]=e(t,n);return r+i.map(e=>e.toUpperCase()).join(n?.delimiter??`_`)+a}export{t as toConstantCase};
+//# sourceMappingURL=to-constant-case.js.map

package/dist/to-constant-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-constant-case.js","names":[],"sources":["../src/to-constant-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { splitPrefixSuffix } from './internal/case.transform';\n\n/**\n * Convert a string to constant case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, numbers will be separated.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toConstantCase(str)\n * @example\n *   toConstantCase('test'); // => 'TEST'\n *   toConstantCase('test string'); // => 'TEST_STRING'\n *   toConstantCase('test string', { delimiter: '$' }); // => 'TEST$STRING'\n *   toConstantCase('testV2', { separateNumbers: true }); // => 'TEST_V_2'\n *   toConstantCase('__typename', { prefixCharacters: '_' }); // => '__TYPENAME'\n *   toConstantCase('type__', { suffixCharacters: '_' }); // => 'TYPE__'\n * @category String\n */\nexport function toConstantCase(input: string, options?: ChangeCaseOptions): string {\n  const [prefix, words, suffix] = splitPrefixSuffix(input, options);\n\n  return (\n    prefix\n    + words\n      .map((word) => word.toUpperCase())\n      .join(options?.delimiter ?? '_')\n      + suffix\n  );\n}\n"],"mappings":"iDA2BA,SAAgB,EAAe,EAAe,EAAqC,CACjF,GAAM,CAAC,EAAQ,EAAO,GAAU,EAAkB,EAAO,EAAQ,CAEjE,OACE,EACE,EACC,IAAK,GAAS,EAAK,aAAa,CAAC,CACjC,KAAK,GAAS,WAAa,IAAI,CAC9B"}

package/dist/to-kebab-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`),require(`./to-no-case-BDX0619s.cjs`);const e=require(`./to-kebab-case-Cud7RCjt.cjs`);exports.toKebabCase=e.toKebabCase;
+const e=require(`./to-no-case.cjs`);function t(t,n){return e.toNoCase(t,{delimiter:`-`,...n})}exports.toKebabCase=t;

package/dist/to-kebab-case.d.cts

@@ -1,3 +1,31 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toKebabCase } from "./to-kebab-case-BRVFPXE9.cjs";
-export { toKebabCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-kebab-case.d.ts
+
+/**
+ * Convert a string to kebab case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toKebabCase(str)
+ * @example
+ *   toKebabCase('test'); // => 'test'
+ *   toKebabCase('test string'); // => 'test-string'
+ *   toKebabCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toKebabCase('testV2', { separateNumbers: true }); // => 'test-v-2'
+ *   toKebabCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toKebabCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ * @category String
+ */
+declare function toKebabCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toKebabCase };
+//# sourceMappingURL=to-kebab-case.d.cts.map

package/dist/to-kebab-case.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-kebab-case.d.cts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}

package/dist/to-kebab-case.d.ts

@@ -1,3 +1,31 @@
-import "./case.types-DegX_-fY.js";
-import { toKebabCase } from "./to-kebab-case-BKdi-Rk7.js";
-export { toKebabCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-kebab-case.d.ts
+
+/**
+ * Convert a string to kebab case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toKebabCase(str)
+ * @example
+ *   toKebabCase('test'); // => 'test'
+ *   toKebabCase('test string'); // => 'test-string'
+ *   toKebabCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toKebabCase('testV2', { separateNumbers: true }); // => 'test-v-2'
+ *   toKebabCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toKebabCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ * @category String
+ */
+declare function toKebabCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toKebabCase };
+//# sourceMappingURL=to-kebab-case.d.ts.map

package/dist/to-kebab-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-kebab-case.d.ts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}

package/dist/to-kebab-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import"./to-no-case-Bt57ASib.js";import{toKebabCase as e}from"./to-kebab-case-z5oAWVif.js";export{e as toKebabCase};
+import{toNoCase as e}from"./to-no-case.js";function t(t,n){return e(t,{delimiter:`-`,...n})}export{t as toKebabCase};
+//# sourceMappingURL=to-kebab-case.js.map

package/dist/to-kebab-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-kebab-case.js","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { toNoCase } from './to-no-case';\n\n/**\n * Convert a string to kebab case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, numbers will be separated.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toKebabCase(str)\n * @example\n *   toKebabCase('test'); // => 'test'\n *   toKebabCase('test string'); // => 'test-string'\n *   toKebabCase('test string', { delimiter: '$' }); // => 'test$string'\n *   toKebabCase('testV2', { separateNumbers: true }); // => 'test-v-2'\n *   toKebabCase('__typename', { prefixCharacters: '_' }); // => '__typename'\n *   toKebabCase('type__', { suffixCharacters: '_' }); // => 'type__'\n * @category String\n */\nexport function toKebabCase(input: string, options?: ChangeCaseOptions): string {\n  return toNoCase(\n    input,\n    {\n      delimiter: '-',\n      ...options,\n    },\n  );\n}\n"],"mappings":"2CA2BA,SAAgB,EAAY,EAAe,EAAqC,CAC9E,OAAO,EACL,EACA,CACE,UAAW,IACX,GAAG,EACJ,CACF"}

package/dist/to-no-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`);const e=require(`./to-no-case-BDX0619s.cjs`);exports.toNoCase=e.toNoCase;
+const e=require(`./case.transform-FNx2XsC3.cjs`);function t(t,n){let[r,i,a]=e.r(t,n);return r+i.map(e=>e.toLowerCase()).join(n?.delimiter??` `)+a}exports.toNoCase=t;

package/dist/to-no-case.d.cts

@@ -1,3 +1,31 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toNoCase } from "./to-no-case-D6nPbja8.cjs";
-export { toNoCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-no-case.d.ts
+
+/**
+ * Convert a string to space separated lower case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toNoCase(str)
+ * @example
+ *   toNoCase('test'); // => 'test'
+ *   toNoCase('test string'); // => 'test string'
+ *   toNoCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toNoCase('testV2', { separateNumbers: true }); // => 'test v 2'
+ *   toNoCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toNoCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ * @category String
+ */
+declare function toNoCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toNoCase };
+//# sourceMappingURL=to-no-case.d.cts.map

package/dist/to-no-case.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-no-case.d.cts","names":[],"sources":["../src/to-no-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,QAAA,0BAAkC"}

package/dist/to-no-case.d.ts

@@ -1,3 +1,31 @@
-import "./case.types-DegX_-fY.js";
-import { toNoCase } from "./to-no-case-ctaqyxQN.js";
-export { toNoCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-no-case.d.ts
+
+/**
+ * Convert a string to space separated lower case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toNoCase(str)
+ * @example
+ *   toNoCase('test'); // => 'test'
+ *   toNoCase('test string'); // => 'test string'
+ *   toNoCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toNoCase('testV2', { separateNumbers: true }); // => 'test v 2'
+ *   toNoCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toNoCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ * @category String
+ */
+declare function toNoCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toNoCase };
+//# sourceMappingURL=to-no-case.d.ts.map

package/dist/to-no-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-no-case.d.ts","names":[],"sources":["../src/to-no-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,QAAA,0BAAkC"}

package/dist/to-no-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import{toNoCase as e}from"./to-no-case-Bt57ASib.js";export{e as toNoCase};
+import{r as e}from"./case.transform-CCMWrBmz.js";function t(t,n){let[r,i,a]=e(t,n);return r+i.map(e=>e.toLowerCase()).join(n?.delimiter??` `)+a}export{t as toNoCase};
+//# sourceMappingURL=to-no-case.js.map

package/dist/to-no-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-no-case.js","names":[],"sources":["../src/to-no-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { splitPrefixSuffix } from './internal/case.transform';\n\n/**\n * Convert a string to space separated lower case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, numbers will be separated.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toNoCase(str)\n * @example\n *   toNoCase('test'); // => 'test'\n *   toNoCase('test string'); // => 'test string'\n *   toNoCase('test string', { delimiter: '$' }); // => 'test$string'\n *   toNoCase('testV2', { separateNumbers: true }); // => 'test v 2'\n *   toNoCase('__typename', { prefixCharacters: '_' }); // => '__typename'\n *   toNoCase('type__', { suffixCharacters: '_' }); // => 'type__'\n * @category String\n */\nexport function toNoCase(input: string, options?: ChangeCaseOptions): string {\n  const [prefix, words, suffix] = splitPrefixSuffix(input, options);\n\n  return (\n    prefix\n    + words\n      .map((word) => word.toLowerCase())\n      .join(options?.delimiter ?? ' ')\n      + suffix\n  );\n}\n"],"mappings":"iDA2BA,SAAgB,EAAS,EAAe,EAAqC,CAC3E,GAAM,CAAC,EAAQ,EAAO,GAAU,EAAkB,EAAO,EAAQ,CAEjE,OACE,EACE,EACC,IAAK,GAAS,EAAK,aAAa,CAAC,CACjC,KAAK,GAAS,WAAa,IAAI,CAC9B"}

package/dist/to-pascal-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`);const e=require(`./to-pascal-case-BSZrgkTx.cjs`);exports.toPascalCase=e.toPascalCase;
+const e=require(`./case.transform-FNx2XsC3.cjs`);function t(t,n){let[r,i,a]=e.r(t,n),o=n?.mergeAmbiguousCharacters?e.t():e.n();return r+i.map(o).join(n?.delimiter??``)+a}exports.toPascalCase=t;

package/dist/to-pascal-case.d.cts

@@ -1,3 +1,32 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toPascalCase } from "./to-pascal-case-7nVKvcNg.cjs";
-export { toPascalCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-pascal-case.d.ts
+
+/**
+ * Convert a string to pascal case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalCase(str)
+ * @example
+ *   toPascalCase('test'); // => 'Test'
+ *   toPascalCase('test string'); // => 'TestString'
+ *   toPascalCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalCase('testV2', { separateNumbers: true }); // => 'TestV_2'
+ *   toPascalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ *   toPascalCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'Version1210'
+ * @category String
+ */
+declare function toPascalCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toPascalCase };
+//# sourceMappingURL=to-pascal-case.d.cts.map

package/dist/to-pascal-case.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-pascal-case.d.cts","names":[],"sources":["../src/to-pascal-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,YAAA,0BAAsC"}

package/dist/to-pascal-case.d.ts

@@ -1,3 +1,32 @@
-import "./case.types-DegX_-fY.js";
-import { toPascalCase } from "./to-pascal-case-DUupmGjS.js";
-export { toPascalCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-pascal-case.d.ts
+
+/**
+ * Convert a string to pascal case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalCase(str)
+ * @example
+ *   toPascalCase('test'); // => 'Test'
+ *   toPascalCase('test string'); // => 'TestString'
+ *   toPascalCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalCase('testV2', { separateNumbers: true }); // => 'TestV_2'
+ *   toPascalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ *   toPascalCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'Version1210'
+ * @category String
+ */
+declare function toPascalCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toPascalCase };
+//# sourceMappingURL=to-pascal-case.d.ts.map

package/dist/to-pascal-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-pascal-case.d.ts","names":[],"sources":["../src/to-pascal-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,YAAA,0BAAsC"}

package/dist/to-pascal-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import{toPascalCase as e}from"./to-pascal-case-COG25kzw.js";export{e as toPascalCase};
+import{n as e,r as t,t as n}from"./case.transform-CCMWrBmz.js";function r(r,i){let[a,o,s]=t(r,i),c=i?.mergeAmbiguousCharacters?n():e();return a+o.map(c).join(i?.delimiter??``)+s}export{r as toPascalCase};
+//# sourceMappingURL=to-pascal-case.js.map

package/dist/to-pascal-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-pascal-case.js","names":[],"sources":["../src/to-pascal-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { capitalCaseTransformFactory, pascalCaseTransformFactory, splitPrefixSuffix } from './internal/case.transform';\n\n/**\n * Convert a string to pascal case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, an underscore will be injected before the numbers.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toPascalCase(str)\n * @example\n *   toPascalCase('test'); // => 'Test'\n *   toPascalCase('test string'); // => 'TestString'\n *   toPascalCase('test string', { delimiter: '$' }); // => 'Test$String'\n *   toPascalCase('testV2', { separateNumbers: true }); // => 'TestV_2'\n *   toPascalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'\n *   toPascalCase('type__', { suffixCharacters: '_' }); // => 'Type__'\n *   toPascalCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'Version1210'\n * @category String\n */\nexport function toPascalCase(input: string, options?: ChangeCaseOptions): string {\n  const [prefix, words, suffix] = splitPrefixSuffix(input, options);\n\n  const transform = options?.mergeAmbiguousCharacters\n    ? capitalCaseTransformFactory()\n    : pascalCaseTransformFactory();\n\n  return (\n    prefix\n    + words.map(transform).join(options?.delimiter ?? '')\n    + suffix\n  );\n}\n"],"mappings":"+DA4BA,SAAgB,EAAa,EAAe,EAAqC,CAC/E,GAAM,CAAC,EAAQ,EAAO,GAAU,EAAkB,EAAO,EAAQ,CAE3D,EAAY,GAAS,yBACvB,GAA6B,CAC7B,GAA4B,CAEhC,OACE,EACE,EAAM,IAAI,EAAU,CAAC,KAAK,GAAS,WAAa,GAAG,CACnD"}

package/dist/to-pascal-snake-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`),require(`./to-capital-case-BD9MIiKM.cjs`);const e=require(`./to-pascal-snake-case-C38j94Cu.cjs`);exports.toPascalSnakeCase=e.toPascalSnakeCase;
+const e=require(`./to-capital-case.cjs`);function t(t,n){return e.toCapitalCase(t,{delimiter:`_`,...n})}exports.toPascalSnakeCase=t;

package/dist/to-pascal-snake-case.d.cts

@@ -1,3 +1,31 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toPascalSnakeCase } from "./to-pascal-snake-case-C360MTFV.cjs";
-export { toPascalSnakeCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-pascal-snake-case.d.ts
+
+/**
+ * Convert a string to kebab case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalSnakeCase(str)
+ * @example
+ *   toPascalSnakeCase('test'); // => 'Test'
+ *   toPascalSnakeCase('test string'); // => 'Test_String'
+ *   toPascalSnakeCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalSnakeCase('testV2', { separateNumbers: true }); // => 'Test_V_2'
+ *   toPascalSnakeCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalSnakeCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toPascalSnakeCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toPascalSnakeCase };
+//# sourceMappingURL=to-pascal-snake-case.d.cts.map

package/dist/to-pascal-snake-case.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-pascal-snake-case.d.cts","names":[],"sources":["../src/to-pascal-snake-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,iBAAA,0BAA2C"}

package/dist/to-pascal-snake-case.d.ts

@@ -1,3 +1,31 @@
-import "./case.types-DegX_-fY.js";
-import { toPascalSnakeCase } from "./to-pascal-snake-case-BVvnru7G.js";
-export { toPascalSnakeCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-pascal-snake-case.d.ts
+
+/**
+ * Convert a string to kebab case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalSnakeCase(str)
+ * @example
+ *   toPascalSnakeCase('test'); // => 'Test'
+ *   toPascalSnakeCase('test string'); // => 'Test_String'
+ *   toPascalSnakeCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalSnakeCase('testV2', { separateNumbers: true }); // => 'Test_V_2'
+ *   toPascalSnakeCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalSnakeCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toPascalSnakeCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toPascalSnakeCase };
+//# sourceMappingURL=to-pascal-snake-case.d.ts.map

package/dist/to-pascal-snake-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-pascal-snake-case.d.ts","names":[],"sources":["../src/to-pascal-snake-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,iBAAA,0BAA2C"}

package/dist/to-pascal-snake-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import"./to-capital-case-DFgHWUP7.js";import{toPascalSnakeCase as e}from"./to-pascal-snake-case-C64pBLFr.js";export{e as toPascalSnakeCase};
+import{toCapitalCase as e}from"./to-capital-case.js";function t(t,n){return e(t,{delimiter:`_`,...n})}export{t as toPascalSnakeCase};
+//# sourceMappingURL=to-pascal-snake-case.js.map

package/dist/to-pascal-snake-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-pascal-snake-case.js","names":[],"sources":["../src/to-pascal-snake-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { toCapitalCase } from './to-capital-case';\n\n/**\n * Convert a string to kebab case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, numbers will be separated.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toPascalSnakeCase(str)\n * @example\n *   toPascalSnakeCase('test'); // => 'Test'\n *   toPascalSnakeCase('test string'); // => 'Test_String'\n *   toPascalSnakeCase('test string', { delimiter: '$' }); // => 'Test$String'\n *   toPascalSnakeCase('testV2', { separateNumbers: true }); // => 'Test_V_2'\n *   toPascalSnakeCase('__typename', { prefixCharacters: '_' }); // => '__Typename'\n *   toPascalSnakeCase('type__', { suffixCharacters: '_' }); // => 'Type__'\n * @category String\n */\nexport function toPascalSnakeCase(input: string, options?: ChangeCaseOptions): string {\n  return toCapitalCase(\n    input,\n    {\n      delimiter: '_',\n      ...options,\n    },\n  );\n}\n"],"mappings":"qDA2BA,SAAgB,EAAkB,EAAe,EAAqC,CACpF,OAAO,EACL,EACA,CACE,UAAW,IACX,GAAG,EACJ,CACF"}

package/dist/to-sentence-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`);const e=require(`./to-sentence-case-C2TveqdZ.cjs`);exports.toSentenceCase=e.toSentenceCase;
+const e=require(`./case.transform-FNx2XsC3.cjs`);function t(t,n){let[r,i,a]=e.r(t,n),o=e.t();return r+i.map((e,t)=>t===0?o(e):e.toLowerCase()).join(n?.delimiter??` `)+a}exports.toSentenceCase=t;

package/dist/to-sentence-case.d.cts

@@ -1,3 +1,31 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toSentenceCase } from "./to-sentence-case-7mo0QXqC.cjs";
-export { toSentenceCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-sentence-case.d.ts
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toSentenceCase(str)
+ * @example
+ *   toSentenceCase('test'); // => 'Test'
+ *   toSentenceCase('test string'); // => 'Test string'
+ *   toSentenceCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toSentenceCase('testV2', { separateNumbers: true }); // => 'Test v 2'
+ *   toSentenceCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toSentenceCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toSentenceCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toSentenceCase };
+//# sourceMappingURL=to-sentence-case.d.cts.map

package/dist/to-sentence-case.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-sentence-case.d.cts","names":[],"sources":["../src/to-sentence-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,0BAAwC"}

package/dist/to-sentence-case.d.ts

@@ -1,3 +1,31 @@
-import "./case.types-DegX_-fY.js";
-import { toSentenceCase } from "./to-sentence-case-BTrqI21a.js";
-export { toSentenceCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-sentence-case.d.ts
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toSentenceCase(str)
+ * @example
+ *   toSentenceCase('test'); // => 'Test'
+ *   toSentenceCase('test string'); // => 'Test string'
+ *   toSentenceCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toSentenceCase('testV2', { separateNumbers: true }); // => 'Test v 2'
+ *   toSentenceCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toSentenceCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toSentenceCase(input: string, options?: ChangeCaseOptions): string;
+//#endregion
+export { toSentenceCase };
+//# sourceMappingURL=to-sentence-case.d.ts.map

package/dist/to-sentence-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-sentence-case.d.ts","names":[],"sources":["../src/to-sentence-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,0BAAwC"}

package/dist/to-sentence-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import{toSentenceCase as e}from"./to-sentence-case--9p0YnHo.js";export{e as toSentenceCase};
+import{r as e,t}from"./case.transform-CCMWrBmz.js";function n(n,r){let[i,a,o]=e(n,r),s=t();return i+a.map((e,t)=>t===0?s(e):e.toLowerCase()).join(r?.delimiter??` `)+o}export{n as toSentenceCase};
+//# sourceMappingURL=to-sentence-case.js.map

package/dist/to-sentence-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-sentence-case.js","names":[],"sources":["../src/to-sentence-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { capitalCaseTransformFactory, splitPrefixSuffix } from './internal/case.transform';\n\n/**\n * Convert a string to sentence case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, numbers will be separated.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toSentenceCase(str)\n * @example\n *   toSentenceCase('test'); // => 'Test'\n *   toSentenceCase('test string'); // => 'Test string'\n *   toSentenceCase('test string', { delimiter: '$' }); // => 'Test$String'\n *   toSentenceCase('testV2', { separateNumbers: true }); // => 'Test v 2'\n *   toSentenceCase('__typename', { prefixCharacters: '_' }); // => '__Typename'\n *   toSentenceCase('type__', { suffixCharacters: '_' }); // => 'Type__'\n * @category String\n */\nexport function toSentenceCase(input: string, options?: ChangeCaseOptions): string {\n  const [prefix, words, suffix] = splitPrefixSuffix(input, options);\n\n  const transform = capitalCaseTransformFactory();\n\n  return (\n    prefix\n    + words\n      .map((word, index) => {\n        if (index === 0) {\n          return transform(word);\n        }\n\n        return word.toLowerCase();\n      })\n      .join(options?.delimiter ?? ' ')\n      + suffix\n  );\n}\n"],"mappings":"mDA2BA,SAAgB,EAAe,EAAe,EAAqC,CACjF,GAAM,CAAC,EAAQ,EAAO,GAAU,EAAkB,EAAO,EAAQ,CAE3D,EAAY,GAA6B,CAE/C,OACE,EACE,EACC,KAAK,EAAM,IACN,IAAU,EACL,EAAU,EAAK,CAGjB,EAAK,aAAa,CACzB,CACD,KAAK,GAAS,WAAa,IAAI,CAC9B"}

package/dist/to-single-Chq_hKEk.cjs

@@ -0,0 +1 @@
+function e(e){return Object.assign(e,{single:!0})}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});

package/dist/to-single-vYpRavjM.js

@@ -0,0 +1,2 @@
+function e(e){return Object.assign(e,{single:!0})}export{e as t};
+//# sourceMappingURL=to-single-vYpRavjM.js.map

package/dist/to-single-vYpRavjM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-single-vYpRavjM.js","names":[],"sources":["../src/internal/to-single.ts"],"sourcesContent":["type Single<Func> = Func & { readonly single: true };\n\n// eslint-disable-next-line ts/no-explicit-any -- Typescript requires using `any` to infer any kind of function type, `unknown` is not enough.\nexport function toSingle<Func extends (...args: any) => unknown>(fn: Func): Single<Func> {\n  return Object.assign(fn, { single: true as const });\n}\n"],"mappings":"AAGA,SAAgB,EAAiD,EAAwB,CACvF,OAAO,OAAO,OAAO,EAAI,CAAE,OAAQ,GAAe,CAAC"}

package/dist/to-snake-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`),require(`./to-no-case-BDX0619s.cjs`);const e=require(`./to-snake-case-BuWvjluH.cjs`);exports.toSnakeCase=e.toSnakeCase;
+const e=require(`./to-no-case.cjs`);function t(t,n){return e.toNoCase(t,{delimiter:`_`,...n})}exports.toSnakeCase=t;