Use a small seeded PRNG directly embedded in the code

Author: MYDIH

package-lock.json

@@ -32,15 +32,13 @@
     "README.md"
   ],
   "dependencies": {
-    "luxon": "^3.6.1",
-    "seedrandom": "^3.0.5"
+    "luxon": "^3.6.1"
   },
   "devDependencies": {
     "@tsd/typescript": "^5.8.2",
     "@types/jest": "^29.5.14",
     "@types/luxon": "^3.6.2",
     "@types/node": "^22.14.0",
-    "@types/seedrandom": "^3.0.8",
     "@typescript-eslint/eslint-plugin": "^8.29.0",
     "@typescript-eslint/parser": "^8.29.0",
     "chalk": "^5.4.1",

package.json

@@ -1,8 +1,7 @@
-import seedrandom, { type PRNG } from 'seedrandom';
-
 import { CronFieldCollection } from './CronFieldCollection';
 import { CronDate } from './CronDate';
 import { CronExpression, CronExpressionOptions } from './CronExpression';
+import { type PRNG, seededRandom } from './utils';
 import {
   CronSecond,
   CronMinute,
@@ -96,7 +95,7 @@ export class CronExpressionParser {
     const { strict = false } = options;
     const currentDate = options.currentDate || new CronDate();
 
-    const rand = options.seed ? seedrandom(options.seed) : seedrandom();
+    const rand = options.seed ? seededRandom(options.seed) : seededRandom();
 
     expression = PredefinedExpressions[expression as keyof typeof PredefinedExpressions] || expression;
     const rawFields = CronExpressionParser.#getRawFields(expression, strict);

src/CronExpressionParser.ts

@@ -0,0 +1,25 @@
+// Randomness related utils
+
+function xfnv1a(str: string) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return () => h >>> 0;
+}
+
+function mulberry32(seed: number) {
+  return () => {
+    let t = (seed += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export type PRNG = () => number;
+export function seededRandom(str?: string): PRNG {
+  const seed = str ? xfnv1a(str)() : Math.floor(Math.random() * 10_000_000_000);
+  return mulberry32(seed);
+}

src/utils.ts

@@ -1742,20 +1742,20 @@ describe('CronExpressionParser', () => {
         };
 
         const expressions = [
-          { expression: 'H * * * * *', expected: '10 * * * * *' },
-          { expression: '* H * * * *', expected: '* 33 * * * *' },
-          { expression: '* * H * * *', expected: '* * 19 * * *' },
-          { expression: '* * * H * *', expected: '* * * 27 * *' },
+          { expression: 'H * * * * *', expected: '5 * * * * *' },
+          { expression: '* H * * * *', expected: '* 34 * * * *' },
+          { expression: '* * H * * *', expected: '* * 15 * * *' },
+          { expression: '* * * H * *', expected: '* * * 12 * *' },
           { expression: '* * * * H *', expected: '* * * * 8 *' },
-          { expression: '* * * * * H', expected: '* * * * * 1' },
-          { expression: 'H H * * * *', expected: '10 33 * * * *' },
-          { expression: '* H H * * *', expected: '* 33 19 * * *' },
-          { expression: '* * H H * *', expected: '* * 19 27 * *' },
-          { expression: '* * * H H *', expected: '* * * 27 8 *' },
-          { expression: '* * * * H H', expected: '* * * * 8 1' },
-          { expression: 'H H H H H H', expected: '10 33 19 27 8 1' },
-          { expression: 'H/5 * * * * *', expected: '10/5 * * * * *' },
-          { expression: '* * * * * H#1', expected: '* * * * * 1' },
+          { expression: '* * * * * H', expected: '* * * * * 0' },
+          { expression: 'H H * * * *', expected: '5 34 * * * *' },
+          { expression: '* H H * * *', expected: '* 34 15 * * *' },
+          { expression: '* * H H * *', expected: '* * 15 12 * *' },
+          { expression: '* * * H H *', expected: '* * * 12 8 *' },
+          { expression: '* * * * H H', expected: '* * * * 8 0' },
+          { expression: 'H H H H H H', expected: '5 34 15 12 8 0' },
+          { expression: 'H/5 * * * * *', expected: '5/5 * * * * *' },
+          { expression: '* * * * * H#1', expected: '* * * * * 0' },
         ];
 
         for (const { expression, expected } of expressions) {