Update README

Author: jasny

README.md

@@ -1,14 +1,15 @@
-![Build](https://github.com/jmespath-community/typescript-jmespath/actions/workflows/nodejs.yml/badge.svg?branch=main)
+![Build](https://github.com/letsflow/jmespath/actions/workflows/nodejs.yml/badge.svg?branch=main)
 
 # @letsflow/jmespath
 
-@letsflow/jmespath is a **TypeScript** implementation of the [JMESPath](https://jmespath.site/) spec.
+@letsflow/jmespath is a **TypeScript** implementation of the [JMESPath](https://jmespath.org/) spec.
 
 JMESPath is a query language for JSON. It will take a JSON document
 as input and transform it into another JSON document
 given a JMESPath expression.
 
 This fork extends the original specs, adding the following functionality;
+
 * [Custom functions](#custom-functions)
 * [Root value access](#root-value-access)
 * [Number literals](#number-literals)
@@ -27,9 +28,9 @@ npm install @letsflow/jmespath
 import { search } from '@letsflow/jmespath';
 
 search(
-  {foo: {bar: {baz: [0, 1, 2, 3, 4]}}},
+  { foo: { bar: { baz: [0, 1, 2, 3, 4] } } },
   "foo.bar.baz[2]"
-  );
+);
 
 // OUTPUTS: 2
 ```
@@ -45,46 +46,46 @@ from a list.  Here are a few more examples:
 ```javascript
 import { search } from '@letsflow/jmespath';
 
-/* --- EXAMPLE 1 --- */
-
-let JSON_DOCUMENT = {
+const document = {
   foo: {
     bar: {
       baz: [0, 1, 2, 3, 4]
     }
   }
 };
 
-search(JSON_DOCUMENT, "foo.bar");
+search(document, "foo.bar");
 // OUTPUTS: { baz: [ 0, 1, 2, 3, 4 ] }
+```
 
+```javascript
+import { search } from '@letsflow/jmespath';
 
-/* --- EXAMPLE 2 --- */
-
-JSON_DOCUMENT = {
+const document = {
   "foo": [
-    {"first": "a", "last": "b"},
-    {"first": "c", "last": "d"}
+    { "first": "a", "last": "b" },
+    { "first": "c", "last": "d" }
   ]
 };
 
-search(JSON_DOCUMENT, "foo[*].first")
+search(document, "foo[*].first")
 // OUTPUTS: [ 'a', 'c' ]
+```
 
+```javascript
+import { search } from '@letsflow/jmespath';
 
-/* --- EXAMPLE 3 --- */
-
-JSON_DOCUMENT = {
+const document = {
   "foo": [
-    {"age": 20},
-    {"age": 25},
-    {"age": 30},
-    {"age": 35},
-    {"age": 40}
+    { "age": 20 },
+    { "age": 25 },
+    { "age": 30 },
+    { "age": 35 },
+    { "age": 40 }
   ]
 }
 
-search(JSON_DOCUMENT, "foo[?age > `30`]");
+search(document, "foo[?age > `30`]");
 // OUTPUTS: [ { age: 35 }, { age: 40 } ]
 ```
 
@@ -99,66 +100,59 @@ import { compile, TreeInterpreter } from '@jmespath-community/jmespath';
 
 const ast = compile('foo.bar');
 
-TreeInterpreter.search(ast, {foo: {bar: 'BAZ'}})
+TreeInterpreter.search(ast, { foo: { bar: 'BAZ' } })
 // RETURNS: "BAZ"
-
 ```
 
 ## EXTENSIONS TO ORIGINAL SPEC
 
 ### Custom functions
 
-    #### `registerFunction(functionName: string, customFunction: RuntimeFunction, signature: InputSignature[]): void`
-
-    Extend the list of built-in JMESpath expressions with your own functions.
-
-    ```javascript
-      import {search, registerFunction, TYPE_NUMBER} from '@letsflow/jmespath'
+#### `registerFunction(functionName: string, customFunction: RuntimeFunction, signature: InputSignature[]): void`
 
+Extend the list of built-in JMESpath expressions with your own functions.
 
-      search({ foo: 60, bar: 10 }, 'divide(foo, bar)')
-      // THROWS ERROR: Error: Unknown function: divide()
-
-      registerFunction(
-        'divide', // FUNCTION NAME
-        (resolvedArgs) => {   // CUSTOM FUNCTION
-          const [dividend, divisor] = resolvedArgs;
-          return dividend / divisor;
-        },
-        [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER] }] //SIGNATURE
-      );
-
-      search({ foo: 60,bar: 10 }, 'divide(foo, bar)');
-      // OUTPUTS: 6
-
-    ```
-
-    Optional arguments are supported by setting `{..., optional: true}` in argument signatures
-
+```javascript
+  import {search, registerFunction, TYPE_NUMBER} from '@letsflow/jmespath'
+
+  search({ foo: 60, bar: 10 }, 'divide(foo, bar)')
+  // THROWS ERROR: Error: Unknown function: divide()
+
+  registerFunction(
+    'divide', // FUNCTION NAME
+    (resolvedArgs) => {   // CUSTOM FUNCTION
+      const [dividend, divisor] = resolvedArgs;
+      return dividend / divisor;
+    },
+    [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER] }] //SIGNATURE
+  );
 
-    ```javascript
+  search({ foo: 60, bar: 10 }, 'divide(foo, bar)');
+  // OUTPUTS: 6
+```
 
-      registerFunction(
-        'divide',
-        (resolvedArgs) => {
-          const [dividend, divisor] = resolvedArgs;
-          return dividend / divisor ?? 1; //OPTIONAL DIVISOR THAT DEFAULTS TO 1
-        },
-        [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER], optional: true }] //SIGNATURE
-      );
+Optional arguments are supported by setting `{..., optional: true}` in argument signatures
 
-      search({ foo: 60, bar: 10 }, 'divide(foo)');
-      // OUTPUTS: 60
+```javascript
+  registerFunction(
+    'divide',
+    (resolvedArgs) => {
+      const [dividend, divisor] = resolvedArgs;
+      return dividend / divisor ?? 1; //OPTIONAL DIVISOR THAT DEFAULTS TO 1
+    },
+    [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER], optional: true }] //SIGNATURE
+  );
 
-    ```
+  search({ foo: 60, bar: 10 }, 'divide(foo)');
+  // OUTPUTS: 60
+```
 
 ### Root value access
 
 Use `$` to access the document root.
 
 ```javascript
-
-search({foo: {bar: 999}, baz: [1, 2, 3]}, '$.baz[*].[@, $.foo.bar]')
+search({foo: { bar: 999 }, baz: [1, 2, 3]}, '$.baz[*].[@, $.foo.bar]')
 
 // OUTPUTS:
 // [ [ 1, 999 ], [ 2, 999 ], [ 3, 999 ] ]
@@ -170,7 +164,6 @@ Numbers in the root scope are treated as number literals. This means that you do
 need to quote numbers with backticks.
 
 ```javascript
-
 search([{"bar": 1}, {"bar": 10}]}, '[?bar==10]')
 
 // OUTPUTS;

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@letsflow/jmespath",
   "description": "Typescript implementation of the JMESPath Community specification with additional functionality for LetsFlow",
-  "version": "1.1.4-jasny.1",
+  "version": "1.1.4-jasny.2",
   "publishConfig": {
     "access": "public"
   },