From 0025dbc92db8061b335d0e306ed8e4b68c9ff114 Mon Sep 17 00:00:00 2001
From: joussy <joussyjousse@gmail.com>
Date: Tue, 25 Jun 2024 22:11:28 +0200
Subject: [PATCH] Jsonata language support (#4)

* first try

* autocompletion done
---
 client/src/app.vue                  |  80 +-------
 client/src/jsonata.locales.en-US.ts | 280 +++++++++++++++++++++++++++
 client/src/setupMonaco.ts           | 284 ++++++++++++++++++++++++++++
 3 files changed, 573 insertions(+), 71 deletions(-)
 create mode 100644 client/src/jsonata.locales.en-US.ts
 create mode 100644 client/src/setupMonaco.ts

diff --git a/client/src/app.vue b/client/src/app.vue
index 10b70cc..76a3bf8 100644
--- a/client/src/app.vue
+++ b/client/src/app.vue
@@ -101,6 +101,7 @@ import * as monaco from 'monaco-editor'
 import jsonWorker from "monaco-editor/esm/vs/language/json/json.worker?worker";
 import { Splitpanes, Pane } from 'splitpanes';
 import 'splitpanes/dist/splitpanes.css'
+import { setupJSONata } from './setupMonaco'
 
 enum ColorTheme {
     Auto = "auto",
@@ -212,11 +213,14 @@ export default defineComponent({
             })
             localStorage.setItem("config", configAsString);
         },
-        initializeEditors() {
-            this.registerJsonata();
-            window.MonacoEnvironment = {
-                getWorker: function (workerId: string, label: string): Promise<Worker> | Worker {
-                    return new jsonWorker();
+        initializeEditors() { 
+            if (!window.MonacoEnvironment) {
+                setupJSONata();
+
+                window.MonacoEnvironment = {
+                    getWorker: function (): Promise<Worker> | Worker {
+                        return new jsonWorker();
+                    }
                 }
             }
 
@@ -311,77 +315,11 @@ export default defineComponent({
             }
             this.processing = false;
         },
-        registerJsonata() {
-            // Register a new language
-            monaco.languages.register({ id: 'jsonata' });
-
-            // Register a tokens provider for the language
-            monaco.languages.setMonarchTokensProvider('jsonata', {
-                tokenizer: {
-                    root: [
-                        [/\/\*.*\*\//, "jsonata-comment"],
-                        [/'.*?'/, "jsonata-string"],
-                        [/".*?"/, "jsonata-string"],
-                        [/\$[a-zA-Z0-9_]*/, "jsonata-variable"],
-                        [/[a-zA-Z0-9_]+/, "jsonata-names"],
-                    ]
-                }
-            });
-
-            const brackets = [
-                { open: '(', close: ')' },
-                { open: '[', close: ']' },
-                { open: '{', close: '}' },
-                { open: '"', close: '"' },
-                { open: '\'', close: '\'' },
-                { open: '`', close: '`' },
-            ];
-            monaco.languages.setLanguageConfiguration('jsonata', {
-                brackets: [['(', ')'], ['[', ']'], ['{', '}']],
-                autoClosingPairs: brackets,
-                surroundingPairs: brackets,
-                indentationRules: {
-                    // ^(.*\*/)?\s*\}.*$
-                    decreaseIndentPattern: /^((?!.*?\/\*).*\*\/)?\s*[}\])].*$/,
-                    // ^.*\{[^}"']*$
-                    increaseIndentPattern: /^((?!\/\/).)*(\{[^}"'`]*|\([^)"'`]*|\[[^\]"'`]*)$/
-                }
-            });
-
-            // Define a new theme that contains only rules that match this language
-            monaco.editor.defineTheme('jsonataTheme-light', {
-                base: 'vs',
-                inherit: true,
-                rules: [
-                    { token: 'jsonata-string', foreground: 'a00000' },
-                    { token: 'jsonata-comment', foreground: '008000' },
-                    { token: 'jsonata-variable', foreground: 'ff4000' },
-                    { token: 'jsonata-names', foreground: '0000c0' },
-                ],
-                colors: {
-                    // "editor.background": '#fffffb'
-                }
-            });
-            monaco.editor.defineTheme('jsonataTheme-dark', {
-                base: 'vs-dark',
-                inherit: true,
-                rules: [
-                    { token: 'jsonata-string', foreground: 'ce9178' },
-                    { token: 'jsonata-comment', foreground: '008000' },
-                    { token: 'jsonata-variable', foreground: 'ff4000' },
-                    { token: 'jsonata-names', foreground: '00A4F3' },
-                ],
-                colors: {
-                    // "editor.background": '#fffffb'
-                }
-            });
-        }
     }
 });
 </script>
 
 <style>
-
 .splitpanes {
     background-color: #f8f8f8;
 }
diff --git a/client/src/jsonata.locales.en-US.ts b/client/src/jsonata.locales.en-US.ts
new file mode 100644
index 0000000..5f8384f
--- /dev/null
+++ b/client/src/jsonata.locales.en-US.ts
@@ -0,0 +1,280 @@
+const jsonataLocaleEnUs : Record<string, {args: string, desc: string}> = {
+    "$string": {
+        "args": "arg[, prettify]",
+        "desc": "Casts the `arg` parameter to a string using the following casting rules:\n\n - Strings are unchanged\n - Functions are converted to an empty string\n - Numeric infinity and NaN throw an error because they cannot be represented as a JSON number\n - All other values are converted to a JSON string using the `JSON.stringify` function. If `prettify` is true, then \"prettified\" JSON is produced. i.e One line per field and lines will be indented based on the field depth."
+    },
+    "$length": {
+        "args": "str",
+        "desc": "Returns the number of characters in the string `str`. An error is thrown if `str` is not a string."
+    },
+    "$substring": {
+        "args": "str, start[, length]",
+        "desc": "Returns a string containing the characters in the first parameter `str` starting at position `start` (zero-offset). If `length` is specified, then the substring will contain maximum `length` characters. If `start` is negative then it indicates the number of characters from the end of `str`."
+    },
+    "$substringBefore": {
+        "args": "str, chars",
+        "desc": "Returns the substring before the first occurrence of the character sequence `chars` in `str`. If `str` does not contain `chars`, then it returns `str`."
+    },
+    "$substringAfter": {
+        "args": "str, chars",
+        "desc": "Returns the substring after the first occurrence of the character sequence `chars` in `str`. If `str` does not contain `chars`, then it returns `str`."
+    },
+    "$uppercase": {
+        "args": "str",
+        "desc": "Returns a string with all the characters of `str` converted to uppercase."
+    },
+    "$lowercase": {
+        "args": "str",
+        "desc": "Returns a string with all the characters of `str` converted to lowercase."
+    },
+    "$trim": {
+        "args": "str",
+        "desc": "Normalizes and trims all whitespace characters in `str` by applying the following steps:\n\n - All tabs, carriage returns, and line feeds are replaced with spaces.\n- Contiguous sequences of spaces are reduced to a single space.\n- Trailing and leading spaces are removed.\n\n If `str` is not specified (i.e. this function is invoked with no arguments), then the context value is used as the value of `str`. An error is thrown if `str` is not a string."
+    },
+    "$contains": {
+        "args": "str, pattern",
+        "desc": "Returns `true` if `str` is matched by `pattern`, otherwise it returns `false`. If `str` is not specified (i.e. this function is invoked with one argument), then the context value is used as the value of `str`. The `pattern` parameter can either be a string or a regular expression."
+    },
+    "$split": {
+        "args": "str[, separator][, limit]",
+        "desc": "Splits the `str` parameter into an array of substrings. It is an error if `str` is not a string. The optional `separator` parameter specifies the characters within the `str` about which it should be split as either a string or regular expression. If `separator` is not specified, then the empty string is assumed, and `str` will be split into an array of single characters. It is an error if `separator` is not a string. The optional `limit` parameter is a number that specifies the maximum number of substrings to include in the resultant array. Any additional substrings are discarded. If `limit` is not specified, then `str` is fully split with no limit to the size of the resultant array. It is an error if `limit` is not a non-negative number."
+    },
+    "$join": {
+        "args": "array[, separator]",
+        "desc": "Joins an array of component strings into a single concatenated string with each component string separated by the optional `separator` parameter. It is an error if the input `array` contains an item which isn't a string. If `separator` is not specified, then it is assumed to be the empty string, i.e. no `separator` between the component strings. It is an error if `separator` is not a string."
+    },
+    "$match": {
+        "args": "str, pattern [, limit]",
+        "desc": "Applies the `str` string to the `pattern` regular expression and returns an array of objects, with each object containing information about each occurrence of a match within `str`."
+    },
+    "$replace": {
+        "args": "str, pattern, replacement [, limit]",
+        "desc": "Finds occurrences of `pattern` within `str` and replaces them with `replacement`.\n\nThe optional `limit` parameter is the maximum number of replacements."
+    },
+    "$now": {
+        "args": "$[picture [, timezone]]",
+        "desc": "Generates a timestamp in ISO 8601 compatible format and returns it as a string. If the optional `picture` and `timezone` parameters are supplied, then the current timestamp is formatted as described by the `$fromMillis()` function"
+    },
+    "$base64encode": {
+        "args": "string",
+        "desc": "Converts an ASCII string to a base 64 representation. Each character in the string is treated as a byte of binary data. This requires that all characters in the string are in the 0x00 to 0xFF range, which includes all characters in URI encoded strings. Unicode characters outside of that range are not supported."
+    },
+    "$base64decode": {
+        "args": "string",
+        "desc": "Converts base 64 encoded bytes to a string, using a UTF-8 Unicode codepage."
+    },
+    "$number": {
+        "args": "arg",
+        "desc": "Casts the `arg` parameter to a number using the following casting rules:\n\n - Numbers are unchanged\n - Strings that contain a sequence of characters that represent a legal JSON number are converted to that number\n - All other values cause an error to be thrown."
+    },
+    "$abs": {
+        "args": "number",
+        "desc": "Returns the absolute value of the `number` parameter."
+    },
+    "$floor": {
+        "args": "number",
+        "desc": "Returns the value of `number` rounded down to the nearest integer that is smaller or equal to `number`."
+    },
+    "$ceil": {
+        "args": "number",
+        "desc": "Returns the value of `number` rounded up to the nearest integer that is greater than or equal to `number`."
+    },
+    "$round": {
+        "args": "number [, precision]",
+        "desc": "Returns the value of the `number` parameter rounded to the number of decimal places specified by the optional `precision` parameter."
+    },
+    "$power": {
+        "args": "base, exponent",
+        "desc": "Returns the value of `base` raised to the power of `exponent`."
+    },
+    "$sqrt": {
+        "args": "number",
+        "desc": "Returns the square root of the value of the `number` parameter."
+    },
+    "$random": {
+        "args": "",
+        "desc": "Returns a pseudo random number greater than or equal to zero and less than one."
+    },
+    "$millis": {
+        "args": "",
+        "desc": "Returns the number of milliseconds since the Unix Epoch (1 January, 1970 UTC) as a number. All invocations of `$millis()` within an evaluation of an expression will all return the same value."
+    },
+    "$sum": {
+        "args": "array",
+        "desc": "Returns the arithmetic sum of an `array` of numbers. It is an error if the input `array` contains an item which isn't a number."
+    },
+    "$max": {
+        "args": "array",
+        "desc": "Returns the maximum number in an `array` of numbers. It is an error if the input `array` contains an item which isn't a number."
+    },
+    "$min": {
+        "args": "array",
+        "desc": "Returns the minimum number in an `array` of numbers. It is an error if the input `array` contains an item which isn't a number."
+    },
+    "$average": {
+        "args": "array",
+        "desc": "Returns the mean value of an `array` of numbers. It is an error if the input `array` contains an item which isn't a number."
+    },
+    "$boolean": {
+        "args": "arg",
+        "desc": "Casts the argument to a Boolean using the following rules:\n\n - `Boolean` : unchanged\n - `string`: empty : `false`\n - `string`: non-empty : `true`\n - `number`: `0` : `false`\n - `number`: non-zero : `true`\n - `null` : `false`\n - `array`: empty : `false`\n - `array`: contains a member that casts to `true` : `true`\n - `array`: all members cast to `false` : `false`\n - `object`: empty : `false`\n - `object`: non-empty : `true`\n - `function` : `false`"
+    },
+    "$not": {
+        "args": "arg",
+        "desc": "Returns Boolean NOT on the argument. `arg` is first cast to a boolean"
+    },
+    "$exists": {
+        "args": "arg",
+        "desc": "Returns Boolean `true` if the `arg` expression evaluates to a value, or `false` if the expression does not match anything (e.g. a path to a non-existent field reference)."
+    },
+    "$count": {
+        "args": "array",
+        "desc": "Returns the number of items in the array"
+    },
+    "$append": {
+        "args": "array, array",
+        "desc": "Appends two arrays"
+    },
+    "$sort": {
+        "args": "array [, function]",
+        "desc": "Returns an array containing all the values in the `array` parameter, but sorted into order.\n\nIf a comparator `function` is supplied, then it must be a function that takes two parameters:\n\n`function(left, right)`\n\nThis function gets invoked by the sorting algorithm to compare two values `left` and `right`. If the value of `left` should be placed after the value of `right` in the desired sort order, then the function must return Boolean `true` to indicate a swap. Otherwise it must return `false`."
+    },
+    "$reverse": {
+        "args": "array",
+        "desc": "Returns an array containing all the values from the `array` parameter, but in reverse order."
+    },
+    "$shuffle": {
+        "args": "array",
+        "desc": "Returns an array containing all the values from the `array` parameter, but shuffled into random order."
+    },
+    "$zip": {
+        "args": "array, ...",
+        "desc": "Returns a convolved (zipped) array containing grouped arrays of values from the `array1` … `arrayN` arguments from index 0, 1, 2...."
+    },
+    "$keys": {
+        "args": "object",
+        "desc": "Returns an array containing the keys in the object. If the argument is an array of objects, then the array returned contains a de-duplicated list of all the keys in all of the objects."
+    },
+    "$lookup": {
+        "args": "object, key",
+        "desc": "Returns the value associated with key in object. If the first argument is an array of objects, then all of the objects in the array are searched, and the values associated with all occurrences of key are returned."
+    },
+    "$spread": {
+        "args": "object",
+        "desc": "Splits an object containing key/value pairs into an array of objects, each of which has a single key/value pair from the input object. If the parameter is an array of objects, then the resultant array contains an object for every key/value pair in every object in the supplied array."
+    },
+    "$merge": {
+        "args": "array&lt;object&gt;",
+        "desc": "Merges an array of `objects` into a single `object` containing all the key/value pairs from each of the objects in the input array. If any of the input objects contain the same key, then the returned `object` will contain the value of the last one in the array. It is an error if the input array contains an item that is not an object."
+    },
+    "$sift": {
+        "args": "object, function",
+        "desc": "Returns an object that contains only the key/value pairs from the `object` parameter that satisfy the predicate `function` passed in as the second parameter.\n\nThe `function` that is supplied as the second parameter must have the following signature:\n\n`function(value [, key [, object]])`"
+    },
+    "$each": {
+        "args": "object, function",
+        "desc": "Returns an array containing the values return by the `function` when applied to each key/value pair in the `object`."
+    },
+    "$map": {
+        "args": "array, function",
+        "desc": "Returns an array containing the results of applying the `function` parameter to each value in the `array` parameter.\n\nThe `function` that is supplied as the second parameter must have the following signature:\n\n`function(value [, index [, array]])`"
+    },
+    "$filter": {
+        "args": "array, function",
+        "desc": "Returns an array containing only the values in the `array` parameter that satisfy the `function` predicate.\n\nThe `function` that is supplied as the second parameter must have the following signature:\n\n`function(value [, index [, array]])`"
+    },
+    "$reduce": {
+        "args": "array, function [, init]",
+        "desc": "Returns an aggregated value derived from applying the `function` parameter successively to each value in `array` in combination with the result of the previous application of the function.\n\nThe function must accept two arguments, and behaves like an infix operator between each value within the `array`. The signature of `function` must be of the form: `myfunc($accumulator, $value[, $index[, $array]])`\n\nThe optional `init` parameter is used as the initial value in the aggregation."
+    },
+    "$flowContext": {
+        "args": "string[, string]",
+        "desc": "Retrieves a flow context property.\n\nThis is a Node-RED defined function."
+    },
+    "$globalContext": {
+        "args": "string[, string]",
+        "desc": "Retrieves a global context property.\n\nThis is a Node-RED defined function."
+    },
+    "$pad": {
+        "args": "string, width [, char]",
+        "desc": "Returns a copy of the `string` with extra padding, if necessary, so that its total number of characters is at least the absolute value of the `width` parameter.\n\nIf `width` is a positive number, then the string is padded to the right; if negative, it is padded to the left.\n\nThe optional `char` argument specifies the padding character(s) to use. If not specified, it defaults to the space character."
+    },
+    "$fromMillis": {
+        "args": "number, [, picture [, timezone]]",
+        "desc": "Convert the `number` representing milliseconds since the Unix Epoch (1 January, 1970 UTC) to a formatted string representation of the timestamp as specified by the picture string.\n\nIf the optional `picture` parameter is omitted, then the timestamp is formatted in the ISO 8601 format.\n\nIf the optional `picture` string is supplied, then the timestamp is formatted according to the representation specified in that string. The behaviour of this function is consistent with the two-argument version of the XPath/XQuery function `format-dateTime` as defined in the XPath F&O 3.1 specification. The picture string parameter defines how the timestamp is formatted and has the same syntax as `format-dateTime`.\n\nIf the optional `timezone` string is supplied, then the formatted timestamp will be in that timezone. The `timezone` string should be in the format '±HHMM', where ± is either the plus or minus sign and HHMM is the offset in hours and minutes from UTC. Positive offset for timezones east of UTC, negative offset for timezones west of UTC."
+    },
+    "$formatNumber": {
+        "args": "number, picture [, options]",
+        "desc": "Casts the `number` to a string and formats it to a decimal representation as specified by the `picture` string.\n\n The behaviour of this function is consistent with the XPath/XQuery function `fn:format-number` as defined in the XPath F&O 3.1 specification. The `picture` string parameter defines how the number is formatted and has the same syntax as `fn:format-number`.\n\nThe optional third argument `options` is used to override the default locale specific formatting characters such as the decimal separator. If supplied, this argument must be an object containing name/value pairs specified in the decimal format section of the XPath F&O 3.1 specification."
+    },
+    "$formatBase": {
+        "args": "number [, radix]",
+        "desc": "Casts the `number` to a string and formats it to an integer represented in the number base specified by the `radix` argument. If `radix` is not specified, then it defaults to base 10. `radix` can be between 2 and 36, otherwise an error is thrown."
+    },
+    "$toMillis": {
+        "args": "timestamp",
+        "desc": "Convert a `timestamp` string in the ISO 8601 format to the number of milliseconds since the Unix Epoch (1 January, 1970 UTC) as a number. An error is thrown if the string is not in the correct format."
+    },
+    "$env": {
+        "args": "arg",
+        "desc": "Returns the value of an environment variable.\n\nThis is a Node-RED defined function."
+    },
+    "$eval": {
+        "args": "expr [, context]",
+        "desc": "Parses and evaluates the string `expr` which contains literal JSON or a JSONata expression using the current context as the context for evaluation."
+    },
+    "$formatInteger": {
+        "args": "number, picture",
+        "desc": "Casts the `number` to a string and formats it to an integer representation as specified by the `picture` string. The picture string parameter defines how the number is formatted and has the same syntax as `fn:format-integer` from the XPath F&O 3.1 specification."
+    },
+    "$parseInteger": {
+        "args": "string, picture",
+        "desc": "Parses the contents of the `string` parameter to an integer (as a JSON number) using the format specified by the `picture` string. The `picture` string parameter has the same format as `$formatInteger`."
+    },
+    "$error": {
+        "args": "[str]",
+        "desc": "Throws an error with a message. The optional `str` will replace the default message of `$error() function evaluated`"
+    },
+    "$assert": {
+        "args": "arg, str",
+        "desc": "If `arg` is `true` the function returns `undefined`. If `arg` is `false` an exception is thrown with `str` as the message of the exception."
+    },
+    "$single": {
+        "args": "array, function",
+        "desc": "Returns the one and only value in the `array` parameter that satisfies the `function` predicate (i.e. the `function` returns Boolean `true` when passed the value). Throws an exception if the number of matching values is not exactly one.\n\nThe function should be supplied in the following signature: `function(value [, index [, array]])` where value is each input of the array, index is the position of that value and the whole array is passed as the third argument"
+    },
+    "$encodeUrlComponent": {
+        "args": "str",
+        "desc": "Encodes a Uniform Resource Locator (URL) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character.\n\nExample: `$encodeUrlComponent(\"?x=test\")` => `\"%3Fx%3Dtest\"`"
+    },
+    "$encodeUrl": {
+        "args": "str",
+        "desc": "Encodes a Uniform Resource Locator (URL) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character.\n\nExample: `$encodeUrl(\"https://mozilla.org/?x=шеллы\")` => `\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\"`"
+    },
+    "$decodeUrlComponent": {
+        "args": "str",
+        "desc": "Decodes a Uniform Resource Locator (URL) component previously created by encodeUrlComponent.\n\nExample: `$decodeUrlComponent(\"%3Fx%3Dtest\")` => `\"?x=test\"`"
+    },
+    "$decodeUrl": {
+        "args": "str",
+        "desc": "Decodes a Uniform Resource Locator (URL) previously created by encodeUrl.\n\nExample: `$decodeUrl(\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\")` => `\"https://mozilla.org/?x=шеллы\"`"
+    },
+    "$distinct": {
+        "args": "array",
+        "desc": "Returns an array with duplicate values removed from `array`"
+    },
+    "$type": {
+        "args": "value",
+        "desc": "Returns the type of `value` as a string. If `value` is undefined, this will return `undefined`"
+    },
+    "$moment": {
+        "args": "[str]",
+        "desc": "Gets a date object using the Moment library."
+    },
+    "$clone": {
+        "args": "value",
+        "desc": "Safely clone an object."
+    }
+}
+
+export default jsonataLocaleEnUs;
\ No newline at end of file
diff --git a/client/src/setupMonaco.ts b/client/src/setupMonaco.ts
new file mode 100644
index 0000000..a8b67e2
--- /dev/null
+++ b/client/src/setupMonaco.ts
@@ -0,0 +1,284 @@
+import * as monaco from 'monaco-editor'
+import jsonataLocaleEnUs from './jsonata.locales.en-US';
+
+/* Copied from Node-Red project:
+https://github.com/node-red/node-red/blob/9d054543a765451a41b5959c1e5dba617097a93c/packages/node_modules/%40node-red/editor-client/src/js/ui/editors/code-editors/monaco.js
+ */
+
+function setupJSONata() {
+    // Register the language 'jsonata'
+    monaco.languages.register({ id: 'jsonata' });
+
+    // Setup tokens for JSONata
+    monaco.languages.setMonarchTokensProvider('jsonata',
+        {
+            // Set defaultToken to invalid to see what you do not tokenize yet
+            defaultToken: 'invalid',
+            tokenPostfix: '.js',
+            keywords: ["function", "true", "true", "null", "Infinity", "NaN", "undefined"].concat(Object.keys(Object.keys(jsonataLocaleEnUs))),
+            operatorsKeywords: ['and', 'or', 'in'],
+            operators: [
+                '<=', '>=', '!=', '==', '!=', '=>', '+', '-', '*', '/', '%',
+                ':=', '~>', '?', ':', '..', '@', '#', '|', '^', '*', '**',
+            ],
+            // we include these common regular expressions
+            symbols: /[=><!~?:&|+\-*\/\^%@#]+/,
+            escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+            digits: /\d+(_+\d+)*/,
+            octaldigits: /[0-7]+(_+[0-7]+)*/,
+            binarydigits: /[0-1]+(_+[0-1]+)*/,
+            hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+
+            regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+            regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+
+            // The main tokenizer
+            tokenizer: {
+                root: [
+                    [/[{}]/, 'delimiter.bracket'],
+                    { include: 'common' }
+                ],
+
+                common: [
+                    // identifiers and keywords
+                    [/([a-zA-Z][\w$]*)|([$][\w$]*)/, {
+                        cases: {
+                            '@keywords': 'keyword',
+                            '@operatorsKeywords': 'keyword',
+                            '$2': 'variable', //when its not a key word but starts with $, use "tag" for colourisation
+                            //'$2': 'tag', //when its not a key word but starts with $, use "tag" for colourisation
+                            //'$2': 'constant', //alt colourisation
+                            //'$2': 'attribute', //alt colourisation
+                            //'$2': 'identifier.variable', //alt custom colourisation
+                            '@default': 'identifier'
+                        }
+                    }],
+                    [/[$][\w\$]*/, 'variable'],
+
+                    // whitespace
+                    { include: '@whitespace' },
+
+                    // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+                    [/\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|\/|,|\)|\]|\}|$))/, { token: 'regexp', bracket: '@open', next: '@regexp' }],
+
+                    // delimiters and operators
+                    [/[()\[\]]/, '@brackets'],
+                    [/[<>](?!@symbols)/, '@brackets'],
+                    [/(@symbols)|(\.\.)/, {
+                        cases: {
+                            '@operators': 'operator',
+                            '@default': ''
+                        }
+                    }],
+
+                    // numbers
+                    [/(@digits)[eE]([\-+]?(@digits))?/, 'number.float'],
+                    [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, 'number.float'],
+                    [/0[xX](@hexdigits)/, 'number.hex'],
+                    [/0[oO]?(@octaldigits)/, 'number.octal'],
+                    [/0[bB](@binarydigits)/, 'number.binary'],
+                    [/(@digits)/, 'number'],
+
+                    // delimiter: after number because of .\d floats
+                    [/[?:;,.]/, 'delimiter'],
+
+                    // strings
+                    [/"([^"\\]|\\.)*$/, 'string.invalid'],  // non-teminated string
+                    [/'([^'\\]|\\.)*$/, 'string.invalid'],  // non-teminated string
+                    [/"/, 'string', '@string_double'],
+                    [/'/, 'string', '@string_single'],
+                    [/`/, 'string', '@string_backtick'],
+                ],
+
+                whitespace: [
+                    [/[ \t\r\n]+/, ''],
+                    [/\/\*\*(?!\/)/, 'comment.doc', '@jsdoc'],
+                    [/\/\*/, 'comment', '@comment'],
+                    [/\/\/.*$/, 'comment'],
+                ],
+
+                comment: [
+                    [/[^\/*]+/, 'comment'],
+                    [/\*\//, 'comment', '@pop'],
+                    [/[\/*]/, 'comment']
+                ],
+
+                jsdoc: [
+                    [/[^\/*]+/, 'comment.doc'],
+                    [/\*\//, 'comment.doc', '@pop'],
+                    [/[\/*]/, 'comment.doc']
+                ],
+
+                // We match regular expression quite precisely
+                regexp: [
+                    [/(\{)(\d+(?:,\d*)?)(\})/, ['regexp.escape.control', 'regexp.escape.control', 'regexp.escape.control']],
+                    [/(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/, ['regexp.escape.control', { token: 'regexp.escape.control', next: '@regexrange' }]],
+                    [/(\()(\?:|\?=|\?!)/, ['regexp.escape.control', 'regexp.escape.control']],
+                    [/[()]/, 'regexp.escape.control'],
+                    [/@regexpctl/, 'regexp.escape.control'],
+                    [/[^\\\/]/, 'regexp'],
+                    [/@regexpesc/, 'regexp.escape'],
+                    [/\\\./, 'regexp.invalid'],
+                    [/(\/)([gimsuy]*)/, [{ token: 'regexp', bracket: '@close', next: '@pop' }, 'keyword.other']],
+                ],
+
+                regexrange: [
+                    [/-/, 'regexp.escape.control'],
+                    [/\^/, 'regexp.invalid'],
+                    [/@regexpesc/, 'regexp.escape'],
+                    [/[^\]]/, 'regexp'],
+                    [/\]/, { token: 'regexp.escape.control', next: '@pop', bracket: '@close' }],
+                ],
+
+                string_double: [
+                    [/[^\\"]+/, 'string'],
+                    [/@escapes/, 'string.escape'],
+                    [/\\./, 'string.escape.invalid'],
+                    [/"/, 'string', '@pop']
+                ],
+
+                string_single: [
+                    [/[^\\']+/, 'string'],
+                    [/@escapes/, 'string.escape'],
+                    [/\\./, 'string.escape.invalid'],
+                    [/'/, 'string', '@pop']
+                ],
+
+                string_backtick: [
+                    [/\$\{/, { token: 'delimiter.bracket', next: '@bracketCounting' }],
+                    [/[^\\`$]+/, 'string'],
+                    [/@escapes/, 'string.escape'],
+                    [/\\./, 'string.escape.invalid'],
+                    [/`/, 'string', '@pop']
+                ],
+
+                bracketCounting: [
+                    [/\{/, 'delimiter.bracket', '@bracketCounting'],
+                    [/\}/, 'delimiter.bracket', '@pop'],
+                    { include: 'common' }
+                ],
+            },
+        }
+
+    );
+
+    // Setup JSONata language config
+    monaco.languages.setLanguageConfiguration('jsonata', {
+        comments: {
+            lineComment: '//',
+            blockComment: ['/*', '*/']
+        },
+        brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')']
+        ],
+        autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string'] }
+        ],
+        surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '<', close: '>' }
+        ],
+        folding: {
+            markers: {
+                start: new RegExp('^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))'),
+                end: new RegExp('^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))')
+            }
+        }
+    });
+
+    // Register a completion item provider for JSONata snippets
+    monaco.languages.registerCompletionItemProvider('jsonata', {
+        provideCompletionItems: function (model, position) {
+            var _word = model.getWordUntilPosition(position);
+            if (!_word) { return; }
+            var startColumn = _word.startColumn;
+            var word = _word.word;
+            if (word[0] !== "$" && position.column > 1) { startColumn--; }
+            var range = {
+                startLineNumber: position.lineNumber,
+                endLineNumber: position.lineNumber,
+                startColumn: startColumn,
+                endColumn: _word.endColumn
+            };
+            let jsonataSuggestions = Object.keys(jsonataLocaleEnUs).map((functionName: string) => {
+                const args = jsonataLocaleEnUs[functionName].args;
+                const desc = jsonataLocaleEnUs[functionName].desc;
+                const title = `${functionName}(${args})`;
+                const insertText = `\\${functionName}(${args.replaceAll("[", "").replaceAll("]", "")})`;
+                const documentation = { value: '`' + title + '`\n\n' + desc };
+                return {
+                    label: functionName,
+                    kind: monaco.languages.CompletionItemKind.Function,
+                    documentation: documentation,
+                    insertText: insertText,
+                    insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                    range: range
+                }
+            });
+            return { suggestions: jsonataSuggestions };
+        }
+    });
+
+    // Register a hover provider for JSONata functions
+    monaco.languages.registerHoverProvider('jsonata', {
+        provideHover: function (model, position) {
+            var w = model.getWordAtPosition(position);
+            var f = w && w.word;
+            if (!f) { return; }
+            if (f[0] !== "$" && position.column > 1) {
+                f = "$" + f;
+            } else {
+                return;
+            }
+            if (!jsonataLocaleEnUs[f]) { return; }
+            let args = jsonataLocaleEnUs[f].args;
+            let desc = jsonataLocaleEnUs[f].desc;
+            if (!args) { return; }
+            var title = f + "(" + args + ")";
+
+            /** @type {monaco.Range} */
+            var r = new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column + (w?.word?.length ?? 0));
+            return {
+                range: r,
+                contents: [
+                    { value: '**`' + title + '`**' },
+                    { value: desc },
+                ]
+            }
+        }
+    })
+
+    // Define a new theme that contains only rules that match this language
+    monaco.editor.defineTheme('jsonataTheme-light', {
+        base: 'vs',
+        inherit: true,
+        rules: [
+            { token: 'variable', foreground: 'ff4000' },
+        ],
+        colors: {
+            // "editor.background": '#fffffb'
+        }
+    });
+    monaco.editor.defineTheme('jsonataTheme-dark', {
+        base: 'vs-dark',
+        inherit: true,
+        rules: [
+            { token: 'variable', foreground: 'ff4000' },
+        ],
+        colors: {
+            // "editor.background": '#fffffb'
+        }
+    });
+}
+
+export { setupJSONata }
\ No newline at end of file