ts-case-convert 2.3.2 → 3.0.0

package/README.md

@@ -18,11 +18,13 @@
   </a>
 </p>
 
-ts-case-convert is a zero dependency implementation for converting object keys between camelCase, snake_case, PascalCase, and SCREAMING_SNAKE_CASE while preserving TypeScript type information, code completion, and type validation. See tests for detailed conversion tests.
+ts-case-convert is a zero dependency implementation for converting object keys between camelCase, snake_case, PascalCase, and SCREAMING_SNAKE_CASE, accepting upper and lower kebab-case input, while preserving TypeScript type information, code completion, and type validation. See tests for detailed conversion tests.
 
 ## Usage
 
 ```typescript
+import { objectToCamel, objectToSnake, objectToScreamingSnake } from 'ts-case-convert';
+
 const camel = objectToCamel({
   hello_world: 'helloWorld',
   a_number: 5,
@@ -38,7 +40,7 @@ const camel = objectToCamel({
 
 type CheckCamel = typeof camel.anArrayOfObjects[0]['aB']; // -> 'string'
 const ab: CheckCamel = camel.anArrayOfObjects[0]['aB']; // -> valid
-console.log(camel.anArrayOfObjects.aB); // -> 'ab'
+console.log(camel.anArrayOfObjects[0].aB); // -> 'ab'
 
 const snake = objectToSnake({
   helloWorld: 'helloWorld',
@@ -54,8 +56,8 @@ const snake = objectToSnake({
 });
 
 type CheckSnake = typeof snake.an_array_of_objects[0]['a_b']; // -> 'string'
-const ab: CheckSnake = snake.an_array_of_objects[0]['a_b']; // -> valid
-console.log(snake.an_array_of_objects.a_b); // -> 'ab'
+const snakeAB: CheckSnake = snake.an_array_of_objects[0]['a_b']; // -> valid
+console.log(snake.an_array_of_objects[0].a_b); // -> 'ab'
 
 const screamingSnake = objectToScreamingSnake({
   helloWorld: 'helloWorld',
@@ -69,16 +71,92 @@ type CheckScreamingSnake = typeof screamingSnake.NESTED_OBJECT.API_VERSION; // -
 console.log(screamingSnake.S3_ID); // -> 'id'
 ```
 
+## Supported input cases
+
+The string functions `toCamel`, `toPascal`, `toSnake`, and `toScreamingSnake` convert a single name. The corresponding `objectTo…` functions convert keys recursively through objects and arrays, preserving values such as `Date` and `Uint8Array`. Both entry points export all four modes and their matching TypeScript types.
+
+The converters recognize the input style before applying the output rules:
+
+| Input style | Example | Camel | Pascal | Snake | Screaming snake |
+| --- | --- | --- | --- | --- | --- |
+| camelCase | `apiVersion` | `apiVersion` | `ApiVersion` | `api_version` | `API_VERSION` |
+| PascalCase | `ApiVersion` | `apiVersion` | `ApiVersion` | `api_version` | `API_VERSION` |
+| snake_case | `api_version` | `apiVersion` | `ApiVersion` | `api_version` | `API_VERSION` |
+| SCREAMING_SNAKE_CASE | `API_VERSION` | `apiVersion` | `ApiVersion` | `api_version` | `API_VERSION` |
+| Lower kebab | `content-type` | `contentType` | `ContentType` | `content_type` | `CONTENT_TYPE` |
+| Title kebab | `Content-Type` | `contentType` | `ContentType` | `content_type` | `CONTENT_TYPE` |
+| Upper kebab | `CONTENT-TYPE` | `contentType` | `ContentType` | `content_type` | `CONTENT_TYPE` |
+
+For input without underscores or hyphens, camel and Pascal conversion change only the first character. Internal capitals remain unchanged: `AbcDEF` becomes `abcDEF` in camel case, and `abcDEF` becomes `AbcDEF` in Pascal case. This also preserves `HTTPServer` as `hTTPServer` in camel case and `ABC` as `aBC`.
+
+For camel/Pascal input, snake conversion inserts an underscore before each capital after the first. It does not group capital runs into acronyms: `abcDEF` becomes `abc_d_e_f`, and `HTTPServer` becomes `h_t_t_p_server`. Screaming snake uses the same boundaries and uppercases the result.
+
+For separated input, underscores and hyphens separate words, and consecutive capitals stay together. `API_VERSION` becomes `apiVersion`, `ApiVersion`, `api_version`, or `API_VERSION`. Capitalization boundaries use ASCII letters; other characters remain within the words.
+
+```typescript
+import { objectToCamel, toPascal, toSnake, type ToCamel } from 'ts-case-convert';
+
+const output = objectToCamel({ API_VERSION: 2, 'Content-Type': 'text/plain' });
+console.log(output.apiVersion); // 2; inferred as number
+console.log(output.contentType); // 'text/plain'; inferred as string
+
+type Name = ToCamel<'API_VERSION'>; // 'apiVersion'
+console.log(toPascal('API_VERSION')); // 'ApiVersion'
+console.log(toSnake('HTTPServer')); // 'h_t_t_p_server'
+```
+
+Signed decimal string keys such as `'-1'` and `'-12.5'` stay unchanged. Numeric object keys such as `42` become string keys such as `'42'` in both the returned value and its type. Repeated, leading, and trailing separators are not valid case styles. They are accepted without validation, and empty words are ignored: `a__b` becomes `aB`, `AB`, `a_b`, or `A_B`; `trailing_` becomes `trailing`, `Trailing`, `trailing`, or `TRAILING`. Empty strings and strings containing only separators become empty strings. The runtime result and inferred type follow the same rules.
+
+## Awkward inputs
+
+The converters follow spelling rules rather than guessing what an acronym means. Existing camel/Pascal capitals are preserved when changing between those two styles, and each capital starts a word when converting to snake case. These inputs can therefore give surprising results:
+
+| Input | Camel | Pascal | Snake | Screaming snake |
+| --- | --- | --- | --- | --- |
+| `AbcDEF` | `abcDEF` | `AbcDEF` | `abc_d_e_f` | `ABC_D_E_F` |
+| `HTTPServer` | `hTTPServer` | `HTTPServer` | `h_t_t_p_server` | `H_T_T_P_SERVER` |
+| `ABC` | `aBC` | `ABC` | `a_b_c` | `A_B_C` |
+| `API_VERSION` | `apiVersion` | `ApiVersion` | `api_version` | `API_VERSION` |
+| `a__b` | `aB` | `AB` | `a_b` | `A_B` |
+| `trailing_` | `trailing` | `Trailing` | `trailing` | `TRAILING` |
+| `a1` | `a1` | `A1` | `a_1` | `A_1` |
+| `A1` | `a1` | `A1` | `a1` | `A1` |
+
+The last two rows use default number splitting, which depends on the input letter case. The `no-split-numbers` entry point produces `a1` and `A1` for both rows in snake and screaming snake output. Repeated or trailing separators are invalid case styles, but their types and runtime values still agree. Use one consistent input style when predictable word boundaries matter.
+
+## Migrating to 3.0.0
+
+Version 3 changes both returned keys and literal types. Update property access, serialized payloads, and integrations that rely on version 2 spellings:
+
+| Conversion | Input | Version 2 runtime | Version 3 runtime and type |
+| --- | --- | --- | --- |
+| Camel | `API_VERSION` | `aPI_VERSION` | `apiVersion` |
+| Pascal | `API_VERSION` | `API_VERSION` | `ApiVersion` |
+| Snake | `API_VERSION` | `a_p_i__v_e_r_s_i_o_n` | `api_version` |
+| Camel | `Content-Type` | `content-Type` | `contentType` |
+| Snake | `content-type` | `content-type` | `content_type` |
+| Camel | `a__b` | `a_B` | `aB` |
+| Camel | `trailing_` | `trailing_` | `trailing` |
+
+Separated uppercase words are normalized (`API_VERSION` becomes `apiVersion`, `ApiVersion`, `api_version`, or `API_VERSION`). Existing camel/Pascal names retain their previous conversion rules, including an underscore before each capital for snake output; standalone `ABC` becomes `aBC` in camel case and stays `ABC` in Pascal case. Every word boundary is converted; the old ten-replacement limit is removed. These changes apply to string functions, recursive object conversion, and `ts-case-convert/no-split-numbers`.
+
+Distinct input keys can normalize to the same output key. For example, `a_b`, `a__b`, and `a-b` all become `aB` in camel case. Object conversion keeps the value of the last key visited by `Object.entries`; choose inputs without such collisions when every value must be retained.
+
 ## No Number Splitting
 
