@valbuild/core 0.12.0

package/dist/valbuild-core.esm.js

@@ -0,0 +1,1265 @@
+import { _ as _inherits, a as _createSuper, S as Schema, g as getValPath, n as newSelectorProxy, b as SourceOrExpr, E as Expr, I as ImageSchema, c as _objectSpread2, d as _defineProperty, V as VAL_EXTENSION, i as image, P as Path, e as createValPathOfItem, f as isSelector, h as isSerializedVal, j as file, k as isFile, F as FILE_REF_PROP, l as convertImageSource, m as getSchema } from './index-55916dcd.esm.js';
+export { F as FILE_REF_PROP, G as GenericSelector, S as Schema, V as VAL_EXTENSION, o as expr } from './index-55916dcd.esm.js';
+import { _ as _classCallCheck, a as _createClass, b as _typeof, c as _slicedToArray, d as _toConsumableArray } from './createClass-012eebbf.esm.js';
+import { _ as _createForOfIteratorHelper, i as isErr, a as isOk, e as err, o as ok } from './result-b96df128.esm.js';
+import { P as PatchError } from './ops-6fae92a1.esm.js';
+
+var ObjectSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(ObjectSchema, _Schema);
+  var _super = _createSuper(ObjectSchema);
+  function ObjectSchema(items) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, ObjectSchema);
+    _this = _super.call(this);
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(ObjectSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      if (!src) {
+        return false;
+      }
+
+      // TODO: checks all props
+
+      return _typeof(src) === "object" && !Array.isArray(src);
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new ObjectSchema(this.items, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "object",
+        items: Object.fromEntries(Object.entries(this.items).map(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            key = _ref2[0],
+            schema = _ref2[1];
+          return [key, schema.serialize()];
+        })),
+        opt: this.opt
+      };
+    }
+  }]);
+  return ObjectSchema;
+}(Schema);
+var object = function object(schema) {
+  return new ObjectSchema(schema);
+};
+
+var ArraySchema = /*#__PURE__*/function (_Schema) {
+  _inherits(ArraySchema, _Schema);
+  var _super = _createSuper(ArraySchema);
+  function ArraySchema(item) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, ArraySchema);
+    _this = _super.call(this);
+    _this.item = item;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(ArraySchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      if (!src) {
+        return false;
+      }
+
+      // TODO: checks all items
+      return _typeof(src) === "object" && Array.isArray(src);
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new ArraySchema(this.item, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "array",
+        item: this.item.serialize(),
+        opt: this.opt
+      };
+    }
+  }]);
+  return ArraySchema;
+}(Schema);
+var array = function array(schema) {
+  return new ArraySchema(schema);
+};
+
+var I18nSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(I18nSchema, _Schema);
+  var _super = _createSuper(I18nSchema);
+  function I18nSchema(locales, item) {
+    var _this;
+    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    _classCallCheck(this, I18nSchema);
+    _this = _super.call(this);
+    _this.locales = locales;
+    _this.item = item;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(I18nSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new I18nSchema(this.locales, this.item, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "i18n",
+        item: this.item.serialize(),
+        locales: this.locales,
+        opt: this.opt
+      };
+    }
+  }]);
+  return I18nSchema;
+}(Schema);
+var i18n$1 = function i18n(locales) {
+  return function (schema) {
+    return new I18nSchema(locales, schema);
+  };
+};
+
+var UnionSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(UnionSchema, _Schema);
+  var _super = _createSuper(UnionSchema);
+  function UnionSchema(key, items) {
+    var _this;
+    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    _classCallCheck(this, UnionSchema);
+    _this = _super.call(this);
+    _this.key = key;
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(UnionSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "union",
+        key: this.key,
+        items: this.items.map(function (o) {
+          return o.serialize();
+        }),
+        opt: this.opt
+      };
+    }
+  }]);
+  return UnionSchema;
+}(Schema);
+var union = function union(key) {
+  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    objects[_key - 1] = arguments[_key];
+  }
+  return new UnionSchema(key, objects);
+};
+
+var OneOfSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(OneOfSchema, _Schema);
+  var _super = _createSuper(OneOfSchema);
+  function OneOfSchema(selector) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, OneOfSchema);
+    _this = _super.call(this);
+    _this.selector = selector;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(OneOfSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new OneOfSchema(this.selector, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      var path = getValPath(this.selector);
+      if (!path) {
+        throw new Error("Cannot serialize oneOf schema with empty selector. Make sure a Val module is used.");
+      }
+      return {
+        type: "oneOf",
+        selector: path,
+        opt: this.opt
+      };
+    }
+  }]);
+  return OneOfSchema;
+}(Schema);
+var oneOf = function oneOf(valModule) {
+  return new OneOfSchema(valModule);
+};
+
+var RichTextSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(RichTextSchema, _Schema);
+  var _super = _createSuper(RichTextSchema);
+  function RichTextSchema() {
+    var _this;
+    var opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    _classCallCheck(this, RichTextSchema);
+    _this = _super.call(this);
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(RichTextSchema, [{
+    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 RichTextSchema(true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "richtext",
+        opt: this.opt
+      };
+    }
+  }]);
+  return RichTextSchema;
+}(Schema);
+var richtext = function richtext() {
+  return new RichTextSchema();
+};
+{
+  content("/test/richtext1", richtext(), {
+    children: [{
+      children: [{
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: "",
+        text: "Heading 1",
+        type: "text",
+        version: 1
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "heading",
+      version: 1,
+      tag: "h1"
+    }, {
+      children: [{
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: "",
+        text: "Heading 2",
+        type: "text",
+        version: 1
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "heading",
+      version: 1,
+      tag: "h2"
+    }, {
+      children: [],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [{
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: "",
+        text: "Normal",
+        type: "text",
+        version: 1
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [{
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: "font-size: 20px;",
+        text: "Normal Font size 20",
+        type: "text",
+        version: 1
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [{
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: "font-family: serif;",
+        text: "Normal font type serif",
+        type: "text",
+        version: 1
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [{
+        detail: 0,
+        format: 1,
+        mode: "normal",
+        style: "font-family: serif;",
+        text: "Serif and bold",
+        type: "text",
+        version: 1
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [{
+        detail: 0,
+        format: 2,
+        mode: "normal",
+        style: "",
+        text: "Arial and italic",
+        type: "text",
+        version: 1
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [],
+      direction: null,
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [{
+        children: [{
+          detail: 0,
+          format: 0,
+          mode: "normal",
+          style: "",
+          text: "Num list 1",
+          type: "text",
+          version: 1
+        }],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "listitem",
+        version: 1,
+        value: 1
+      }, {
+        children: [{
+          detail: 0,
+          format: 0,
+          mode: "normal",
+          style: "",
+          text: "Num list 2",
+          type: "text",
+          version: 1
+        }
+        // TODO: image
+        // {
+        //   altText: "",
+        //   height: 0,
+        //   maxWidth: 0,
+        //   src: "https://picsum.photos/id/237/200/300",
+        //   type: "image",
+        //   version: 1,
+        //   width: 0,
+        // },
+        ],
+
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "listitem",
+        version: 1,
+        value: 2
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "list",
+      version: 1,
+      listType: "number",
+      start: 1,
+      tag: "ol"
+    }, {
+      children: [],
+      direction: null,
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [{
+        children: [{
+          detail: 0,
+          format: 0,
+          mode: "normal",
+          style: "",
+          text: "Bullet list 1",
+          type: "text",
+          version: 1
+        }],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "listitem",
+        version: 1,
+        value: 1
+      }, {
+        children: [{
+          detail: 0,
+          format: 0,
+          mode: "normal",
+          style: "",
+          text: "Bullet list 2",
+          type: "text",
+          version: 1
+        }],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "listitem",
+        version: 1,
+        value: 2
+      }],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "list",
+      version: 1,
+      listType: "bullet",
+      start: 1,
+      tag: "ul"
+    }, {
+      children: [],
+      direction: null,
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }, {
+      children: [],
+      direction: null,
+      format: "",
+      indent: 0,
+      type: "paragraph",
+      version: 1
+    }],
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    type: "root",
+    version: 1
+  });
+}
+
+function content(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+id,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+schema,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+source) {
+  return newSelectorProxy(source, id, schema);
+}
+function getRawSource(valModule) {
+  var sourceOrExpr = valModule[SourceOrExpr];
+  if (sourceOrExpr instanceof Expr) {
+    throw Error("Cannot get raw source of an Expr");
+  }
+  var source = sourceOrExpr;
+  return source;
+}
+function splitModuleIdAndModulePath(path) {
+  return [path.slice(0, path.indexOf(".")), path.slice(path.indexOf(".") + 1)];
+}
+function isObjectSchema(schema) {
+  return schema instanceof ObjectSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "object";
+}
+function isArraySchema(schema) {
+  return schema instanceof ArraySchema || _typeof(schema) === "object" && "type" in schema && schema.type === "array";
+}
+function isI18nSchema(schema) {
+  return schema instanceof I18nSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "i18n";
+}
+function isUnionSchema(schema) {
+  return schema instanceof UnionSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "union";
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function isRichTextSchema(schema) {
+  return schema instanceof RichTextSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "richtext";
+}
+function isImageSchema(schema) {
+  return schema instanceof ImageSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "image";
+}
+function resolvePath(path, valModule, schema) {
+  var parts = parsePath(path);
+  var origParts = _toConsumableArray(parts);
+  var resolvedSchema = schema;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var resolvedSource = valModule;
+  var _loop = function _loop() {
+    var part = parts.shift();
+    if (part === undefined) {
+      throw Error("Unexpected undefined part");
+    }
+    if (isArraySchema(resolvedSchema)) {
+      if (Number.isNaN(Number(part))) {
+        throw Error("Invalid path: array schema ".concat(resolvedSchema, " must have ").concat(part, " a number as path"));
+      }
+      if (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+        throw Error("Schema type error: expected source to be type of array, but got ".concat(_typeof(resolvedSource)));
+      }
+      if (!resolvedSource[part]) {
+        var _resolvedSource;
+        throw Error("Invalid path: array source (length: ".concat((_resolvedSource = resolvedSource) === null || _resolvedSource === void 0 ? void 0 : _resolvedSource.length, ") did not have index ").concat(part, " from path: ").concat(path));
+      }
+      resolvedSource = resolvedSource[part];
+      resolvedSchema = resolvedSchema.item;
+    } else if (isObjectSchema(resolvedSchema)) {
+      if (_typeof(resolvedSource) !== "object") {
+        throw Error("Schema type error: expected source to be type of object, but got ".concat(_typeof(resolvedSource)));
+      }
+      if (!resolvedSource[part]) {
+        throw Error("Invalid path: object source did not have key ".concat(part, " from path: ").concat(path));
+      }
+      resolvedSource = resolvedSource[part];
+      resolvedSchema = resolvedSchema.items[part];
+    } else if (isI18nSchema(resolvedSchema)) {
+      if (!resolvedSchema.locales.includes(part)) {
+        throw Error("Invalid path: i18n schema ".concat(resolvedSchema, " supports locales ").concat(resolvedSchema.locales.join(", "), ", but found: ").concat(part));
+      }
+      if (!Object.keys(resolvedSource).includes(part)) {
+        throw Error("Schema type error: expected source to be type of i18n with locale ".concat(part, ", but got ").concat(JSON.stringify(Object.keys(resolvedSource))));
+      }
+      resolvedSource = resolvedSource[part];
+      resolvedSchema = resolvedSchema.item;
+    } else if (isImageSchema(resolvedSchema)) {
+      return {
+        v: {
+          path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+            return JSON.stringify(p);
+          }).join("."),
+          // TODO: create a function generate path from parts (not sure if this always works)
+          schema: resolvedSchema,
+          source: resolvedSource
+        }
+      };
+    } else if (isUnionSchema(resolvedSchema)) {
+      var _key = resolvedSchema.key;
+      var keyValue = resolvedSource[_key];
+      if (!keyValue) {
+        throw Error("Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key, " in path: ").concat(path));
+      }
+      var schemaOfUnionKey = resolvedSchema.items.find(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      function (child) {
+        var _child$items, _child$items$_key;
+        return (child === null || child === void 0 ? void 0 : (_child$items = child.items) === null || _child$items === void 0 ? void 0 : (_child$items$_key = _child$items[_key]) === null || _child$items$_key === void 0 ? void 0 : _child$items$_key.value) === keyValue;
+      });
+      if (!schemaOfUnionKey) {
+        throw Error("Invalid path: union schema ".concat(resolvedSchema, " did not have a child object with ").concat(_key, " of value ").concat(keyValue, " in path: ").concat(path));
+      }
+      resolvedSchema = schemaOfUnionKey.items[part];
+      resolvedSource = resolvedSource[part];
+    } else if (isRichTextSchema(resolvedSchema)) {
+      return {
+        v: {
+          path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+            return JSON.stringify(p);
+          }).join("."),
+          // TODO: create a function generate path from parts (not sure if this always works)
+          schema: resolvedSchema,
+          source: resolvedSource
+        }
+      };
+    } else {
+      throw Error("Invalid path: ".concat(part, " resolved to an unexpected schema ").concat(JSON.stringify(resolvedSchema)));
+    }
+  };
+  while (parts.length > 0) {
+    var _ret = _loop();
+    if (_typeof(_ret) === "object") return _ret.v;
+  }
+  if (parts.length > 0) {
+    throw Error("Invalid path: ".concat(parts.join("."), " is not a valid path"));
+  }
+  return {
+    path: path,
+    schema: resolvedSchema,
+    source: resolvedSource
+  };
+}
+function parsePath(input) {
+  var result = [];
+  var i = 0;
+  while (i < input.length) {
+    var part = "";
+    if (input[i] === '"') {
+      // Parse a quoted string
+      i++;
+      while (i < input.length && input[i] !== '"') {
+        if (input[i] === "\\" && input[i + 1] === '"') {
+          // Handle escaped double quotes
+          part += '"';
+          i++;
+        } else {
+          part += input[i];
+        }
+        i++;
+      }
+      if (input[i] !== '"') {
+        var _input$i;
+        throw new Error("Invalid input (".concat(JSON.stringify(input), "): Missing closing double quote: ").concat((_input$i = input[i]) !== null && _input$i !== void 0 ? _input$i : "at end of string", " (char: ").concat(i, "; length: ").concat(input.length, ")"));
+      }
+    } else {
+      // Parse a regular string
+      while (i < input.length && input[i] !== ".") {
+        part += input[i];
+        i++;
+      }
+    }
+    if (part !== "") {
+      result.push(part);
+    }
+    i++;
+  }
+  return result;
+}
+
+/**
+ * I18n sources cannot have nested remote sources.
+ */
+
+/**
+ * An i18n source is a map of locales to sources.
+ *
+ * Its selector will default to the underlying source. It is possible to call `.all` on i18n sources, which returns an object with all the locales
+ *
+ */
+
+function i18n(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+locales) {
+  return function (source) {
+    return _objectSpread2(_objectSpread2({}, source), {}, _defineProperty({}, VAL_EXTENSION, "i18n"));
+  };
+}
+
+var NumberSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(NumberSchema, _Schema);
+  var _super = _createSuper(NumberSchema);
+  function NumberSchema(options) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, NumberSchema);
+    _this = _super.call(this);
+    _this.options = options;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(NumberSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return typeof src === "number";
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new NumberSchema(this.options, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "number",
+        options: this.options,
+        opt: this.opt
+      };
+    }
+  }]);
+  return NumberSchema;
+}(Schema);
+var number = function number(options) {
+  return new NumberSchema(options);
+};
+
+var StringSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(StringSchema, _Schema);
+  var _super = _createSuper(StringSchema);
+  function StringSchema(options) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, StringSchema);
+    _this = _super.call(this);
+    _this.options = options;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(StringSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return typeof src === "string";
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new StringSchema(this.options, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "string",
+        options: this.options,
+        opt: this.opt
+      };
+    }
+  }]);
+  return StringSchema;
+}(Schema);
+var string = function string(options) {
+  return new StringSchema(options);
+};
+
+var BooleanSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(BooleanSchema, _Schema);
+  var _super = _createSuper(BooleanSchema);
+  function BooleanSchema() {
+    var _this;
+    var opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    _classCallCheck(this, BooleanSchema);
+    _this = _super.call(this);
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(BooleanSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return typeof src === "boolean";
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new BooleanSchema(true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "boolean",
+        opt: this.opt
+      };
+    }
+  }]);
+  return BooleanSchema;
+}(Schema);
+var _boolean = function _boolean() {
+  return new BooleanSchema();
+};
+
+var LiteralSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(LiteralSchema, _Schema);
+  var _super = _createSuper(LiteralSchema);
+  function LiteralSchema(value) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, LiteralSchema);
+    _this = _super.call(this);
+    _this.value = value;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(LiteralSchema, [{
+    key: "validate",
+    value: function validate(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "match",
+    value: function match(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return typeof src === "string";
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new LiteralSchema(this.value, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "literal",
+        value: this.value,
+        opt: this.opt
+      };
+    }
+  }]);
+  return LiteralSchema;
+}(Schema);
+var literal = function literal(value) {
+  return new LiteralSchema(value);
+};
+
+function initSchema(locales) {
+  return {
+    string: string,
+    "boolean": _boolean,
+    array: array,
+    object: object,
+    number: number,
+    union: union,
+    oneOf: oneOf,
+    richtext: richtext,
+    image: image,
+    literal: literal,
+    i18n: i18n$1(locales)
+  };
+}
+
+function fetchVal(selector, locale) {
+  return Promise.resolve(getVal(selector));
+}
+function getVal(selector,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+locale) {
+  return newValProxy(serializedValOfSelectorSource(selector));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isArrayOrArraySelector(child) {
+  if (isSelector(child)) {
+    return _typeof(child[SourceOrExpr]) === "object" && _typeof(child[SourceOrExpr]) !== null && Array.isArray(child[SourceOrExpr]);
+  }
+  return Array.isArray(child);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isObjectOrObjectSelector(child) {
+  if (isSelector(child)) {
+    return _typeof(child[SourceOrExpr]) === "object" && _typeof(child[SourceOrExpr]) !== null && !Array.isArray(child[SourceOrExpr]);
+  }
+  return _typeof(child) === "object";
+}
+function serializedValOfSelectorSource(selector) {
+  var wrappedSelector = newSelectorProxy(selector); // NOTE: we do this if call-site uses a literal with selectors inside
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function rec(child) {
+    var isArray = isArrayOrArraySelector(child);
+    var isObject = isObjectOrObjectSelector(child);
+    if (isArray) {
+      var array = SourceOrExpr in child ? child[SourceOrExpr] : child;
+      var valPath = Path in child ? child[Path] : undefined;
+      return {
+        val: array.map(function (item, i) {
+          return rec(isSelector(item) // NOTE: We do this since selectors currently do not create selectors of items unless specifically required.
+          ? item : newSelectorProxy(item, createValPathOfItem(valPath, i)));
+        }),
+        valPath: valPath
+      };
+    } else if (isObject) {
+      var obj = SourceOrExpr in child ? child[SourceOrExpr] : child;
+      var _valPath = Path in child ? child[Path] : undefined;
+      return {
+        val: obj !== null && Object.fromEntries(Object.entries(obj).map(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            key = _ref2[0],
+            value = _ref2[1];
+          return [key, rec(isSelector(value) // NOTE: We do this since selectors currently do not create selectors of items unless specifically required.
+          ? value : newSelectorProxy(value, createValPathOfItem(_valPath, key)))];
+        })),
+        valPath: _valPath
+      };
+    } else if (isSelector(child)) {
+      return {
+        val: rec(child[SourceOrExpr]),
+        valPath: child[Path]
+      };
+    } else {
+      return child;
+    }
+  }
+  return rec(wrappedSelector);
+}
+function strip(value) {
+  var val = isSerializedVal(value) ? value.val : value;
+  switch (_typeof(val)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid val type: ".concat(_typeof(val)));
+    case "object":
+      if (val === null) {
+        return null;
+      } else if (Array.isArray(val)) {
+        return val.map(strip);
+      } else {
+        return Object.fromEntries(Object.entries(val).map(function (_ref3) {
+          var _ref4 = _slicedToArray(_ref3, 2),
+            key = _ref4[0],
+            value = _ref4[1];
+          return [key, value && strip(value)];
+        }));
+      }
+    // intentional fallthrough
+    // eslint-disable-next-line no-fallthrough
+    default:
+      return val;
+  }
+}
+function newValProxy(val) {
+  var _ref5;
+  var source = val.val;
+  switch (_typeof(source)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid val type: ".concat(_typeof(source)));
+    case "object":
+      if (source !== null) {
+        // Handles both objects and arrays!
+        return new Proxy(source, {
+          has: function has(target, prop) {
+            if (prop === "val") {
+              return true;
+            }
+            if (prop === Path) {
+              return true;
+            }
+            return hasOwn(target, prop);
+          },
+          get: function get(target, prop) {
+            if (prop === Path) {
+              return val.valPath;
+            }
+            if (prop === "val") {
+              return strip(val);
+            }
+            if (Array.isArray(target) && prop === "length") {
+              return target.length;
+            }
+            if (hasOwn(source, prop)) {
+              var _Reflect$get$valPath, _Reflect$get;
+              return newValProxy({
+                val: Reflect.get(target, prop).val,
+                valPath: (_Reflect$get$valPath = (_Reflect$get = Reflect.get(target, prop)) === null || _Reflect$get === void 0 ? void 0 : _Reflect$get.valPath) !== null && _Reflect$get$valPath !== void 0 ? _Reflect$get$valPath : createValPathOfItem(val.valPath, Array.isArray(target) ? Number(prop) : prop)
+              });
+            }
+            return Reflect.get(target, prop);
+          }
+        });
+      }
+    // intentional fallthrough
+    // eslint-disable-next-line no-fallthrough
+    default:
+      return _ref5 = {}, _defineProperty(_ref5, Path, val.valPath), _defineProperty(_ref5, "val", val.val), _ref5;
+  }
+}
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+/**
+ * Remote sources cannot include other remote sources.
+ */
+
+var REMOTE_REF_PROP = "_ref"; // TODO: same as FILE_REF_PROP so use same prop?
+
+/**
+ * A remote source is a hash that represents a remote object.
+ *
+ * It will be resolved into a ValRemote object.
+ */
+
+function remote(ref) {
+  var _ref;
+  return _ref = {}, _defineProperty(_ref, REMOTE_REF_PROP, ref), _defineProperty(_ref, VAL_EXTENSION, "remote"), _ref;
+}
+function isRemote(obj) {
+  return _typeof(obj) === "object" && obj !== null && VAL_EXTENSION in obj && obj[VAL_EXTENSION] === "remote" && REMOTE_REF_PROP in obj && typeof obj[REMOTE_REF_PROP] === "string";
+}
+
+var initVal = function initVal(options) {
+  var locales = options === null || options === void 0 ? void 0 : options.locales;
+  var s = initSchema(locales === null || locales === void 0 ? void 0 : locales.required);
+  if (locales !== null && locales !== void 0 && locales.required) {
+    console.error("Locales / i18n currently not implemented");
+    return {
+      val: {
+        content: content,
+        i18n: i18n,
+        remote: remote,
+        getPath: getValPath,
+        key: getValPath,
+        file: file
+      },
+      fetchVal: fetchVal,
+      s: s
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+  }
+
+  return {
+    val: {
+      content: content,
+      remote: remote,
+      getPath: getValPath,
+      key: getValPath,
+      file: file
+    },
+    fetchVal: fetchVal,
+    s: _objectSpread2(_objectSpread2({}, s), {}, {
+      i18n: undefined
+    })
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  };
+};
+
+function derefPath(path) {
+  var dereffedPath = [];
+  var referencedPath = null;
+  var _iterator = _createForOfIteratorHelper(path),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var segment = _step.value;
+      if (segment.startsWith("$")) {
+        var dereffedSegment = segment.slice(1);
+        dereffedPath.push(dereffedSegment);
+        referencedPath = [];
+        var _iterator2 = _createForOfIteratorHelper(path.slice(dereffedPath.length)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _segment = _step2.value;
+            if (_segment.startsWith("$")) {
+              return err(new PatchError("Cannot reference within reference: ".concat(_segment, ". Path: ").concat(path.join("/"))));
+            }
+            referencedPath.push(_segment);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        break;
+      } else {
+        dereffedPath.push(segment);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return ok([dereffedPath, referencedPath]);
+}
+function derefPatch(patch, document, ops) {
+  var remotePatches = {};
+  var fileUpdates = {};
+  var dereferencedPatch = [];
+  var _iterator3 = _createForOfIteratorHelper(patch),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var op = _step3.value;
+      if (op.op === "replace") {
+        var maybeDerefRes = derefPath(op.path);
+        if (isErr(maybeDerefRes)) {
+          return maybeDerefRes;
+        }
+        var _maybeDerefRes$value = _slicedToArray(maybeDerefRes.value, 2),
+          dereffedPath = _maybeDerefRes$value[0],
+          referencedPath = _maybeDerefRes$value[1];
+        if (referencedPath) {
+          var maybeValue = ops.get(document, dereffedPath);
+          if (isOk(maybeValue)) {
+            var value = maybeValue.value;
+            if (isFile(value)) {
+              if (referencedPath.length > 0) {
+                return err(new PatchError("Cannot sub-reference file reference at path: ".concat(dereffedPath.join("/"))));
+              }
+              if (typeof op.value !== "string") {
+                return err(new PatchError("Expected base64 encoded string value for file reference, got ".concat(JSON.stringify(op.value))));
+              }
+              fileUpdates[value[FILE_REF_PROP]] = op.value;
+            } else if (isRemote(value)) {
+              if (!remotePatches[value[REMOTE_REF_PROP]]) {
+                remotePatches[value[REMOTE_REF_PROP]] = [];
+              }
+              remotePatches[value[REMOTE_REF_PROP]].push({
+                op: "replace",
+                path: referencedPath,
+                value: op.value
+              });
+            } else {
+              return err(new PatchError("Unknown reference: ".concat(JSON.stringify(op), " at path: ").concat(dereffedPath.join("/"))));
+            }
+          } else {
+            return maybeValue;
+          }
+        } else {
+          dereferencedPatch.push(op);
+        }
+      } else {
+        var _maybeDerefRes = derefPath(op.path);
+        if (isErr(_maybeDerefRes)) {
+          return _maybeDerefRes;
+        }
+        var _maybeDerefRes$value2 = _slicedToArray(_maybeDerefRes.value, 2),
+          _referencedPath = _maybeDerefRes$value2[1];
+        if (_referencedPath) {
+          throw new Error("Unimplemented operation: ".concat(JSON.stringify(op)));
+        }
+        dereferencedPatch.push(op);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return ok({
+    remotePatches: remotePatches,
+    fileUpdates: fileUpdates,
+    dereferencedPatch: dereferencedPatch
+  });
+}
+
+var Internal = {
+  convertImageSource: convertImageSource,
+  getSchema: getSchema,
+  getValPath: getValPath,
+  getVal: getVal,
+  getRawSource: getRawSource,
+  resolvePath: resolvePath,
+  splitModuleIdAndModulePath: splitModuleIdAndModulePath
+};
+
+export { Internal, derefPatch, fetchVal, initVal };