jsonata-python 0.5.2__tar.gz → 0.6.0__tar.gz

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/.github/workflows/test.yml

@@ -9,7 +9,7 @@ jobs:
   test:
     strategy:
       matrix:
-        python: ['3.9', '3.10', '3.11', '3.12']
+        python: ['3.9', '3.10', '3.11', '3.12', '3.13']
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonata-python
-Version: 0.5.2
+Version: 0.6.0
 Summary: Pure Python implementation of JSONata
 Project-URL: Homepage, https://github.com/rayokota/jsonata-python
 Project-URL: Bug Reports, https://github.com/rayokota/jsonata-python/issues
@@ -278,7 +278,7 @@ options:
   -f {auto,json,string}, --format {auto,json,string}
                         Input format (default=auto)
   -o <arg>, --output <arg>
-                        JSON output file (- for stdin)
+                        JSON output file (default=stdout)
   -oc <arg>, --ocharset <arg>
                         Output character set (default=utf-8)
   -time                 Print performance timers to stderr
@@ -287,7 +287,7 @@ options:
                         JSONata variable bindings
   -bf <file>, --bindings-file <file>
                         JSONata variable bindings file
-  -it, --interactive    Interactive REPL
+  -it, --interactive    Interactive REPL (requires input file)
 ```
 
 ### Examples
@@ -317,6 +317,11 @@ helloworld.json
     "frederic.smith@very-serious.com"
   ]
 }
+
+% python3 -m jsonata.cli -i helloworld.json -it
+Enter an expression to have it evaluated.
+JSONata> (a & b)
+hello world
 ```
 
 ## Running Tests

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/README.md

@@ -61,7 +61,7 @@ options:
   -f {auto,json,string}, --format {auto,json,string}
                         Input format (default=auto)
   -o <arg>, --output <arg>
-                        JSON output file (- for stdin)
+                        JSON output file (default=stdout)
   -oc <arg>, --ocharset <arg>
                         Output character set (default=utf-8)
   -time                 Print performance timers to stderr
@@ -70,7 +70,7 @@ options:
                         JSONata variable bindings
   -bf <file>, --bindings-file <file>
                         JSONata variable bindings file
-  -it, --interactive    Interactive REPL
+  -it, --interactive    Interactive REPL (requires input file)
 ```
 
 ### Examples
@@ -100,6 +100,11 @@ helloworld.json
     "frederic.smith@very-serious.com"
   ]
 }
+
+% python3 -m jsonata.cli -i helloworld.json -it
+Enter an expression to have it evaluated.
+JSONata> (a & b)
+hello world
 ```
 
 ## Running Tests

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/.github/workflows/jsonata.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [12.x, 14.x, 16.x, 18.x, 20.x]
+        node-version: [12.x, 14.x, 16.x, 18.x, 20.x, 22.x]
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -26,10 +26,10 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v3
-      - name: Use Node.js 18.x
+      - name: Use Node.js 22.x
         uses: actions/setup-node@v3
         with:
-          node-version: 18.x
+          node-version: 22.x
       - name: Install and build
         run: npm install && npm test
       - name: Publish to NPM
@@ -47,10 +47,10 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v3
-      - name: Use Node.js 18.x
+      - name: Use Node.js 22.x
         uses: actions/setup-node@v3
         with:
-          node-version: 18.x
+          node-version: 22.x
       - name: Build documentation
         run: |
           cd website

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/CHANGELOG.md

