@sleekcms/client 3.1.0 → 3.2.0

package/index.global.js

@@ -0,0 +1,1824 @@
+var SleekCMS = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // node_modules/jmespath/jmespath.js
+  var require_jmespath = __commonJS({
+    "node_modules/jmespath/jmespath.js"(exports) {
+      (function(exports2) {
+        "use strict";
+        function isArray(obj) {
+          if (obj !== null) {
+            return Object.prototype.toString.call(obj) === "[object Array]";
+          } else {
+            return false;
+          }
+        }
+        function isObject(obj) {
+          if (obj !== null) {
+            return Object.prototype.toString.call(obj) === "[object Object]";
+          } else {
+            return false;
+          }
+        }
+        function strictDeepEqual(first, second) {
+          if (first === second) {
+            return true;
+          }
+          var firstType = Object.prototype.toString.call(first);
+          if (firstType !== Object.prototype.toString.call(second)) {
+            return false;
+          }
+          if (isArray(first) === true) {
+            if (first.length !== second.length) {
+              return false;
+            }
+            for (var i = 0; i < first.length; i++) {
+              if (strictDeepEqual(first[i], second[i]) === false) {
+                return false;
+              }
+            }
+            return true;
+          }
+          if (isObject(first) === true) {
+            var keysSeen = {};
+            for (var key in first) {
+              if (hasOwnProperty.call(first, key)) {
+                if (strictDeepEqual(first[key], second[key]) === false) {
+                  return false;
+                }
+                keysSeen[key] = true;
+              }
+            }
+            for (var key2 in second) {
+              if (hasOwnProperty.call(second, key2)) {
+                if (keysSeen[key2] !== true) {
+                  return false;
+                }
+              }
+            }
+            return true;
+          }
+          return false;
+        }
+        function isFalse(obj) {
+          if (obj === "" || obj === false || obj === null) {
+            return true;
+          } else if (isArray(obj) && obj.length === 0) {
+            return true;
+          } else if (isObject(obj)) {
+            for (var key in obj) {
+              if (obj.hasOwnProperty(key)) {
+                return false;
+              }
+            }
+            return true;
+          } else {
+            return false;
+          }
+        }
+        function objValues(obj) {
+          var keys = Object.keys(obj);
+          var values = [];
+          for (var i = 0; i < keys.length; i++) {
+            values.push(obj[keys[i]]);
+          }
+          return values;
+        }
+        function merge(a, b) {
+          var merged = {};
+          for (var key in a) {
+            merged[key] = a[key];
+          }
+          for (var key2 in b) {
+            merged[key2] = b[key2];
+          }
+          return merged;
+        }
+        var trimLeft;
+        if (typeof String.prototype.trimLeft === "function") {
+          trimLeft = function(str) {
+            return str.trimLeft();
+          };
+        } else {
+          trimLeft = function(str) {
+            return str.match(/^\s*(.*)/)[1];
+          };
+        }
+        var TYPE_NUMBER = 0;
+        var TYPE_ANY = 1;
+        var TYPE_STRING = 2;
+        var TYPE_ARRAY = 3;
+        var TYPE_OBJECT = 4;
+        var TYPE_BOOLEAN = 5;
+        var TYPE_EXPREF = 6;
+        var TYPE_NULL = 7;
+        var TYPE_ARRAY_NUMBER = 8;
+        var TYPE_ARRAY_STRING = 9;
+        var TYPE_NAME_TABLE = {
+          0: "number",
+          1: "any",
+          2: "string",
+          3: "array",
+          4: "object",
+          5: "boolean",
+          6: "expression",
+          7: "null",
+          8: "Array<number>",
+          9: "Array<string>"
+        };
+        var TOK_EOF = "EOF";
+        var TOK_UNQUOTEDIDENTIFIER = "UnquotedIdentifier";
+        var TOK_QUOTEDIDENTIFIER = "QuotedIdentifier";
+        var TOK_RBRACKET = "Rbracket";
+        var TOK_RPAREN = "Rparen";
+        var TOK_COMMA = "Comma";
+        var TOK_COLON = "Colon";
+        var TOK_RBRACE = "Rbrace";
+        var TOK_NUMBER = "Number";
+        var TOK_CURRENT = "Current";
+        var TOK_EXPREF = "Expref";
+        var TOK_PIPE = "Pipe";
+        var TOK_OR = "Or";
+        var TOK_AND = "And";
+        var TOK_EQ = "EQ";
+        var TOK_GT = "GT";
+        var TOK_LT = "LT";
+        var TOK_GTE = "GTE";
+        var TOK_LTE = "LTE";
+        var TOK_NE = "NE";
+        var TOK_FLATTEN = "Flatten";
+        var TOK_STAR = "Star";
+        var TOK_FILTER = "Filter";
+        var TOK_DOT = "Dot";
+        var TOK_NOT = "Not";
+        var TOK_LBRACE = "Lbrace";
+        var TOK_LBRACKET = "Lbracket";
+        var TOK_LPAREN = "Lparen";
+        var TOK_LITERAL = "Literal";
+        var basicTokens = {
+          ".": TOK_DOT,
+          "*": TOK_STAR,
+          ",": TOK_COMMA,
+          ":": TOK_COLON,
+          "{": TOK_LBRACE,
+          "}": TOK_RBRACE,
+          "]": TOK_RBRACKET,
+          "(": TOK_LPAREN,
+          ")": TOK_RPAREN,
+          "@": TOK_CURRENT
+        };
+        var operatorStartToken = {
+          "<": true,
+          ">": true,
+          "=": true,
+          "!": true
+        };
+        var skipChars = {
+          " ": true,
+          "	": true,
+          "\n": true
+        };
+        function isAlpha(ch) {
+          return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_";
+        }
+        function isNum(ch) {
+          return ch >= "0" && ch <= "9" || ch === "-";
+        }
+        function isAlphaNum(ch) {
+          return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+        }
+        function Lexer() {
+        }
+        Lexer.prototype = {
+          tokenize: function(stream) {
+            var tokens = [];
+            this._current = 0;
+            var start;
+            var identifier;
+            var token;
+            while (this._current < stream.length) {
+              if (isAlpha(stream[this._current])) {
+                start = this._current;
+                identifier = this._consumeUnquotedIdentifier(stream);
+                tokens.push({
+                  type: TOK_UNQUOTEDIDENTIFIER,
+                  value: identifier,
+                  start
+                });
+              } else if (basicTokens[stream[this._current]] !== void 0) {
+                tokens.push({
+                  type: basicTokens[stream[this._current]],
+                  value: stream[this._current],
+                  start: this._current
+                });
+                this._current++;
+              } else if (isNum(stream[this._current])) {
+                token = this._consumeNumber(stream);
+                tokens.push(token);
+              } else if (stream[this._current] === "[") {
+                token = this._consumeLBracket(stream);
+                tokens.push(token);
+              } else if (stream[this._current] === '"') {
+                start = this._current;
+                identifier = this._consumeQuotedIdentifier(stream);
+                tokens.push({
+                  type: TOK_QUOTEDIDENTIFIER,
+                  value: identifier,
+                  start
+                });
+              } else if (stream[this._current] === "'") {
+                start = this._current;
+                identifier = this._consumeRawStringLiteral(stream);
+                tokens.push({
+                  type: TOK_LITERAL,
+                  value: identifier,
+                  start
+                });
+              } else if (stream[this._current] === "`") {
+                start = this._current;
+                var literal = this._consumeLiteral(stream);
+                tokens.push({
+                  type: TOK_LITERAL,
+                  value: literal,
+                  start
+                });
+              } else if (operatorStartToken[stream[this._current]] !== void 0) {
+                tokens.push(this._consumeOperator(stream));
+              } else if (skipChars[stream[this._current]] !== void 0) {
+                this._current++;
+              } else if (stream[this._current] === "&") {
+                start = this._current;
+                this._current++;
+                if (stream[this._current] === "&") {
+                  this._current++;
+                  tokens.push({ type: TOK_AND, value: "&&", start });
+                } else {
+                  tokens.push({ type: TOK_EXPREF, value: "&", start });
+                }
+              } else if (stream[this._current] === "|") {
+                start = this._current;
+                this._current++;
+                if (stream[this._current] === "|") {
+                  this._current++;
+                  tokens.push({ type: TOK_OR, value: "||", start });
+                } else {
+                  tokens.push({ type: TOK_PIPE, value: "|", start });
+                }
+              } else {
+                var error = new Error("Unknown character:" + stream[this._current]);
+                error.name = "LexerError";
+                throw error;
+              }
+            }
+            return tokens;
+          },
+          _consumeUnquotedIdentifier: function(stream) {
+            var start = this._current;
+            this._current++;
+            while (this._current < stream.length && isAlphaNum(stream[this._current])) {
+              this._current++;
+            }
+            return stream.slice(start, this._current);
+          },
+          _consumeQuotedIdentifier: function(stream) {
+            var start = this._current;
+            this._current++;
+            var maxLength = stream.length;
+            while (stream[this._current] !== '"' && this._current < maxLength) {
+              var current = this._current;
+              if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === '"')) {
+                current += 2;
+              } else {
+                current++;
+              }
+              this._current = current;
+            }
+            this._current++;
+            return JSON.parse(stream.slice(start, this._current));
+          },
+          _consumeRawStringLiteral: function(stream) {
+            var start = this._current;
+            this._current++;
+            var maxLength = stream.length;
+            while (stream[this._current] !== "'" && this._current < maxLength) {
+              var current = this._current;
+              if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === "'")) {
+                current += 2;
+              } else {
+                current++;
+              }
+              this._current = current;
+            }
+            this._current++;
+            var literal = stream.slice(start + 1, this._current - 1);
+            return literal.replace("\\'", "'");
+          },
+          _consumeNumber: function(stream) {
+            var start = this._current;
+            this._current++;
+            var maxLength = stream.length;
+            while (isNum(stream[this._current]) && this._current < maxLength) {
+              this._current++;
+            }
+            var value = parseInt(stream.slice(start, this._current));
+            return { type: TOK_NUMBER, value, start };
+          },
+          _consumeLBracket: function(stream) {
+            var start = this._current;
+            this._current++;
+            if (stream[this._current] === "?") {
+              this._current++;
+              return { type: TOK_FILTER, value: "[?", start };
+            } else if (stream[this._current] === "]") {
+              this._current++;
+              return { type: TOK_FLATTEN, value: "[]", start };
+            } else {
+              return { type: TOK_LBRACKET, value: "[", start };
+            }
+          },
+          _consumeOperator: function(stream) {
+            var start = this._current;
+            var startingChar = stream[start];
+            this._current++;
+            if (startingChar === "!") {
+              if (stream[this._current] === "=") {
+                this._current++;
+                return { type: TOK_NE, value: "!=", start };
+              } else {
+                return { type: TOK_NOT, value: "!", start };
+              }
+            } else if (startingChar === "<") {
+              if (stream[this._current] === "=") {
+                this._current++;
+                return { type: TOK_LTE, value: "<=", start };
+              } else {
+                return { type: TOK_LT, value: "<", start };
+              }
+            } else if (startingChar === ">") {
+              if (stream[this._current] === "=") {
+                this._current++;
+                return { type: TOK_GTE, value: ">=", start };
+              } else {
+                return { type: TOK_GT, value: ">", start };
+              }
+            } else if (startingChar === "=") {
+              if (stream[this._current] === "=") {
+                this._current++;
+                return { type: TOK_EQ, value: "==", start };
+              }
+            }
+          },
+          _consumeLiteral: function(stream) {
+            this._current++;
+            var start = this._current;
+            var maxLength = stream.length;
+            var literal;
+            while (stream[this._current] !== "`" && this._current < maxLength) {
+              var current = this._current;
+              if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === "`")) {
+                current += 2;
+              } else {
+                current++;
+              }
+              this._current = current;
+            }
+            var literalString = trimLeft(stream.slice(start, this._current));
+            literalString = literalString.replace("\\`", "`");
+            if (this._looksLikeJSON(literalString)) {
+              literal = JSON.parse(literalString);
+            } else {
+              literal = JSON.parse('"' + literalString + '"');
+            }
+            this._current++;
+            return literal;
+          },
+          _looksLikeJSON: function(literalString) {
+            var startingChars = '[{"';
+            var jsonLiterals = ["true", "false", "null"];
+            var numberLooking = "-0123456789";
+            if (literalString === "") {
+              return false;
+            } else if (startingChars.indexOf(literalString[0]) >= 0) {
+              return true;
+            } else if (jsonLiterals.indexOf(literalString) >= 0) {
+              return true;
+            } else if (numberLooking.indexOf(literalString[0]) >= 0) {
+              try {
+                JSON.parse(literalString);
+                return true;
+              } catch (ex) {
+                return false;
+              }
+            } else {
+              return false;
+            }
+          }
+        };
+        var bindingPower = {};
+        bindingPower[TOK_EOF] = 0;
+        bindingPower[TOK_UNQUOTEDIDENTIFIER] = 0;
+        bindingPower[TOK_QUOTEDIDENTIFIER] = 0;
+        bindingPower[TOK_RBRACKET] = 0;
+        bindingPower[TOK_RPAREN] = 0;
+        bindingPower[TOK_COMMA] = 0;
+        bindingPower[TOK_RBRACE] = 0;
+        bindingPower[TOK_NUMBER] = 0;
+        bindingPower[TOK_CURRENT] = 0;
+        bindingPower[TOK_EXPREF] = 0;
+        bindingPower[TOK_PIPE] = 1;
+        bindingPower[TOK_OR] = 2;
+        bindingPower[TOK_AND] = 3;
+        bindingPower[TOK_EQ] = 5;
+        bindingPower[TOK_GT] = 5;
+        bindingPower[TOK_LT] = 5;
+        bindingPower[TOK_GTE] = 5;
+        bindingPower[TOK_LTE] = 5;
+        bindingPower[TOK_NE] = 5;
+        bindingPower[TOK_FLATTEN] = 9;
+        bindingPower[TOK_STAR] = 20;
+        bindingPower[TOK_FILTER] = 21;
+        bindingPower[TOK_DOT] = 40;
+        bindingPower[TOK_NOT] = 45;
+        bindingPower[TOK_LBRACE] = 50;
+        bindingPower[TOK_LBRACKET] = 55;
+        bindingPower[TOK_LPAREN] = 60;
+        function Parser() {
+        }
+        Parser.prototype = {
+          parse: function(expression) {
+            this._loadTokens(expression);
+            this.index = 0;
+            var ast = this.expression(0);
+            if (this._lookahead(0) !== TOK_EOF) {
+              var t = this._lookaheadToken(0);
+              var error = new Error(
+                "Unexpected token type: " + t.type + ", value: " + t.value
+              );
+              error.name = "ParserError";
+              throw error;
+            }
+            return ast;
+          },
+          _loadTokens: function(expression) {
+            var lexer = new Lexer();
+            var tokens = lexer.tokenize(expression);
+            tokens.push({ type: TOK_EOF, value: "", start: expression.length });
+            this.tokens = tokens;
+          },
+          expression: function(rbp) {
+            var leftToken = this._lookaheadToken(0);
+            this._advance();
+            var left = this.nud(leftToken);
+            var currentToken = this._lookahead(0);
+            while (rbp < bindingPower[currentToken]) {
+              this._advance();
+              left = this.led(currentToken, left);
+              currentToken = this._lookahead(0);
+            }
+            return left;
+          },
+          _lookahead: function(number) {
+            return this.tokens[this.index + number].type;
+          },
+          _lookaheadToken: function(number) {
+            return this.tokens[this.index + number];
+          },
+          _advance: function() {
+            this.index++;
+          },
+          nud: function(token) {
+            var left;
+            var right;
+            var expression;
+            switch (token.type) {
+              case TOK_LITERAL:
+                return { type: "Literal", value: token.value };
+              case TOK_UNQUOTEDIDENTIFIER:
+                return { type: "Field", name: token.value };
+              case TOK_QUOTEDIDENTIFIER:
+                var node = { type: "Field", name: token.value };
+                if (this._lookahead(0) === TOK_LPAREN) {
+                  throw new Error("Quoted identifier not allowed for function names.");
+                }
+                return node;
+              case TOK_NOT:
+                right = this.expression(bindingPower.Not);
+                return { type: "NotExpression", children: [right] };
+              case TOK_STAR:
+                left = { type: "Identity" };
+                right = null;
+                if (this._lookahead(0) === TOK_RBRACKET) {
+                  right = { type: "Identity" };
+                } else {
+                  right = this._parseProjectionRHS(bindingPower.Star);
+                }
+                return { type: "ValueProjection", children: [left, right] };
+              case TOK_FILTER:
+                return this.led(token.type, { type: "Identity" });
+              case TOK_LBRACE:
+                return this._parseMultiselectHash();
+              case TOK_FLATTEN:
+                left = { type: TOK_FLATTEN, children: [{ type: "Identity" }] };
+                right = this._parseProjectionRHS(bindingPower.Flatten);
+                return { type: "Projection", children: [left, right] };
+              case TOK_LBRACKET:
+                if (this._lookahead(0) === TOK_NUMBER || this._lookahead(0) === TOK_COLON) {
+                  right = this._parseIndexExpression();
+                  return this._projectIfSlice({ type: "Identity" }, right);
+                } else if (this._lookahead(0) === TOK_STAR && this._lookahead(1) === TOK_RBRACKET) {
+                  this._advance();
+                  this._advance();
+                  right = this._parseProjectionRHS(bindingPower.Star);
+                  return {
+                    type: "Projection",
+                    children: [{ type: "Identity" }, right]
+                  };
+                }
+                return this._parseMultiselectList();
+              case TOK_CURRENT:
+                return { type: TOK_CURRENT };
+              case TOK_EXPREF:
+                expression = this.expression(bindingPower.Expref);
+                return { type: "ExpressionReference", children: [expression] };
+              case TOK_LPAREN:
+                var args = [];
+                while (this._lookahead(0) !== TOK_RPAREN) {
+                  if (this._lookahead(0) === TOK_CURRENT) {
+                    expression = { type: TOK_CURRENT };
+                    this._advance();
+                  } else {
+                    expression = this.expression(0);
+                  }
+                  args.push(expression);
+                }
+                this._match(TOK_RPAREN);
+                return args[0];
+              default:
+                this._errorToken(token);
+            }
+          },
+          led: function(tokenName, left) {
+            var right;
+            switch (tokenName) {
+              case TOK_DOT:
+                var rbp = bindingPower.Dot;
+                if (this._lookahead(0) !== TOK_STAR) {
+                  right = this._parseDotRHS(rbp);
+                  return { type: "Subexpression", children: [left, right] };
+                }
+                this._advance();
+                right = this._parseProjectionRHS(rbp);
+                return { type: "ValueProjection", children: [left, right] };
+              case TOK_PIPE:
+                right = this.expression(bindingPower.Pipe);
+                return { type: TOK_PIPE, children: [left, right] };
+              case TOK_OR:
+                right = this.expression(bindingPower.Or);
+                return { type: "OrExpression", children: [left, right] };
+              case TOK_AND:
+                right = this.expression(bindingPower.And);
+                return { type: "AndExpression", children: [left, right] };
+              case TOK_LPAREN:
+                var name = left.name;
+                var args = [];
+                var expression, node;
+                while (this._lookahead(0) !== TOK_RPAREN) {
+                  if (this._lookahead(0) === TOK_CURRENT) {
+                    expression = { type: TOK_CURRENT };
+                    this._advance();
+                  } else {
+                    expression = this.expression(0);
+                  }
+                  if (this._lookahead(0) === TOK_COMMA) {
+                    this._match(TOK_COMMA);
+                  }
+                  args.push(expression);
+                }
+                this._match(TOK_RPAREN);
+                node = { type: "Function", name, children: args };
+                return node;
+              case TOK_FILTER:
+                var condition = this.expression(0);
+                this._match(TOK_RBRACKET);
+                if (this._lookahead(0) === TOK_FLATTEN) {
+                  right = { type: "Identity" };
+                } else {
+                  right = this._parseProjectionRHS(bindingPower.Filter);
+                }
+                return { type: "FilterProjection", children: [left, right, condition] };
+              case TOK_FLATTEN:
+                var leftNode = { type: TOK_FLATTEN, children: [left] };
+                var rightNode = this._parseProjectionRHS(bindingPower.Flatten);
+                return { type: "Projection", children: [leftNode, rightNode] };
+              case TOK_EQ:
+              case TOK_NE:
+              case TOK_GT:
+              case TOK_GTE:
+              case TOK_LT:
+              case TOK_LTE:
+                return this._parseComparator(left, tokenName);
+              case TOK_LBRACKET:
+                var token = this._lookaheadToken(0);
+                if (token.type === TOK_NUMBER || token.type === TOK_COLON) {
+                  right = this._parseIndexExpression();
+                  return this._projectIfSlice(left, right);
+                }
+                this._match(TOK_STAR);
+                this._match(TOK_RBRACKET);
+                right = this._parseProjectionRHS(bindingPower.Star);
+                return { type: "Projection", children: [left, right] };
+              default:
+                this._errorToken(this._lookaheadToken(0));
+            }
+          },
+          _match: function(tokenType) {
+            if (this._lookahead(0) === tokenType) {
+              this._advance();
+            } else {
+              var t = this._lookaheadToken(0);
+              var error = new Error("Expected " + tokenType + ", got: " + t.type);
+              error.name = "ParserError";
+              throw error;
+            }
+          },
+          _errorToken: function(token) {
+            var error = new Error("Invalid token (" + token.type + '): "' + token.value + '"');
+            error.name = "ParserError";
+            throw error;
+          },
+          _parseIndexExpression: function() {
+            if (this._lookahead(0) === TOK_COLON || this._lookahead(1) === TOK_COLON) {
+              return this._parseSliceExpression();
+            } else {
+              var node = {
+                type: "Index",
+                value: this._lookaheadToken(0).value
+              };
+              this._advance();
+              this._match(TOK_RBRACKET);
+              return node;
+            }
+          },
+          _projectIfSlice: function(left, right) {
+            var indexExpr = { type: "IndexExpression", children: [left, right] };
+            if (right.type === "Slice") {
+              return {
+                type: "Projection",
+                children: [indexExpr, this._parseProjectionRHS(bindingPower.Star)]
+              };
+            } else {
+              return indexExpr;
+            }
+          },
+          _parseSliceExpression: function() {
+            var parts = [null, null, null];
+            var index = 0;
+            var currentToken = this._lookahead(0);
+            while (currentToken !== TOK_RBRACKET && index < 3) {
+              if (currentToken === TOK_COLON) {
+                index++;
+                this._advance();
+              } else if (currentToken === TOK_NUMBER) {
+                parts[index] = this._lookaheadToken(0).value;
+                this._advance();
+              } else {
+                var t = this._lookahead(0);
+                var error = new Error("Syntax error, unexpected token: " + t.value + "(" + t.type + ")");
+                error.name = "Parsererror";
+                throw error;
+              }
+              currentToken = this._lookahead(0);
+            }
+            this._match(TOK_RBRACKET);
+            return {
+              type: "Slice",
+              children: parts
+            };
+          },
+          _parseComparator: function(left, comparator) {
+            var right = this.expression(bindingPower[comparator]);
+            return { type: "Comparator", name: comparator, children: [left, right] };
+          },
+          _parseDotRHS: function(rbp) {
+            var lookahead = this._lookahead(0);
+            var exprTokens = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER, TOK_STAR];
+            if (exprTokens.indexOf(lookahead) >= 0) {
+              return this.expression(rbp);
+            } else if (lookahead === TOK_LBRACKET) {
+              this._match(TOK_LBRACKET);
+              return this._parseMultiselectList();
+            } else if (lookahead === TOK_LBRACE) {
+              this._match(TOK_LBRACE);
+              return this._parseMultiselectHash();
+            }
+          },
+          _parseProjectionRHS: function(rbp) {
+            var right;
+            if (bindingPower[this._lookahead(0)] < 10) {
+              right = { type: "Identity" };
+            } else if (this._lookahead(0) === TOK_LBRACKET) {
+              right = this.expression(rbp);
+            } else if (this._lookahead(0) === TOK_FILTER) {
+              right = this.expression(rbp);
+            } else if (this._lookahead(0) === TOK_DOT) {
+              this._match(TOK_DOT);
+              right = this._parseDotRHS(rbp);
+            } else {
+              var t = this._lookaheadToken(0);
+              var error = new Error("Sytanx error, unexpected token: " + t.value + "(" + t.type + ")");
+              error.name = "ParserError";
+              throw error;
+            }
+            return right;
+          },
+          _parseMultiselectList: function() {
+            var expressions = [];
+            while (this._lookahead(0) !== TOK_RBRACKET) {
+              var expression = this.expression(0);
+              expressions.push(expression);
+              if (this._lookahead(0) === TOK_COMMA) {
+                this._match(TOK_COMMA);
+                if (this._lookahead(0) === TOK_RBRACKET) {
+                  throw new Error("Unexpected token Rbracket");
+                }
+              }
+            }
+            this._match(TOK_RBRACKET);
+            return { type: "MultiSelectList", children: expressions };
+          },
+          _parseMultiselectHash: function() {
+            var pairs = [];
+            var identifierTypes = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER];
+            var keyToken, keyName, value, node;
+            for (; ; ) {
+              keyToken = this._lookaheadToken(0);
+              if (identifierTypes.indexOf(keyToken.type) < 0) {
+                throw new Error("Expecting an identifier token, got: " + keyToken.type);
+              }
+              keyName = keyToken.value;
+              this._advance();
+              this._match(TOK_COLON);
+              value = this.expression(0);
+              node = { type: "KeyValuePair", name: keyName, value };
+              pairs.push(node);
+              if (this._lookahead(0) === TOK_COMMA) {
+                this._match(TOK_COMMA);
+              } else if (this._lookahead(0) === TOK_RBRACE) {
+                this._match(TOK_RBRACE);
+                break;
+              }
+            }
+            return { type: "MultiSelectHash", children: pairs };
+          }
+        };
+        function TreeInterpreter(runtime) {
+          this.runtime = runtime;
+        }
+        TreeInterpreter.prototype = {
+          search: function(node, value) {
+            return this.visit(node, value);
+          },
+          visit: function(node, value) {
+            var matched, current, result, first, second, field, left, right, collected, i;
+            switch (node.type) {
+              case "Field":
+                if (value !== null && isObject(value)) {
+                  field = value[node.name];
+                  if (field === void 0) {
+                    return null;
+                  } else {
+                    return field;
+                  }
+                }
+                return null;
+              case "Subexpression":
+                result = this.visit(node.children[0], value);
+                for (i = 1; i < node.children.length; i++) {
+                  result = this.visit(node.children[1], result);
+                  if (result === null) {
+                    return null;
+                  }
+                }
+                return result;
+              case "IndexExpression":
+                left = this.visit(node.children[0], value);
+                right = this.visit(node.children[1], left);
+                return right;
+              case "Index":
+                if (!isArray(value)) {
+                  return null;
+                }
+                var index = node.value;
+                if (index < 0) {
+                  index = value.length + index;
+                }
+                result = value[index];
+                if (result === void 0) {
+                  result = null;
+                }
+                return result;
+              case "Slice":
+                if (!isArray(value)) {
+                  return null;
+                }
+                var sliceParams = node.children.slice(0);
+                var computed = this.computeSliceParams(value.length, sliceParams);
+                var start = computed[0];
+                var stop = computed[1];
+                var step = computed[2];
+                result = [];
+                if (step > 0) {
+                  for (i = start; i < stop; i += step) {
+                    result.push(value[i]);
+                  }
+                } else {
+                  for (i = start; i > stop; i += step) {
+                    result.push(value[i]);
+                  }
+                }
+                return result;
+              case "Projection":
+                var base = this.visit(node.children[0], value);
+                if (!isArray(base)) {
+                  return null;
+                }
+                collected = [];
+                for (i = 0; i < base.length; i++) {
+                  current = this.visit(node.children[1], base[i]);
+                  if (current !== null) {
+                    collected.push(current);
+                  }
+                }
+                return collected;
+              case "ValueProjection":
+                base = this.visit(node.children[0], value);
+                if (!isObject(base)) {
+                  return null;
+                }
+                collected = [];
+                var values = objValues(base);
+                for (i = 0; i < values.length; i++) {
+                  current = this.visit(node.children[1], values[i]);
+                  if (current !== null) {
+                    collected.push(current);
+                  }
+                }
+                return collected;
+              case "FilterProjection":
+                base = this.visit(node.children[0], value);
+                if (!isArray(base)) {
+                  return null;
+                }
+                var filtered = [];
+                var finalResults = [];
+                for (i = 0; i < base.length; i++) {
+                  matched = this.visit(node.children[2], base[i]);
+                  if (!isFalse(matched)) {
+                    filtered.push(base[i]);
+                  }
+                }
+                for (var j = 0; j < filtered.length; j++) {
+                  current = this.visit(node.children[1], filtered[j]);
+                  if (current !== null) {
+                    finalResults.push(current);
+                  }
+                }
+                return finalResults;
+              case "Comparator":
+                first = this.visit(node.children[0], value);
+                second = this.visit(node.children[1], value);
+                switch (node.name) {
+                  case TOK_EQ:
+                    result = strictDeepEqual(first, second);
+                    break;
+                  case TOK_NE:
+                    result = !strictDeepEqual(first, second);
+                    break;
+                  case TOK_GT:
+                    result = first > second;
+                    break;
+                  case TOK_GTE:
+                    result = first >= second;
+                    break;
+                  case TOK_LT:
+                    result = first < second;
+                    break;
+                  case TOK_LTE:
+                    result = first <= second;
+                    break;
+                  default:
+                    throw new Error("Unknown comparator: " + node.name);
+                }
+                return result;
+              case TOK_FLATTEN:
+                var original = this.visit(node.children[0], value);
+                if (!isArray(original)) {
+                  return null;
+                }
+                var merged = [];
+                for (i = 0; i < original.length; i++) {
+                  current = original[i];
+                  if (isArray(current)) {
+                    merged.push.apply(merged, current);
+                  } else {
+                    merged.push(current);
+                  }
+                }
+                return merged;
+              case "Identity":
+                return value;
+              case "MultiSelectList":
+                if (value === null) {
+                  return null;
+                }
+                collected = [];
+                for (i = 0; i < node.children.length; i++) {
+                  collected.push(this.visit(node.children[i], value));
+                }
+                return collected;
+              case "MultiSelectHash":
+                if (value === null) {
+                  return null;
+                }
+                collected = {};
+                var child;
+                for (i = 0; i < node.children.length; i++) {
+                  child = node.children[i];
+                  collected[child.name] = this.visit(child.value, value);
+                }
+                return collected;
+              case "OrExpression":
+                matched = this.visit(node.children[0], value);
+                if (isFalse(matched)) {
+                  matched = this.visit(node.children[1], value);
+                }
+                return matched;
+              case "AndExpression":
+                first = this.visit(node.children[0], value);
+                if (isFalse(first) === true) {
+                  return first;
+                }
+                return this.visit(node.children[1], value);
+              case "NotExpression":
+                first = this.visit(node.children[0], value);
+                return isFalse(first);
+              case "Literal":
+                return node.value;
+              case TOK_PIPE:
+                left = this.visit(node.children[0], value);
+                return this.visit(node.children[1], left);
+              case TOK_CURRENT:
+                return value;
+              case "Function":
+                var resolvedArgs = [];
+                for (i = 0; i < node.children.length; i++) {
+                  resolvedArgs.push(this.visit(node.children[i], value));
+                }
+                return this.runtime.callFunction(node.name, resolvedArgs);
+              case "ExpressionReference":
+                var refNode = node.children[0];
+                refNode.jmespathType = TOK_EXPREF;
+                return refNode;
+              default:
+                throw new Error("Unknown node type: " + node.type);
+            }
+          },
+          computeSliceParams: function(arrayLength, sliceParams) {
+            var start = sliceParams[0];
+            var stop = sliceParams[1];
+            var step = sliceParams[2];
+            var computed = [null, null, null];
+            if (step === null) {
+              step = 1;
+            } else if (step === 0) {
+              var error = new Error("Invalid slice, step cannot be 0");
+              error.name = "RuntimeError";
+              throw error;
+            }
+            var stepValueNegative = step < 0 ? true : false;
+            if (start === null) {
+              start = stepValueNegative ? arrayLength - 1 : 0;
+            } else {
+              start = this.capSliceRange(arrayLength, start, step);
+            }
+            if (stop === null) {
+              stop = stepValueNegative ? -1 : arrayLength;
+            } else {
+              stop = this.capSliceRange(arrayLength, stop, step);
+            }
+            computed[0] = start;
+            computed[1] = stop;
+            computed[2] = step;
+            return computed;
+          },
+          capSliceRange: function(arrayLength, actualValue, step) {
+            if (actualValue < 0) {
+              actualValue += arrayLength;
+              if (actualValue < 0) {
+                actualValue = step < 0 ? -1 : 0;
+              }
+            } else if (actualValue >= arrayLength) {
+              actualValue = step < 0 ? arrayLength - 1 : arrayLength;
+            }
+            return actualValue;
+          }
+        };
+        function Runtime(interpreter) {
+          this._interpreter = interpreter;
+          this.functionTable = {
+            // name: [function, <signature>]
+            // The <signature> can be:
+            //
+            // {
+            //   args: [[type1, type2], [type1, type2]],
+            //   variadic: true|false
+            // }
+            //
+            // Each arg in the arg list is a list of valid types
+            // (if the function is overloaded and supports multiple
+            // types.  If the type is "any" then no type checking
+            // occurs on the argument.  Variadic is optional
+            // and if not provided is assumed to be false.
+            abs: { _func: this._functionAbs, _signature: [{ types: [TYPE_NUMBER] }] },
+            avg: { _func: this._functionAvg, _signature: [{ types: [TYPE_ARRAY_NUMBER] }] },
+            ceil: { _func: this._functionCeil, _signature: [{ types: [TYPE_NUMBER] }] },
+            contains: {
+              _func: this._functionContains,
+              _signature: [
+                { types: [TYPE_STRING, TYPE_ARRAY] },
+                { types: [TYPE_ANY] }
+              ]
+            },
+            "ends_with": {
+              _func: this._functionEndsWith,
+              _signature: [{ types: [TYPE_STRING] }, { types: [TYPE_STRING] }]
+            },
+            floor: { _func: this._functionFloor, _signature: [{ types: [TYPE_NUMBER] }] },
+            length: {
+              _func: this._functionLength,
+              _signature: [{ types: [TYPE_STRING, TYPE_ARRAY, TYPE_OBJECT] }]
+            },
+            map: {
+              _func: this._functionMap,
+              _signature: [{ types: [TYPE_EXPREF] }, { types: [TYPE_ARRAY] }]
+            },
+            max: {
+              _func: this._functionMax,
+              _signature: [{ types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING] }]
+            },
+            "merge": {
+              _func: this._functionMerge,
+              _signature: [{ types: [TYPE_OBJECT], variadic: true }]
+            },
+            "max_by": {
+              _func: this._functionMaxBy,
+              _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+            },
+            sum: { _func: this._functionSum, _signature: [{ types: [TYPE_ARRAY_NUMBER] }] },
+            "starts_with": {
+              _func: this._functionStartsWith,
+              _signature: [{ types: [TYPE_STRING] }, { types: [TYPE_STRING] }]
+            },
+            min: {
+              _func: this._functionMin,
+              _signature: [{ types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING] }]
+            },
+            "min_by": {
+              _func: this._functionMinBy,
+              _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+            },
+            type: { _func: this._functionType, _signature: [{ types: [TYPE_ANY] }] },
+            keys: { _func: this._functionKeys, _signature: [{ types: [TYPE_OBJECT] }] },
+            values: { _func: this._functionValues, _signature: [{ types: [TYPE_OBJECT] }] },
+            sort: { _func: this._functionSort, _signature: [{ types: [TYPE_ARRAY_STRING, TYPE_ARRAY_NUMBER] }] },
+            "sort_by": {
+              _func: this._functionSortBy,
+              _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+            },
+            join: {
+              _func: this._functionJoin,
+              _signature: [
+                { types: [TYPE_STRING] },
+                { types: [TYPE_ARRAY_STRING] }
+              ]
+            },
+            reverse: {
+              _func: this._functionReverse,
+              _signature: [{ types: [TYPE_STRING, TYPE_ARRAY] }]
+            },
+            "to_array": { _func: this._functionToArray, _signature: [{ types: [TYPE_ANY] }] },
+            "to_string": { _func: this._functionToString, _signature: [{ types: [TYPE_ANY] }] },
+            "to_number": { _func: this._functionToNumber, _signature: [{ types: [TYPE_ANY] }] },
+            "not_null": {
+              _func: this._functionNotNull,
+              _signature: [{ types: [TYPE_ANY], variadic: true }]
+            }
+          };
+        }
+        Runtime.prototype = {
+          callFunction: function(name, resolvedArgs) {
+            var functionEntry = this.functionTable[name];
+            if (functionEntry === void 0) {
+              throw new Error("Unknown function: " + name + "()");
+            }
+            this._validateArgs(name, resolvedArgs, functionEntry._signature);
+            return functionEntry._func.call(this, resolvedArgs);
+          },
+          _validateArgs: function(name, args, signature) {
+            var pluralized;
+            if (signature[signature.length - 1].variadic) {
+              if (args.length < signature.length) {
+                pluralized = signature.length === 1 ? " argument" : " arguments";
+                throw new Error("ArgumentError: " + name + "() takes at least" + signature.length + pluralized + " but received " + args.length);
+              }
+            } else if (args.length !== signature.length) {
+              pluralized = signature.length === 1 ? " argument" : " arguments";
+              throw new Error("ArgumentError: " + name + "() takes " + signature.length + pluralized + " but received " + args.length);
+            }
+            var currentSpec;
+            var actualType;
+            var typeMatched;
+            for (var i = 0; i < signature.length; i++) {
+              typeMatched = false;
+              currentSpec = signature[i].types;
+              actualType = this._getTypeName(args[i]);
+              for (var j = 0; j < currentSpec.length; j++) {
+                if (this._typeMatches(actualType, currentSpec[j], args[i])) {
+                  typeMatched = true;
+                  break;
+                }
+              }
+              if (!typeMatched) {
+                var expected = currentSpec.map(function(typeIdentifier) {
+                  return TYPE_NAME_TABLE[typeIdentifier];
+                }).join(",");
+                throw new Error("TypeError: " + name + "() expected argument " + (i + 1) + " to be type " + expected + " but received type " + TYPE_NAME_TABLE[actualType] + " instead.");
+              }
+            }
+          },
+          _typeMatches: function(actual, expected, argValue) {
+            if (expected === TYPE_ANY) {
+              return true;
+            }
+            if (expected === TYPE_ARRAY_STRING || expected === TYPE_ARRAY_NUMBER || expected === TYPE_ARRAY) {
+              if (expected === TYPE_ARRAY) {
+                return actual === TYPE_ARRAY;
+              } else if (actual === TYPE_ARRAY) {
+                var subtype;
+                if (expected === TYPE_ARRAY_NUMBER) {
+                  subtype = TYPE_NUMBER;
+                } else if (expected === TYPE_ARRAY_STRING) {
+                  subtype = TYPE_STRING;
+                }
+                for (var i = 0; i < argValue.length; i++) {
+                  if (!this._typeMatches(
+                    this._getTypeName(argValue[i]),
+                    subtype,
+                    argValue[i]
+                  )) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+            } else {
+              return actual === expected;
+            }
+          },
+          _getTypeName: function(obj) {
+            switch (Object.prototype.toString.call(obj)) {
+              case "[object String]":
+                return TYPE_STRING;
+              case "[object Number]":
+                return TYPE_NUMBER;
+              case "[object Array]":
+                return TYPE_ARRAY;
+              case "[object Boolean]":
+                return TYPE_BOOLEAN;
+              case "[object Null]":
+                return TYPE_NULL;
+              case "[object Object]":
+                if (obj.jmespathType === TOK_EXPREF) {
+                  return TYPE_EXPREF;
+                } else {
+                  return TYPE_OBJECT;
+                }
+            }
+          },
+          _functionStartsWith: function(resolvedArgs) {
+            return resolvedArgs[0].lastIndexOf(resolvedArgs[1]) === 0;
+          },
+          _functionEndsWith: function(resolvedArgs) {
+            var searchStr = resolvedArgs[0];
+            var suffix = resolvedArgs[1];
+            return searchStr.indexOf(suffix, searchStr.length - suffix.length) !== -1;
+          },
+          _functionReverse: function(resolvedArgs) {
+            var typeName = this._getTypeName(resolvedArgs[0]);
+            if (typeName === TYPE_STRING) {
+              var originalStr = resolvedArgs[0];
+              var reversedStr = "";
+              for (var i = originalStr.length - 1; i >= 0; i--) {
+                reversedStr += originalStr[i];
+              }
+              return reversedStr;
+            } else {
+              var reversedArray = resolvedArgs[0].slice(0);
+              reversedArray.reverse();
+              return reversedArray;
+            }
+          },
+          _functionAbs: function(resolvedArgs) {
+            return Math.abs(resolvedArgs[0]);
+          },
+          _functionCeil: function(resolvedArgs) {
+            return Math.ceil(resolvedArgs[0]);
+          },
+          _functionAvg: function(resolvedArgs) {
+            var sum = 0;
+            var inputArray = resolvedArgs[0];
+            for (var i = 0; i < inputArray.length; i++) {
+              sum += inputArray[i];
+            }
+            return sum / inputArray.length;
+          },
+          _functionContains: function(resolvedArgs) {
+            return resolvedArgs[0].indexOf(resolvedArgs[1]) >= 0;
+          },
+          _functionFloor: function(resolvedArgs) {
+            return Math.floor(resolvedArgs[0]);
+          },
+          _functionLength: function(resolvedArgs) {
+            if (!isObject(resolvedArgs[0])) {
+              return resolvedArgs[0].length;
+            } else {
+              return Object.keys(resolvedArgs[0]).length;
+            }
+          },
+          _functionMap: function(resolvedArgs) {
+            var mapped = [];
+            var interpreter = this._interpreter;
+            var exprefNode = resolvedArgs[0];
+            var elements = resolvedArgs[1];
+            for (var i = 0; i < elements.length; i++) {
+              mapped.push(interpreter.visit(exprefNode, elements[i]));
+            }
+            return mapped;
+          },
+          _functionMerge: function(resolvedArgs) {
+            var merged = {};
+            for (var i = 0; i < resolvedArgs.length; i++) {
+              var current = resolvedArgs[i];
+              for (var key in current) {
+                merged[key] = current[key];
+              }
+            }
+            return merged;
+          },
+          _functionMax: function(resolvedArgs) {
+            if (resolvedArgs[0].length > 0) {
+              var typeName = this._getTypeName(resolvedArgs[0][0]);
+              if (typeName === TYPE_NUMBER) {
+                return Math.max.apply(Math, resolvedArgs[0]);
+              } else {
+                var elements = resolvedArgs[0];
+                var maxElement = elements[0];
+                for (var i = 1; i < elements.length; i++) {
+                  if (maxElement.localeCompare(elements[i]) < 0) {
+                    maxElement = elements[i];
+                  }
+                }
+                return maxElement;
+              }
+            } else {
+              return null;
+            }
+          },
+          _functionMin: function(resolvedArgs) {
+            if (resolvedArgs[0].length > 0) {
+              var typeName = this._getTypeName(resolvedArgs[0][0]);
+              if (typeName === TYPE_NUMBER) {
+                return Math.min.apply(Math, resolvedArgs[0]);
+              } else {
+                var elements = resolvedArgs[0];
+                var minElement = elements[0];
+                for (var i = 1; i < elements.length; i++) {
+                  if (elements[i].localeCompare(minElement) < 0) {
+                    minElement = elements[i];
+                  }
+                }
+                return minElement;
+              }
+            } else {
+              return null;
+            }
+          },
+          _functionSum: function(resolvedArgs) {
+            var sum = 0;
+            var listToSum = resolvedArgs[0];
+            for (var i = 0; i < listToSum.length; i++) {
+              sum += listToSum[i];
+            }
+            return sum;
+          },
+          _functionType: function(resolvedArgs) {
+            switch (this._getTypeName(resolvedArgs[0])) {
+              case TYPE_NUMBER:
+                return "number";
+              case TYPE_STRING:
+                return "string";
+              case TYPE_ARRAY:
+                return "array";
+              case TYPE_OBJECT:
+                return "object";
+              case TYPE_BOOLEAN:
+                return "boolean";
+              case TYPE_EXPREF:
+                return "expref";
+              case TYPE_NULL:
+                return "null";
+            }
+          },
+          _functionKeys: function(resolvedArgs) {
+            return Object.keys(resolvedArgs[0]);
+          },
+          _functionValues: function(resolvedArgs) {
+            var obj = resolvedArgs[0];
+            var keys = Object.keys(obj);
+            var values = [];
+            for (var i = 0; i < keys.length; i++) {
+              values.push(obj[keys[i]]);
+            }
+            return values;
+          },
+          _functionJoin: function(resolvedArgs) {
+            var joinChar = resolvedArgs[0];
+            var listJoin = resolvedArgs[1];
+            return listJoin.join(joinChar);
+          },
+          _functionToArray: function(resolvedArgs) {
+            if (this._getTypeName(resolvedArgs[0]) === TYPE_ARRAY) {
+              return resolvedArgs[0];
+            } else {
+              return [resolvedArgs[0]];
+            }
+          },
+          _functionToString: function(resolvedArgs) {
+            if (this._getTypeName(resolvedArgs[0]) === TYPE_STRING) {
+              return resolvedArgs[0];
+            } else {
+              return JSON.stringify(resolvedArgs[0]);
+            }
+          },
+          _functionToNumber: function(resolvedArgs) {
+            var typeName = this._getTypeName(resolvedArgs[0]);
+            var convertedValue;
+            if (typeName === TYPE_NUMBER) {
+              return resolvedArgs[0];
+            } else if (typeName === TYPE_STRING) {
+              convertedValue = +resolvedArgs[0];
+              if (!isNaN(convertedValue)) {
+                return convertedValue;
+              }
+            }
+            return null;
+          },
+          _functionNotNull: function(resolvedArgs) {
+            for (var i = 0; i < resolvedArgs.length; i++) {
+              if (this._getTypeName(resolvedArgs[i]) !== TYPE_NULL) {
+                return resolvedArgs[i];
+              }
+            }
+            return null;
+          },
+          _functionSort: function(resolvedArgs) {
+            var sortedArray = resolvedArgs[0].slice(0);
+            sortedArray.sort();
+            return sortedArray;
+          },
+          _functionSortBy: function(resolvedArgs) {
+            var sortedArray = resolvedArgs[0].slice(0);
+            if (sortedArray.length === 0) {
+              return sortedArray;
+            }
+            var interpreter = this._interpreter;
+            var exprefNode = resolvedArgs[1];
+            var requiredType = this._getTypeName(
+              interpreter.visit(exprefNode, sortedArray[0])
+            );
+            if ([TYPE_NUMBER, TYPE_STRING].indexOf(requiredType) < 0) {
+              throw new Error("TypeError");
+            }
+            var that = this;
+            var decorated = [];
+            for (var i = 0; i < sortedArray.length; i++) {
+              decorated.push([i, sortedArray[i]]);
+            }
+            decorated.sort(function(a, b) {
+              var exprA = interpreter.visit(exprefNode, a[1]);
+              var exprB = interpreter.visit(exprefNode, b[1]);
+              if (that._getTypeName(exprA) !== requiredType) {
+                throw new Error(
+                  "TypeError: expected " + requiredType + ", received " + that._getTypeName(exprA)
+                );
+              } else if (that._getTypeName(exprB) !== requiredType) {
+                throw new Error(
+                  "TypeError: expected " + requiredType + ", received " + that._getTypeName(exprB)
+                );
+              }
+              if (exprA > exprB) {
+                return 1;
+              } else if (exprA < exprB) {
+                return -1;
+              } else {
+                return a[0] - b[0];
+              }
+            });
+            for (var j = 0; j < decorated.length; j++) {
+              sortedArray[j] = decorated[j][1];
+            }
+            return sortedArray;
+          },
+          _functionMaxBy: function(resolvedArgs) {
+            var exprefNode = resolvedArgs[1];
+            var resolvedArray = resolvedArgs[0];
+            var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]);
+            var maxNumber = -Infinity;
+            var maxRecord;
+            var current;
+            for (var i = 0; i < resolvedArray.length; i++) {
+              current = keyFunction(resolvedArray[i]);
+              if (current > maxNumber) {
+                maxNumber = current;
+                maxRecord = resolvedArray[i];
+              }
+            }
+            return maxRecord;
+          },
+          _functionMinBy: function(resolvedArgs) {
+            var exprefNode = resolvedArgs[1];
+            var resolvedArray = resolvedArgs[0];
+            var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]);
+            var minNumber = Infinity;
+            var minRecord;
+            var current;
+            for (var i = 0; i < resolvedArray.length; i++) {
+              current = keyFunction(resolvedArray[i]);
+              if (current < minNumber) {
+                minNumber = current;
+                minRecord = resolvedArray[i];
+              }
+            }
+            return minRecord;
+          },
+          createKeyFunction: function(exprefNode, allowedTypes) {
+            var that = this;
+            var interpreter = this._interpreter;
+            var keyFunc = function(x) {
+              var current = interpreter.visit(exprefNode, x);
+              if (allowedTypes.indexOf(that._getTypeName(current)) < 0) {
+                var msg = "TypeError: expected one of " + allowedTypes + ", received " + that._getTypeName(current);
+                throw new Error(msg);
+              }
+              return current;
+            };
+            return keyFunc;
+          }
+        };
+        function compile(stream) {
+          var parser = new Parser();
+          var ast = parser.parse(stream);
+          return ast;
+        }
+        function tokenize(stream) {
+          var lexer = new Lexer();
+          return lexer.tokenize(stream);
+        }
+        function search2(data, expression) {
+          var parser = new Parser();
+          var runtime = new Runtime();
+          var interpreter = new TreeInterpreter(runtime);
+          runtime._interpreter = interpreter;
+          var node = parser.parse(expression);
+          return interpreter.search(node, data);
+        }
+        exports2.tokenize = tokenize;
+        exports2.compile = compile;
+        exports2.search = search2;
+        exports2.strictDeepEqual = strictDeepEqual;
+      })(typeof exports === "undefined" ? exports.jmespath = {} : exports);
+    }
+  });
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    createAsyncClient: () => createAsyncClient,
+    createSyncClient: () => createSyncClient
+  });
+
+  // src/lib.ts
+  var jmespath = __toESM(require_jmespath(), 1);
+  var envTagCache = /* @__PURE__ */ new Map();
+  function getBaseUrl(token, devEnv) {
+    let [env, siteId, ...rest] = token.split("-");
+    if (devEnv === "production") return `https://pub.sleekcms.com/${siteId}`;
+    else if (devEnv === "development") return `https://pub.sleekcms.net/${siteId}`;
+    else if (devEnv === "localhost") return `http://localhost:9001/localhost/${siteId}`;
+    else throw new Error(`[SleekCMS] Unknown devEnv: ${devEnv}`);
+  }
+  function applyJmes(data, query) {
+    if (!query) return data;
+    return jmespath.search(data, query);
+  }
+  function getUrl({ siteToken, env, search: search2, lang, devEnv = "production" }) {
+    const baseUrl = getBaseUrl(siteToken, devEnv).replace(/\/$/, "");
+    const url = new URL(`${baseUrl}/${env ?? "latest"}`);
+    if (search2) url.searchParams.append("search", search2);
+    if (lang) url.searchParams.append("lang", lang);
+    return url.toString();
+  }
+  async function fetchEnvTag({ siteToken, env }) {
+    const url = getUrl({ siteToken, env });
+    try {
+      let res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: siteToken
+        }
+      });
+      if (res.ok) {
+        let data = await res.json();
+        if (data.tag) {
+          return data.tag;
+        }
+      }
+    } catch (e) {
+      console.error("[SleekCMS] Unable to resolve env tag.");
+    }
+    return env;
+  }
+  async function fetchSiteContent(options) {
+    const { siteToken, env = "latest", resolveEnv = false, search: search2, lang, cache, cacheMinutes } = options;
+    let url = getUrl({ siteToken, env, search: search2, lang });
+    if (resolveEnv) {
+      const cacheKey2 = `${siteToken}:${env}`;
+      let tag = envTagCache.get(cacheKey2);
+      try {
+        if (!tag) {
+          tag = await fetchEnvTag({ siteToken, env });
+          envTagCache.set(cacheKey2, tag);
+        }
+        url = getUrl({ siteToken, env: tag, search: search2, lang });
+      } catch (error) {
+        console.warn("[SleekCMS] Failed to resolve env tag, using cached content instead.");
+      }
+    }
+    const cacheKey = url;
+    const fetchAndCache = async () => {
+      const res = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: siteToken
+        }
+      });
+      if (!res.ok) {
+        let message = res.statusText;
+        try {
+          const data2 = await res.json();
+          if (data2 && data2.message) message = data2.message;
+        } catch {
+        }
+        throw new Error(`[SleekCMS] Request failed (${res.status}): ${message}`);
+      }
+      const data = await res.json();
+      if (cache) {
+        try {
+          const cacheData = { data, _ts: Date.now() };
+          await Promise.resolve(cache.setItem(cacheKey, JSON.stringify(cacheData)));
+        } catch (e) {
+          console.warn("[SleekCMS] Cache write failed:", e);
+        }
+      }
+      return data;
+    };
+    if (cache) {
+      try {
+        const cached = await Promise.resolve(cache.getItem(cacheKey));
+        if (cached) {
+          try {
+            const cachedData = JSON.parse(cached);
+            if (cachedData._ts !== void 0) {
+              if (cacheMinutes) {
+                const now = Date.now();
+                const expiryMs = cacheMinutes * 60 * 1e3;
+                const age = now - cachedData._ts;
+                if (age >= expiryMs) {
+                  try {
+                    return await fetchAndCache();
+                  } catch (error) {
+                    console.warn("[SleekCMS] Fetch failed, using expired cache:", error);
+                  }
+                }
+              }
+              return cachedData.data;
+            } else {
+              return cachedData;
+            }
+          } catch (e) {
+          }
+        }
+      } catch (e) {
+        console.warn("[SleekCMS] Cache read failed:", e);
+      }
+    }
+    return await fetchAndCache();
+  }
+  function extractSlugs(pages, path) {
+    const slugs = [];
+    const pagesList = pages ?? [];
+    for (const page of pagesList) {
+      const pth = typeof page._path === "string" ? page._path : "";
+      if (pth.startsWith(path) && "_slug" in page && typeof page._slug === "string") {
+        slugs.push(page._slug);
+      }
+    }
+    return slugs;
+  }
+  function filterPagesByPath(pages, path, options) {
+    const pagesList = pages ?? [];
+    return pagesList.filter((p) => {
+      const pth = typeof p._path === "string" ? p._path : "";
+      if (path && !pth.startsWith(path)) return false;
+      if (options?.collection && !("_slug" in p)) return false;
+      return true;
+    });
+  }
+
+  // src/index.ts
+  var MemoryCache = class {
+    cache = /* @__PURE__ */ new Map();
+    getItem(key) {
+      return this.cache.get(key) ?? null;
+    }
+    setItem(key, value) {
+      this.cache.set(key, value);
+    }
+  };
+  async function createSyncClient(options) {
+    const cache = options.cache ?? new MemoryCache();
+    const data = await fetchSiteContent({ ...options, cache });
+    function getContent(query) {
+      return applyJmes(data, query);
+    }
+    function getPages(path, options2) {
+      if (!path) {
+        throw new Error("[SleekCMS] path is required for getPages");
+      }
+      return filterPagesByPath(data.pages, path, options2);
+    }
+    function getPage(path) {
+      if (!path) {
+        throw new Error("[SleekCMS] path is required for getPage");
+      }
+      const pages = data.pages ?? [];
+      const page = pages.find((p) => {
+        const pth = typeof p._path === "string" ? p._path : "";
+        return pth === path;
+      });
+      return page ?? null;
+    }
+    function getEntry(handle) {
+      if (!handle) {
+        throw new Error("[SleekCMS] handle is required for getEntry");
+      }
+      const entries = data.entries ?? {};
+      const entry = entries[handle] ?? null;
+      return entry;
+    }
+    function getSlugs(path) {
+      if (!path) {
+        throw new Error("[SleekCMS] path is required for getSlugs");
+      }
+      return extractSlugs(data.pages, path);
+    }
+    function getImage(name) {
+      if (!name) return null;
+      return data.images ? data.images[name] : null;
+    }
+    function getOptions(name) {
+      if (!name) return null;
+      const options2 = data.options ?? {};
+      const optionSet = options2[name];
+      return Array.isArray(optionSet) ? optionSet : null;
+    }
+    return {
+      getContent,
+      getPages,
+      getPage,
+      getEntry,
+      getSlugs,
+      getImage,
+      getOptions
+    };
+  }
+  function createAsyncClient(options) {
+    const { siteToken, env = "latest", resolveEnv, lang } = options;
+    const cache = options.cache ?? new MemoryCache();
+    let syncClient = null;
+    async function getContent(search2) {
+      if (!search2 && !syncClient) {
+        syncClient = await createSyncClient({ siteToken, env, resolveEnv, lang, cache });
+      }
+      if (syncClient) return syncClient.getContent(search2);
+      if (!search2) return null;
+      return await fetchSiteContent({ siteToken, env, search: search2, lang, cache, resolveEnv });
+    }
+    async function getPages(path, options2) {
+      if (syncClient) return syncClient.getPages(path, options2);
+      const pages = await fetchSiteContent({ siteToken, env, search: "pages", lang, cache, resolveEnv });
+      return filterPagesByPath(pages, path, options2);
+    }
+    async function getPage(path) {
+      if (syncClient) return syncClient.getPage(path);
+      const pages = await fetchSiteContent({ siteToken, env, search: "pages", lang, cache, resolveEnv });
+      const page = pages?.find((p) => {
+        const pth = typeof p._path === "string" ? p._path : "";
+        return pth === path;
+      });
+      return page ?? null;
+    }
+    async function getEntry(handle) {
+      if (syncClient) return syncClient.getEntry(handle);
+      let search2 = `entries.${handle}`;
+      return await fetchSiteContent({ siteToken, env, search: search2, lang, cache, resolveEnv });
+    }
+    async function getSlugs(path) {
+      if (syncClient) return syncClient.getSlugs(path);
+      const pages = await fetchSiteContent({ siteToken, env, search: "pages", lang, cache, resolveEnv });
+      return extractSlugs(pages, path);
+    }
+    async function getImage(name) {
+      if (syncClient) return syncClient.getImage(name);
+      const images = await fetchSiteContent({ siteToken, env, search: "images", lang, cache, resolveEnv });
+      return images ? images[name] : null;
+    }
+    async function getOptions(name) {
+      if (syncClient) return syncClient.getOptions(name);
+      const options2 = await fetchSiteContent({ siteToken, env, search: "options", lang, cache, resolveEnv });
+      const optionSet = options2[name];
+      return Array.isArray(optionSet) ? optionSet : null;
+    }
+    async function _getEnvTag() {
+      let resp = await fetchEnvTag({ siteToken, env });
+      return resp;
+    }
+    function _getFetchUrl() {
+      return getUrl(options);
+    }
+    return {
+      getContent,
+      getPages,
+      getPage,
+      getEntry,
+      getSlugs,
+      getImage,
+      getOptions,
+      _getFetchUrl,
+      _getEnvTag
+    };
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map