-The default snake case conversion splits lowercase letters from following numbers:
+The default snake and screaming snake conversions split a lowercase letter from a following digit run, unless that run is followed by a capital and then a lowercase letter:
 
 ```typescript
 import { toSnake } from 'ts-case-convert';
 
 console.log(toSnake('myItem1')); // -> 'my_item_1'
+console.log(toSnake('s3Id')); // -> 's3_id'
+console.log(toSnake('http23Status')); // -> 'http23_status'
+console.log(toSnake('A1')); // -> 'a1' (the input letter is uppercase)
 ```
 
+Camel and Pascal conversion never split digit runs. Explicit word separators still apply in every mode.
+
 Use the `no-split-numbers` import path when numbers should stay attached to the preceding word. It exports the same runtime function and type names as the default entry point.
 
 ```typescript
@@ -116,7 +194,7 @@ pnpm run test
 
 ## Documentation
 
-See [tests](./test/caseConvert.test.ts), [bug regression tests](./test/caseConvert.bugs.test.ts), and [no-split-numbers tests](./test/no-split-numbers.test.ts).
+See [tests](./test/caseConvert.test.ts), [bug regression tests](./test/caseConvert.bugs.test.ts), [no-split-numbers tests](./test/no-split-numbers.test.ts), [input case tests](./test/case-forms.test.ts), [kebab input tests](./test/kebab-case.test.ts), and [recursive conversion tests](./test/recursive-cases.test.ts).
 
 ## 📝 License
 

package/lib/caseConvert.d.ts

@@ -10,15 +10,15 @@ export declare function objectToScreamingSnake<T extends object>(obj: T): Object
 export declare function objectToScreamingSnakeNoSplitNumbers<T extends object>(obj: T): ObjectToScreamingSnake<T, false>;
 export declare function toPascal<T extends string>(term: T): ToPascal<T>;
 export declare function objectToPascal<T extends object>(obj: T): ObjectToPascal<T>;
-export type ToCamel<S extends string | number | symbol> = S extends string ? S extends NumericKey ? S : S extends `${infer Head}_${infer Tail}` ? `${ToCamel<Uncapitalize<Head>>}${Capitalize<ToCamel<Tail>>}` : S extends `${infer Head}-${infer Tail}` ? `${ToCamel<Uncapitalize<Head>>}${Capitalize<ToCamel<Tail>>}` : Uncapitalize<S> : never;
+export type ToCamel<S extends string | number | symbol> = ConvertKey<S, 'camel', false>;
 export type ObjectToCamel<T extends object | undefined | null> = T extends undefined ? undefined : T extends null ? null : T extends Array<infer ArrayType> ? Array<ConvertArrayItem<ArrayType, 'camel'>> : T extends Uint8Array ? Uint8Array : T extends Date ? Date : {
     [K in keyof T as ToCamel<K>]: ConvertObjectValue<T[K], 'camel'>;
 };
-export type ToPascal<S extends string | number | symbol> = S extends string ? S extends NumericKey ? S : S extends `${infer Head}_${infer Tail}` ? `${Capitalize<ToCamel<Head>>}${Capitalize<ToCamel<Tail>>}` : S extends `${infer Head}-${infer Tail}` ? `${Capitalize<ToCamel<Head>>}${Capitalize<ToCamel<Tail>>}` : Capitalize<S> : never;
+export type ToPascal<S extends string | number | symbol> = ConvertKey<S, 'pascal', false>;
 export type ObjectToPascal<T extends object | undefined | null> = T extends undefined ? undefined : T extends null ? null : T extends Array<infer ArrayType> ? Array<ConvertArrayItem<ArrayType, 'pascal'>> : T extends Uint8Array ? Uint8Array : T extends Date ? Date : {
     [K in keyof T as ToPascal<K>]: ConvertObjectValue<T[K], 'pascal'>;
 };
-export type ToSnake<S extends string | number | symbol, SplitNumbers extends boolean = true> = S extends string ? string extends S ? string : S extends NumericKey ? S : SnakeScan<S, '', 'start', SplitNumbers> : never;
+export type ToSnake<S extends string | number | symbol, SplitNumbers extends boolean = true> = ConvertKey<S, 'snake', SplitNumbers>;
 export type ObjectToSnake<T extends object | undefined | null, SplitNumbers extends boolean = true> = T extends undefined ? undefined : T extends null ? null : T extends Array<infer ArrayType> ? Array<ConvertArrayItem<ArrayType, 'snake', SplitNumbers>> : T extends Uint8Array ? Uint8Array : T extends Date ? Date : {
     [K in keyof T as ToSnake<K, SplitNumbers>]: ConvertObjectValue<T[K], 'snake', SplitNumbers>;
 };
@@ -27,15 +27,15 @@ export type ObjectToScreamingSnake<T extends object | undefined | null, SplitNum
     [K in keyof T as ToScreamingSnake<K, SplitNumbers>]: ConvertObjectValue<T[K], 'screamingSnake', SplitNumbers>;
 };
 type CaseMode = 'camel' | 'pascal' | 'snake' | 'screamingSnake';
-type NumericKey = `${number}`;
-type SnakeScan<S extends string, Acc extends string, Previous extends CharacterKind, SplitNumbers extends boolean> = S extends `${infer Head}${infer Tail}` ? Head extends Numbers ? TakeNumberRun<S> extends [
-    infer NumberRun extends string,
-    infer AfterNumber extends string
-] ? SnakeScan<AfterNumber, `${Acc}${NumberSeparator<Previous, AfterNumber, SplitNumbers>}${NumberRun}`, 'number', SplitNumbers> : never : Head extends CapitalLetters ? SnakeScan<Tail, `${Acc}${WordSeparator<Acc>}${Lowercase<Head>}`, 'upper', SplitNumbers> : Head extends LowercaseLetters ? SnakeScan<Tail, `${Acc}${Head}`, 'lower', SplitNumbers> : SnakeScan<Tail, `${Acc}${Head}`, 'other', SplitNumbers> : Acc;
+type ConvertKey<S extends string | number | symbol, Mode extends CaseMode, SplitNumbers extends boolean> = S extends number ? ConvertKey<`${S}`, Mode, SplitNumbers> : S extends string ? string extends S ? string : IsNumericKey<S> extends true ? S : S extends `${string}${'_' | '-'}${string}` ? ConvertKeyScan<S, Mode, SplitNumbers> : Mode extends 'camel' ? Uncapitalize<S> : Mode extends 'pascal' ? Capitalize<S> : ConvertKeyScan<S, Mode, SplitNumbers, true> : never;
+type IsNumericKey<S extends string> = S extends `-${infer Unsigned}` ? IsDecimal<Unsigned> : IsDecimal<S>;
+type IsDecimal<S extends string> = S extends `${infer Whole}.${infer Fraction}` ? IsDigits<Whole> extends true ? IsDigits<Fraction> : false : IsDigits<S>;
+type IsDigits<S extends string> = S extends '' ? false : TakeNumberRun<S> extends [string, ''] ? true : false;
+type AppendWord<Acc extends string, Word extends string, Mode extends CaseMode> = Word extends '' ? Acc : Mode extends 'snake' ? Acc extends '' ? Lowercase<Word> : `${Acc}_${Lowercase<Word>}` : Mode extends 'pascal' ? `${Acc}${Capitalize<Lowercase<Word>>}` : Acc extends '' ? Lowercase<Word> : `${Acc}${Capitalize<Lowercase<Word>>}`;
+type ConvertKeyScan<S extends string, Mode extends CaseMode, SplitNumbers extends boolean, SeparateCapitals extends boolean = false, Acc extends string = '', Word extends string = '', Previous extends string = ''> = string extends S ? string : S extends `${infer Head}${infer Tail}` ? string extends Head ? string : Head extends '_' | '-' ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, AppendWord<Acc, Word, Mode>> : Head extends Numbers ? TakeNumberRun<S> extends [infer Digits extends string, infer After extends string] ? SplitNumber<Previous, After, SplitNumbers> extends true ? ConvertKeyScan<After, Mode, SplitNumbers, SeparateCapitals, AppendWord<Acc, Word, Mode>, Digits, '0'> : ConvertKeyScan<After, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Digits}`, '0'> : never : Head extends CapitalLetters ? StartsWord<Previous, Tail, SeparateCapitals> extends true ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, AppendWord<Acc, Word, Mode>, Head, Head> : ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Head}`, Head> : Head extends LowercaseLetters ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Head}`, Head> : Extract<CapitalLetters | LowercaseLetters | Numbers | '_' | '-', Head> extends never ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Head}`, Head> : string : S extends '' ? AppendWord<Acc, Word, Mode> : string;
+type StartsWord<Previous extends string, Tail extends string, SeparateCapitals extends boolean> = SeparateCapitals extends true ? true : Previous extends LowercaseLetters | Numbers ? true : Previous extends CapitalLetters ? Tail extends `${LowercaseLetters}${string}` ? true : false : false;
 type TakeNumberRun<S extends string, Acc extends string = ''> = S extends `${infer Head}${infer Tail}` ? Head extends Numbers ? TakeNumberRun<Tail, `${Acc}${Head}`> : [Acc, S] : [Acc, ''];
-type NumberSeparator<Previous extends CharacterKind, AfterNumber extends string, SplitNumbers extends boolean> = SplitNumbers extends false ? '' : Previous extends 'lower' ? AfterNumber extends `${CapitalLetters}${LowercaseLetters}${string}` ? '' : '_' : '';
-type WordSeparator<Acc extends string> = Acc extends '' ? '' : Acc extends `${string}_` ? '' : '_';
-type CharacterKind = 'start' | 'lower' | 'upper' | 'number' | 'other';
+type SplitNumber<Previous extends string, AfterNumber extends string, SplitNumbers extends boolean> = SplitNumbers extends false ? false : Previous extends LowercaseLetters ? AfterNumber extends `${CapitalLetters}${LowercaseLetters}${string}` ? false : true : false;
 type Convert<T extends object | undefined | null, Mode extends CaseMode, SplitNumbers extends boolean> = Mode extends 'camel' ? ObjectToCamel<T> : Mode extends 'pascal' ? ObjectToPascal<T> : Mode extends 'snake' ? ObjectToSnake<T, SplitNumbers> : ObjectToScreamingSnake<T, SplitNumbers>;
 type ConvertArrayItem<T, Mode extends CaseMode, SplitNumbers extends boolean = true> = T extends object ? Convert<T, Mode, SplitNumbers> : T;
 type ConvertObjectValue<T, Mode extends CaseMode, SplitNumbers extends boolean = true> = T extends Array<infer ArrayType> ? Array<ConvertArrayItem<ArrayType, Mode, SplitNumbers>> : T extends object | undefined | null ? Convert<T, Mode, SplitNumbers> : T;

package/lib/caseConvert.js

@@ -33,49 +33,89 @@ function convertObject(obj, keyConverter) {
     }
     return out;
 }
-function toCamel(term) {
+// Keep these word boundaries in sync with ConvertKeyScan below.
+function convertKey(term, mode, splitNumbers = false) {
+    var _a, _b, _c, _d;
     if (isNumericKey(term)) {
         return term;
     }
-    return (term.length === 1
-        ? term.toLowerCase()
-        : term
-            .replace(/^([A-Z])/, (m) => m[0].toLowerCase())
-            .replace(/[_-]([a-z0-9])/g, (m) => m[1].toUpperCase()));
-}
-function objectToCamel(obj) {
-    return convertObject(obj, toCamel);
-}
-function toSnakeWithSplitNumbers(term, splitNumbers) {
-    var _a;
-    if (isNumericKey(term)) {
-        return term;
+    const hasSeparators = /[_-]/.test(term);
+    // Existing camel/Pascal names retain every letter after the first.
+    if ((mode === 'camel' || mode === 'pascal') && !hasSeparators) {
+        const first = term.charAt(0);
+        return (mode === 'camel' ? first.toLowerCase() : first.toUpperCase()) + term.slice(1);
     }
-    let result = term;
-    let circuitBreaker = 0;
-    if (splitNumbers) {
-        while ((((_a = /([a-z])([0-9]+)(?![0-9]*[A-Z][a-z])/.exec(result)) === null || _a === void 0 ? void 0 : _a.length) || 0) >
-            2 &&
-            circuitBreaker < 10) {
-            result = result.replace(/([a-z])([0-9]+)(?![0-9]*[A-Z][a-z])/, (_all, head, numbers) => `${head.toLowerCase()}_${numbers.toLowerCase()}`);
-            circuitBreaker += 1;
+    let result = '';
+    let wordStart = 0;
+    const appendWord = (end) => {
+        if (end === wordStart) {
+            return;
+        }
+        const word = term.slice(wordStart, end).toLowerCase();
+        if (mode === 'snake') {
+            result += `${result ? '_' : ''}${word}`;
+        }
+        else {
+            result += mode === 'pascal' || result !== ''
+                ? word[0].toUpperCase() + word.slice(1)
+                : word;
+        }
+    };
+    for (let index = 0; index < term.length; index += 1) {
+        const current = term[index];
+        const previous = (_a = term[index - 1]) !== null && _a !== void 0 ? _a : '';
+        if (current === '_' || current === '-') {
+            appendWord(index);
+            wordStart = index + 1;
+        }
+        else if (splitNumbers && isDigit(current)) {
+            let afterNumber = index + 1;
+            while (afterNumber < term.length && isDigit(term[afterNumber])) {
+                afterNumber += 1;
+            }
+            if (isLowercase(previous) &&
+                !(isUppercase((_b = term[afterNumber]) !== null && _b !== void 0 ? _b : '') && isLowercase((_c = term[afterNumber + 1]) !== null && _c !== void 0 ? _c : ''))) {
+                appendWord(index);
+                wordStart = index;
+            }
+            index = afterNumber - 1;
+        }
+        else if (index > wordStart && isUppercase(current) &&
+            (!hasSeparators || isLowercase(previous) || isDigit(previous) ||
+                (isUppercase(previous) && isLowercase((_d = term[index + 1]) !== null && _d !== void 0 ? _d : '')))) {
+            appendWord(index);
+            wordStart = index;
         }
     }
-    // Match only the character before a capital to avoid rescanning long prefixes.
-    result = result.replace(/(.)(?=[A-Z])/g, (head) => circuitBreaker++ < 10 ? `${head}_` : head);
-    return result.toLowerCase();
+    appendWord(term.length);
+    return result;
+}
+function isLowercase(character) {
+    return character >= 'a' && character <= 'z';
+}
+function isUppercase(character) {
+    return character >= 'A' && character <= 'Z';
+}
+function isDigit(character) {
+    return character >= '0' && character <= '9';
+}
+function toCamel(term) {
+    return convertKey(term, 'camel');
+}
+function objectToCamel(obj) {
+    return convertObject(obj, toCamel);
 }
 function toSnake(term) {
-    return toSnakeWithSplitNumbers(term, true);
+    return convertKey(term, 'snake', true);
 }
 function toSnakeNoSplitNumbers(term) {
-    return toSnakeWithSplitNumbers(term, false);
+    return convertKey(term, 'snake', false);
 }
 function objectToSnake(obj) {
-    return convertObject(obj, (key) => toSnakeWithSplitNumbers(key, true));
+    return convertObject(obj, toSnake);
 }
 function objectToSnakeNoSplitNumbers(obj) {
-    return convertObject(obj, (key) => toSnakeWithSplitNumbers(key, false));
+    return convertObject(obj, toSnakeNoSplitNumbers);
 }
 function toScreamingSnake(term) {
     return toSnake(term).toUpperCase();
@@ -90,10 +130,7 @@ function objectToScreamingSnakeNoSplitNumbers(obj) {
     return convertObject(obj, toScreamingSnakeNoSplitNumbers);
 }
 function toPascal(term) {
-    if (isNumericKey(term)) {
-        return term;
-    }
-    return toCamel(term).replace(/^([a-z])/, (m) => m[0].toUpperCase());
+    return convertKey(term, 'pascal');
 }
 function objectToPascal(obj) {
     return convertObject(obj, toPascal);
@@ -101,4 +138,4 @@ function objectToPascal(obj) {
 function isNumericKey(term) {
     return /^-?\d+(?:\.\d+)?$/.test(term);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caseConvert.js","sourceRoot":"","sources":["../src/caseConvert.ts"],"names":[],"mappings":"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","sourcesContent":["function convertObject<TInput extends object, TResult>(\n  obj: TInput,\n  keyConverter: (arg: string) => string,\n): TResult {\n  if (obj === null || typeof obj === 'undefined' || typeof obj !== 'object') {\n    return obj as unknown as TResult;\n  }\n\n  const out = (Array.isArray(obj) ? [] : {}) as TResult;\n  for (const [k, v] of Object.entries(obj)) {\n\n    // @ts-ignore\n\n    out[keyConverter(k)] = Array.isArray(v)\n      ? (v.map(<ArrayItem extends object>(item: ArrayItem) =>\n          typeof item === 'object' &&\n          !(item instanceof Uint8Array) &&\n          !(item instanceof Date)\n            ? convertObject<\n                ArrayItem,\n                TResult extends ObjectToCamel<TInput>\n                  ? ObjectToCamel<ArrayItem>\n                  : TResult extends ObjectToPascal<TInput>\n                  ? ObjectToPascal<ArrayItem>\n                  : TResult extends ObjectToScreamingSnake<TInput>\n                  ? ObjectToScreamingSnake<ArrayItem>\n                  : ObjectToSnake<ArrayItem>\n              >(item, keyConverter)\n            : item,\n        ) as unknown[])\n      : v instanceof Uint8Array || v instanceof Date\n      ? v\n      : typeof v === 'object'\n      ? convertObject<\n          typeof v,\n          TResult extends ObjectToCamel<TInput>\n            ? ObjectToCamel<typeof v>\n            : TResult extends ObjectToPascal<TInput>\n            ? ObjectToPascal<typeof v>\n            : TResult extends ObjectToScreamingSnake<TInput>\n            ? ObjectToScreamingSnake<typeof v>\n            : ObjectToSnake<typeof v>\n        >(v, keyConverter)\n      : (v as unknown);\n  }\n  return out;\n}\n\nexport function toCamel<T extends string>(term: T): ToCamel<T> {\n  if (isNumericKey(term)) {\n    return term as ToCamel<T>;\n  }\n\n  return (\n    term.length === 1\n      ? term.toLowerCase()\n      : term\n          .replace(/^([A-Z])/, (m) => m[0].toLowerCase())\n          .replace(/[_-]([a-z0-9])/g, (m) => m[1].toUpperCase())\n  ) as ToCamel<T>;\n}\n\nexport function objectToCamel<T extends object>(obj: T): ObjectToCamel<T> {\n  return convertObject(obj, toCamel);\n}\n\nfunction toSnakeWithSplitNumbers(term: string, splitNumbers: boolean): string {\n  if (isNumericKey(term)) {\n    return term;\n  }\n\n  let result: string = term;\n  let circuitBreaker = 0;\n\n  if (splitNumbers) {\n    while (\n      (/([a-z])([0-9]+)(?![0-9]*[A-Z][a-z])/.exec(result)?.length || 0) >\n        2 &&\n      circuitBreaker < 10\n    ) {\n      result = result.replace(\n        /([a-z])([0-9]+)(?![0-9]*[A-Z][a-z])/,\n        (_all, head: string, numbers: string) =>\n          `${head.toLowerCase()}_${numbers.toLowerCase()}`,\n      );\n\n      circuitBreaker += 1;\n    }\n  }\n\n  // Match only the character before a capital to avoid rescanning long prefixes.\n  result = result.replace(/(.)(?=[A-Z])/g, (head: string) =>\n    circuitBreaker++ < 10 ? `${head}_` : head,\n  );\n\n  return result.toLowerCase();\n}\n\nexport function toSnake<T extends string>(term: T): ToSnake<T> {\n  return toSnakeWithSplitNumbers(term, true) as ToSnake<T>;\n}\n\nexport function toSnakeNoSplitNumbers<T extends string>(\n  term: T,\n): ToSnake<T, false> {\n  return toSnakeWithSplitNumbers(term, false) as ToSnake<T, false>;\n}\n\nexport function objectToSnake<T extends object>(obj: T): ObjectToSnake<T> {\n  return convertObject(obj, (key) => toSnakeWithSplitNumbers(key, true));\n}\n\nexport function objectToSnakeNoSplitNumbers<T extends object>(\n  obj: T,\n): ObjectToSnake<T, false> {\n  return convertObject(obj, (key) => toSnakeWithSplitNumbers(key, false));\n}\n\nexport function toScreamingSnake<T extends string>(\n  term: T,\n): ToScreamingSnake<T> {\n  return toSnake(term).toUpperCase() as ToScreamingSnake<T>;\n}\n\nexport function toScreamingSnakeNoSplitNumbers<T extends string>(\n  term: T,\n): ToScreamingSnake<T, false> {\n  return toSnakeNoSplitNumbers(term).toUpperCase() as ToScreamingSnake<T, false>;\n}\n\nexport function objectToScreamingSnake<T extends object>(\n  obj: T,\n): ObjectToScreamingSnake<T> {\n  return convertObject(obj, toScreamingSnake);\n}\n\nexport function objectToScreamingSnakeNoSplitNumbers<T extends object>(\n  obj: T,\n): ObjectToScreamingSnake<T, false> {\n  return convertObject(obj, toScreamingSnakeNoSplitNumbers);\n}\n\nexport function toPascal<T extends string>(term: T): ToPascal<T> {\n  if (isNumericKey(term)) {\n    return term as ToPascal<T>;\n  }\n\n  return toCamel(term).replace(/^([a-z])/, (m) =>\n    m[0].toUpperCase(),\n  ) as ToPascal<T>;\n}\n\nexport function objectToPascal<T extends object>(obj: T): ObjectToPascal<T> {\n  return convertObject(obj, toPascal);\n}\n\nexport type ToCamel<S extends string | number | symbol> = S extends string\n  ? S extends NumericKey\n    ? S\n    : S extends `${infer Head}_${infer Tail}`\n    ? `${ToCamel<Uncapitalize<Head>>}${Capitalize<ToCamel<Tail>>}`\n    : S extends `${infer Head}-${infer Tail}`\n    ? `${ToCamel<Uncapitalize<Head>>}${Capitalize<ToCamel<Tail>>}`\n    : Uncapitalize<S>\n  : never;\n\nexport type ObjectToCamel<T extends object | undefined | null> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'camel'>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToCamel<K>]: ConvertObjectValue<T[K], 'camel'>;\n      };\n\nexport type ToPascal<S extends string | number | symbol> = S extends string\n  ? S extends NumericKey\n    ? S\n    : S extends `${infer Head}_${infer Tail}`\n    ? `${Capitalize<ToCamel<Head>>}${Capitalize<ToCamel<Tail>>}`\n    : S extends `${infer Head}-${infer Tail}`\n    ? `${Capitalize<ToCamel<Head>>}${Capitalize<ToCamel<Tail>>}`\n    : Capitalize<S>\n  : never;\n\nexport type ObjectToPascal<T extends object | undefined | null> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'pascal'>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToPascal<K>]: ConvertObjectValue<T[K], 'pascal'>;\n      };\n\nexport type ToSnake<\n  S extends string | number | symbol,\n  SplitNumbers extends boolean = true,\n> = S extends string\n  ? string extends S\n    ? string\n    : S extends NumericKey\n    ? S\n    : SnakeScan<S, '', 'start', SplitNumbers>\n  : never;\n\nexport type ObjectToSnake<\n  T extends object | undefined | null,\n  SplitNumbers extends boolean = true,\n> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'snake', SplitNumbers>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToSnake<K, SplitNumbers>]: ConvertObjectValue<\n          T[K],\n          'snake',\n          SplitNumbers\n        >;\n      };\n\nexport type ToScreamingSnake<\n  S extends string | number | symbol,\n  SplitNumbers extends boolean = true,\n> = Uppercase<ToSnake<S, SplitNumbers>>;\n\nexport type ObjectToScreamingSnake<\n  T extends object | undefined | null,\n  SplitNumbers extends boolean = true,\n> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'screamingSnake', SplitNumbers>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToScreamingSnake<K, SplitNumbers>]: ConvertObjectValue<\n          T[K],\n          'screamingSnake',\n          SplitNumbers\n        >;\n      };\n\ntype CaseMode = 'camel' | 'pascal' | 'snake' | 'screamingSnake';\n\ntype NumericKey = `${number}`;\n\ntype SnakeScan<\n  S extends string,\n  Acc extends string,\n  Previous extends CharacterKind,\n  SplitNumbers extends boolean,\n> = S extends `${infer Head}${infer Tail}`\n  ? Head extends Numbers\n    ? TakeNumberRun<S> extends [\n        infer NumberRun extends string,\n        infer AfterNumber extends string,\n      ]\n      ? SnakeScan<\n          AfterNumber,\n          `${Acc}${NumberSeparator<\n            Previous,\n            AfterNumber,\n            SplitNumbers\n          >}${NumberRun}`,\n          'number',\n          SplitNumbers\n        >\n      : never\n    : Head extends CapitalLetters\n    ? SnakeScan<\n        Tail,\n        `${Acc}${WordSeparator<Acc>}${Lowercase<Head>}`,\n        'upper',\n        SplitNumbers\n      >\n    : Head extends LowercaseLetters\n    ? SnakeScan<Tail, `${Acc}${Head}`, 'lower', SplitNumbers>\n    : SnakeScan<Tail, `${Acc}${Head}`, 'other', SplitNumbers>\n  : Acc;\n\ntype TakeNumberRun<\n  S extends string,\n  Acc extends string = '',\n> = S extends `${infer Head}${infer Tail}`\n  ? Head extends Numbers\n    ? TakeNumberRun<Tail, `${Acc}${Head}`>\n    : [Acc, S]\n  : [Acc, ''];\n\ntype NumberSeparator<\n  Previous extends CharacterKind,\n  AfterNumber extends string,\n  SplitNumbers extends boolean,\n> = SplitNumbers extends false\n  ? ''\n  : Previous extends 'lower'\n  ? AfterNumber extends `${CapitalLetters}${LowercaseLetters}${string}`\n    ? ''\n    : '_'\n  : '';\n\ntype WordSeparator<Acc extends string> = Acc extends ''\n  ? ''\n  : Acc extends `${string}_`\n  ? ''\n  : '_';\n\ntype CharacterKind = 'start' | 'lower' | 'upper' | 'number' | 'other';\n\ntype Convert<\n  T extends object | undefined | null,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean,\n> =\n  Mode extends 'camel'\n    ? ObjectToCamel<T>\n    : Mode extends 'pascal'\n    ? ObjectToPascal<T>\n    : Mode extends 'snake'\n    ? ObjectToSnake<T, SplitNumbers>\n    : ObjectToScreamingSnake<T, SplitNumbers>;\n\ntype ConvertArrayItem<\n  T,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean = true,\n> = T extends object\n  ? Convert<T, Mode, SplitNumbers>\n  : T;\n\ntype ConvertObjectValue<\n  T,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean = true,\n> = T extends Array<infer ArrayType>\n  ? Array<ConvertArrayItem<ArrayType, Mode, SplitNumbers>>\n  : T extends object | undefined | null\n  ? Convert<T, Mode, SplitNumbers>\n  : T;\n\nfunction isNumericKey(term: string): boolean {\n  return /^-?\\d+(?:\\.\\d+)?$/.test(term);\n}\n\ntype CapitalLetters =\n  | 'A'\n  | 'B'\n  | 'C'\n  | 'D'\n  | 'E'\n  | 'F'\n  | 'G'\n  | 'H'\n  | 'I'\n  | 'J'\n  | 'K'\n  | 'L'\n  | 'M'\n  | 'N'\n  | 'O'\n  | 'P'\n  | 'Q'\n  | 'R'\n  | 'S'\n  | 'T'\n  | 'U'\n  | 'V'\n  | 'W'\n  | 'X'\n  | 'Y'\n  | 'Z';\n\ntype LowercaseLetters =\n  | 'a'\n  | 'b'\n  | 'c'\n  | 'd'\n  | 'e'\n  | 'f'\n  | 'g'\n  | 'h'\n  | 'i'\n  | 'j'\n  | 'k'\n  | 'l'\n  | 'm'\n  | 'n'\n  | 'o'\n  | 'p'\n  | 'q'\n  | 'r'\n  | 's'\n  | 't'\n  | 'u'\n  | 'v'\n  | 'w'\n  | 'x'\n  | 'y'\n  | 'z';\n\ntype Numbers = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caseConvert.js","sourceRoot":"","sources":["../src/caseConvert.ts"],"names":[],"mappings":"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","sourcesContent":["function convertObject<TInput extends object, TResult>(\n  obj: TInput,\n  keyConverter: (arg: string) => string,\n): TResult {\n  if (obj === null || typeof obj === 'undefined' || typeof obj !== 'object') {\n    return obj as unknown as TResult;\n  }\n\n  const out = (Array.isArray(obj) ? [] : {}) as TResult;\n  for (const [k, v] of Object.entries(obj)) {\n\n    // @ts-ignore\n\n    out[keyConverter(k)] = Array.isArray(v)\n      ? (v.map(<ArrayItem extends object>(item: ArrayItem) =>\n          typeof item === 'object' &&\n          !(item instanceof Uint8Array) &&\n          !(item instanceof Date)\n            ? convertObject<\n                ArrayItem,\n                TResult extends ObjectToCamel<TInput>\n                  ? ObjectToCamel<ArrayItem>\n                  : TResult extends ObjectToPascal<TInput>\n                  ? ObjectToPascal<ArrayItem>\n                  : TResult extends ObjectToScreamingSnake<TInput>\n                  ? ObjectToScreamingSnake<ArrayItem>\n                  : ObjectToSnake<ArrayItem>\n              >(item, keyConverter)\n            : item,\n        ) as unknown[])\n      : v instanceof Uint8Array || v instanceof Date\n      ? v\n      : typeof v === 'object'\n      ? convertObject<\n          typeof v,\n          TResult extends ObjectToCamel<TInput>\n            ? ObjectToCamel<typeof v>\n            : TResult extends ObjectToPascal<TInput>\n            ? ObjectToPascal<typeof v>\n            : TResult extends ObjectToScreamingSnake<TInput>\n            ? ObjectToScreamingSnake<typeof v>\n            : ObjectToSnake<typeof v>\n        >(v, keyConverter)\n      : (v as unknown);\n  }\n  return out;\n}\n\n// Keep these word boundaries in sync with ConvertKeyScan below.\nfunction convertKey(term: string, mode: CaseMode, splitNumbers = false): string {\n  if (isNumericKey(term)) {\n    return term;\n  }\n\n  const hasSeparators = /[_-]/.test(term);\n  // Existing camel/Pascal names retain every letter after the first.\n  if ((mode === 'camel' || mode === 'pascal') && !hasSeparators) {\n    const first = term.charAt(0);\n    return (mode === 'camel' ? first.toLowerCase() : first.toUpperCase()) + term.slice(1);\n  }\n\n  let result = '';\n  let wordStart = 0;\n  const appendWord = (end: number): void => {\n    if (end === wordStart) {\n      return;\n    }\n    const word = term.slice(wordStart, end).toLowerCase();\n    if (mode === 'snake') {\n      result += `${result ? '_' : ''}${word}`;\n    } else {\n      result += mode === 'pascal' || result !== ''\n        ? word[0].toUpperCase() + word.slice(1)\n        : word;\n    }\n  };\n\n  for (let index = 0; index < term.length; index += 1) {\n    const current = term[index];\n    const previous = term[index - 1] ?? '';\n    if (current === '_' || current === '-') {\n      appendWord(index);\n      wordStart = index + 1;\n    } else if (splitNumbers && isDigit(current)) {\n      let afterNumber = index + 1;\n      while (afterNumber < term.length && isDigit(term[afterNumber])) {\n        afterNumber += 1;\n      }\n      if (isLowercase(previous) &&\n          !(isUppercase(term[afterNumber] ?? '') && isLowercase(term[afterNumber + 1] ?? ''))) {\n        appendWord(index);\n        wordStart = index;\n      }\n      index = afterNumber - 1;\n    } else if (index > wordStart && isUppercase(current) &&\n        (!hasSeparators || isLowercase(previous) || isDigit(previous) ||\n          (isUppercase(previous) && isLowercase(term[index + 1] ?? '')))) {\n      appendWord(index);\n      wordStart = index;\n    }\n  }\n  appendWord(term.length);\n  return result;\n}\n\nfunction isLowercase(character: string): boolean {\n  return character >= 'a' && character <= 'z';\n}\n\nfunction isUppercase(character: string): boolean {\n  return character >= 'A' && character <= 'Z';\n}\n\nfunction isDigit(character: string): boolean {\n  return character >= '0' && character <= '9';\n}\n\nexport function toCamel<T extends string>(term: T): ToCamel<T> {\n  return convertKey(term, 'camel') as ToCamel<T>;\n}\n\nexport function objectToCamel<T extends object>(obj: T): ObjectToCamel<T> {\n  return convertObject(obj, toCamel);\n}\n\nexport function toSnake<T extends string>(term: T): ToSnake<T> {\n  return convertKey(term, 'snake', true) as ToSnake<T>;\n}\n\nexport function toSnakeNoSplitNumbers<T extends string>(\n  term: T,\n): ToSnake<T, false> {\n  return convertKey(term, 'snake', false) as ToSnake<T, false>;\n}\n\nexport function objectToSnake<T extends object>(obj: T): ObjectToSnake<T> {\n  return convertObject(obj, toSnake);\n}\n\nexport function objectToSnakeNoSplitNumbers<T extends object>(\n  obj: T,\n): ObjectToSnake<T, false> {\n  return convertObject(obj, toSnakeNoSplitNumbers);\n}\n\nexport function toScreamingSnake<T extends string>(\n  term: T,\n): ToScreamingSnake<T> {\n  return toSnake(term).toUpperCase() as ToScreamingSnake<T>;\n}\n\nexport function toScreamingSnakeNoSplitNumbers<T extends string>(\n  term: T,\n): ToScreamingSnake<T, false> {\n  return toSnakeNoSplitNumbers(term).toUpperCase() as ToScreamingSnake<T, false>;\n}\n\nexport function objectToScreamingSnake<T extends object>(\n  obj: T,\n): ObjectToScreamingSnake<T> {\n  return convertObject(obj, toScreamingSnake);\n}\n\nexport function objectToScreamingSnakeNoSplitNumbers<T extends object>(\n  obj: T,\n): ObjectToScreamingSnake<T, false> {\n  return convertObject(obj, toScreamingSnakeNoSplitNumbers);\n}\n\nexport function toPascal<T extends string>(term: T): ToPascal<T> {\n  return convertKey(term, 'pascal') as ToPascal<T>;\n}\n\nexport function objectToPascal<T extends object>(obj: T): ObjectToPascal<T> {\n  return convertObject(obj, toPascal);\n}\n\nexport type ToCamel<S extends string | number | symbol> =\n  ConvertKey<S, 'camel', false>;\n\nexport type ObjectToCamel<T extends object | undefined | null> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'camel'>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToCamel<K>]: ConvertObjectValue<T[K], 'camel'>;\n      };\n\nexport type ToPascal<S extends string | number | symbol> =\n  ConvertKey<S, 'pascal', false>;\n\nexport type ObjectToPascal<T extends object | undefined | null> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'pascal'>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToPascal<K>]: ConvertObjectValue<T[K], 'pascal'>;\n      };\n\nexport type ToSnake<\n  S extends string | number | symbol,\n  SplitNumbers extends boolean = true,\n> = ConvertKey<S, 'snake', SplitNumbers>;\n\nexport type ObjectToSnake<\n  T extends object | undefined | null,\n  SplitNumbers extends boolean = true,\n> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'snake', SplitNumbers>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToSnake<K, SplitNumbers>]: ConvertObjectValue<\n          T[K],\n          'snake',\n          SplitNumbers\n        >;\n      };\n\nexport type ToScreamingSnake<\n  S extends string | number | symbol,\n  SplitNumbers extends boolean = true,\n> = Uppercase<ToSnake<S, SplitNumbers>>;\n\nexport type ObjectToScreamingSnake<\n  T extends object | undefined | null,\n  SplitNumbers extends boolean = true,\n> =\n  T extends undefined\n    ? undefined\n    : T extends null\n    ? null\n    : T extends Array<infer ArrayType>\n    ? Array<ConvertArrayItem<ArrayType, 'screamingSnake', SplitNumbers>>\n    : T extends Uint8Array\n    ? Uint8Array\n    : T extends Date\n    ? Date\n    : {\n        [K in keyof T as ToScreamingSnake<K, SplitNumbers>]: ConvertObjectValue<\n          T[K],\n          'screamingSnake',\n          SplitNumbers\n        >;\n      };\n\ntype CaseMode = 'camel' | 'pascal' | 'snake' | 'screamingSnake';\n\ntype ConvertKey<\n  S extends string | number | symbol,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean,\n> = S extends number\n  ? ConvertKey<`${S}`, Mode, SplitNumbers>\n  : S extends string\n  ? string extends S\n    ? string\n    : IsNumericKey<S> extends true\n    ? S\n    : S extends `${string}${'_' | '-'}${string}`\n    ? ConvertKeyScan<S, Mode, SplitNumbers>\n    : Mode extends 'camel'\n    ? Uncapitalize<S>\n    : Mode extends 'pascal'\n    ? Capitalize<S>\n    : ConvertKeyScan<S, Mode, SplitNumbers, true>\n  : never;\n\n// Signed decimal strings use the same grammar as isNumericKey at runtime.\ntype IsNumericKey<S extends string> = S extends `-${infer Unsigned}`\n  ? IsDecimal<Unsigned>\n  : IsDecimal<S>;\n\ntype IsDecimal<S extends string> = S extends `${infer Whole}.${infer Fraction}`\n  ? IsDigits<Whole> extends true\n    ? IsDigits<Fraction>\n    : false\n  : IsDigits<S>;\n\ntype IsDigits<S extends string> = S extends ''\n  ? false\n  : TakeNumberRun<S> extends [string, ''] ? true : false;\n\ntype AppendWord<\n  Acc extends string,\n  Word extends string,\n  Mode extends CaseMode,\n> = Word extends ''\n  ? Acc\n  : Mode extends 'snake'\n  ? Acc extends '' ? Lowercase<Word> : `${Acc}_${Lowercase<Word>}`\n  : Mode extends 'pascal'\n  ? `${Acc}${Capitalize<Lowercase<Word>>}`\n  : Acc extends '' ? Lowercase<Word> : `${Acc}${Capitalize<Lowercase<Word>>}`;\n\ntype ConvertKeyScan<\n  S extends string,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean,\n  SeparateCapitals extends boolean = false,\n  Acc extends string = '',\n  Word extends string = '',\n  Previous extends string = '',\n> = string extends S\n  ? string\n  : S extends `${infer Head}${infer Tail}`\n  ? string extends Head\n    ? string\n    : Head extends '_' | '-'\n    ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, AppendWord<Acc, Word, Mode>>\n    : Head extends Numbers\n    ? TakeNumberRun<S> extends [infer Digits extends string, infer After extends string]\n      ? SplitNumber<Previous, After, SplitNumbers> extends true\n        ? ConvertKeyScan<After, Mode, SplitNumbers, SeparateCapitals, AppendWord<Acc, Word, Mode>, Digits, '0'>\n        : ConvertKeyScan<After, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Digits}`, '0'>\n      : never\n    : Head extends CapitalLetters\n    ? StartsWord<Previous, Tail, SeparateCapitals> extends true\n      ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, AppendWord<Acc, Word, Mode>, Head, Head>\n      : ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Head}`, Head>\n    : Head extends LowercaseLetters\n    ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Head}`, Head>\n    : Extract<CapitalLetters | LowercaseLetters | Numbers | '_' | '-', Head> extends never\n    ? ConvertKeyScan<Tail, Mode, SplitNumbers, SeparateCapitals, Acc, `${Word}${Head}`, Head>\n    : string\n  : S extends '' ? AppendWord<Acc, Word, Mode> : string;\n\ntype StartsWord<\n  Previous extends string,\n  Tail extends string,\n  SeparateCapitals extends boolean,\n> = SeparateCapitals extends true\n  ? true\n  : Previous extends LowercaseLetters | Numbers\n    ? true\n    : Previous extends CapitalLetters\n    ? Tail extends `${LowercaseLetters}${string}` ? true : false\n    : false;\n\ntype TakeNumberRun<\n  S extends string,\n  Acc extends string = '',\n> = S extends `${infer Head}${infer Tail}`\n  ? Head extends Numbers\n    ? TakeNumberRun<Tail, `${Acc}${Head}`>\n    : [Acc, S]\n  : [Acc, ''];\n\ntype SplitNumber<\n  Previous extends string,\n  AfterNumber extends string,\n  SplitNumbers extends boolean,\n> = SplitNumbers extends false\n  ? false\n  : Previous extends LowercaseLetters\n  ? AfterNumber extends `${CapitalLetters}${LowercaseLetters}${string}`\n    ? false\n    : true\n  : false;\n\ntype Convert<\n  T extends object | undefined | null,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean,\n> =\n  Mode extends 'camel'\n    ? ObjectToCamel<T>\n    : Mode extends 'pascal'\n    ? ObjectToPascal<T>\n    : Mode extends 'snake'\n    ? ObjectToSnake<T, SplitNumbers>\n    : ObjectToScreamingSnake<T, SplitNumbers>;\n\ntype ConvertArrayItem<\n  T,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean = true,\n> = T extends object\n  ? Convert<T, Mode, SplitNumbers>\n  : T;\n\ntype ConvertObjectValue<\n  T,\n  Mode extends CaseMode,\n  SplitNumbers extends boolean = true,\n> = T extends Array<infer ArrayType>\n  ? Array<ConvertArrayItem<ArrayType, Mode, SplitNumbers>>\n  : T extends object | undefined | null\n  ? Convert<T, Mode, SplitNumbers>\n  : T;\n\nfunction isNumericKey(term: string): boolean {\n  return /^-?\\d+(?:\\.\\d+)?$/.test(term);\n}\n\ntype CapitalLetters =\n  | 'A'\n  | 'B'\n  | 'C'\n  | 'D'\n  | 'E'\n  | 'F'\n  | 'G'\n  | 'H'\n  | 'I'\n  | 'J'\n  | 'K'\n  | 'L'\n  | 'M'\n  | 'N'\n  | 'O'\n  | 'P'\n  | 'Q'\n  | 'R'\n  | 'S'\n  | 'T'\n  | 'U'\n  | 'V'\n  | 'W'\n  | 'X'\n  | 'Y'\n  | 'Z';\n\ntype LowercaseLetters =\n  | 'a'\n  | 'b'\n  | 'c'\n  | 'd'\n  | 'e'\n  | 'f'\n  | 'g'\n  | 'h'\n  | 'i'\n  | 'j'\n  | 'k'\n  | 'l'\n  | 'm'\n  | 'n'\n  | 'o'\n  | 'p'\n  | 'q'\n  | 'r'\n  | 's'\n  | 't'\n  | 'u'\n  | 'v'\n  | 'w'\n  | 'x'\n  | 'y'\n  | 'z';\n\ntype Numbers = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';\n"]}

package/package.json

@@ -62,7 +62,7 @@
       ]
     }
   },
-  "version": "2.3.2",
+  "version": "3.0.0",
   "types": "lib/index.d.ts",
   "exports": {
     ".": {