@valbuild/core 0.12.0

package/dist/ops-6fae92a1.esm.js

@@ -0,0 +1,12 @@
+import { a as _createClass, _ as _classCallCheck } from './createClass-012eebbf.esm.js';
+
+var PatchError = /*#__PURE__*/_createClass(function PatchError(message) {
+  _classCallCheck(this, PatchError);
+  this.message = message;
+});
+
+/**
+ * NOTE: MAY mutate the input document.
+ */
+
+export { PatchError as P };

package/dist/ops-87cdbafc.cjs.dev.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var createClass = require('./createClass-a436dbfe.cjs.dev.js');
+
+var PatchError = /*#__PURE__*/createClass._createClass(function PatchError(message) {
+  createClass._classCallCheck(this, PatchError);
+  this.message = message;
+});
+
+/**
+ * NOTE: MAY mutate the input document.
+ */
+
+exports.PatchError = PatchError;

package/dist/ops-ae4d1bc2.cjs.prod.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var createClass = require('./createClass-de7426aa.cjs.prod.js');
+
+var PatchError = /*#__PURE__*/createClass._createClass(function PatchError(message) {
+  createClass._classCallCheck(this, PatchError);
+  this.message = message;
+});
+
+/**
+ * NOTE: MAY mutate the input document.
+ */
+
+exports.PatchError = PatchError;

package/dist/result-26f67b40.cjs.prod.js

@@ -0,0 +1,299 @@
+'use strict';
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+function isNonEmpty(array) {
+  return array.length > 0;
+}
+function flatten(array) {
+  return array.flat(1);
+}
+function map$1(fn) {
+  function mapFn(array) {
+    return array.map(fn);
+  }
+  return mapFn;
+}
+
+var array = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  isNonEmpty: isNonEmpty,
+  flatten: flatten,
+  map: map$1
+});
+
+/**
+ * Singleton instance of Ok<void>. Used to optimize results whose Ok values are
+ * void.
+ */
+var voidOk = Object.freeze({
+  kind: "ok",
+  value: undefined
+});
+function ok(value) {
+  if (value === undefined) return voidOk;
+  return {
+    kind: "ok",
+    value: value
+  };
+}
+function err(error) {
+  return {
+    kind: "err",
+    error: error
+  };
+}
+function isOk(result) {
+  return result === voidOk || result.kind === "ok";
+}
+function isErr(result) {
+  return result !== voidOk && result.kind === "err";
+}
+/**
+ * If all results are Ok (or if results is empty), returns Ok with all the Ok
+ * values concatenated into an array. If any result is Err, returns Err with all
+ * Err values concatenated into an array.
+ *
+ * @see {@link all} for use with simple array types.
+ */
+function allT(results) {
+  var values = [];
+  var errors = [];
+  var _iterator = _createForOfIteratorHelper(results),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _result = _step.value;
+      if (isOk(_result)) {
+        values.push(_result.value);
+      } else {
+        errors.push(_result.error);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (isNonEmpty(errors)) {
+    return err(errors);
+  } else {
+    return ok(values);
+  }
+}
+
+/**
+ * If all results are Ok (or if results is empty), returns Ok with all the Ok
+ * values concatenated into an array. If any result is Err, returns Err with all
+ * Err values concatenated into an array.
+ *
+ * @see {@link allT} for use with tuple types.
+ */
+function all(results) {
+  return allT(results);
+}
+
+/**
+ * If all results are Ok (or if results is empty), returns Ok. If any result is
+ * Err, returns Err with all Err values concatenated into an array.
+ */
+function allV(results) {
+  var errs = [];
+  var _iterator2 = _createForOfIteratorHelper(results),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _result2 = _step2.value;
+      if (isErr(_result2)) {
+        errs.push(_result2.error);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (isNonEmpty(errs)) {
+    return err(errs);
+  }
+  return voidOk;
+}
+
+/**
+ * Perform a reduction over an array with a Result-returning reducer. If the
+ * reducer returns Ok, its value is used as the next value. If the reducer
+ * returns Err, it is returned immediately.
+ *
+ * flatMapReduce is a short-circuiting equivalent to:
+ * ```
+ * arr.reduce(
+ *   (accRes, current, currentIndex) =>
+ *     flatMap((acc) => reducer(acc, current, currentIndex))(accRes),
+ *   ok(initVal)
+ * )
+ * ```
+ */
+function flatMapReduce(reducer, initVal) {
+  return function (arr) {
+    var val = ok(initVal);
+    for (var i = 0; i < arr.length && isOk(val); ++i) {
+      val = reducer(val.value, arr[i], i);
+    }
+    return val;
+  };
+}
+function map(onOk) {
+  return function (result) {
+    if (isOk(result)) {
+      return ok(onOk(result.value));
+    } else {
+      return result;
+    }
+  };
+}
+function flatMap(onOk) {
+  return function (result) {
+    if (isOk(result)) {
+      return onOk(result.value);
+    } else {
+      return result;
+    }
+  };
+}
+function mapErr(onErr) {
+  return function (result) {
+    if (isErr(result)) {
+      return err(onErr(result.error));
+    } else {
+      return result;
+    }
+  };
+}
+function fromPredicate(refinement, onFalse) {
+  return function (value) {
+    if (refinement(value)) {
+      return ok(value);
+    } else {
+      return err(onFalse(value));
+    }
+  };
+}
+
+// NOTE: Function overload resolution seems to fail when declared as overloaded
+// function type, so a value with a callable type is used instead.
+var filterOrElse = function filterOrElse(refinement, onFalse) {
+  return function (result) {
+    if (isOk(result)) {
+      if (refinement(result.value)) {
+        return result;
+      } else {
+        return err(onFalse(result.value));
+      }
+    } else {
+      return result;
+    }
+  };
+};
+
+var result = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  voidOk: voidOk,
+  ok: ok,
+  err: err,
+  isOk: isOk,
+  isErr: isErr,
+  allT: allT,
+  all: all,
+  allV: allV,
+  flatMapReduce: flatMapReduce,
+  map: map,
+  flatMap: flatMap,
+  mapErr: mapErr,
+  fromPredicate: fromPredicate,
+  filterOrElse: filterOrElse
+});
+
+exports._arrayLikeToArray = _arrayLikeToArray;
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;
+exports._unsupportedIterableToArray = _unsupportedIterableToArray;
+exports.all = all;
+exports.allT = allT;
+exports.array = array;
+exports.err = err;
+exports.filterOrElse = filterOrElse;
+exports.flatMap = flatMap;
+exports.flatMapReduce = flatMapReduce;
+exports.flatten = flatten;
+exports.isErr = isErr;
+exports.isNonEmpty = isNonEmpty;
+exports.isOk = isOk;
+exports.map = map;
+exports.map$1 = map$1;
+exports.mapErr = mapErr;
+exports.ok = ok;
+exports.result = result;

