@naturalcycles/js-lib 14.149.2 → 14.150.0

package/dist/index.d.ts

@@ -78,6 +78,7 @@ export * from './env';
 export * from './http/http.model';
 export * from './http/fetcher';
 export * from './http/fetcher.model';
+export * from './string/hash.util';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';
 import { z, ZodSchema, ZodError, ZodIssue } from 'zod';

package/dist/index.js

@@ -82,6 +82,7 @@ tslib_1.__exportStar(require("./env"), exports);
 tslib_1.__exportStar(require("./http/http.model"), exports);
 tslib_1.__exportStar(require("./http/fetcher"), exports);
 tslib_1.__exportStar(require("./http/fetcher.model"), exports);
+tslib_1.__exportStar(require("./string/hash.util"), exports);
 tslib_1.__exportStar(require("./zod/zod.util"), exports);
 tslib_1.__exportStar(require("./zod/zod.shared.schemas"), exports);
 const zod_1 = require("zod");

package/dist/object/object.util.d.ts

@@ -44,7 +44,7 @@ export declare function _filterObject<T extends AnyObject>(obj: T, predicate: Ob
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.

package/dist/object/object.util.js

@@ -93,7 +93,7 @@ exports._filterObject = _filterObject;
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.
@@ -297,7 +297,7 @@ exports._invertMap = _invertMap;
  */
 function _get(obj = {}, path = '') {
     return path
-        .replace(/\[([^\]]+)]/g, '.$1')
+        .replaceAll(/\[([^\]]+)]/g, '.$1')
         .split('.')
         .reduce((o, p) => o?.[p], obj);
 }

package/dist/string/case.js

@@ -5,17 +5,17 @@ const words_1 = require("./lodash/words");
 const string_util_1 = require("./string.util");
 function _camelCase(s) {
     // return s.replace(/(_\w)/g, m => m[1]!.toUpperCase())
-    return (0, words_1.words)(s.replace(/['\u2019]/g, '')).reduce((result, word, index) => {
+    return (0, words_1.words)(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => {
         word = word.toLowerCase();
         return result + (index ? (0, string_util_1._upperFirst)(word) : word);
     }, '');
 }
 exports._camelCase = _camelCase;
 function _snakeCase(s) {
-    return (0, words_1.words)(s.replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '_' : '') + word.toLowerCase(), '');
+    return (0, words_1.words)(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '_' : '') + word.toLowerCase(), '');
 }
 exports._snakeCase = _snakeCase;
 function _kebabCase(s) {
-    return (0, words_1.words)(s.replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '-' : '') + word.toLowerCase(), '');
+    return (0, words_1.words)(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '-' : '') + word.toLowerCase(), '');
 }
 exports._kebabCase = _kebabCase;

package/dist/string/escape.js

