@alwatr/hash-string 5.2.10 → 5.2.12

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.2.12](https://github.com/Alwatr/nanolib/compare/@alwatr/hash-string@5.2.11...@alwatr/hash-string@5.2.12) (2025-09-15)
+
+**Note:** Version bump only for package @alwatr/hash-string
+
+## [5.2.11](https://github.com/Alwatr/nanolib/compare/@alwatr/hash-string@5.2.10...@alwatr/hash-string@5.2.11) (2025-09-14)
+
+### 🔨 Code Refactoring
+
+* **hash:** remove djb2Hash implementation and tests ([140a1e1](https://github.com/Alwatr/nanolib/commit/140a1e191bbe864379e2621919f7fbc37f403afa))
+
 ## [5.2.10](https://github.com/Alwatr/nanolib/compare/@alwatr/hash-string@5.2.9...@alwatr/hash-string@5.2.10) (2025-09-13)
 
 **Note:** Version bump only for package @alwatr/hash-string

package/dist/main.cjs

@@ -1,68 +1,3 @@
-/* @alwatr/hash-string v5.2.10 */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/main.ts
-var main_exports = {};
-__export(main_exports, {
-  djb2Hash: () => djb2Hash,
-  nanoHash: () => nanoHash
-});
-module.exports = __toCommonJS(main_exports);
-
-// src/djb2-hash.ts
-function djb2Hash(str) {
-  let hashValue = 5381;
-  for (let i = str.length - 1; i >= 0; i--) {
-    hashValue = (hashValue << 5) + hashValue ^ str.charCodeAt(i);
-  }
-  return hashValue >>> 0;
-}
-
-// src/nano-hash.ts
-function nanoHash(str, prefix, repeat = 1) {
-  if (repeat < 1) {
-    throw new Error("The repeat parameter must be greater than or equal to 1");
-  }
-  let hash1 = 3735928559;
-  let hash2 = 1103547991;
-  if (typeof str === "number") {
-    str = str.toString();
-  }
-  const len = str.length;
-  for (let i = 0; i < len; i++) {
-    const char = str.charCodeAt(i);
-    hash1 = Math.imul(hash1 ^ char, 2654435761);
-    hash2 = Math.imul(hash2 ^ char, 1597334677);
-  }
-  hash1 = Math.imul(hash1 ^ hash1 >>> 16, 2246822507) ^ Math.imul(hash2 ^ hash2 >>> 13, 3266489909);
-  hash2 = Math.imul(hash2 ^ hash2 >>> 16, 2246822507) ^ Math.imul(hash1 ^ hash1 >>> 13, 3266489909);
-  const result = prefix + (hash1 >>> 0).toString(36) + (hash2 >>> 0).toString(36);
-  if (repeat === 1) {
-    return result;
-  } else {
-    return nanoHash(result, prefix, repeat - 1);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  djb2Hash,
-  nanoHash
-});
+/* @alwatr/hash-string v5.2.12 */
+"use strict";var __defProp=Object.defineProperty;var __getOwnPropDesc=Object.getOwnPropertyDescriptor;var __getOwnPropNames=Object.getOwnPropertyNames;var __hasOwnProp=Object.prototype.hasOwnProperty;var __export=(target,all)=>{for(var name in all)__defProp(target,name,{get:all[name],enumerable:true})};var __copyProps=(to,from,except,desc)=>{if(from&&typeof from==="object"||typeof from==="function"){for(let key of __getOwnPropNames(from))if(!__hasOwnProp.call(to,key)&&key!==except)__defProp(to,key,{get:()=>from[key],enumerable:!(desc=__getOwnPropDesc(from,key))||desc.enumerable})}return to};var __toCommonJS=mod=>__copyProps(__defProp({},"__esModule",{value:true}),mod);var main_exports={};__export(main_exports,{nanoHash:()=>nanoHash});module.exports=__toCommonJS(main_exports);function nanoHash(str,prefix,repeat=1){if(repeat<1){throw new Error("The repeat parameter must be greater than or equal to 1")}let hash1=3735928559;let hash2=1103547991;if(typeof str==="number"){str=str.toString()}const len=str.length;for(let i=0;i<len;i++){const char=str.charCodeAt(i);hash1=Math.imul(hash1^char,2654435761);hash2=Math.imul(hash2^char,1597334677)}hash1=Math.imul(hash1^hash1>>>16,2246822507)^Math.imul(hash2^hash2>>>13,3266489909);hash2=Math.imul(hash2^hash2>>>16,2246822507)^Math.imul(hash1^hash1>>>13,3266489909);const result=prefix+(hash1>>>0).toString(36)+(hash2>>>0).toString(36);if(repeat===1){return result}else{return nanoHash(result,prefix,repeat-1)}}0&&(module.exports={nanoHash});
 //# sourceMappingURL=main.cjs.map

package/dist/main.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../src/main.ts", "../src/djb2-hash.ts", "../src/nano-hash.ts"],
-  "sourcesContent": ["export * from './djb2-hash.js';\nexport * from './nano-hash.js';\n", "/**\n * DJB2 hash algorithm but faster!\n *\n * This implementation is based on Daniel J. Bernstein's popular 'times 33' hash algorithm,\n * commonly known as DJB2. It's known for its simplicity, speed, and good distribution properties\n * for short strings, making it suitable for general purpose hashing needs.\n *\n * Performance improvements in this version:\n * - Uses right-to-left iteration to avoid repeated length lookups\n * - Employs bit shifting operations for faster computation\n * - Final right shift ensures unsigned 32-bit integer output\n *\n * @param {string} str - The input string to be hashed\n * @returns {number} A 32-bit unsigned integer hash value\n *\n * @example\n * // Returns a numeric hash value\n * const hashValue = djb2Hash(\"hello world\");\n */\nexport function djb2Hash(str: string): number {\n  // 5381 is a prime number used as initial value in the DJB2 algorithm\n  let hashValue = 5381;\n\n  // Reverse loop for better performance - avoids repeated length property lookup\n  for (let i = str.length - 1; i >= 0; i--) {\n    // Using left shift (*2) and addition instead of multiplication by 33\n    // (hash * 33) is equivalent to ((hash << 5) + hash)\n    hashValue = ((hashValue << 5) + hashValue) ^ str.charCodeAt(i);\n  }\n\n  return hashValue >>> 0;\n}\n", "/**\n * Simple hash string for fast hashing (like md5).\n * This function is not very secure and should not be used for security purposes.\n * But it cannot be reversed easily and brute force can take up to years for fast computers.\n *\n * @param str - The string or number to hash\n * @param prefix - A prefix to add to the beginning of the hash result\n * @param repeat - Number of times to repeat the hashing process for increased complexity (default: 3)\n * @returns A hashed string with the specified prefix\n */\nexport function nanoHash(str: string | number, prefix: string, repeat = 1): string {\n  if (repeat < 1) {\n    throw new Error('The repeat parameter must be greater than or equal to 1');\n  }\n\n  let hash1 = 0xdeadbeef;\n  let hash2 = 0x41c6ce57;\n\n  if (typeof str === 'number') {\n    str = str.toString();\n  }\n\n  const len = str.length;\n  for (let i = 0; i < len; i++) {\n    const char = str.charCodeAt(i);\n    hash1 = Math.imul(hash1 ^ char, 2654435761);\n    hash2 = Math.imul(hash2 ^ char, 1597334677);\n  }\n\n  hash1 = Math.imul(hash1 ^ (hash1 >>> 16), 2246822507) ^ Math.imul(hash2 ^ (hash2 >>> 13), 3266489909);\n  hash2 = Math.imul(hash2 ^ (hash2 >>> 16), 2246822507) ^ Math.imul(hash1 ^ (hash1 >>> 13), 3266489909);\n\n  const result = prefix + (hash1 >>> 0).toString(36) + (hash2 >>> 0).toString(36);\n  if (repeat === 1) {\n    return result;\n  }\n  else {\n    return nanoHash(result, prefix, repeat - 1);\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACmBO,SAAS,SAAS,KAAqB;AAE5C,MAAI,YAAY;AAGhB,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AAGxC,iBAAc,aAAa,KAAK,YAAa,IAAI,WAAW,CAAC;AAAA,EAC/D;AAEA,SAAO,cAAc;AACvB;;;ACrBO,SAAS,SAAS,KAAsB,QAAgB,SAAS,GAAW;AACjF,MAAI,SAAS,GAAG;AACd,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AAEA,MAAI,QAAQ;AACZ,MAAI,QAAQ;AAEZ,MAAI,OAAO,QAAQ,UAAU;AAC3B,UAAM,IAAI,SAAS;AAAA,EACrB;AAEA,QAAM,MAAM,IAAI;AAChB,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,UAAM,OAAO,IAAI,WAAW,CAAC;AAC7B,YAAQ,KAAK,KAAK,QAAQ,MAAM,UAAU;AAC1C,YAAQ,KAAK,KAAK,QAAQ,MAAM,UAAU;AAAA,EAC5C;AAEA,UAAQ,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU,IAAI,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU;AACpG,UAAQ,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU,IAAI,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU;AAEpG,QAAM,SAAS,UAAU,UAAU,GAAG,SAAS,EAAE,KAAK,UAAU,GAAG,SAAS,EAAE;AAC9E,MAAI,WAAW,GAAG;AAChB,WAAO;AAAA,EACT,OACK;AACH,WAAO,SAAS,QAAQ,QAAQ,SAAS,CAAC;AAAA,EAC5C;AACF;",
+  "sources": ["../src/main.ts"],
+  "sourcesContent": ["/**\n * Simple hash string for fast hashing (like md5).\n * This function is not very secure and should not be used for security purposes.\n * But it cannot be reversed easily and brute force can take up to years for fast computers.\n *\n * @param str - The string or number to hash\n * @param prefix - A prefix to add to the beginning of the hash result\n * @param repeat - Number of times to repeat the hashing process for increased complexity (default: 3)\n * @returns A hashed string with the specified prefix\n */\nexport function nanoHash(str: string | number, prefix: string, repeat = 1): string {\n  if (repeat < 1) {\n    throw new Error('The repeat parameter must be greater than or equal to 1');\n  }\n\n  let hash1 = 0xdeadbeef;\n  let hash2 = 0x41c6ce57;\n\n  if (typeof str === 'number') {\n    str = str.toString();\n  }\n\n  const len = str.length;\n  for (let i = 0; i < len; i++) {\n    const char = str.charCodeAt(i);\n    hash1 = Math.imul(hash1 ^ char, 2654435761);\n    hash2 = Math.imul(hash2 ^ char, 1597334677);\n  }\n\n  hash1 = Math.imul(hash1 ^ (hash1 >>> 16), 2246822507) ^ Math.imul(hash2 ^ (hash2 >>> 13), 3266489909);\n  hash2 = Math.imul(hash2 ^ (hash2 >>> 16), 2246822507) ^ Math.imul(hash1 ^ (hash1 >>> 13), 3266489909);\n\n  const result = prefix + (hash1 >>> 0).toString(36) + (hash2 >>> 0).toString(36);\n  if (repeat === 1) {\n    return result;\n  }\n  else {\n    return nanoHash(result, prefix, repeat - 1);\n  }\n}\n"],
+  "mappings": ";qqBAAA,6GAUO,SAAS,SAAS,IAAsB,OAAgB,OAAS,EAAW,CACjF,GAAI,OAAS,EAAG,CACd,MAAM,IAAI,MAAM,yDAAyD,CAC3E,CAEA,IAAI,MAAQ,WACZ,IAAI,MAAQ,WAEZ,GAAI,OAAO,MAAQ,SAAU,CAC3B,IAAM,IAAI,SAAS,CACrB,CAEA,MAAM,IAAM,IAAI,OAChB,QAAS,EAAI,EAAG,EAAI,IAAK,IAAK,CAC5B,MAAM,KAAO,IAAI,WAAW,CAAC,EAC7B,MAAQ,KAAK,KAAK,MAAQ,KAAM,UAAU,EAC1C,MAAQ,KAAK,KAAK,MAAQ,KAAM,UAAU,CAC5C,CAEA,MAAQ,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EAAI,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EACpG,MAAQ,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EAAI,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EAEpG,MAAM,OAAS,QAAU,QAAU,GAAG,SAAS,EAAE,GAAK,QAAU,GAAG,SAAS,EAAE,EAC9E,GAAI,SAAW,EAAG,CAChB,OAAO,MACT,KACK,CACH,OAAO,SAAS,OAAQ,OAAQ,OAAS,CAAC,CAC5C,CACF",
   "names": []
 }

package/dist/main.d.ts

@@ -1,3 +1,12 @@
-export * from './djb2-hash.js';
-export * from './nano-hash.js';
+/**
+ * Simple hash string for fast hashing (like md5).
+ * This function is not very secure and should not be used for security purposes.
+ * But it cannot be reversed easily and brute force can take up to years for fast computers.
+ *
+ * @param str - The string or number to hash
+ * @param prefix - A prefix to add to the beginning of the hash result
+ * @param repeat - Number of times to repeat the hashing process for increased complexity (default: 3)
+ * @returns A hashed string with the specified prefix
+ */
+export declare function nanoHash(str: string | number, prefix: string, repeat?: number): string;
 //# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,MAAM,CA6BjF"}

package/dist/main.mjs

@@ -1,41 +1,3 @@
-/* @alwatr/hash-string v5.2.10 */
-
-// src/djb2-hash.ts
-function djb2Hash(str) {
-  let hashValue = 5381;
-  for (let i = str.length - 1; i >= 0; i--) {
-    hashValue = (hashValue << 5) + hashValue ^ str.charCodeAt(i);
-  }
-  return hashValue >>> 0;
-}
-
-// src/nano-hash.ts
-function nanoHash(str, prefix, repeat = 1) {
-  if (repeat < 1) {
-    throw new Error("The repeat parameter must be greater than or equal to 1");
-  }
-  let hash1 = 3735928559;
-  let hash2 = 1103547991;
-  if (typeof str === "number") {
-    str = str.toString();
-  }
-  const len = str.length;
-  for (let i = 0; i < len; i++) {
-    const char = str.charCodeAt(i);
-    hash1 = Math.imul(hash1 ^ char, 2654435761);
-    hash2 = Math.imul(hash2 ^ char, 1597334677);
-  }
-  hash1 = Math.imul(hash1 ^ hash1 >>> 16, 2246822507) ^ Math.imul(hash2 ^ hash2 >>> 13, 3266489909);
-  hash2 = Math.imul(hash2 ^ hash2 >>> 16, 2246822507) ^ Math.imul(hash1 ^ hash1 >>> 13, 3266489909);
-  const result = prefix + (hash1 >>> 0).toString(36) + (hash2 >>> 0).toString(36);
-  if (repeat === 1) {
-    return result;
-  } else {
-    return nanoHash(result, prefix, repeat - 1);
-  }
-}
-export {
-  djb2Hash,
-  nanoHash
-};
+/* @alwatr/hash-string v5.2.12 */
+function nanoHash(str,prefix,repeat=1){if(repeat<1){throw new Error("The repeat parameter must be greater than or equal to 1")}let hash1=3735928559;let hash2=1103547991;if(typeof str==="number"){str=str.toString()}const len=str.length;for(let i=0;i<len;i++){const char=str.charCodeAt(i);hash1=Math.imul(hash1^char,2654435761);hash2=Math.imul(hash2^char,1597334677)}hash1=Math.imul(hash1^hash1>>>16,2246822507)^Math.imul(hash2^hash2>>>13,3266489909);hash2=Math.imul(hash2^hash2>>>16,2246822507)^Math.imul(hash1^hash1>>>13,3266489909);const result=prefix+(hash1>>>0).toString(36)+(hash2>>>0).toString(36);if(repeat===1){return result}else{return nanoHash(result,prefix,repeat-1)}}export{nanoHash};
 //# sourceMappingURL=main.mjs.map

package/dist/main.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../src/djb2-hash.ts", "../src/nano-hash.ts"],
-  "sourcesContent": ["/**\n * DJB2 hash algorithm but faster!\n *\n * This implementation is based on Daniel J. Bernstein's popular 'times 33' hash algorithm,\n * commonly known as DJB2. It's known for its simplicity, speed, and good distribution properties\n * for short strings, making it suitable for general purpose hashing needs.\n *\n * Performance improvements in this version:\n * - Uses right-to-left iteration to avoid repeated length lookups\n * - Employs bit shifting operations for faster computation\n * - Final right shift ensures unsigned 32-bit integer output\n *\n * @param {string} str - The input string to be hashed\n * @returns {number} A 32-bit unsigned integer hash value\n *\n * @example\n * // Returns a numeric hash value\n * const hashValue = djb2Hash(\"hello world\");\n */\nexport function djb2Hash(str: string): number {\n  // 5381 is a prime number used as initial value in the DJB2 algorithm\n  let hashValue = 5381;\n\n  // Reverse loop for better performance - avoids repeated length property lookup\n  for (let i = str.length - 1; i >= 0; i--) {\n    // Using left shift (*2) and addition instead of multiplication by 33\n    // (hash * 33) is equivalent to ((hash << 5) + hash)\n    hashValue = ((hashValue << 5) + hashValue) ^ str.charCodeAt(i);\n  }\n\n  return hashValue >>> 0;\n}\n", "/**\n * Simple hash string for fast hashing (like md5).\n * This function is not very secure and should not be used for security purposes.\n * But it cannot be reversed easily and brute force can take up to years for fast computers.\n *\n * @param str - The string or number to hash\n * @param prefix - A prefix to add to the beginning of the hash result\n * @param repeat - Number of times to repeat the hashing process for increased complexity (default: 3)\n * @returns A hashed string with the specified prefix\n */\nexport function nanoHash(str: string | number, prefix: string, repeat = 1): string {\n  if (repeat < 1) {\n    throw new Error('The repeat parameter must be greater than or equal to 1');\n  }\n\n  let hash1 = 0xdeadbeef;\n  let hash2 = 0x41c6ce57;\n\n  if (typeof str === 'number') {\n    str = str.toString();\n  }\n\n  const len = str.length;\n  for (let i = 0; i < len; i++) {\n    const char = str.charCodeAt(i);\n    hash1 = Math.imul(hash1 ^ char, 2654435761);\n    hash2 = Math.imul(hash2 ^ char, 1597334677);\n  }\n\n  hash1 = Math.imul(hash1 ^ (hash1 >>> 16), 2246822507) ^ Math.imul(hash2 ^ (hash2 >>> 13), 3266489909);\n  hash2 = Math.imul(hash2 ^ (hash2 >>> 16), 2246822507) ^ Math.imul(hash1 ^ (hash1 >>> 13), 3266489909);\n\n  const result = prefix + (hash1 >>> 0).toString(36) + (hash2 >>> 0).toString(36);\n  if (repeat === 1) {\n    return result;\n  }\n  else {\n    return nanoHash(result, prefix, repeat - 1);\n  }\n}\n"],
-  "mappings": ";;;AAmBO,SAAS,SAAS,KAAqB;AAE5C,MAAI,YAAY;AAGhB,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AAGxC,iBAAc,aAAa,KAAK,YAAa,IAAI,WAAW,CAAC;AAAA,EAC/D;AAEA,SAAO,cAAc;AACvB;;;ACrBO,SAAS,SAAS,KAAsB,QAAgB,SAAS,GAAW;AACjF,MAAI,SAAS,GAAG;AACd,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AAEA,MAAI,QAAQ;AACZ,MAAI,QAAQ;AAEZ,MAAI,OAAO,QAAQ,UAAU;AAC3B,UAAM,IAAI,SAAS;AAAA,EACrB;AAEA,QAAM,MAAM,IAAI;AAChB,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,UAAM,OAAO,IAAI,WAAW,CAAC;AAC7B,YAAQ,KAAK,KAAK,QAAQ,MAAM,UAAU;AAC1C,YAAQ,KAAK,KAAK,QAAQ,MAAM,UAAU;AAAA,EAC5C;AAEA,UAAQ,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU,IAAI,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU;AACpG,UAAQ,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU,IAAI,KAAK,KAAK,QAAS,UAAU,IAAK,UAAU;AAEpG,QAAM,SAAS,UAAU,UAAU,GAAG,SAAS,EAAE,KAAK,UAAU,GAAG,SAAS,EAAE;AAC9E,MAAI,WAAW,GAAG;AAChB,WAAO;AAAA,EACT,OACK;AACH,WAAO,SAAS,QAAQ,QAAQ,SAAS,CAAC;AAAA,EAC5C;AACF;",
+  "sources": ["../src/main.ts"],
+  "sourcesContent": ["/**\n * Simple hash string for fast hashing (like md5).\n * This function is not very secure and should not be used for security purposes.\n * But it cannot be reversed easily and brute force can take up to years for fast computers.\n *\n * @param str - The string or number to hash\n * @param prefix - A prefix to add to the beginning of the hash result\n * @param repeat - Number of times to repeat the hashing process for increased complexity (default: 3)\n * @returns A hashed string with the specified prefix\n */\nexport function nanoHash(str: string | number, prefix: string, repeat = 1): string {\n  if (repeat < 1) {\n    throw new Error('The repeat parameter must be greater than or equal to 1');\n  }\n\n  let hash1 = 0xdeadbeef;\n  let hash2 = 0x41c6ce57;\n\n  if (typeof str === 'number') {\n    str = str.toString();\n  }\n\n  const len = str.length;\n  for (let i = 0; i < len; i++) {\n    const char = str.charCodeAt(i);\n    hash1 = Math.imul(hash1 ^ char, 2654435761);\n    hash2 = Math.imul(hash2 ^ char, 1597334677);\n  }\n\n  hash1 = Math.imul(hash1 ^ (hash1 >>> 16), 2246822507) ^ Math.imul(hash2 ^ (hash2 >>> 13), 3266489909);\n  hash2 = Math.imul(hash2 ^ (hash2 >>> 16), 2246822507) ^ Math.imul(hash1 ^ (hash1 >>> 13), 3266489909);\n\n  const result = prefix + (hash1 >>> 0).toString(36) + (hash2 >>> 0).toString(36);\n  if (repeat === 1) {\n    return result;\n  }\n  else {\n    return nanoHash(result, prefix, repeat - 1);\n  }\n}\n"],
+  "mappings": ";AAUO,SAAS,SAAS,IAAsB,OAAgB,OAAS,EAAW,CACjF,GAAI,OAAS,EAAG,CACd,MAAM,IAAI,MAAM,yDAAyD,CAC3E,CAEA,IAAI,MAAQ,WACZ,IAAI,MAAQ,WAEZ,GAAI,OAAO,MAAQ,SAAU,CAC3B,IAAM,IAAI,SAAS,CACrB,CAEA,MAAM,IAAM,IAAI,OAChB,QAAS,EAAI,EAAG,EAAI,IAAK,IAAK,CAC5B,MAAM,KAAO,IAAI,WAAW,CAAC,EAC7B,MAAQ,KAAK,KAAK,MAAQ,KAAM,UAAU,EAC1C,MAAQ,KAAK,KAAK,MAAQ,KAAM,UAAU,CAC5C,CAEA,MAAQ,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EAAI,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EACpG,MAAQ,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EAAI,KAAK,KAAK,MAAS,QAAU,GAAK,UAAU,EAEpG,MAAM,OAAS,QAAU,QAAU,GAAG,SAAS,EAAE,GAAK,QAAU,GAAG,SAAS,EAAE,EAC9E,GAAI,SAAW,EAAG,CAChB,OAAO,MACT,KACK,CACH,OAAO,SAAS,OAAQ,OAAQ,OAAS,CAAC,CAC5C,CACF",
   "names": []
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@alwatr/hash-string",
   "description": "A simple utility to generate a hash string.",
-  "version": "5.2.10",
+  "version": "5.2.12",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com>",
   "bugs": "https://github.com/Alwatr/nanolib/issues",
   "devDependencies": {
-    "@alwatr/nano-build": "6.1.2",
+    "@alwatr/nano-build": "6.2.0",
     "@alwatr/prettier-config": "5.0.3",
     "@alwatr/tsconfig-base": "6.0.1",
     "jest": "^30.1.3",
@@ -72,5 +72,5 @@
   },
   "type": "module",
   "types": "./dist/main.d.ts",
-  "gitHead": "4da18811162df49c118acd71086cdbe38b27f250"
+  "gitHead": "e081773e1ba6bf1c62c07d7dc966b174fa7dd3ea"
 }

package/dist/djb2-hash.d.ts

@@ -1,21 +0,0 @@
-/**
- * DJB2 hash algorithm but faster!
- *
- * This implementation is based on Daniel J. Bernstein's popular 'times 33' hash algorithm,
- * commonly known as DJB2. It's known for its simplicity, speed, and good distribution properties
- * for short strings, making it suitable for general purpose hashing needs.
- *
- * Performance improvements in this version:
- * - Uses right-to-left iteration to avoid repeated length lookups
- * - Employs bit shifting operations for faster computation
- * - Final right shift ensures unsigned 32-bit integer output
- *
- * @param {string} str - The input string to be hashed
- * @returns {number} A 32-bit unsigned integer hash value
- *
- * @example
- * // Returns a numeric hash value
- * const hashValue = djb2Hash("hello world");
- */
-export declare function djb2Hash(str: string): number;
-//# sourceMappingURL=djb2-hash.d.ts.map

package/dist/djb2-hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"djb2-hash.d.ts","sourceRoot":"","sources":["../src/djb2-hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAY5C"}

package/dist/nano-hash.d.ts

@@ -1,12 +0,0 @@
-/**
- * Simple hash string for fast hashing (like md5).
- * This function is not very secure and should not be used for security purposes.
- * But it cannot be reversed easily and brute force can take up to years for fast computers.
- *
- * @param str - The string or number to hash
- * @param prefix - A prefix to add to the beginning of the hash result
- * @param repeat - Number of times to repeat the hashing process for increased complexity (default: 3)
- * @returns A hashed string with the specified prefix
- */
-export declare function nanoHash(str: string | number, prefix: string, repeat?: number): string;
-//# sourceMappingURL=nano-hash.d.ts.map

package/dist/nano-hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nano-hash.d.ts","sourceRoot":"","sources":["../src/nano-hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,MAAM,CA6BjF"}

package/src/djb2-hash.test.js

@@ -1,72 +0,0 @@
-import {djb2Hash} from '@alwatr/hash-string';
-
-describe('djb2Hash', () => {
-  it('should generate numeric hash values for string inputs', () => {
-    const result = djb2Hash('test');
-    expect(typeof result).toBe('number');
-    expect(Number.isInteger(result)).toBe(true);
-  });
-
-  it('should return different hashes for different inputs', () => {
-    const hash1 = djb2Hash('test1');
-    const hash2 = djb2Hash('test2');
-    expect(hash1).not.toBe(hash2);
-  });
-
-  it('should generate consistent hashes for the same input', () => {
-    const input = 'consistencyTest';
-    const hash1 = djb2Hash(input);
-    const hash2 = djb2Hash(input);
-    expect(hash1).toBe(hash2);
-  });
-
-  it('should handle empty strings', () => {
-    const result = djb2Hash('');
-    expect(typeof result).toBe('number');
-    // The hash for an empty string should be the initial value right-shifted by 0
-    expect(result).toBe(5381 >>> 0);
-  });
-
-  it('should handle special characters', () => {
-    const result = djb2Hash('!@#$%^&*()');
-    expect(typeof result).toBe('number');
-    expect(Number.isInteger(result)).toBe(true);
-  });
-
-  it('should handle long strings', () => {
-    const longString = 'a'.repeat(1000);
-    const result = djb2Hash(longString);
-    expect(typeof result).toBe('number');
-    expect(Number.isInteger(result)).toBe(true);
-  });
-
-  it('should handle Unicode characters', () => {
-    const unicodeString = '😀🌍🚀';
-    const result = djb2Hash(unicodeString);
-    expect(typeof result).toBe('number');
-    expect(Number.isInteger(result)).toBe(true);
-  });
-
-  it('should produce 32-bit unsigned integer outputs', () => {
-    const inputs = ['test', 'hello world', 'unicode 😀', 'a'.repeat(1000)];
-
-    for (const input of inputs) {
-      const result = djb2Hash(input);
-      expect(result).toBeLessThanOrEqual(0xffffffff); // Max 32-bit unsigned int
-      expect(result).toBeGreaterThanOrEqual(0);
-    }
-  });
-
-  it('should produce deterministic results', () => {
-    // Test with known hash values
-    expect(djb2Hash('hello')).toBe(181380007);
-    expect(djb2Hash('world')).toBe(164394279);
-    expect(djb2Hash('hello world')).toBe(2616892229);
-    expect(djb2Hash('')).toBe(5381);
-  });
-
-  it('should handle case sensitivity', () => {
-    expect(djb2Hash('Hello')).not.toBe(djb2Hash('hello'));
-    expect(djb2Hash('WORLD')).not.toBe(djb2Hash('world'));
-  });
-});