fix(jmespath): avoid mutating arrays in sort and reverse

packages/jmespath/src/Functions.ts

@@ -353,7 +353,7 @@ class Functions {
   })
   public funcReverse(arg: string | Array<unknown>): string | Array<unknown> {
     return Array.isArray(arg)
-      ? arg.reverse()
+      ? arg.toReversed()
       : arg.split('').reverse().join('');
   }
 
@@ -366,7 +366,7 @@ class Functions {
     argumentsSpecs: [['array-number', 'array-string']],
   })
   public funcSort(arg: Array<string> | Array<number>): Array<unknown> {
-    return arg.sort((a: string | number, b: string | number): number => {
+    return arg.toSorted((a: string | number, b: string | number): number => {
       if (typeof a === 'string') {
         // We can safely cast a and b to string here because the signature decorator
         // already enforces that all elements are of the same type

packages/jmespath/tests/unit/compliance/functions.test.ts

@@ -2,6 +2,46 @@ import { describe, expect, it } from 'vitest';
 import { search } from '../../../src/index.js';
 
 describe('Functions tests', () => {
+  it.each([
+    {
+      expression: 'sort(numbers)',
+      expected: [1, 2, 3],
+    },
+    {
+      expression: 'sort(strings)',
+      expected: ['a', 'b', 'c'],
+    },
+    {
+      expression: 'reverse(numbers)',
+      expected: [2, 1, 3],
+    },
+    {
+      expression: 'reverse(strings)',
+      expected: ['a', 'c', 'b'],
+    },
+  ])(
+    'does not mutate the input when evaluating $expression',
+    ({ expression, expected }) => {
+      // Prepare
+      const data = {
+        numbers: [3, 1, 2],
+        strings: ['b', 'c', 'a'],
+      };
+
+      // Act
+      const result = search(expression, data);
+
+      // Assess
+      expect(result).toStrictEqual(expected);
+      expect(data).toStrictEqual({
+        numbers: [3, 1, 2],
+        strings: ['b', 'c', 'a'],
+      });
+      expect(result).not.toBe(data.numbers);
+      expect(result).not.toBe(data.strings);
+    }
+  );
+
   it.each([
     {
       expression: 'abs(foo)',