@@ -16,19 +16,19 @@ exports.htmlUnescape = exports.htmlEscape = void 0;
 // Multiple `.replace()` calls are actually faster than using replacer functions
 function _htmlEscape(s) {
     return s
-        .replace(/&/g, '&') // Must happen first or else it will escape other just-escaped characters.
-        .replace(/"/g, '"')
-        .replace(/'/g, ''')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
+        .replaceAll('&', '&amp;') // Must happen first or else it will escape other just-escaped characters.
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
 }
 function _htmlUnescape(html) {
     return html
-        .replace(/&gt;/g, '>')
-        .replace(/&lt;/g, '<')
-        .replace(/&#0?39;/g, "'")
-        .replace(/&quot;/g, '"')
-        .replace(/&amp;/g, '&'); // Must happen last or else it will unescape other characters in the wrong order.
+        .replaceAll('&gt;', '>')
+        .replaceAll('&lt;', '<')
+        .replaceAll(/&#0?39;/g, "'")
+        .replaceAll('&quot;', '"')
+        .replaceAll('&amp;', '&'); // Must happen last or else it will unescape other characters in the wrong order.
 }
 function htmlEscape(strings, ...values) {
     if (typeof strings === 'string') {

package/dist/string/hash.util.d.ts

@@ -0,0 +1,38 @@
+import { Integer } from '../types';
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+export declare function hashCode16(s: string): string;
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+export declare function hashCode36(s: string): string;
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+export declare function hashCode64(s: string): string;
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+export declare function hashCode(s: string): Integer;

package/dist/string/hash.util.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashCode = exports.hashCode64 = exports.hashCode36 = exports.hashCode16 = void 0;
+const BASE62 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+// const BASE64 = BASE62 + '+/'
+const BASE64URL = BASE62 + '-_';
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+function hashCode16(s) {
+    return hashCode(s).toString(16);
+}
+exports.hashCode16 = hashCode16;
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+function hashCode36(s) {
+    return hashCode(s).toString(36);
+}
+exports.hashCode36 = hashCode36;
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+function hashCode64(s) {
+    return numberToBase(hashCode(s), BASE64URL);
+}
+exports.hashCode64 = hashCode64;
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+function hashCode(s) {
+    let hash = 0;
+    let i = 0;
+    const len = s.length;
+    while (i < len) {
+        // eslint-disable-next-line no-bitwise, unicorn/prefer-math-trunc, unicorn/prefer-code-point
+        hash = ((hash << 5) - hash + s.charCodeAt(i++)) << 0;
+    }
+    return hash + 2147483647 + 1;
+}
+exports.hashCode = hashCode;
+/**
+ * Source: https://gist.github.com/alkaruno/b84162bae5115f4ca99b
+ */
+function numberToBase(n, alphabet) {
+    const alen = alphabet.length;
+    let result = '';
+    do {
+        result = alphabet.charAt(n % alen) + result;
+        n = Math.floor(n / alen) - 1;
+    } while (n > -1);
+    return result;
+}

package/dist/string/pupa.js

@@ -52,9 +52,9 @@ function pupa(template, data, opt = {}) {
     // The regex tries to match either a number inside `{{ }}` or a valid JS identifier or key path.
     const doubleBraceRegex = /{{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi;
     if (doubleBraceRegex.test(template)) {
-        template = template.replace(doubleBraceRegex, composeHtmlEscape(replace));
+        template = template.replaceAll(doubleBraceRegex, composeHtmlEscape(replace));
     }
     const braceRegex = /{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi;
-    return template.replace(braceRegex, replace);
+    return template.replaceAll(braceRegex, replace);
 }
 exports.pupa = pupa;

package/dist/string/string.util.d.ts

@@ -35,13 +35,6 @@ export declare function _substringAfterLast(s: string, delimiter: string): strin
  * // `someFile`
  */
 export declare function _substringBetweenLast(s: string, leftDelimiter: string, rightDelimiter: string): string;
-/**
- * Polyfill for es2021 `String.prototype.replaceAll`.
- * Uses regex implementation that's a bit faster than another popular "split/join" implementation.
- *
- * Based on: https://stackoverflow.com/a/1144788/4919972
- */
-export declare function _replaceAll(s: string, find: string, replaceWith: string): string;
 /**
  * Converts `\n` (aka new-line) to `<br>`, to be presented in HTML.
  * Keeps `\n`, so if it's printed in non-HTML environment it still looks ok-ish.

package/dist/string/string.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._nl2br = exports._replaceAll = exports._substringBetweenLast = exports._substringAfterLast = exports._substringAfter = exports._substringBeforeLast = exports._substringBefore = exports._truncateMiddle = exports._truncate = exports._removeWhitespace = exports._split = exports._lowerFirst = exports._upperFirst = exports._capitalize = void 0;
+exports._nl2br = exports._substringBetweenLast = exports._substringAfterLast = exports._substringAfter = exports._substringBeforeLast = exports._substringBefore = exports._truncateMiddle = exports._truncate = exports._removeWhitespace = exports._split = exports._lowerFirst = exports._upperFirst = exports._capitalize = void 0;
 /**
  * Converts the first character of string to upper case and the remaining to lower case.
  */
@@ -29,7 +29,7 @@ function _split(str, separator, limit) {
 }
 exports._split = _split;
 function _removeWhitespace(s) {
-    return s.replace(/\s/g, '');
+    return s.replaceAll(/\s/g, '');
 }
 exports._removeWhitespace = _removeWhitespace;
 /**
@@ -92,21 +92,11 @@ function _substringBetweenLast(s, leftDelimiter, rightDelimiter) {
     return _substringBefore(_substringAfterLast(s, leftDelimiter), rightDelimiter);
 }
 exports._substringBetweenLast = _substringBetweenLast;
-/**
- * Polyfill for es2021 `String.prototype.replaceAll`.
- * Uses regex implementation that's a bit faster than another popular "split/join" implementation.
- *
- * Based on: https://stackoverflow.com/a/1144788/4919972
- */
-function _replaceAll(s, find, replaceWith) {
-    return s.replace(new RegExp(find, 'g'), replaceWith);
-}
-exports._replaceAll = _replaceAll;
 /**
  * Converts `\n` (aka new-line) to `<br>`, to be presented in HTML.
  * Keeps `\n`, so if it's printed in non-HTML environment it still looks ok-ish.
  */
 function _nl2br(s) {
-    return s.replace(/\n/g, '<br>\n');
+    return s.replaceAll('\n', '<br>\n');
 }
 exports._nl2br = _nl2br;

package/dist-esm/index.js

@@ -78,6 +78,7 @@ export * from './env';
 export * from './http/http.model';
 export * from './http/fetcher';
 export * from './http/fetcher.model';
+export * from './string/hash.util';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';
 import { z, ZodSchema, ZodError } from 'zod';

package/dist-esm/object/object.util.js

@@ -82,7 +82,7 @@ export function _filterObject(obj, predicate, mutate = false) {
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.
@@ -275,7 +275,7 @@ export function _invertMap(m) {
  */
 export function _get(obj = {}, path = '') {
     return path
-        .replace(/\[([^\]]+)]/g, '.$1')
+        .replaceAll(/\[([^\]]+)]/g, '.$1')
         .split('.')
         .reduce((o, p) => o === null || o === void 0 ? void 0 : o[p], obj);
 }

package/dist-esm/string/case.js

@@ -2,14 +2,14 @@ import { words } from './lodash/words';
 import { _upperFirst } from './string.util';
 export function _camelCase(s) {
     // return s.replace(/(_\w)/g, m => m[1]!.toUpperCase())
-    return words(s.replace(/['\u2019]/g, '')).reduce((result, word, index) => {
+    return words(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => {
         word = word.toLowerCase();
         return result + (index ? _upperFirst(word) : word);
     }, '');
 }
 export function _snakeCase(s) {
-    return words(s.replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '_' : '') + word.toLowerCase(), '');
+    return words(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '_' : '') + word.toLowerCase(), '');
 }
 export function _kebabCase(s) {
-    return words(s.replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '-' : '') + word.toLowerCase(), '');
+    return words(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '-' : '') + word.toLowerCase(), '');
 }

package/dist-esm/string/escape.js

@@ -13,19 +13,19 @@ Reasons:
 // Multiple `.replace()` calls are actually faster than using replacer functions
 function _htmlEscape(s) {
     return s
-        .replace(/&/g, '&') // Must happen first or else it will escape other just-escaped characters.
-        .replace(/"/g, '"')
-        .replace(/'/g, ''')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
+        .replaceAll('&', '&amp;') // Must happen first or else it will escape other just-escaped characters.
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
 }
 function _htmlUnescape(html) {
     return html
-        .replace(/&gt;/g, '>')
-        .replace(/&lt;/g, '<')
-        .replace(/&#0?39;/g, "'")
-        .replace(/&quot;/g, '"')
-        .replace(/&amp;/g, '&'); // Must happen last or else it will unescape other characters in the wrong order.
+        .replaceAll('&gt;', '>')
+        .replaceAll('&lt;', '<')
+        .replaceAll(/&#0?39;/g, "'")
+        .replaceAll('&quot;', '"')
+        .replaceAll('&amp;', '&'); // Must happen last or else it will unescape other characters in the wrong order.
 }
 export function htmlEscape(strings, ...values) {
     if (typeof strings === 'string') {

package/dist-esm/string/hash.util.js

@@ -0,0 +1,67 @@
+const BASE62 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+// const BASE64 = BASE62 + '+/'
+const BASE64URL = BASE62 + '-_';
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+export function hashCode16(s) {
+    return hashCode(s).toString(16);
+}
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+export function hashCode36(s) {
+    return hashCode(s).toString(36);
+}
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+export function hashCode64(s) {
+    return numberToBase(hashCode(s), BASE64URL);
+}
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+export function hashCode(s) {
+    let hash = 0;
+    let i = 0;
+    const len = s.length;
+    while (i < len) {
+        // eslint-disable-next-line no-bitwise, unicorn/prefer-math-trunc, unicorn/prefer-code-point
+        hash = ((hash << 5) - hash + s.charCodeAt(i++)) << 0;
+    }
+    return hash + 2147483647 + 1;
+}
+/**
+ * Source: https://gist.github.com/alkaruno/b84162bae5115f4ca99b
+ */
+function numberToBase(n, alphabet) {
+    const alen = alphabet.length;
+    let result = '';
+    do {
+        result = alphabet.charAt(n % alen) + result;
+        n = Math.floor(n / alen) - 1;
+    } while (n > -1);
+    return result;
+}

package/dist-esm/string/pupa.js

@@ -48,8 +48,8 @@ export function pupa(template, data, opt = {}) {
     // The regex tries to match either a number inside `{{ }}` or a valid JS identifier or key path.
     const doubleBraceRegex = /{{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi;
     if (doubleBraceRegex.test(template)) {
-        template = template.replace(doubleBraceRegex, composeHtmlEscape(replace));
+        template = template.replaceAll(doubleBraceRegex, composeHtmlEscape(replace));
     }
     const braceRegex = /{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi;
-    return template.replace(braceRegex, replace);
+    return template.replaceAll(braceRegex, replace);
 }

package/dist-esm/string/string.util.js

@@ -22,7 +22,7 @@ export function _split(str, separator, limit) {
     return [...parts.slice(0, limit - 1), parts.slice(limit - 1).join(separator)];
 }
 export function _removeWhitespace(s) {
-    return s.replace(/\s/g, '');
+    return s.replaceAll(/\s/g, '');
 }
 /**
  * _.truncate('hi-diddly-ho there, neighborino')
@@ -77,19 +77,10 @@ export function _substringAfterLast(s, delimiter) {
 export function _substringBetweenLast(s, leftDelimiter, rightDelimiter) {
     return _substringBefore(_substringAfterLast(s, leftDelimiter), rightDelimiter);
 }
-/**
- * Polyfill for es2021 `String.prototype.replaceAll`.
- * Uses regex implementation that's a bit faster than another popular "split/join" implementation.
- *
- * Based on: https://stackoverflow.com/a/1144788/4919972
- */
-export function _replaceAll(s, find, replaceWith) {
-    return s.replace(new RegExp(find, 'g'), replaceWith);
-}
 /**
  * Converts `\n` (aka new-line) to `<br>`, to be presented in HTML.
  * Keeps `\n`, so if it's printed in non-HTML environment it still looks ok-ish.
  */
 export function _nl2br(s) {
-    return s.replace(/\n/g, '<br>\n');
+    return s.replaceAll('\n', '<br>\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.149.2",
+  "version": "14.150.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",
@@ -16,7 +16,9 @@
     "@naturalcycles/dev-lib": "^13.0.1",
     "@naturalcycles/nodejs-lib": "^12.33.4",
     "@naturalcycles/time-lib": "^3.5.1",
-    "@types/node": "^18.0.0",
+    "@types/crypto-js": "^4.1.1",
+    "@types/node": "^20.1.0",
+    "crypto-js": "^4.1.1",
     "jest": "^29.0.0",
     "prettier": "^2.1.2",
     "rxjs": "^7.0.1",

package/src/index.ts

@@ -78,6 +78,7 @@ export * from './env'
 export * from './http/http.model'
 export * from './http/fetcher'
 export * from './http/fetcher.model'
+export * from './string/hash.util'
 export * from './zod/zod.util'
 export * from './zod/zod.shared.schemas'
 import { z, ZodSchema, ZodError, ZodIssue } from 'zod'

package/src/object/object.util.ts

@@ -111,7 +111,7 @@ export function _filterObject<T extends AnyObject>(
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.
@@ -322,7 +322,7 @@ export function _invertMap<K, V>(m: ReadonlyMap<K, V>): Map<V, K> {
  */
 export function _get<T extends AnyObject>(obj = {} as T, path = ''): unknown {
   return path
-    .replace(/\[([^\]]+)]/g, '.$1')
+    .replaceAll(/\[([^\]]+)]/g, '.$1')
     .split('.')
     .reduce((o, p) => o?.[p], obj)
 }

package/src/string/case.ts

@@ -3,21 +3,21 @@ import { _upperFirst } from './string.util'
 
 export function _camelCase(s: string): string {
   // return s.replace(/(_\w)/g, m => m[1]!.toUpperCase())
-  return words(s.replace(/['\u2019]/g, '')).reduce((result, word, index) => {
+  return words(s.replaceAll(/['\u2019]/g, '')).reduce((result, word, index) => {
     word = word.toLowerCase()
     return result + (index ? _upperFirst(word) : word)
   }, '')
 }
 
 export function _snakeCase(s: string): string {
-  return words(s.replace(/['\u2019]/g, '')).reduce(
+  return words(s.replaceAll(/['\u2019]/g, '')).reduce(
     (result, word, index) => result + (index ? '_' : '') + word.toLowerCase(),
     '',
   )
 }
 
 export function _kebabCase(s: string): string {
-  return words(s.replace(/['\u2019]/g, '')).reduce(
+  return words(s.replaceAll(/['\u2019]/g, '')).reduce(
     (result, word, index) => result + (index ? '-' : '') + word.toLowerCase(),
     '',
   )

package/src/string/escape.ts

@@ -14,20 +14,20 @@ Reasons:
 // Multiple `.replace()` calls are actually faster than using replacer functions
 function _htmlEscape(s: string): string {
   return s
-    .replace(/&/g, '&') // Must happen first or else it will escape other just-escaped characters.
-    .replace(/"/g, '"')
-    .replace(/'/g, ''')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
+    .replaceAll('&', '&amp;') // Must happen first or else it will escape other just-escaped characters.
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
 }
 
 function _htmlUnescape(html: string): string {
   return html
-    .replace(/&gt;/g, '>')
-    .replace(/&lt;/g, '<')
-    .replace(/&#0?39;/g, "'")
-    .replace(/&quot;/g, '"')
-    .replace(/&amp;/g, '&') // Must happen last or else it will unescape other characters in the wrong order.
+    .replaceAll('&gt;', '>')
+    .replaceAll('&lt;', '<')
+    .replaceAll(/&#0?39;/g, "'")
+    .replaceAll('&quot;', '"')
+    .replaceAll('&amp;', '&') // Must happen last or else it will unescape other characters in the wrong order.
 }
 
 export function htmlEscape(strings: string | TemplateStringsArray, ...values: any[]): string {

package/src/string/hash.util.ts

@@ -0,0 +1,76 @@
+import { Integer } from '../types'
+
+const BASE62 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+// const BASE64 = BASE62 + '+/'
+const BASE64URL = BASE62 + '-_'
+
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+export function hashCode16(s: string): string {
+  return hashCode(s).toString(16)
+}
+
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+export function hashCode36(s: string): string {
+  return hashCode(s).toString(36)
+}
+
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+export function hashCode64(s: string): string {
+  return numberToBase(hashCode(s), BASE64URL)
+}
+
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+export function hashCode(s: string): Integer {
+  let hash = 0
+  let i = 0
+  const len = s.length
+  while (i < len) {
+    // eslint-disable-next-line no-bitwise, unicorn/prefer-math-trunc, unicorn/prefer-code-point
+    hash = ((hash << 5) - hash + s.charCodeAt(i++)) << 0
+  }
+  return hash + 2147483647 + 1
+}
+
+/**
+ * Source: https://gist.github.com/alkaruno/b84162bae5115f4ca99b
+ */
+function numberToBase(n: number, alphabet: string): string {
+  const alen = alphabet.length
+  let result = ''
+
+  do {
+    result = alphabet.charAt(n % alen) + result
+    n = Math.floor(n / alen) - 1
+  } while (n > -1)
+
+  return result
+}

package/src/string/pupa.ts

@@ -77,10 +77,10 @@ export function pupa(template: string, data: any[] | AnyObject, opt: PupaOptions
   const doubleBraceRegex = /{{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}}/gi
 
   if (doubleBraceRegex.test(template)) {
-    template = template.replace(doubleBraceRegex, composeHtmlEscape(replace))
+    template = template.replaceAll(doubleBraceRegex, composeHtmlEscape(replace))
   }
 
   const braceRegex = /{(\d+|[a-z$_][\w\-$]*?(?:\.[\w\-$]*?)*?)}/gi
 
-  return template.replace(braceRegex, replace)
+  return template.replaceAll(braceRegex, replace)
 }

package/src/string/string.util.ts

@@ -25,7 +25,7 @@ export function _split(str: string, separator: string, limit: number): string[]
 }
 
 export function _removeWhitespace(s: string): string {
-  return s.replace(/\s/g, '')
+  return s.replaceAll(/\s/g, '')
 }
 
 /**
@@ -90,20 +90,10 @@ export function _substringBetweenLast(
   return _substringBefore(_substringAfterLast(s, leftDelimiter), rightDelimiter)
 }
 
-/**
- * Polyfill for es2021 `String.prototype.replaceAll`.
- * Uses regex implementation that's a bit faster than another popular "split/join" implementation.
- *
- * Based on: https://stackoverflow.com/a/1144788/4919972
- */
-export function _replaceAll(s: string, find: string, replaceWith: string): string {
-  return s.replace(new RegExp(find, 'g'), replaceWith)
-}
-
 /**
  * Converts `\n` (aka new-line) to `<br>`, to be presented in HTML.
  * Keeps `\n`, so if it's printed in non-HTML environment it still looks ok-ish.
  */
 export function _nl2br(s: string): string {
-  return s.replace(/\n/g, '<br>\n')
+  return s.replaceAll('\n', '<br>\n')
 }