@@ -1,3 +1,20 @@
+#### 2.1.0 Milestone Release
+
+- New syntax (`?:` default operator) supports fallback to RHS if the LHS is Boolean equivalent to false (PR #784)
+- New syntax (`??` coalescing operator) supports fallback to RHS if the LHS is non-existent (PR #784)
+- Improve regex generation for DateTime parser (PR #728)
+- Truncate fractional part of numeric argument of `$pad` function (PR #729)
+- Await array elements (PR #747)
+- Various documentation fixes and improvements
+
+#### 2.0.6 Maintenance Release
+
+- Protect __evaluate_entry and __evaluate_exit callbacks (PR #700)
+- Add undocumented/private API to hook into when a new frame is created (PR #701)
+  - Note this is internal and may change in a future release.
+- Update typescript defintion (PR #704)
+- Chain operator should respect array constructor (PR #714)
+
 #### 2.0.5 Maintenance Release
 
 - Fix leaking internal references in expressions when using lambdas (issue #691)

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/README.md

@@ -2,8 +2,6 @@
 
 JSON query and transformation language
 
-[![NPM statistics](https://nodei.co/npm/jsonata.png?downloads=true&downloadRank=true)](https://nodei.co/npm/jsonata/)
-
 Reference implementation of the [JSONata query and transformation language](http://jsonata.org/).
 
 * [JSONata in 5 minutes](https://www.youtube.com/embed/ZBaK40rtIBM)

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/docs/embedding-extending.md

@@ -39,7 +39,7 @@ var result = await expression.evaluate({example: [{value: 4}, {value: 7}, {value
 
 `input` should be a JavaScript value such as would be returned from `JSON.parse()`. If `input` could not have been parsed from a JSON string (is circular, contains functions, ...), `evaluate`'s behaviour is not defined. `result` is a new JavaScript value suitable for `JSON.stringify()`ing.
 
-`bindings`, if present, contains variable names and values (including functions) to be bound:
+`bindings`, if present, contain variable names and values (including functions) to be bound:
 
 ```javascript
 await jsonata("$a + $b()").evaluate({}, {a: 4, b: () => 78});
@@ -168,7 +168,7 @@ Each type symbol may also have *options* applied.
 
 ### Writing higher-order function extensions
 
-It is possible to write and extension function that takes one or more functions in its list of arguments and/or returns
+It is possible to write an extension function that takes one or more functions in its list of arguments and/or returns
  a function as its return value.
 
 

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/docs/higher-order-functions.md

@@ -7,7 +7,31 @@ sidebar_label: Higher Order Functions
 ## `$map()`
 __Signature:__ `$map(array, function)`
 
-Returns an array containing the results of applying the `function` parameter to each value in the `array` parameter.
+If the input argument is an array of 2 or more elements, returns an array containing the results of applying the `function` parameter to each value in the `array` parameter.
+
+```
+$map([1,2,3], function($v) { $v * 2 })
+```
+
+evaluates to
+
+```
+[ 2, 4, 6 ]
+```
+
+If the input argument is an array with 1 element, returns the single result of applying the `function` parameter to each value in the `array` parameter.
+
+```
+$map([2], function($v) { $v * 2 })
+```
+
+evaluates to
+
+```
+4
+```
+
+If the input argument is an empty array, returns nothing (represented in Javascript as `undefined`)
 
 The function that is supplied as the second parameter must have the following signature:
 

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/docs/numeric-functions.md

@@ -18,7 +18,7 @@ If `arg` is not specified (i.e. this function is invoked with no arguments), the
 
 __Examples__  
 - `$number("5")` => `5`  
-- `$number("0x12")` => `0x18`  
+- `$number("0x12")` => `18`  
 - `["1", "2", "3", "4", "5"].$number()` => `[1, 2, 3, 4, 5]`
 
 

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/docs/other-operators.md

@@ -25,6 +25,36 @@ __Example__
 
 `Price < 50 ? "Cheap" : "Expensive"`
 
+## `?:` (Default/Elvis)
+
+The default (or "elvis") operator returns the left-hand side if it has an effective Boolean value of `true`, otherwise it returns the right-hand side. This is useful for providing fallback values when an expression may evaluate to a value with an effective Boolean value of `false` (such as `null`, `false`, `0`, `''`, or `undefined`).
+
+__Syntax__
+
+`<expr1> ?: <expr2>`
+
+__Example__
+
+`foo.bar ?: 'default'` => `'default'` (if `foo.bar` is evaluates to Boolean `false`)
+
+## `??` (Coalescing)
+
+The coalescing operator returns the left-hand side if it is defined (not `undefined`), otherwise it returns the right-hand side. This is useful for providing fallback values only when the left-hand side is missing or not present (empty sequence), but not for other values with an effective Boolean value of `false` like `0`, `false`, or `''`.
+
+__Syntax__
+
+`<expr1> ?? <expr2>`
+
+__Example__
+
+`foo.bar ?? 42` => `42` (if `foo.bar` is undefined)
+
+`foo.bar ?? 'default'` => `'default'` (if `foo.bar` is undefined)
+
+`0 ?? 1` => `0`
+
+`'' ?? 'fallback'` => `''`
+
 ## `:=` (Variable binding)
 
 The variable binding operator is used to bind the value of the RHS to the variable name defined on the LHS.  The variable binding is scoped to the current block and any nested blocks.  It is an error if the LHS is not a `$` followed by a valid variable name.

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/docs/programming.md

@@ -40,6 +40,8 @@ Produces [this](http://try.jsonata.org/ryYn78Q0m), if you're interested!
 
 ## Conditional logic
 
+### Ternary operator (`? :`)
+
 If/then/else constructs can be written using the ternary operator "? :".
 
 `predicate ? expr1 : expr2`
@@ -68,6 +70,84 @@ __Examples__
 ]</div>
 </div>
 
+### Elvis/Default operator (`?:`)
+
+The default (or "elvis") operator is syntactic sugar for a common pattern using the ternary operator. It returns the left-hand side if it has an effective Boolean value of `true`, otherwise it returns the right-hand side.
+
+`expr1 ?: expr2`
+
+This is equivalent to:
+
+`expr1 ? expr1 : expr2`
+
+The elvis operator is useful for providing fallback values when an expression may evaluate to a value with an effective Boolean value of `false`, without having to repeat the expression twice as you would with the ternary operator.
+
+__Examples__
+
+<div class="jsonata-ex">
+  <div>Account.Order.Product.{
+    `Product Name`: $.'Product Name',
+    `Category`: $.Category ?: "Uncategorized"
+}</div>
+  <div>[
+  {
+    "Product Name": "Bowler Hat",
+    "Category": "Uncategorized"
+  },
+  {
+    "Product Name": "Trilby hat",
+    "Category": "Uncategorized"
+  },
+  {
+    "Product Name": "Bowler Hat",
+    "Category": "Uncategorized"
+  },
+  {
+    "Product Name": "Cloak",
+    "Category": "Uncategorized"
+  }
+]</div>
+</div>
+
+### Coalescing operator (`??`)
+
+The coalescing operator is syntactic sugar for a common pattern using the ternary operator with the `$exists` function. It returns the left-hand side if it is defined (not `undefined`), otherwise it returns the right-hand side.
+
+`expr1 ?? expr2`
+
+This is equivalent to:
+
+`$exists(expr1) ? expr1 : expr2`
+
+The coalescing operator is useful for providing fallback values only when the left-hand side is missing or not present (empty sequence), but not for other values with an effective Boolean value of `false` like `0`, `false`, or `''`. It avoids having to evaluate the expression twice and explicitly use the `$exists` function as you would with the ternary operator.
+
+__Examples__
+
+<div class="jsonata-ex">
+  <div>Account.Order.{
+    "OrderID": OrderID, 
+    Rating": ($sum(Product.Rating) / $count(Product.Rating)) ?? 0
+}</div>
+  <div>[
+  {
+    "OrderID": "order101",
+    "Rating": 5
+  },
+  {
+    "OrderID": "order102",
+    "Rating": 3
+  },
+  {
+    "OrderID": "order103",
+    "Rating": 4
+  },
+  {
+    "OrderID": "order104",
+    "Rating": 2
+  }
+]</div>
+</div>
+
 ## Variables
 
 Any name that starts with a dollar '$' is a variable.  A variable is a named reference to a value.  The value can be one of any type in the language's [type system](processing#the-jsonata-type-system).

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/docs/regex.md

@@ -66,7 +66,7 @@ This returns the following JSONata object (JSON, but also with a function proper
 This contains information of the first matching substring within this famous palindrome, specifically:
 - `match` - the substring within the original string that matches the regex
 - `start` - the starting position (zero offset) of the matching substring within the original string
-- `end` - the endinging position of the matching substring within the original string
+- `end` - the ending position of the matching substring within the original string
 - `groups` - if capturing groups are used in the regex, then this array contains a string for the text captured by each group
 - `next()` - when invoked, will return details of the second occurrence of any matching substring (and so on).
 

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/jsonata.d.ts

@@ -50,8 +50,8 @@ declare namespace jsonata {
   }
 
   interface Environment {
-    bind(name: string, value: any): void;
-    lookup(name: string): any;
+    bind(name: string | symbol, value: any): void;
+    lookup(name: string | symbol): any;
     readonly timestamp: Date;
     readonly async: boolean;
   }

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsonata",
-  "version": "2.0.5",
+  "version": "2.1.0",
   "description": "JSON query and transformation language",
   "module": "jsonata.js",
   "main": "jsonata.js",

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/src/datetime.js

@@ -612,7 +612,7 @@ const dateTime = (function () {
                             def.integerFormat.mandatoryDigits = def.width.min;
                         }
                     }
-                    if ('YMD'.indexOf(def.component) !== -1) {
+                    if (def.component === 'Y') {
                         // §9.8.4.4
                         def.n = -1;
                         if (def.width && def.width.max !== undefined) {
@@ -625,6 +625,11 @@ const dateTime = (function () {
                             }
                         }
                     }
+                    // if the previous part is also an integer with no intervening markup, then its width for parsing must be precisely defined
+                    const previousPart = spec[spec.length - 1];
+                    if (previousPart && previousPart.integerFormat) {
+                        previousPart.integerFormat.parseWidth = previousPart.integerFormat.mandatoryDigits;
+                    }
                 }
                 if (def.component === 'Z' || def.component === 'z') {
                     def.integerFormat = analyseIntegerPicture(def.presentation1);
@@ -990,7 +995,6 @@ const dateTime = (function () {
                         return offsetHours * 60 + offsetMinutes;
                     };
                 } else if (part.integerFormat) {
-                    part.integerFormat.n = part.n;
                     res = generateRegex(part.integerFormat);
                 } else {
                     // must be a month or day name
@@ -1035,16 +1039,6 @@ const dateTime = (function () {
         } else { // type === 'integer'
             matcher.type = 'integer';
             const isUpper = formatSpec.case === tcase.UPPER;
-            let occurrences;
-            if(formatSpec.n && formatSpec.n > 0){
-                if(formatSpec.optionalDigits === 0){
-                    occurrences = `{${formatSpec.n}}`;
-                } else {
-                    occurrences = `{${formatSpec.n - formatSpec.optionalDigits},${formatSpec.n}}`;
-                }
-            } else {
-                occurrences = '+';
-            }
 
             switch (formatSpec.primary) {
                 case formats.LETTERS:
@@ -1066,7 +1060,12 @@ const dateTime = (function () {
                     };
                     break;
                 case formats.DECIMAL:
-                    matcher.regex = `[0-9]${occurrences}`;
+                    matcher.regex = '[0-9]';
+                    if (formatSpec.parseWidth) {
+                        matcher.regex += `{${formatSpec.parseWidth}}`;
+                    } else {
+                        matcher.regex += '+';
+                    }
                     if (formatSpec.ordinal) {
                         // ordinals
                         matcher.regex += '(?:th|st|nd|rd)';

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/src/functions.js

@@ -293,6 +293,7 @@ const functions = (() => {
         }
 
         var result;
+        width = Math.trunc(width);
         var padLength = Math.abs(width) - length(str);
         if (padLength > 0) {
             var padding = (new Array(padLength + 1)).join(char);
@@ -1419,7 +1420,7 @@ const functions = (() => {
             if (arg !== 0) {
                 result = true;
             }
-        } else if (arg !== null && typeof arg === 'object') {
+        } else if (arg !== null && typeof arg === 'object' && !isFunction(arg)) {
             if (Object.keys(arg).length > 0) {
                 result = true;
             }

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/src/jsonata.js

@@ -50,7 +50,7 @@ var jsonata = (function() {
     async function evaluate(expr, input, environment) {
         var result;
 
-        var entryCallback = environment.lookup('__evaluate_entry');
+        var entryCallback = environment.lookup(Symbol.for('jsonata.__evaluate_entry'));
         if(entryCallback) {
             await entryCallback(expr, input, environment);
         }
@@ -124,7 +124,7 @@ var jsonata = (function() {
             result = await evaluateGroupExpression(expr.group, result, environment);
         }
 
-        var exitCallback = environment.lookup('__evaluate_exit');
+        var exitCallback = environment.lookup(Symbol.for('jsonata.__evaluate_exit'));
         if(exitCallback) {
             await exitCallback(expr, input, environment, result);
         }
@@ -397,7 +397,7 @@ var jsonata = (function() {
                 // count in from end of array
                 index = input.length + index;
             }
-            var item = input[index];
+            var item = await input[index];
             if(typeof item !== 'undefined') {
                 if(Array.isArray(item)) {
                     results = item;
@@ -1837,7 +1837,7 @@ var jsonata = (function() {
      */
     function createFrame(enclosingEnvironment) {
         var bindings = {};
-        return {
+        const newFrame = {
             bind: function (name, value) {
                 bindings[name] = value;
             },
@@ -1857,6 +1857,16 @@ var jsonata = (function() {
                 ancestry: [ null ]
             }
         };
+
+        if (enclosingEnvironment) {
+            var framePushCallback = enclosingEnvironment.lookup(Symbol.for('jsonata.__createFrame_push'));
+            if(framePushCallback) {
+                framePushCallback(enclosingEnvironment, newFrame);
+            }
+        }
+       
+
+        return newFrame
     }
 
     // Function registration

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/src/parser.js

@@ -40,6 +40,8 @@ const parser = (() => {
         '<=': 40,
         '>=': 40,
         '~>': 40,
+        '?:': 40,
+        '??': 40,
         'and': 30,
         'or': 25,
         'in': 40,
@@ -198,6 +200,16 @@ const parser = (() => {
                 position += 2;
                 return create('operator', '~>');
             }
+            if (currentChar === '?' && path.charAt(position + 1) === ':') {
+                // ?: default / elvis operator
+                position += 2;
+                return create('operator', '?:');
+            }
+            if (currentChar === '?' && path.charAt(position + 1) === '?') {
+                // ?? coalescing operator
+                position += 2;
+                return create('operator', '??');
+            }
             // test for single char operators
             if (Object.prototype.hasOwnProperty.call(operators, currentChar)) {
                 position++;
@@ -566,6 +578,20 @@ const parser = (() => {
         prefix("-"); // unary numeric negation
         infix("~>"); // function application
 
+        // coalescing operator
+        infix("??", operators['??'], function (left) {
+            this.type = 'condition';
+            this.condition = {
+                type: 'function',
+                value: '(',
+                procedure: { type: 'variable', value: 'exists' },
+                arguments: [left]
+            };
+            this.then = left;
+            this.else = expression(0);
+            return this;
+        });
+
         infixr("(error)", 10, function (left) {
             this.lhs = left;
 
@@ -849,6 +875,15 @@ const parser = (() => {
             return this;
         });
 
+        // elvis/default operator
+        infix("?:", operators['?:'], function (left) {
+            this.type = 'condition';
+            this.condition = left;
+            this.then = left;
+            this.else = expression(0);
+            return this;
+        });
+
         // object transformer
         prefix("|", function () {
             this.type = 'transform';

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/test/async-function.js

@@ -176,3 +176,13 @@ describe('Handle chained functions that end in promises', function() {
     });
 
 });
+
+describe('Array with Promise items', function() {
+    it('should await each item', async function() {
+        var data = {
+            list: [Promise.resolve({name: 'hello'})]
+        };
+        var expr = jsonata('list[0].name');
+        return expect(expr.evaluate(data)).to.eventually.equal('hello');
+    });
+});

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/test/implementation-tests.js

@@ -1024,6 +1024,21 @@ describe("Tests that include infinite recursion", () => {
     });
 });
 
+describe("Tests that use internal frame push callbacks", () => {
+    describe("frame push callback bound to expression", function()  {
+        it("calls callback when new frame created", function(done) {
+            var expr = jsonata("( )");
+            expr.assign(Symbol.for('jsonata.__createFrame_push'), function(parentEnv, newEnv) {
+                expect(parentEnv).to.not.equal(newEnv);
+                expect(parentEnv).to.include.keys(['lookup', 'bind']);
+                expect(newEnv).to.include.keys(['lookup', 'bind']);
+                done();
+            });
+            expr.evaluate();
+        });
+    });
+});
+
 /**
  * Protect the process/browser from a runnaway expression
  * i.e. Infinite loop (tail recursion), or excessive stack growth
@@ -1057,11 +1072,11 @@ function timeboxExpression(expr, timeout, maxDepth) {
     };
 
     // register callbacks
-    expr.assign("__evaluate_entry", function() {
+    expr.assign(Symbol.for('jsonata.__evaluate_entry'), function() {
         depth++;
         checkRunnaway();
     });
-    expr.assign("__evaluate_exit", function() {
+    expr.assign(Symbol.for('jsonata.__evaluate_exit'), function() {
         depth--;
         checkRunnaway();
     });

{jsonata_python-0.5.2 → jsonata_python-0.6.0}/jsonata/test/run-test-suite.js

@@ -178,12 +178,12 @@ function timeboxExpression(expr, timeout, maxDepth) {
     };
 
     // register callbacks
-    expr.assign("__evaluate_entry", function(expr, input, env) {
+    expr.assign(Symbol.for('jsonata.__evaluate_entry'), function(expr, input, env) {
         if (env.isParallelCall) return;
         depth++;
         checkRunnaway();
     });
-    expr.assign("__evaluate_exit", function(expr, input, env) {
+    expr.assign(Symbol.for('jsonata.__evaluate_exit'), function(expr, input, env) {
         if (env.isParallelCall) return;
         depth--;
         checkRunnaway();

jsonata_python-0.6.0/jsonata/test/test-suite/groups/coalescing-operator/case000.json

@@ -0,0 +1,6 @@
+{
+    "expr": "bar ?? 42",
+    "dataset": "dataset0",
+    "bindings": {},
+    "result": 98
+}

jsonata_python-0.6.0/jsonata/test/test-suite/groups/coalescing-operator/case001.json

@@ -0,0 +1,6 @@
+{
+    "expr": "foo.bar ?? 98",
+    "dataset": "dataset0",
+    "bindings": {},
+    "result": 42
+}

jsonata_python-0.6.0/jsonata/test/test-suite/groups/coalescing-operator/case002.json

@@ -0,0 +1,6 @@
+{
+    "expr": "foo.blah[0].baz.fud ?? 98",
+    "dataset": "dataset0",
+    "bindings": {},
+    "result": "hello"
+}

jsonata_python-0.6.0/jsonata/test/test-suite/groups/coalescing-operator/case003.json

@@ -0,0 +1,7 @@
+{
+    "description": "undefined property uses default number on rhs",
+    "expr": "baz ?? 42",
+    "dataset": "dataset0",
+    "bindings": {},
+    "result": 42
+}