@cjser/camelcase 9.0.0-cjser.2 → 10.0.0-cjser.2

package/dist-cjser/index.cjs

@@ -16,36 +16,40 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/@cjser/camelcase/index.js
+// packages/@cjser/camelcase.tmp-26-1791822176987/index.js
 var index_exports = {};
 __export(index_exports, {
   default: () => camelCase
 });
 module.exports = __toCommonJS(index_exports);
-var UPPERCASE = /[\p{Lu}]/u;
-var LOWERCASE = /[\p{Ll}]/u;
-var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/u;
-var SEPARATORS = /[_.\- ]+/;
-var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
-var LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source);
-var SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
-var NUMBERS_AND_IDENTIFIER = new RegExp(String.raw`\d+` + IDENTIFIER.source, "gu");
+var UPPERCASE = new RegExp("\\p{Uppercase_Letter}", "v");
+var LOWERCASE = new RegExp("\\p{Lowercase_Letter}", "v");
+var ALPHABETIC = new RegExp("\\p{Alphabetic}", "v");
+var DIGIT = new RegExp("\\p{Decimal_Number}", "v");
+var LEADING_CAPITAL = new RegExp("^\\p{Uppercase_Letter}(?!\\p{Uppercase_Letter})", "v");
+var SEPARATORS = new RegExp("[ \\-._]+", "v");
+var LEADING_PREFIX = new RegExp("^[$_]*", "v");
+var IDENTIFIER = new RegExp("(?<identifier>[\\p{Alphabetic}\\p{Number}_]|$)", "v");
+var LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source, "v");
+var SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gv");
+var NUMBERS_AND_IDENTIFIER = new RegExp(String.raw`\p{Decimal_Number}+` + IDENTIFIER.source, "gv");
 var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase2) => {
+  const characters = [...string];
   let isLastCharLower = false;
   let isLastCharUpper = false;
   let isLastLastCharUpper = false;
   let isLastLastCharPreserved = false;
-  for (let index = 0; index < string.length; index++) {
-    const character = string[index];
-    isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
+  for (let index = 0; index < characters.length; index++) {
+    const character = characters[index];
+    isLastLastCharPreserved = index > 2 ? characters[index - 3] === "-" : true;
     if (isLastCharLower && UPPERCASE.test(character)) {
-      string = string.slice(0, index) + "-" + string.slice(index);
+      characters.splice(index, 0, "-");
       isLastCharLower = false;
       isLastLastCharUpper = isLastCharUpper;
       isLastCharUpper = true;
       index++;
     } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase2)) {
-      string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
+      characters.splice(index - 1, 0, "-");
       isLastLastCharUpper = isLastCharUpper;
       isLastCharUpper = false;
       isLastCharLower = true;
@@ -55,49 +59,44 @@ var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUp
       isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
     }
   }
-  return string;
+  return characters.join("");
 };
 var preserveConsecutiveUppercase = (input, toLowerCase) => input.replace(LEADING_CAPITAL, (match) => toLowerCase(match));
