@alwatr/hash-string 5.2.9 → 5.2.11

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.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
+
 ## [5.2.9](https://github.com/Alwatr/nanolib/compare/@alwatr/hash-string@5.2.8...@alwatr/hash-string@5.2.9) (2025-09-13)
 
 ### 🧹 Miscellaneous Chores

package/dist/main.cjs

@@ -1,4 +1,4 @@
-/* @alwatr/hash-string v5.2.9 */
+/* @alwatr/hash-string v5.2.11 */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -21,21 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // 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");
@@ -62,7 +50,6 @@ function nanoHash(str, prefix, repeat = 1) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  djb2Hash,
   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": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,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;",
   "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,15 +1,6 @@
-/* @alwatr/hash-string v5.2.9 */
+/* @alwatr/hash-string v5.2.11 */
 
-// 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
+// src/main.ts
 function nanoHash(str, prefix, repeat = 1) {
   if (repeat < 1) {
     throw new Error("The repeat parameter must be greater than or equal to 1");
@@ -35,7 +26,6 @@ function nanoHash(str, prefix, repeat = 1) {
   }
 }
 export {
-  djb2Hash,
   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,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;",
   "names": []
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@alwatr/hash-string",
   "description": "A simple utility to generate a hash string.",
-  "version": "5.2.9",
+  "version": "5.2.11",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com>",
   "bugs": "https://github.com/Alwatr/nanolib/issues",
   "devDependencies": {
-    "@alwatr/nano-build": "6.1.1",
+    "@alwatr/nano-build": "6.1.2",
     "@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": "0555c6f5ac11e7a911deee9bc90cfa44b6fe0b48"
+  "gitHead": "1d91d3b82939741f42655e6d9f9b4e8d00af4f85"
 }

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'));
-  });
-});