Added stable JSON serialize.

Library for `fast-json-stable-stringify` would not build.
Switch to `@noble/hashes`

Author: jasny

README.md

@@ -218,6 +218,7 @@ Generates an array of numbers or prefixed strings from `start` to `end - 1`. If
 
 **Example**:
 ```jmespath
+range(5)                // [0, 1, 2, 3, 4]
 range(1, 5)             // [1, 2, 3, 4]
 range(1, 5, 'item_')    // ["item_1", "item_2", "item_3", "item_4"]
 ```
@@ -246,7 +247,7 @@ to_object([['key1', 'value1'], ['key2', 'value2']])
 json_serialize(value)
 ```
 
-_Uses a [deterministic version of JSON.stringify](https://www.npmjs.com/package/fast-json-stable-stringify) to serialize the value._
+_Uses a deterministic version of JSON.stringify to serialize the value._
 
 **Description**:  
 Serializes a JSON value to a string.

package.json

@@ -87,8 +87,7 @@
     "vitest": "^2.1.8"
   },
   "dependencies": {
-    "fast-json-stable-stringify": "^2.1.0",
-    "hash.js": "^1.1.7",
+    "@noble/hashes": "^1.7.1",
     "uuid": "^11.0.5"
   }
 }

src/Runtime.ts

@@ -25,9 +25,11 @@ import type {
 } from './JSON.type';
 import type { TreeInterpreter } from './TreeInterpreter';
 
-import stringify from 'fast-json-stable-stringify';
-import hash from 'hash.js';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import { bytesToHex } from '@noble/hashes/utils';
 import { NIL, v4 as uuidv4, v5 as uuidv5 } from 'uuid';
+import jsonStringify from './utils/json-serialize';
 
 export enum InputArgument {
   TYPE_NUMBER = 0,
@@ -631,28 +633,41 @@ export class Runtime {
     return condition ? thenValue : elseValue ?? null;
   };
 
-  private functionRange: RuntimeFunction<[number, number, string], Array<number | string>> = ([start, end, prefix]) => {
-    return Array.from({ length: end - start }, (_, i) => (prefix ? `${prefix}${i + start}` : i + start));
+  private functionRange: RuntimeFunction<[number, number?, string?], Array<number | string>> = ([
+    start,
+    end,
+    prefix,
+  ]) => {
+    if (end === undefined) {
+      end = start;
+      start = 0;
+    }
+
+    return Array.from({ length: end - start }, (_, i) => (prefix !== undefined ? `${prefix}${i + start}` : i + start));
   };
 
   private functionToObject: RuntimeFunction<[JSONArrayKeyValuePairs], JSONObject> = ([array]) => {
     return Object.fromEntries(array);
   };
 
   private functionJsonSerialize: RuntimeFunction<[JSONValue], string> = ([inputValue]) => {
-    return stringify(inputValue);
+    const result = jsonStringify(inputValue);
+    if (result === undefined) {
+      throw new Error('invalid-value');
+    }
+    return result;
   };
 
   private functionJsonParse: RuntimeFunction<[string], JSONValue> = ([inputValue]) => {
     return JSON.parse(inputValue);
   };
 
   private functionSha256: RuntimeFunction<[string], string> = ([inputValue]) => {
-    return hash.sha256().update(inputValue).digest('hex');
+    return bytesToHex(sha256(inputValue));
   };
 
   private functionSha512: RuntimeFunction<[string], string> = ([inputValue]) => {
-    return hash.sha512().update(inputValue).digest('hex');
+    return bytesToHex(sha512(inputValue));
   };
 
   private functionUuid: RuntimeFunction<[string?, string?], string> = ([name, ns]) => {
@@ -663,7 +678,7 @@ export class Runtime {
     // Match the pattern between slashes and any flags after the last slash
     const match = regexString.match(/^\/(.*?)\/([gimsuy]*)$/);
     if (!match) {
-      throw new Error('Invalid regex string format');
+      throw new Error('invalid-regex');
     }
     return new RegExp(match[1], match[2]);
   }
@@ -1124,6 +1139,7 @@ export class Runtime {
         },
         {
           types: [InputArgument.TYPE_NUMBER],
+          optional: true,
         },
         {
           types: [InputArgument.TYPE_STRING],

src/utils/json-serialize.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types,@typescript-eslint/no-explicit-any */
+
+export default function jsonStringify(data: any): string | undefined {
+  const seen: any[] = [];
+
+  function stringifyNode(node: any): string | undefined {
+    if (node && typeof node.toJSON === 'function') {
+      node = node.toJSON();
+    }
+
+    if (node === undefined) {
+      return;
+    }
+    if (typeof node === 'number') {
+      return isFinite(node) ? String(node) : 'null';
+    }
+    if (typeof node !== 'object') {
+      return JSON.stringify(node);
+    }
+
+    if (Array.isArray(node)) {
+      const arrayOutput = node.map(item => stringifyNode(item) || 'null').join(',');
+      return `[${arrayOutput}]`;
+    }
+
+    if (node === null) {
+      return 'null';
+    }
+
+    if (seen.includes(node)) {
+      throw new TypeError('Converting circular structure to JSON');
+    }
+
+    const seenIndex = seen.push(node) - 1;
+    const keys = Object.keys(node).sort();
+    const objectOutput = keys
+      .map(key => {
+        const value = stringifyNode(node[key]);
+        return value ? `${JSON.stringify(key)}:${value}` : undefined;
+      })
+      .filter(entry => entry !== undefined)
+      .join(',');
+
+    seen.splice(seenIndex, 1);
+    return `{${objectOutput}}`;
+  }
+
+  return stringifyNode(data);
+}

test/jmespath-functions.spec.ts

@@ -1,7 +1,9 @@
 import { describe, it, expect } from 'vitest';
 import { search, registerFunction, TYPE_NUMBER } from '../src';
 import { expectError } from './error.utils';
-import { sha256, sha512 } from 'hash.js';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import { bytesToHex } from '@noble/hashes/utils';
 
 describe('Evaluates functions', () => {
   it('from_items()', () => {
@@ -162,11 +164,11 @@ describe('Added functions', () => {
   });
 
   it('sha256', () => {
-    expect(search('hello world', 'sha256(@)')).toEqual(sha256().update('hello world').digest('hex'));
+    expect(search('hello world', 'sha256(@)')).toEqual(bytesToHex(sha256('hello world')));
   });
 
   it('sha512', () => {
-    expect(search('hello world', 'sha512(@)')).toEqual(sha512().update('hello world').digest('hex'));
+    expect(search('hello world', 'sha512(@)')).toEqual(bytesToHex(sha512('hello world')));
   });
 
   it('uuid', () => {