package/dist/result-48320acd.cjs.dev.js

@@ -0,0 +1,299 @@
+'use strict';
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+function isNonEmpty(array) {
+  return array.length > 0;
+}
+function flatten(array) {
+  return array.flat(1);
+}
+function map$1(fn) {
+  function mapFn(array) {
+    return array.map(fn);
+  }
+  return mapFn;
+}
+
+var array = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  isNonEmpty: isNonEmpty,
+  flatten: flatten,
+  map: map$1
+});
+
+/**
+ * Singleton instance of Ok<void>. Used to optimize results whose Ok values are
+ * void.
+ */
+var voidOk = Object.freeze({
+  kind: "ok",
+  value: undefined
+});
+function ok(value) {
+  if (value === undefined) return voidOk;
+  return {
+    kind: "ok",
+    value: value
+  };
+}
+function err(error) {
+  return {
+    kind: "err",
+    error: error
+  };
+}
+function isOk(result) {
+  return result === voidOk || result.kind === "ok";
+}
+function isErr(result) {
+  return result !== voidOk && result.kind === "err";
+}
+/**
+ * If all results are Ok (or if results is empty), returns Ok with all the Ok
+ * values concatenated into an array. If any result is Err, returns Err with all
+ * Err values concatenated into an array.
+ *
+ * @see {@link all} for use with simple array types.
+ */
+function allT(results) {
+  var values = [];
+  var errors = [];
+  var _iterator = _createForOfIteratorHelper(results),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _result = _step.value;
+      if (isOk(_result)) {
+        values.push(_result.value);
+      } else {
+        errors.push(_result.error);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (isNonEmpty(errors)) {
+    return err(errors);
+  } else {
+    return ok(values);
+  }
+}
+
+/**
+ * If all results are Ok (or if results is empty), returns Ok with all the Ok
+ * values concatenated into an array. If any result is Err, returns Err with all
+ * Err values concatenated into an array.
+ *
+ * @see {@link allT} for use with tuple types.
+ */
+function all(results) {
+  return allT(results);
+}
+
+/**
+ * If all results are Ok (or if results is empty), returns Ok. If any result is
+ * Err, returns Err with all Err values concatenated into an array.
+ */
+function allV(results) {
+  var errs = [];
+  var _iterator2 = _createForOfIteratorHelper(results),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _result2 = _step2.value;
+      if (isErr(_result2)) {
+        errs.push(_result2.error);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (isNonEmpty(errs)) {
+    return err(errs);
+  }
+  return voidOk;
+}
+
+/**
+ * Perform a reduction over an array with a Result-returning reducer. If the
+ * reducer returns Ok, its value is used as the next value. If the reducer
+ * returns Err, it is returned immediately.
+ *
+ * flatMapReduce is a short-circuiting equivalent to:
+ * ```
+ * arr.reduce(
+ *   (accRes, current, currentIndex) =>
+ *     flatMap((acc) => reducer(acc, current, currentIndex))(accRes),
+ *   ok(initVal)
+ * )
+ * ```
+ */
+function flatMapReduce(reducer, initVal) {
+  return function (arr) {
+    var val = ok(initVal);
+    for (var i = 0; i < arr.length && isOk(val); ++i) {
+      val = reducer(val.value, arr[i], i);
+    }
+    return val;
+  };
+}
+function map(onOk) {
+  return function (result) {
+    if (isOk(result)) {
+      return ok(onOk(result.value));
+    } else {
+      return result;
+    }
+  };
+}
+function flatMap(onOk) {
+  return function (result) {
+    if (isOk(result)) {
+      return onOk(result.value);
+    } else {
+      return result;
+    }
+  };
+}
+function mapErr(onErr) {
+  return function (result) {
+    if (isErr(result)) {
+      return err(onErr(result.error));
+    } else {
+      return result;
+    }
+  };
+}
+function fromPredicate(refinement, onFalse) {
+  return function (value) {
+    if (refinement(value)) {
+      return ok(value);
+    } else {
+      return err(onFalse(value));
+    }
+  };
+}
+
+// NOTE: Function overload resolution seems to fail when declared as overloaded
+// function type, so a value with a callable type is used instead.
+var filterOrElse = function filterOrElse(refinement, onFalse) {
+  return function (result) {
+    if (isOk(result)) {
+      if (refinement(result.value)) {
+        return result;
+      } else {
+        return err(onFalse(result.value));
+      }
+    } else {
+      return result;
+    }
+  };
+};
+
+var result = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  voidOk: voidOk,
+  ok: ok,
+  err: err,
+  isOk: isOk,
+  isErr: isErr,
+  allT: allT,
+  all: all,
+  allV: allV,
+  flatMapReduce: flatMapReduce,
+  map: map,
+  flatMap: flatMap,
+  mapErr: mapErr,
+  fromPredicate: fromPredicate,
+  filterOrElse: filterOrElse
+});
+
+exports._arrayLikeToArray = _arrayLikeToArray;
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;
+exports._unsupportedIterableToArray = _unsupportedIterableToArray;
+exports.all = all;
+exports.allT = allT;
+exports.array = array;
+exports.err = err;
+exports.filterOrElse = filterOrElse;
+exports.flatMap = flatMap;
+exports.flatMapReduce = flatMapReduce;
+exports.flatten = flatten;
+exports.isErr = isErr;
+exports.isNonEmpty = isNonEmpty;
+exports.isOk = isOk;
+exports.map = map;
+exports.map$1 = map$1;
+exports.mapErr = mapErr;
+exports.ok = ok;
+exports.result = result;