@valbuild/core 0.12.0

package/dist/index-b49a2c60.cjs.dev.js

@@ -0,0 +1,1031 @@
+'use strict';
+
+var createClass = require('./createClass-a436dbfe.cjs.dev.js');
+var result = require('./result-48320acd.cjs.dev.js');
+
+function _defineProperty(obj, key, value) {
+  key = createClass._toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived),
+      result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
+  };
+}
+
+var Schema = /*#__PURE__*/function () {
+  function Schema() {
+    createClass._classCallCheck(this, Schema);
+  }
+  createClass._createClass(Schema, [{
+    key: "remote",
+    value: function remote() {
+      // TODO: Schema<never, "Cannot create remote schema from non-remote source.">
+      throw new Error("You need Val Ultra to use .remote()");
+    }
+  }]);
+  return Schema;
+}();
+
+// TODO: SourceError<"Could not determine type of Schema">
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+/**
+ * Selectors can be used to select parts of a Val module.
+ * Unlike queries, joins, aggregates etc is and will not be supported.
+ *
+ * They are designed to be be used as if they were "normal" JSON data,
+ * though some concessions had to be made because of TypeScript limitations.
+ *
+ * Selectors works equally on source content, defined in code, and remote content.
+ *
+ * @example
+ * // Select the title of a document
+ * const titles = useVal(docsVal.map((doc) => doc.title));
+ *
+ * @example
+ * // Match on a union type
+ * const titles = useVal(docsVal.map((doc) => doc.fold("type")({
+ *   newsletter: (newsletter) => newsletter.title,
+ *   email: (email) => email.subject,
+ * }));
+ *
+ */
+
+/**
+ * @internal
+ */
+var GetSchema = Symbol("GetSchema");
+/**
+/**
+ * @internal
+ */
+var Path = Symbol("Path");
+/**
+ * @internal
+ */
+var SourceOrExpr = Symbol("SourceOrExpr");
+/**
+ * @internal
+ */
+var ValError = Symbol("ValError");
+var GenericSelector = /*#__PURE__*/function () {
+  function GenericSelector(valOrExpr, path, schema, error) {
+    createClass._classCallCheck(this, GenericSelector);
+    this[Path] = path;
+    this[SourceOrExpr] = valOrExpr;
+    this[ValError] = error;
+    this[GetSchema] = schema;
+  }
+  createClass._createClass(GenericSelector, [{
+    key: "assert",
+    value: function assert(schema, other) {
+      throw new Error("Not implemented");
+    }
+  }]);
+  return GenericSelector;
+}();
+
+/**
+ * Use this type to convert types that accepts both Source and Selectors
+ *
+ * An example would be where literals are supported like in most higher order functions (e.g. map in array)
+ **/
+
+function getSchema(selector) {
+  return selector[GetSchema];
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+var Expr = /*#__PURE__*/createClass._createClass(function Expr(span) {
+  createClass._classCallCheck(this, Expr);
+  this.span = span;
+});
+var StringLiteral = /*#__PURE__*/function (_Expr) {
+  _inherits(StringLiteral, _Expr);
+  var _super = _createSuper(StringLiteral);
+  function StringLiteral(value, span) {
+    var _this;
+    createClass._classCallCheck(this, StringLiteral);
+    _this = _super.call(this, span);
+    _defineProperty(_assertThisInitialized(_this), "type", "StringLiteral");
+    _this.value = value;
+    return _this;
+  }
+  createClass._createClass(StringLiteral, [{
+    key: "transpile",
+    value: function transpile() {
+      return "'".concat(this.value, "'");
+    }
+  }]);
+  return StringLiteral;
+}(Expr);
+var Sym = /*#__PURE__*/function (_Expr2) {
+  _inherits(Sym, _Expr2);
+  var _super2 = _createSuper(Sym);
+  function Sym(value, span) {
+    var _this2;
+    createClass._classCallCheck(this, Sym);
+    _this2 = _super2.call(this, span);
+    _defineProperty(_assertThisInitialized(_this2), "type", "Sym");
+    _this2.value = value;
+    return _this2;
+  }
+  createClass._createClass(Sym, [{
+    key: "transpile",
+    value: function transpile() {
+      return this.value;
+    }
+  }]);
+  return Sym;
+}(Expr);
+var NilSym = new Sym("()");
+var StringTemplate = /*#__PURE__*/function (_Expr3) {
+  _inherits(StringTemplate, _Expr3);
+  var _super3 = _createSuper(StringTemplate);
+  function StringTemplate(children, span) {
+    var _this3;
+    createClass._classCallCheck(this, StringTemplate);
+    _this3 = _super3.call(this, span);
+    _defineProperty(_assertThisInitialized(_this3), "type", "StringTemplate");
+    _this3.children = children;
+    return _this3;
+  }
+  createClass._createClass(StringTemplate, [{
+    key: "transpile",
+    value: function transpile() {
+      return "'".concat(this.children.map(function (child) {
+        if (child instanceof StringLiteral) {
+          return child.value;
+        } else {
+          return "${".concat(child.transpile(), "}");
+        }
+      }).join(""), "'");
+    }
+  }]);
+  return StringTemplate;
+}(Expr);
+var Call = /*#__PURE__*/function (_Expr4) {
+  _inherits(Call, _Expr4);
+  var _super4 = _createSuper(Call);
+  function Call(children, isAnon, span) {
+    var _this4;
+    createClass._classCallCheck(this, Call);
+    _this4 = _super4.call(this, span);
+    _defineProperty(_assertThisInitialized(_this4), "type", "Call");
+    _this4.children = children;
+    _this4.isAnon = isAnon;
+    return _this4;
+  }
+  createClass._createClass(Call, [{
+    key: "transpile",
+    value: function transpile() {
+      if (this.isAnon) {
+        return "!(".concat(this.children.map(function (child) {
+          return child.transpile();
+        }).join(" "), ")");
+      }
+      return "(".concat(this.children.map(function (child) {
+        return child.transpile();
+      }).join(" "), ")");
+    }
+  }]);
+  return Call;
+}(Expr);
+
+/* Branded extension types: file, remote, i18n  */
+var VAL_EXTENSION = "_type";
+
+/**
+ * A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time.
+ *
+ * An example where this is useful is remote types, where the type of the remote source is known at compile time,
+ * but the value is not there before it is fetched.
+ *
+ * @example
+ * type Example<T> = string & PhantomType<T>;
+ *
+ **/
+
+var FILE_REF_PROP = "_ref";
+
+/**
+ * A file source represents the path to a (local) file.
+ *
+ * It will be resolved into a Asset object.
+ *
+ */
+
+function file(ref, metadata) {
+  var _ref;
+  return _ref = {}, _defineProperty(_ref, FILE_REF_PROP, ref), _defineProperty(_ref, VAL_EXTENSION, "file"), _defineProperty(_ref, "metadata", metadata), _ref;
+}
+function isFile(obj) {
+  return createClass._typeof(obj) === "object" && obj !== null && VAL_EXTENSION in obj && obj[VAL_EXTENSION] === "file" && FILE_REF_PROP in obj && typeof obj[FILE_REF_PROP] === "string";
+}
+
+var ImageSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(ImageSchema, _Schema);
+  var _super = _createSuper(ImageSchema);
+  function ImageSchema(options) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    createClass._classCallCheck(this, ImageSchema);
+    _this = _super.call(this);
+    _this.options = options;
+    _this.opt = opt;
+    return _this;
+  }
+  createClass._createClass(ImageSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      // TODO:
+      return true;
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new ImageSchema(this.options, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "image",
+        options: this.options,
+        opt: this.opt
+      };
+    }
+  }]);
+  return ImageSchema;
+}(Schema);
+var image = function image(options) {
+  return new ImageSchema(options);
+};
+var convertImageSource = function convertImageSource(src) {
+  var _src$metadata;
+  // TODO: /public should be configurable
+  return {
+    url: src[FILE_REF_PROP].slice("/public".length) + "?sha256=".concat((_src$metadata = src.metadata) === null || _src$metadata === void 0 ? void 0 : _src$metadata.sha256),
+    metadata: src.metadata
+  };
+};
+
+function isSerializedVal(val) {
+  return createClass._typeof(val) === "object" && val !== null && val !== undefined && ("val" in val || "valPath" in val);
+}
+
+/**
+ * The path of the source value.
+ *
+ * @example
+ * '/app/blogs.0.text' // the text property of the first element of the /app/blogs module
+ */
+
+/**
+ * The path inside the module.
+ *
+ * @example
+ * '0."text"' // the text property of the first element of the module
+ */
+
+/**
+ * The id of the module.
+ *
+ * @example
+ * '/app/blogs' // the /app/blogs module
+ */
+
+function getValPath(valOrSelector) {
+  return valOrSelector[Path];
+}
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function _andThen(f, source, path) {
+  if (source) {
+    return newSelectorProxy(f(newSelectorProxy(source, path)));
+  }
+  return newSelectorProxy(source, path);
+}
+function isSelector(source) {
+  return createClass._typeof(source) === "object" && source !== null && (SourceOrExpr in source || Path in source);
+}
+function newSelectorProxy(source, path, moduleSchema) {
+  var _ref;
+  if (createClass._typeof(source) === "object") {
+    if (isSelector(source)) {
+      return source;
+    } else if (isSerializedVal(source)) {
+      return newSelectorProxy(source.val, source.valPath);
+    }
+  }
+  if (source && source[FILE_REF_PROP] && source[VAL_EXTENSION] === "file") {
+    var fileRef = source[FILE_REF_PROP];
+    if (typeof fileRef !== "string") {
+      throw Error("Invalid file ref: " + fileRef);
+    }
+    return newSelectorProxy(convertImageSource(source), path, moduleSchema);
+  }
+  switch (createClass._typeof(source)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid selector type: ".concat(createClass._typeof(source), ": ").concat(source));
+    case "object":
+      // Handles both objects and arrays!
+      if (source !== null) {
+        return new Proxy(source, {
+          // TODO: see proxy docs if we want more traps
+          has: function has(target, prop) {
+            if (prop === SourceOrExpr) {
+              return true;
+            }
+            if (prop === Path) {
+              return true;
+            }
+            if (prop === "andThen") {
+              return true;
+            }
+            if (prop === GetSchema) {
+              return true;
+            }
+            return prop in target;
+          },
+          get: function get(target, prop) {
+            if (prop === SourceOrExpr) {
+              return source;
+            }
+            if (prop === Path) {
+              return path;
+            }
+            if (prop === GetSchema) {
+              return moduleSchema;
+            }
+            if (prop === "andThen") {
+              return function (f) {
+                return _andThen(f, source, path);
+              };
+            }
+            if (Array.isArray(target)) {
+              if (prop === "filter") {
+                return function (f) {
+                  var filtered = target.map(function (a, i) {
+                    return newSelectorProxy(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
+                  }).filter(function (a) {
+                    if (f && f instanceof Schema) {
+                      return f.match(unValify(a));
+                    } else {
+                      return unValify(f(a));
+                    }
+                  });
+                  return newSelectorProxy(filtered, path, moduleSchema);
+                };
+              } else if (prop === "map") {
+                return function (f) {
+                  var filtered = target.map(function (a, i) {
+                    var valueOrSelector = f(newSelectorProxy(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item), newSelectorProxy(i));
+                    if (isSelector(valueOrSelector)) {
+                      return valueOrSelector;
+                    }
+                    return newSelectorProxy(valueOrSelector);
+                  });
+                  return newSelectorProxy(filtered, path, moduleSchema);
+                };
+              }
+            }
+            if (Array.isArray(target) && prop === "length") {
+              return newSelectorProxy(target.length);
+            }
+            var reflectedValue = Reflect.get(target, prop);
+            if (hasOwn(source, prop)) {
+              if (!Number.isNaN(Number(prop))) {
+                return newSelectorProxy(reflectedValue, createValPathOfItem(path, Number(prop)), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
+              }
+              return newSelectorProxy(reflectedValue, createValPathOfItem(path, prop), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.items[prop]);
+            }
+            return reflectedValue;
+          }
+        });
+      }
+    // intentional fallthrough
+    // eslint-disable-next-line no-fallthrough
+    default:
+      return _ref = {
+        eq: function eq(other) {
+          var otherValue = other;
+          if (isSelector(other)) {
+            otherValue = other[SourceOrExpr];
+            if (otherValue instanceof Expr) {
+              throw Error("TODO: Cannot evaluate equality with an Expr");
+            }
+          }
+          return newSelectorProxy(source === otherValue, undefined);
+        },
+        andThen: function andThen(f) {
+          return _andThen(f, source === undefined ? null : source, path);
+        }
+      }, _defineProperty(_ref, SourceOrExpr, source === undefined ? null : source), _defineProperty(_ref, Path, path), _ref;
+  }
+}
+function createValPathOfItem(arrayPath, prop) {
+  if (createClass._typeof(prop) === "symbol") {
+    throw Error("Cannot create val path of array item with symbol prop: ".concat(prop.toString()));
+  }
+  return arrayPath && "".concat(arrayPath, ".").concat(JSON.stringify(prop));
+}
+
+// TODO: could we do .val on the objects instead?
+function unValify(valueOrSelector) {
+  if (createClass._typeof(valueOrSelector) === "object" && (SourceOrExpr in valueOrSelector || Path in valueOrSelector)) {
+    var selectorValue = valueOrSelector[SourceOrExpr];
+    return selectorValue;
+  }
+  return valueOrSelector;
+}
+
+var WHITE_SPACE = ["\n", "\r", "\t", " "];
+function tokenize(input) {
+  var tokens = [];
+  var cursor = 0;
+  while (cursor < input.length) {
+    var _char = input[cursor];
+    var peek = input[cursor + 1];
+    // TODO: remove this not used any more
+    if (_char === "!" && peek === "(") {
+      tokens.push({
+        type: "!(",
+        span: [cursor, cursor + 1]
+      });
+      cursor += 2;
+    } else if (_char === "(") {
+      tokens.push({
+        type: "(",
+        span: [cursor, cursor]
+      });
+      cursor++;
+    } else if (_char === ")") {
+      tokens.push({
+        type: ")",
+        span: [cursor, cursor]
+      });
+      cursor++;
+    } else if (_char === "'" || _char === "}") {
+      var _start = cursor;
+      var value = "";
+      var unescapedValue = "";
+      var escaped = false;
+      if (_char === "}") {
+        tokens.push({
+          type: "}",
+          span: [cursor, cursor]
+        });
+      } else if (_char === "'") {
+        tokens.push({
+          type: "'",
+          span: [cursor, cursor]
+        });
+      }
+      while (cursor < input.length) {
+        if (_char === "\\") {
+          escaped = !escaped;
+        } else {
+          escaped = false;
+        }
+        if (peek === "'" && !escaped) {
+          cursor += 2;
+          break;
+        } else if (_char === "$" && peek === "{") {
+          cursor += 2;
+          break;
+        }
+        cursor++;
+        _char = input[cursor];
+        peek = input[cursor + 1];
+        if (!(_char === "$" && peek === "{") && cursor < input.length) {
+          if (!(_char === "\\" && !escaped // counter-intuitive, but escape just became false if this was a backslash we want to escape
+          )) {
+            value += _char;
+          }
+          unescapedValue += _char;
+        }
+      }
+      var cursorOffset = peek === "'" && !escaped ? 2 : _char === "$" && peek === "{" ? 3 : 1;
+      if (value) {
+        tokens.push(_objectSpread2({
+          type: "string",
+          span: [_start + 1, cursor - cursorOffset],
+          value: value
+        }, unescapedValue !== value && {
+          unescapedValue: unescapedValue
+        }));
+      }
+      if (peek === "'" && !escaped) {
+        tokens.push({
+          type: "'",
+          span: [cursor - 1, cursor - 1]
+        });
+      } else if (_char === "$" && peek === "{") {
+        tokens.push({
+          type: "${",
+          span: [cursor - cursorOffset + 1, cursor - 1]
+        });
+      }
+    } else if (WHITE_SPACE.includes(_char)) {
+      var _start2 = cursor;
+      while (WHITE_SPACE.includes(input[cursor]) && cursor < input.length) {
+        cursor++;
+      }
+      tokens.push({
+        type: "ws",
+        span: [_start2, cursor - 1]
+      });
+    } else {
+      var _value = "";
+      var _start3 = cursor;
+      do {
+        _char = input[cursor];
+        peek = input[cursor + 1];
+        _value += _char;
+        cursor++;
+      } while (!WHITE_SPACE.includes(peek) && peek !== ")" && peek !== "'" && cursor < input.length);
+      tokens.push({
+        type: "token",
+        span: [_start3, cursor - 1],
+        value: _value
+      });
+    }
+  }
+  return [tokens, cursor];
+}
+
+var ParserError = /*#__PURE__*/createClass._createClass(function ParserError(message, span) {
+  createClass._classCallCheck(this, ParserError);
+  this.message = message;
+  this.span = span;
+});
+function parseTokens(inputTokens) {
+  var tokens = inputTokens.slice();
+  function slurpCall(first, isAnon) {
+    var _tokens$, _tokens$2, _tokens$3, _tokens$7, _tokens$8, _args$slice$0$span;
+    // peek
+    if (((_tokens$ = tokens[0]) === null || _tokens$ === void 0 ? void 0 : _tokens$.type) === "ws" && ((_tokens$2 = tokens[1]) === null || _tokens$2 === void 0 ? void 0 : _tokens$2.type) === ")" || ((_tokens$3 = tokens[0]) === null || _tokens$3 === void 0 ? void 0 : _tokens$3.type) === ")") {
+      slurpWs();
+      tokens.shift();
+      return result.ok(new Sym("()", [first.span[0], first.span[1] + 1]));
+    }
+    var args = [];
+    var completed = false;
+    while (!completed) {
+      var _res = slurp();
+      if (result.isOk(_res)) {
+        var _tokens$4, _tokens$5, _tokens$6;
+        args.push(_res.value);
+        completed = ((_tokens$4 = tokens[0]) === null || _tokens$4 === void 0 ? void 0 : _tokens$4.type) !== "ws" || ((_tokens$5 = tokens[0]) === null || _tokens$5 === void 0 ? void 0 : _tokens$5.type) === "ws" && ((_tokens$6 = tokens[1]) === null || _tokens$6 === void 0 ? void 0 : _tokens$6.type) === ")";
+      } else {
+        return _res;
+      }
+    }
+    if (((_tokens$7 = tokens[0]) === null || _tokens$7 === void 0 ? void 0 : _tokens$7.type) === "ws" && ((_tokens$8 = tokens[1]) === null || _tokens$8 === void 0 ? void 0 : _tokens$8.type) === ")") {
+      tokens.shift();
+    }
+    var last = tokens.shift();
+    if ((last === null || last === void 0 ? void 0 : last.type) !== ")") {
+      return result.err(new ParserError("unbalanced parens: missing a ')'", [first.span[0], first.span[1] + 1]));
+    }
+    return result.ok(new Call(args, isAnon, [first.span[0], ((_args$slice$0$span = args.slice(-1)[0].span) === null || _args$slice$0$span === void 0 ? void 0 : _args$slice$0$span[1]) || -1]));
+  }
+  function slurpWs() {
+    while (((_tokens$9 = tokens[0]) === null || _tokens$9 === void 0 ? void 0 : _tokens$9.type) === "ws") {
+      var _tokens$9;
+      tokens.shift();
+    }
+  }
+  function slurpTemplate(first) {
+    var children = [];
+    while (tokens.length > 0) {
+      var _tokens$10;
+      if (((_tokens$10 = tokens[0]) === null || _tokens$10 === void 0 ? void 0 : _tokens$10.type) === "'") {
+        break;
+      }
+      var nextToken = tokens.shift();
+      if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === "${") {
+        var _res2 = slurp();
+        if (result.isOk(_res2)) {
+          children.push(_res2.value);
+          var _last = tokens.shift();
+          if (!_last) {
+            var _children$slice$0$spa;
+            return result.err(new ParserError("unbalanced string template: missing a '}'", [first.span[0], (_children$slice$0$spa = children.slice(-1)[0].span) === null || _children$slice$0$spa === void 0 ? void 0 : _children$slice$0$spa[1]]));
+          } else if (_last.type !== "}") {
+            return result.err(new ParserError("unbalanced string template: expected '}'", _last.span));
+          }
+        } else {
+          return _res2;
+        }
+      } else if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === "string") {
+        children.push(new StringLiteral(nextToken.unescapedValue || nextToken.value || "", nextToken.span));
+      }
+    }
+    var last = tokens.shift();
+    if (!last) {
+      var _children$slice$0$spa2;
+      return result.err(new ParserError("unbalanced string template: missing a '''", [first.span[0], (_children$slice$0$spa2 = children.slice(-1)[0].span) === null || _children$slice$0$spa2 === void 0 ? void 0 : _children$slice$0$spa2[1]]));
+    } else if (last.type !== "'") {
+      return result.err(new ParserError("unbalanced string template: expected '''", last.span));
+    }
+    return result.ok(new StringTemplate(children, [first.span[0], last.span[1]]));
+  }
+  function slurpString(first) {
+    var _tokens$11, _tokens$12, _tokens$13;
+    if (((_tokens$11 = tokens[0]) === null || _tokens$11 === void 0 ? void 0 : _tokens$11.type) === "string" && ((_tokens$12 = tokens[1]) === null || _tokens$12 === void 0 ? void 0 : _tokens$12.type) === "'") {
+      var stringToken = tokens.shift();
+      var last = tokens.shift();
+      if (!last || !stringToken) {
+        throw Error("Unexpected error: stringToken or last is undefined");
+      }
+      return result.ok(new StringLiteral(stringToken.unescapedValue || stringToken.value || "", [first.span[0], last.span[1]]));
+    } else if (((_tokens$13 = tokens[0]) === null || _tokens$13 === void 0 ? void 0 : _tokens$13.type) === "'") {
+      var _last2 = tokens.shift();
+      if (!_last2) {
+        throw Error("Unexpected error: last is undefined");
+      }
+      return result.ok(new StringLiteral("", [first.span[0], _last2.span[1]]));
+    } else {
+      return slurpTemplate(first);
+    }
+  }
+  function slurp() {
+    slurpWs();
+    var first = tokens.shift();
+    if (!first) {
+      return result.err(new ParserError("expected '(', '!(', string or literal", [0, 0]));
+    }
+    if (first.type === "(" || first.type === "!(") {
+      return slurpCall(first, first.type === "!(");
+    } else if (first.type === "'") {
+      return slurpString(first);
+    } else if (first.type === "token") {
+      var _first$value, _first$value2, _first$value3, _first$value4, _first$value5, _first$value6;
+      if ((_first$value = first.value) !== null && _first$value !== void 0 && _first$value.includes("(") || (_first$value2 = first.value) !== null && _first$value2 !== void 0 && _first$value2.includes(")")) {
+        return result.err(new ParserError("unexpected token: '(' and ')' are not allowed in tokens", first.span));
+      }
+      if ((_first$value3 = first.value) !== null && _first$value3 !== void 0 && _first$value3.includes("'")) {
+        return result.err(new ParserError('unexpected token: "\'" is not allowed in tokens', first.span));
+      }
+      if ((_first$value4 = first.value) !== null && _first$value4 !== void 0 && _first$value4.includes(".")) {
+        return result.err(new ParserError('unexpected token: "." is not allowed in tokens', first.span));
+      }
+      if ((_first$value5 = first.value) !== null && _first$value5 !== void 0 && _first$value5.includes("{") || (_first$value6 = first.value) !== null && _first$value6 !== void 0 && _first$value6.includes("}")) {
+        return result.err(new ParserError("unexpected token: '{' and '}' are not allowed in tokens", first.span));
+      }
+      return result.ok(new Sym(first.value || "", first.span));
+    } else {
+      return result.err(new ParserError("expected '(', '!(' or literal or token".concat(first.value || first.type ? ", got: '".concat(first.value || first.type, "'") : ""), first.span));
+    }
+  }
+  var res = slurp();
+  slurpWs();
+  if (result.isErr(res)) {
+    return res;
+  }
+  if (tokens.length > 0) {
+    return result.err(new ParserError("expected end of input, superfluous tokens", [tokens[0].span[0], tokens.slice(-1)[0].span[1]]));
+  }
+  return res;
+}
+function parse(input) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  var _tokenize = tokenize(input),
+    _tokenize2 = createClass._slicedToArray(_tokenize, 2),
+    tokens = _tokenize2[0];
+    _tokenize2[1]; // TODO: we can use cursor to improve error messages / spans
+  return parseTokens(tokens);
+}
+
+var EvalError = /*#__PURE__*/function () {
+  function EvalError(message, expr) {
+    createClass._classCallCheck(this, EvalError);
+    this.message = message;
+    this.expr = expr;
+  }
+  createClass._createClass(EvalError, [{
+    key: "toString",
+    value: function toString() {
+      return "".concat(this.message, " in: ").concat(this.expr.transpile());
+    }
+  }]);
+  return EvalError;
+}();
+var MAX_STACK_SIZE = 100; // an arbitrary semi-large number
+function evaluateSync(expr, getSource, stack) {
+  // TODO: amount of evaluates should be limited?
+  if (stack.length > MAX_STACK_SIZE) {
+    throw new EvalError("Stack overflow. Final frames: ".concat(stack.slice(-10).map(function (frame, i) {
+      return frame.map(function (s, j) {
+        return "@[".concat(i, ",").concat(j, "]: ").concat(JSON.stringify(s));
+      }).join(", ");
+    }).join(" -> ")), expr);
+  }
+  if (expr instanceof Call) {
+    if (expr.children[0] instanceof Sym) {
+      if (expr.children[0].value === "val") {
+        if (expr.isAnon) {
+          throw new EvalError("cannot call 'val' as anonymous function", expr);
+        }
+        if (expr.children[1] instanceof StringLiteral) {
+          return getSource(expr.children[1].value);
+        } else {
+          throw new EvalError("argument of 'val' must be a string literal", expr);
+        }
+      } else if (expr.children[0].value === "json") {
+        if (expr.children.length !== 2) {
+          throw new EvalError("must call 'json' with exactly one argument", expr);
+        }
+        var value = evaluateSync(expr.children[1], getSource, stack);
+        var valObj = value[SourceOrExpr];
+        var valPath = value[Path];
+        if (typeof valObj !== "string") {
+          throw new EvalError("cannot parse JSON: ".concat(JSON.stringify(valObj), ", expected string"), expr.children[1]);
+        }
+        try {
+          var serialized = JSON.parse(valObj);
+          if (isSerializedVal(serialized)) {
+            return newSelectorProxy(serialized.val, serialized.valPath);
+          }
+          var parsedValue = newSelectorProxy(JSON.parse(valObj), valPath);
+          return parsedValue;
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            throw new EvalError("cannot parse JSON: ".concat(valObj, ", ").concat(e.message, " - value: ").concat(JSON.stringify(value)), expr.children[1]);
+          }
+          throw e;
+        }
+      } else if (expr.children[0].value === "stringify") {
+        // TODO: remove stringify
+        if (expr.children.length !== 2) {
+          throw new EvalError("must call 'stringify' with exactly one argument", expr);
+        }
+        var res = evaluateSync(expr.children[1], getSource, stack);
+        return newSelectorProxy(JSON.stringify(res[SourceOrExpr]));
+      }
+    }
+    var prop = evaluateSync(expr.children[0], getSource, stack)[SourceOrExpr];
+    if (expr.children.length === 1) {
+      // TODO: return if literal only?
+      return newSelectorProxy(prop);
+    }
+    var obj = evaluateSync(expr.children[1], getSource, stack);
+    if (typeof prop !== "string" && typeof prop !== "number") {
+      throw new EvalError("cannot access ".concat(JSON.stringify(obj), " with property ").concat(JSON.stringify(prop), ": is not a string or number"), expr);
+    }
+    if (prop in obj) {
+      if (expr.isAnon) {
+        // anon functions:
+        var maybeFunction = obj[prop];
+        if (typeof maybeFunction !== "function") {
+          throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required higher ordered function got ").concat(createClass._typeof(obj[prop])), expr);
+        }
+        if (expr.children[0] instanceof Sym) {
+          return maybeFunction(function () {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            return evaluateSync(expr.children[2], getSource, stack.concat([args]));
+          });
+        } else {
+          throw new EvalError("cannot call an expression that is not a symbol, got: '".concat(expr.children[0].type, "'"), expr);
+        }
+      } else {
+        // non-anon functions:
+        if (expr.children[0] instanceof Sym) {
+          if (expr.children[0].value === "val") {
+            if (expr.children[1] instanceof StringLiteral) {
+              return getSource(expr.children[1].value);
+            } else {
+              throw new EvalError("argument of 'val' must be a string literal", expr);
+            }
+          }
+        }
+        var args = expr.children.slice(2);
+        if (args.length > 0) {
+          var _maybeFunction = obj[prop];
+          if (typeof _maybeFunction !== "function") {
+            throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required function got ").concat(createClass._typeof(obj[prop])), expr);
+          }
+          return _maybeFunction.apply(void 0, createClass._toConsumableArray(args.map(function (arg) {
+            return evaluateSync(arg, getSource, stack);
+          })));
+        }
+        var maybeValue = obj[prop];
+        if (typeof maybeValue === "function") {
+          throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required value got ").concat(createClass._typeof(obj[prop])), expr);
+        }
+        return maybeValue;
+      }
+    }
+  } else if (expr instanceof Sym) {
+    if (expr.value.startsWith("@")) {
+      var _stack$Number;
+      var _expr$value$slice$spl = expr.value.slice(2, -1).split(","),
+        _expr$value$slice$spl2 = createClass._slicedToArray(_expr$value$slice$spl, 3),
+        i = _expr$value$slice$spl2[0],
+        j = _expr$value$slice$spl2[1],
+        rest = _expr$value$slice$spl2[2];
+      if (rest) {
+        throw new EvalError("cannot access stack: too many indices", expr);
+      }
+      var stackValue = (_stack$Number = stack[Number(i)]) === null || _stack$Number === void 0 ? void 0 : _stack$Number[Number(j)];
+      if (stackValue === undefined) {
+        throw new EvalError("cannot access stack: out of bounds", expr);
+      }
+      return stackValue;
+    } else if (expr.value === "()") {
+      return newSelectorProxy(null);
+    }
+    return newSelectorProxy(expr.value);
+  } else if (expr instanceof StringLiteral) {
+    return newSelectorProxy(expr.value);
+  } else if (expr instanceof StringTemplate) {
+    return newSelectorProxy(expr.children.map(function (child) {
+      if (child instanceof Sym && child.value === "()") {
+        return "null";
+      }
+      var evalRes = evaluateSync(child, getSource, stack);
+      if (child.type === "StringLiteral" || child.type === "StringTemplate") {
+        return evalRes[SourceOrExpr];
+      }
+      if (Path in evalRes) {
+        // a selector, so serialize to Val
+        return JSON.stringify({
+          val: evalRes[SourceOrExpr],
+          valPath: evalRes[Path]
+        });
+      }
+      return JSON.stringify(evalRes[SourceOrExpr]);
+    }).join(""));
+  }
+  throw new EvalError("could not evaluate", expr);
+}
+function evaluate(expr, source, stack) {
+  try {
+    return result.ok(evaluateSync(expr, source, stack));
+  } catch (err) {
+    if (err instanceof EvalError) {
+      return result.err(err);
+    }
+    throw err;
+  }
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  parse: parse,
+  Call: Call,
+  Expr: Expr,
+  NilSym: NilSym,
+  StringLiteral: StringLiteral,
+  StringTemplate: StringTemplate,
+  Sym: Sym,
+  evaluate: evaluate
+});
+
+exports.Call = Call;
+exports.Expr = Expr;
+exports.FILE_REF_PROP = FILE_REF_PROP;
+exports.GenericSelector = GenericSelector;
+exports.ImageSchema = ImageSchema;
+exports.NilSym = NilSym;
+exports.Path = Path;
+exports.Schema = Schema;
+exports.SourceOrExpr = SourceOrExpr;
+exports.StringLiteral = StringLiteral;
+exports.StringTemplate = StringTemplate;
+exports.Sym = Sym;
+exports.VAL_EXTENSION = VAL_EXTENSION;
+exports._createSuper = _createSuper;
+exports._defineProperty = _defineProperty;
+exports._inherits = _inherits;
+exports._objectSpread2 = _objectSpread2;
+exports.convertImageSource = convertImageSource;
+exports.createValPathOfItem = createValPathOfItem;
+exports.evaluate = evaluate;
+exports.file = file;
+exports.getSchema = getSchema;
+exports.getValPath = getValPath;
+exports.image = image;
+exports.index = index;
+exports.isFile = isFile;
+exports.isSelector = isSelector;
+exports.isSerializedVal = isSerializedVal;
+exports.newSelectorProxy = newSelectorProxy;
+exports.parse = parse;