-var processWithCasePreservation = (input, toLowerCase, preserveConsecutiveUppercase2) => {
+var processWithCasePreservation = (input, toLowerCase, shouldPreserveConsecutiveUppercase) => {
   let result = "";
-  let previousWasNumber = false;
-  let previousWasUppercase = false;
+  let wasNumberBefore = false;
   const characters = [...input];
   for (let index = 0; index < characters.length; index++) {
     const character = characters[index];
     const isUpperCase = UPPERCASE.test(character);
-    const nextCharIsUpperCase = index + 1 < characters.length && UPPERCASE.test(characters[index + 1]);
-    if (previousWasNumber && /[\p{Alpha}]/u.test(character)) {
+    const isLoneLeadingCapital = index === 0 && isUpperCase && !(index + 1 < characters.length && UPPERCASE.test(characters[index + 1]));
+    if (wasNumberBefore && ALPHABETIC.test(character)) {
       result += character;
-      previousWasNumber = false;
-      previousWasUppercase = isUpperCase;
-    } else if (preserveConsecutiveUppercase2 && isUpperCase && (previousWasUppercase || nextCharIsUpperCase)) {
+      wasNumberBefore = false;
+    } else if (shouldPreserveConsecutiveUppercase && isUpperCase && !isLoneLeadingCapital) {
       result += character;
-      previousWasUppercase = true;
-    } else if (/\d/.test(character)) {
+    } else if (DIGIT.test(character)) {
       result += character;
-      previousWasNumber = true;
-      previousWasUppercase = false;
+      wasNumberBefore = true;
     } else if (SEPARATORS.test(character)) {
       result += character;
-      previousWasUppercase = false;
+      wasNumberBefore = false;
     } else {
       result += toLowerCase(character);
-      previousWasNumber = false;
-      previousWasUppercase = false;
+      wasNumberBefore = false;
     }
   }
   return result;
 };
 var postProcess = (input, toUpperCase, { capitalizeAfterNumber }) => {
-  const transformNumericIdentifier = capitalizeAfterNumber ? (match, identifier, offset, string) => {
+  const withNumbers = capitalizeAfterNumber ? input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, identifier, offset, string) => {
     const nextCharacter = string.charAt(offset + match.length);
     if (SEPARATORS.test(nextCharacter)) {
       return match;
     }
     return identifier ? match.slice(0, -identifier.length) + toUpperCase(identifier) : match;
-  } : (match) => match;
-  return input.replaceAll(NUMBERS_AND_IDENTIFIER, transformNumericIdentifier).replaceAll(
+  }) : input;
+  return withNumbers.replaceAll(
     SEPARATORS_AND_IDENTIFIER,
     (_, identifier) => toUpperCase(identifier)
   );
@@ -120,7 +119,7 @@ function camelCase(input, options) {
   if (input.length === 0) {
     return "";
   }
-  const leadingPrefix = input.match(/^[_$]*/)[0];
+  const leadingPrefix = input.match(LEADING_PREFIX)[0];
   input = input.slice(leadingPrefix.length);
   if (input.length === 0) {
     return leadingPrefix;
@@ -149,7 +148,8 @@ function camelCase(input, options) {
     input = processWithCasePreservation(input, toLowerCase, options.preserveConsecutiveUppercase);
   }
   if (options.pascalCase && input.length > 0) {
-    input = toUpperCase(input[0]) + input.slice(1);
+    const firstCharacter = String.fromCodePoint(input.codePointAt(0));
+    input = toUpperCase(firstCharacter) + input.slice(firstCharacter.length);
   }
   return leadingPrefix + postProcess(input, toUpperCase, options);
 }

package/index.d.ts

@@ -18,7 +18,7 @@ export type Options = {
 	readonly pascalCase?: boolean;
 
 	/**
-	Preserve consecutive uppercase characters: `foo-BAR` → `FooBAR`
+	Preserve consecutive uppercase characters: `foo-BAR` → `fooBAR`
 
 	@default false
 
@@ -31,17 +31,19 @@ export type Options = {
 
 	camelCase('foo-BAR', {preserveConsecutiveUppercase: false});
 	//=> 'fooBar'
-	````
+	```
 	*/
 	readonly preserveConsecutiveUppercase?: boolean;
 
 	/**
 	Controls whether letters immediately following digits are treated as word boundaries.
 
-	**When `true` (default):**
-	Capitalize the first letter immediately following a numeric sequence, unless a separator intervenes. This aligns with most utilities, such as Lodash.
+	When `true` (default):
+	Capitalize the first letter immediately following a numeric sequence, unless that letter is itself immediately followed by a separator. This is similar to Lodash, which also capitalizes after a number, but without the separator condition.
+
+	The extra condition keeps a token like `b2b` intact, so `b2b_registration` becomes `b2bRegistration` rather than `b2BRegistration`. It also means a trailing separator can stop the capitalization, as in `1a` → `1A` but `1a.` → `1a`.
 
-	**When `false`:**
+	When `false`:
 	Do not treat digits as word boundaries. Preserve the original case of letters immediately following digits. Separators still create word boundaries. This follows the Google Java Style Guide which treats numbers as non-boundary characters.
 
 	@default true
@@ -98,7 +100,7 @@ export type Options = {
 	```
 	import camelCase from '@cjser/camelcase';
 
-	// On a platform with `tr-TR`.`
+	// On a platform with `tr-TR`.
 
 	camelCase('lorem-ipsum');
 	//=> 'loremİpsum'
@@ -150,5 +152,5 @@ camelCase(['__foo__', '--bar']);
 */
 export default function camelcase(
 	input: string | readonly string[],
-	options?: Options
+	options?: Options,
 ): string;

package/index.js

@@ -1,34 +1,46 @@
-const UPPERCASE = /[\p{Lu}]/u;
-const LOWERCASE = /[\p{Ll}]/u;
-const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/u;
-const SEPARATORS = /[_.\- ]+/;
+const UPPERCASE = /\p{Uppercase_Letter}/v;
+const LOWERCASE = /\p{Lowercase_Letter}/v;
+const ALPHABETIC = /\p{Alphabetic}/v;
+// A decimal digit in any script, not only ASCII like `\d`. Other \p{Number} characters, such as superscripts and Roman numerals, are not digit runs.
+const DIGIT = /\p{Decimal_Number}/v;
+const LEADING_CAPITAL = /^\p{Uppercase_Letter}(?!\p{Uppercase_Letter})/v;
+const SEPARATORS = /[ \-._]+/v;
+const LEADING_PREFIX = /^[$_]*/v;
 
 // The |$ alternative allows matching at end-of-string, capturing empty string
 // This enables NUMBERS_AND_IDENTIFIER to match digits at string end (e.g., "test123")
-const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
-
-const LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source);
-const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, 'gu');
-const NUMBERS_AND_IDENTIFIER = new RegExp(String.raw`\d+` + IDENTIFIER.source, 'gu');
+//
+// A combining mark with no base letter is not an identifier, so `a-́b` comes back unchanged. A mark after a base letter is fine, so decomposed `café-bar` still gives `caféBar`.
+const IDENTIFIER = /(?<identifier>[\p{Alphabetic}\p{Number}_]|$)/v;
+
+const LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source, 'v');
+// A long separator run followed by a rejecting character backtracks quadratically (see the input length note in the readme). An atomic run would change the result for inputs like `a-_-!`, where the trailing `_` is the identifier.
+// eslint-disable-next-line regexp/no-super-linear-move
+const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, 'gv');
+// False positive: `\p{Decimal_Number}` is a subset of the identifier class, so a rejecting suffix costs one backtrack, not one per digit. A run of millions of non-ASCII digits can overflow V8's regex stack and throw a RangeError (see the input length note in the readme).
+// eslint-disable-next-line regexp/no-super-linear-move
+const NUMBERS_AND_IDENTIFIER = new RegExp(String.raw`\p{Decimal_Number}+` + IDENTIFIER.source, 'gv');
 
 const preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase) => {
+	// Iterate code points, not code units. Letters outside the basic multilingual plane need a surrogate pair, so indexing the string directly would see two meaningless halves per letter.
+	const characters = [...string];
 	let isLastCharLower = false;
 	let isLastCharUpper = false;
 	let isLastLastCharUpper = false;
 	let isLastLastCharPreserved = false;
 
-	for (let index = 0; index < string.length; index++) {
-		const character = string[index];
+	for (let index = 0; index < characters.length; index++) {
+		const character = characters[index];
 
 		// Was the character 3 positions back inserted as a separator?
 		// Prevents excessive separators by checking if we recently inserted one
 		// index - 3 accounts for: current character, inserted separator, previous character
 		// Default true for early positions activates the preserveConsecutiveUppercase guard
-		isLastLastCharPreserved = index > 2 ? string[index - 3] === '-' : true;
+		isLastLastCharPreserved = index > 2 ? characters[index - 3] === '-' : true;
 
 		if (isLastCharLower && UPPERCASE.test(character)) {
 			// FooBar → Foo-Bar (insert separator before uppercase)
-			string = string.slice(0, index) + '-' + string.slice(index);
+			characters.splice(index, 0, '-');
 			isLastCharLower = false;
 			isLastLastCharUpper = isLastCharUpper;
 			isLastCharUpper = true;
@@ -40,7 +52,7 @@ const preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutive
 			&& (!isLastLastCharPreserved || preserveConsecutiveUppercase)
 		) {
 			// FOOBar → FOO-Bar
-			string = string.slice(0, index - 1) + '-' + string.slice(index - 1);
+			characters.splice(index - 1, 0, '-');
 			isLastLastCharUpper = isLastCharUpper;
 			isLastCharUpper = false;
 			isLastCharLower = true;
@@ -55,54 +67,54 @@ const preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutive
 		}
 	}
 
-	return string;
+	return characters.join('');
 };
 
+// Only a lone leading capital is lowercased. Cased characters that are not Uppercase_Letter (titlecase letters, Roman numerals) survive here, while the capitalizeAfterNumber: false path lowercases them.
 const preserveConsecutiveUppercase = (input, toLowerCase) => input.replace(LEADING_CAPITAL, match => toLowerCase(match));
 
-const processWithCasePreservation = (input, toLowerCase, preserveConsecutiveUppercase) => {
+const processWithCasePreservation = (input, toLowerCase, shouldPreserveConsecutiveUppercase) => {
 	let result = '';
-	let previousWasNumber = false;
-	let previousWasUppercase = false;
+	let wasNumberBefore = false;
 
-	// Convert input to array for lookahead capability
+	// Iterate code points, not code units (see preserveCamelCase)
 	const characters = [...input];
 
 	for (let index = 0; index < characters.length; index++) {
 		const character = characters[index];
 		const isUpperCase = UPPERCASE.test(character);
-		const nextCharIsUpperCase = index + 1 < characters.length && UPPERCASE.test(characters[index + 1]);
 
-		if (previousWasNumber && /[\p{Alpha}]/u.test(character)) {
+		// Mirrors LEADING_CAPITAL: a lone capital at the very start of the string is lowercased, even when preserveConsecutiveUppercase is on.
+		const isLoneLeadingCapital = index === 0
+			&& isUpperCase
+			&& !(index + 1 < characters.length && UPPERCASE.test(characters[index + 1]));
+
+		if (wasNumberBefore && ALPHABETIC.test(character)) {
 			// Letter after number - preserve original case
 			result += character;
-			previousWasNumber = false;
-			previousWasUppercase = isUpperCase;
-		} else if (preserveConsecutiveUppercase && isUpperCase && (previousWasUppercase || nextCharIsUpperCase)) {
-			// Part of consecutive uppercase sequence when preserveConsecutiveUppercase is true - keep it
+			wasNumberBefore = false;
+		} else if (shouldPreserveConsecutiveUppercase && isUpperCase && !isLoneLeadingCapital) {
+			// Mirror the capitalizeAfterNumber: true path, which keeps every capital except a lone leading one.
 			result += character;
-			previousWasUppercase = true;
-		} else if (/\d/.test(character)) {
+		} else if (DIGIT.test(character)) {
 			// Number - keep as-is and track it
 			result += character;
-			previousWasNumber = true;
-			previousWasUppercase = false;
+			wasNumberBefore = true;
 		} else if (SEPARATORS.test(character)) {
-			// Separator - keep as-is and maintain previousWasNumber state
+			// Separator - keep as-is, and end any digit run, so the next letter is lowercased like any other.
 			result += character;
-			previousWasUppercase = false;
+			wasNumberBefore = false;
 		} else {
-			// Regular character - lowercase it
+			// Regular character - lowercase it. This goes one character at a time, so U+03A3 never becomes the final sigma, which depends on the surrounding characters.
 			result += toLowerCase(character);
-			previousWasNumber = false;
-			previousWasUppercase = false;
+			wasNumberBefore = false;
 		}
 	}
 
 	return result;
 };
 
-/**
+/*
 Core post-processing:
 - Collapses separators and uppercases the following identifier character.
 - Optionally uppercases the identifier following a numeric sequence.
@@ -116,8 +128,9 @@ Example: "b2b_registration" with capitalizeAfterNumber: true
 - Pass 2: "_r" matches, replace with "R" → "b2bRegistration"
 */
 const postProcess = (input, toUpperCase, {capitalizeAfterNumber}) => {
-	const transformNumericIdentifier = capitalizeAfterNumber
-		? (match, identifier, offset, string) => {
+	// When `capitalizeAfterNumber` is false, numbers do not create a word boundary, so pass 1 is skipped entirely.
+	const withNumbers = capitalizeAfterNumber
+		? input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, identifier, offset, string) => {
 			const nextCharacter = string.charAt(offset + match.length);
 
 			// If the numeric+identifier run is immediately followed by a separator,
@@ -128,16 +141,13 @@ const postProcess = (input, toUpperCase, {capitalizeAfterNumber}) => {
 
 			// Only uppercase the identifier part (not the digits) for efficiency
 			return identifier ? match.slice(0, -identifier.length) + toUpperCase(identifier) : match;
-		}
-		// When false: numbers do not create a word boundary.
-		: match => match;
-
-	return input
-		.replaceAll(NUMBERS_AND_IDENTIFIER, transformNumericIdentifier)
-		.replaceAll(
-			SEPARATORS_AND_IDENTIFIER,
-			(_, identifier) => toUpperCase(identifier),
-		);
+		})
+		: input;
+
+	return withNumbers.replaceAll(
+		SEPARATORS_AND_IDENTIFIER,
+		(_, identifier) => toUpperCase(identifier),
+	);
 };
 
 export default function camelCase(input, options) {
@@ -166,7 +176,7 @@ export default function camelCase(input, options) {
 	}
 
 	// Preserve leading _ and $ as they have semantic meaning
-	const leadingPrefix = input.match(/^[_$]*/)[0];
+	const leadingPrefix = input.match(LEADING_PREFIX)[0];
 	input = input.slice(leadingPrefix.length);
 
 	if (input.length === 0) {
@@ -217,7 +227,9 @@ export default function camelCase(input, options) {
 	}
 
 	if (options.pascalCase && input.length > 0) {
-		input = toUpperCase(input[0]) + input.slice(1);
+		// Read the first code point, not the first code unit, so astral letters get uppercased.
+		const firstCharacter = String.fromCodePoint(input.codePointAt(0));
+		input = toUpperCase(firstCharacter) + input.slice(firstCharacter.length);
 	}
 
 	return leadingPrefix + postProcess(input, toUpperCase, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjser/camelcase",
-  "version": "9.0.0-cjser.2",
+  "version": "10.0.0-cjser.2",
   "description": "Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar`",
   "license": "MIT",
   "repository": {
@@ -8,11 +8,7 @@
     "url": "https://code.moenext.com/3rdeye/cjser.git"
   },
   "funding": "https://github.com/sponsors/sindresorhus",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "https://sindresorhus.com"
-  },
+  "author": "Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)",
   "type": "module",
   "exports": {
     "types": "./index.d.ts",
@@ -21,10 +17,10 @@
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "scripts": {
-    "test": "xo && ava && tsd"
+    "test": "xo && node --test && nz"
   },
   "files": [
     "index.js",
@@ -32,7 +28,6 @@
     "dist-cjser"
   ],
   "keywords": [
-    "camelcase",
     "camel-case",
     "camel",
     "case",
@@ -48,18 +43,18 @@
     "pascal-case"
   ],
   "devDependencies": {
-    "ava": "^6.4.1",
-    "tsd": "^0.33.0",
-    "xo": "^1.2.3"
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "nz": "^0.1.0",
+    "xo": "^5.0.1"
   },
   "types": "./index.d.ts",
   "main": "./dist-cjser/index.cjs",
   "cjser": {
-    "sourceVersion": "9.0.0",
+    "sourceVersion": "10.0.0",
     "cjserVersion": 2,
     "original": {
       "name": "camelcase",
-      "version": "9.0.0",
+      "version": "10.0.0",
       "exports": {
         "types": "./index.d.ts",
         "default": "./index.js"
@@ -70,7 +65,7 @@
         "index.d.ts"
       ],
       "scripts": {
-        "test": "xo && ava && tsd"
+        "test": "xo && node --test && nz"
       }
     }
   }

package/readme.md

@@ -45,7 +45,9 @@ camelCase(['__foo__', '--bar']);
 ```
 
 > [!NOTE]
-> Not idempotent when special characters are present. `camelCase('{ A')` → `'{A}'`, but `camelCase('{A}')` → `'{a}'`.
+> Not idempotent in general. `camelCase('{ A')` → `'{A'`, but `camelCase('{A')` → `'{a'`.
+>
+> Mixed case input is not idempotent either, because the word boundaries have to be guessed: `camelCase('Ac_c A')` → `'acCA'`, but `camelCase('acCA')` → `'acCa'`.
 
 ## API
 
@@ -53,7 +55,7 @@ camelCase(['__foo__', '--bar']);
 
 #### input
 
-Type: `string | string[]`
+Type: `string | readonly string[]`
 
 The string to convert to camel case.
 
@@ -83,7 +85,7 @@ camelCase('foo-bar', {pascalCase: false});
 Type: `boolean`\
 Default: `false`
 
-Preserve consecutive uppercase characters: `foo-BAR` → `FooBAR`
+Preserve consecutive uppercase characters: `foo-BAR` → `fooBAR`
 
 ```js
 import camelCase from 'camelcase';
@@ -93,7 +95,7 @@ camelCase('foo-BAR', {preserveConsecutiveUppercase: true});
 
 camelCase('foo-BAR', {preserveConsecutiveUppercase: false});
 //=> 'fooBar'
-````
+```
 
 ##### capitalizeAfterNumber
 
@@ -102,10 +104,12 @@ Default: `true`
 
 Controls whether letters immediately following digits are treated as word boundaries.
 
-**When `true` (default):**
-Capitalize the first letter immediately following a numeric sequence, unless a separator intervenes. This aligns with most utilities, such as Lodash.
+When `true` (default):
+Capitalize the first letter immediately following a numeric sequence, unless that letter is itself immediately followed by a separator. This is similar to Lodash, which also capitalizes after a number, but without the separator condition.
+
+The extra condition keeps a token like `b2b` intact, so `b2b_registration` becomes `b2bRegistration` rather than `b2BRegistration`. It also means a trailing separator can stop the capitalization, as in `1a` → `1A` but `1a.` → `1a`.
 
-**When `false`:**
+When `false`:
 Do not treat digits as word boundaries. Preserve the original case of letters immediately following digits. Separators still create word boundaries. This follows the Google Java Style Guide which treats numbers as non-boundary characters.
 
 ```js
@@ -131,7 +135,7 @@ camelCase('foo_2_bar', {capitalizeAfterNumber: false});
 
 ##### locale
 
-Type: `false | string | string[]`\
+Type: `false | string | readonly string[]`\
 Default: The host environment’s current locale.
 
 The locale parameter indicates the locale to be used to convert to upper/lower case according to any locale-specific case mappings. If multiple locales are given in an array, the best available locale is used.