@valbuild/core 0.14.0 → 0.16.0

package/dist/SelectorProxy-63c2d0e2.esm.js

@@ -0,0 +1,722 @@
+import { b as _arrayLikeToArray, c as _unsupportedIterableToArray } from './result-b96df128.esm.js';
+
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+function _defineProperty(obj, key, value) {
+  key = _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 _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+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() {
+    _classCallCheck(this, Schema);
+  }
+  _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()");
+    }
+
+    /** MUTATES! since internal and perf sensitive */
+  }, {
+    key: "appendValidationError",
+    value: function appendValidationError(current, path, message, value) {
+      if (current) {
+        if (current[path]) {
+          current[path].push({
+            message: message,
+            value: value
+          });
+        } else {
+          current[path] = [{
+            message: message,
+            value: value
+          }];
+        }
+        return current;
+      } else {
+        return _defineProperty({}, path, [{
+          message: message,
+          value: value
+        }]);
+      }
+    }
+  }]);
+  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) {
+    _classCallCheck(this, GenericSelector);
+    this[Path] = path;
+    this[SourceOrExpr] = valOrExpr;
+    this[ValError] = error;
+    this[GetSchema] = schema;
+  }
+  _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(function Expr(span) {
+  _classCallCheck(this, Expr);
+  this.span = span;
+});
+var StringLiteral = /*#__PURE__*/function (_Expr) {
+  _inherits(StringLiteral, _Expr);
+  var _super = _createSuper(StringLiteral);
+  function StringLiteral(value, span) {
+    var _this;
+    _classCallCheck(this, StringLiteral);
+    _this = _super.call(this, span);
+    _defineProperty(_assertThisInitialized(_this), "type", "StringLiteral");
+    _this.value = value;
+    return _this;
+  }
+  _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;
+    _classCallCheck(this, Sym);
+    _this2 = _super2.call(this, span);
+    _defineProperty(_assertThisInitialized(_this2), "type", "Sym");
+    _this2.value = value;
+    return _this2;
+  }
+  _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;
+    _classCallCheck(this, StringTemplate);
+    _this3 = _super3.call(this, span);
+    _defineProperty(_assertThisInitialized(_this3), "type", "StringTemplate");
+    _this3.children = children;
+    return _this3;
+  }
+  _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;
+    _classCallCheck(this, Call);
+    _this4 = _super4.call(this, span);
+    _defineProperty(_assertThisInitialized(_this4), "type", "Call");
+    _this4.children = children;
+    _this4.isAnon = isAnon;
+    return _this4;
+  }
+  _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 _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;
+    _classCallCheck(this, ImageSchema);
+    _this = _super.call(this);
+    _this.options = options;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(ImageSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (src === null || src === undefined) {
+        return _defineProperty({}, path, [{
+          message: "Non-optional image was null or undefined.",
+          value: src
+        }]);
+      }
+      if (typeof src[FILE_REF_PROP] !== "string") {
+        return _defineProperty({}, path, [{
+          message: "Image did not have a file reference string. Got: ".concat(_typeof(src[FILE_REF_PROP])),
+          value: src
+        }]);
+      }
+      if (src[VAL_EXTENSION] !== "file") {
+        return _defineProperty({}, path, [{
+          message: "Image did not have the valid file extension type. Got: ".concat(src[VAL_EXTENSION]),
+          value: src
+        }]);
+      }
+      if (src.metadata) {
+        return _defineProperty({}, path, [{
+          message: "Found metadata, but it could not be validated. Image metadata must be an object with the required props: width (positive number), height (positive number) and sha256 (string of length 64 of the base16 hash).",
+          // These validation errors will have to be picked up by logic outside of this package and revalidated. Reasons: 1) we have to read files to verify the metadata, which is handled differently in different runtimes (Browser, QuickJS, Node.js); 2) we want to keep this package dependency free.
+          value: src,
+          fixes: ["image:replace-metadata"]
+        }]);
+      }
+      return _defineProperty({}, path, [{
+        message: "Could not validate Image metadata.",
+        value: src,
+        fixes: ["image:add-metadata"]
+      }]);
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return (src === null || src === void 0 ? void 0 : src[FILE_REF_PROP]) === "image" && (src === null || src === void 0 ? void 0 : src[VAL_EXTENSION]) === "file";
+    }
+  }, {
+    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 _typeof(val) === "object" && val !== null && val !== undefined && ("val" in val || "valPath" in val);
+}
+function isVal(val) {
+  return _typeof(val) === "object" && val !== null && val !== undefined && Path in val && "val" 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 _typeof(source) === "object" && source !== null && (SourceOrExpr in source || Path in source);
+}
+function newSelectorProxy(source, path, moduleSchema) {
+  var _ref;
+  if (_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 (_typeof(source)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid selector type: ".concat(_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.assert(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), _defineProperty(_ref, GetSchema, moduleSchema), _ref;
+  }
+}
+function createValPathOfItem(arrayPath, prop) {
+  if (_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 (_typeof(valueOrSelector) === "object" && (SourceOrExpr in valueOrSelector || Path in valueOrSelector)) {
+    var selectorValue = valueOrSelector[SourceOrExpr];
+    return selectorValue;
+  }
+  return valueOrSelector;
+}
+
+export { Call as C, Expr as E, FILE_REF_PROP as F, GenericSelector as G, ImageSchema as I, NilSym as N, Path as P, Schema as S, VAL_EXTENSION as V, _inherits as _, _createSuper as a, _classCallCheck as b, _createClass as c, _objectSpread2 as d, _defineProperty as e, _typeof as f, getValPath as g, file as h, image as i, _slicedToArray as j, isFile as k, createValPathOfItem as l, SourceOrExpr as m, newSelectorProxy as n, isSelector as o, isSerializedVal as p, convertImageSource as q, getSchema as r, isVal as s, Sym as t, StringLiteral as u, StringTemplate as v, _toConsumableArray as w };