@exodus/xqa 5.5.0 → 7.0.0

package/dist/consumer-neverthrow.mjs

@@ -0,0 +1,547 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.cjs.js
+var require_index_cjs = __commonJS({
+  "../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.cjs.js"(exports) {
+    "use strict";
+    var defaultErrorConfig = {
+      withStackTrace: false
+    };
+    var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+      const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+      const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+      return {
+        data,
+        message,
+        stack: maybeStack
+      };
+    };
+    function __awaiter(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    }
+    function __values(o) {
+      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+      if (m) return m.call(o);
+      if (o && typeof o.length === "number") return {
+        next: function() {
+          if (o && i >= o.length) o = void 0;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __await(v) {
+      return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var g = generator.apply(thisArg, _arguments || []), i, q = [];
+      return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+        return this;
+      }, i;
+      function awaitReturn(f) {
+        return function(v) {
+          return Promise.resolve(v).then(f, reject);
+        };
+      }
+      function verb(n, f) {
+        if (g[n]) {
+          i[n] = function(v) {
+            return new Promise(function(a, b) {
+              q.push([n, v, a, b]) > 1 || resume(n, v);
+            });
+          };
+          if (f) i[n] = f(i[n]);
+        }
+      }
+      function resume(n, v) {
+        try {
+          step(g[n](v));
+        } catch (e) {
+          settle(q[0][3], e);
+        }
+      }
+      function step(r) {
+        r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+      }
+      function fulfill(value) {
+        resume("next", value);
+      }
+      function reject(value) {
+        resume("throw", value);
+      }
+      function settle(f, v) {
+        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+      }
+    }
+    function __asyncDelegator(o) {
+      var i, p;
+      return i = {}, verb("next"), verb("throw", function(e) {
+        throw e;
+      }), verb("return"), i[Symbol.iterator] = function() {
+        return this;
+      }, i;
+      function verb(n, f) {
+        i[n] = o[n] ? function(v) {
+          return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+        } : f;
+      }
+    }
+    function __asyncValues(o) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var m = o[Symbol.asyncIterator], i;
+      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+        return this;
+      }, i);
+      function verb(n) {
+        i[n] = o[n] && function(v) {
+          return new Promise(function(resolve, reject) {
+            v = o[n](v), settle(resolve, reject, v.done, v.value);
+          });
+        };
+      }
+      function settle(resolve, reject, d, v) {
+        Promise.resolve(v).then(function(v2) {
+          resolve({ value: v2, done: d });
+        }, reject);
+      }
+    }
+    var ResultAsync2 = class _ResultAsync {
+      constructor(res) {
+        this._promise = res;
+      }
+      static fromSafePromise(promise) {
+        const newPromise = promise.then((value) => new Ok(value));
+        return new _ResultAsync(newPromise);
+      }
+      static fromPromise(promise, errorFn) {
+        const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+        return new _ResultAsync(newPromise);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      static fromThrowable(fn, errorFn) {
+        return (...args) => {
+          return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+            try {
+              return new Ok(yield fn(...args));
+            } catch (error) {
+              return new Err(errorFn ? errorFn(error) : error);
+            }
+          }))());
+        };
+      }
+      static combine(asyncResultList) {
+        return combineResultAsyncList(asyncResultList);
+      }
+      static combineWithAllErrors(asyncResultList) {
+        return combineResultAsyncListWithAllErrors(asyncResultList);
+      }
+      map(f) {
+        return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+          if (res.isErr()) {
+            return new Err(res.error);
+          }
+          return new Ok(yield f(res.value));
+        })));
+      }
+      andThrough(f) {
+        return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+          if (res.isErr()) {
+            return new Err(res.error);
+          }
+          const newRes = yield f(res.value);
+          if (newRes.isErr()) {
+            return new Err(newRes.error);
+          }
+          return new Ok(res.value);
+        })));
+      }
+      andTee(f) {
+        return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+          if (res.isErr()) {
+            return new Err(res.error);
+          }
+          try {
+            yield f(res.value);
+          } catch (e) {
+          }
+          return new Ok(res.value);
+        })));
+      }
+      orTee(f) {
+        return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+          if (res.isOk()) {
+            return new Ok(res.value);
+          }
+          try {
+            yield f(res.error);
+          } catch (e) {
+          }
+          return new Err(res.error);
+        })));
+      }
+      mapErr(f) {
+        return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+          if (res.isOk()) {
+            return new Ok(res.value);
+          }
+          return new Err(yield f(res.error));
+        })));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      andThen(f) {
+        return new _ResultAsync(this._promise.then((res) => {
+          if (res.isErr()) {
+            return new Err(res.error);
+          }
+          const newValue = f(res.value);
+          return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+        }));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      orElse(f) {
+        return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+          if (res.isErr()) {
+            return f(res.error);
+          }
+          return new Ok(res.value);
+        })));
+      }
+      match(ok3, _err) {
+        return this._promise.then((res) => res.match(ok3, _err));
+      }
+      unwrapOr(t) {
+        return this._promise.then((res) => res.unwrapOr(t));
+      }
+      /**
+       * @deprecated will be removed in 9.0.0.
+       *
+       * You can use `safeTry` without this method.
+       * @example
+       * ```typescript
+       * safeTry(async function* () {
+       *   const okValue = yield* yourResult
+       * })
+       * ```
+       * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+       */
+      safeUnwrap() {
+        return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+          return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+        });
+      }
+      // Makes ResultAsync implement PromiseLike<Result>
+      then(successCallback, failureCallback) {
+        return this._promise.then(successCallback, failureCallback);
+      }
+      [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+          const result = yield __await(this._promise);
+          if (result.isErr()) {
+            yield yield __await(errAsync2(result.error));
+          }
+          return yield __await(result.value);
+        });
+      }
+    };
+    function okAsync2(value) {
+      return new ResultAsync2(Promise.resolve(new Ok(value)));
+    }
+    function errAsync2(err3) {
+      return new ResultAsync2(Promise.resolve(new Err(err3)));
+    }
+    var fromPromise = ResultAsync2.fromPromise;
+    var fromSafePromise = ResultAsync2.fromSafePromise;
+    var fromAsyncThrowable = ResultAsync2.fromThrowable;
+    var combineResultList = (resultList) => {
+      let acc = ok2([]);
+      for (const result of resultList) {
+        if (result.isErr()) {
+          acc = err2(result.error);
+          break;
+        } else {
+          acc.map((list) => list.push(result.value));
+        }
+      }
+      return acc;
+    };
+    var combineResultAsyncList = (asyncResultList) => ResultAsync2.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+    var combineResultListWithAllErrors = (resultList) => {
+      let acc = ok2([]);
+      for (const result of resultList) {
+        if (result.isErr() && acc.isErr()) {
+          acc.error.push(result.error);
+        } else if (result.isErr() && acc.isOk()) {
+          acc = err2([result.error]);
+        } else if (result.isOk() && acc.isOk()) {
+          acc.value.push(result.value);
+        }
+      }
+      return acc;
+    };
+    var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync2.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+    exports.Result = void 0;
+    (function(Result2) {
+      function fromThrowable3(fn, errorFn) {
+        return (...args) => {
+          try {
+            const result = fn(...args);
+            return ok2(result);
+          } catch (e) {
+            return err2(errorFn ? errorFn(e) : e);
+          }
+        };
+      }
+      Result2.fromThrowable = fromThrowable3;
+      function combine(resultList) {
+        return combineResultList(resultList);
+      }
+      Result2.combine = combine;
+      function combineWithAllErrors(resultList) {
+        return combineResultListWithAllErrors(resultList);
+      }
+      Result2.combineWithAllErrors = combineWithAllErrors;
+    })(exports.Result || (exports.Result = {}));
+    function ok2(value) {
+      return new Ok(value);
+    }
+    function err2(err3) {
+      return new Err(err3);
+    }
+    function safeTry(body) {
+      const n = body().next();
+      if (n instanceof Promise) {
+        return new ResultAsync2(n.then((r) => r.value));
+      }
+      return n.value;
+    }
+    var Ok = class {
+      constructor(value) {
+        this.value = value;
+      }
+      isOk() {
+        return true;
+      }
+      isErr() {
+        return !this.isOk();
+      }
+      map(f) {
+        return ok2(f(this.value));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      mapErr(_f) {
+        return ok2(this.value);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      andThen(f) {
+        return f(this.value);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      andThrough(f) {
+        return f(this.value).map((_value) => this.value);
+      }
+      andTee(f) {
+        try {
+          f(this.value);
+        } catch (e) {
+        }
+        return ok2(this.value);
+      }
+      orTee(_f) {
+        return ok2(this.value);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      orElse(_f) {
+        return ok2(this.value);
+      }
+      asyncAndThen(f) {
+        return f(this.value);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      asyncAndThrough(f) {
+        return f(this.value).map(() => this.value);
+      }
+      asyncMap(f) {
+        return ResultAsync2.fromSafePromise(f(this.value));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      unwrapOr(_v) {
+        return this.value;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      match(ok3, _err) {
+        return ok3(this.value);
+      }
+      safeUnwrap() {
+        const value = this.value;
+        return (function* () {
+          return value;
+        })();
+      }
+      _unsafeUnwrap(_) {
+        return this.value;
+      }
+      _unsafeUnwrapErr(config) {
+        throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-this-alias, require-yield
+      *[Symbol.iterator]() {
+        return this.value;
+      }
+    };
+    var Err = class {
+      constructor(error) {
+        this.error = error;
+      }
+      isOk() {
+        return false;
+      }
+      isErr() {
+        return !this.isOk();
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      map(_f) {
+        return err2(this.error);
+      }
+      mapErr(f) {
+        return err2(f(this.error));
+      }
+      andThrough(_f) {
+        return err2(this.error);
+      }
+      andTee(_f) {
+        return err2(this.error);
+      }
+      orTee(f) {
+        try {
+          f(this.error);
+        } catch (e) {
+        }
+        return err2(this.error);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      andThen(_f) {
+        return err2(this.error);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+      orElse(f) {
+        return f(this.error);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      asyncAndThen(_f) {
+        return errAsync2(this.error);
+      }
+      asyncAndThrough(_f) {
+        return errAsync2(this.error);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      asyncMap(_f) {
+        return errAsync2(this.error);
+      }
+      unwrapOr(v) {
+        return v;
+      }
+      match(_ok, err3) {
+        return err3(this.error);
+      }
+      safeUnwrap() {
+        const error = this.error;
+        return (function* () {
+          yield err2(error);
+          throw new Error("Do not use this generator out of `safeTry`");
+        })();
+      }
+      _unsafeUnwrap(config) {
+        throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+      }
+      _unsafeUnwrapErr(_) {
+        return this.error;
+      }
+      *[Symbol.iterator]() {
+        const self = this;
+        yield self;
+        return self;
+      }
+    };
+    var fromThrowable2 = exports.Result.fromThrowable;
+    exports.Err = Err;
+    exports.Ok = Ok;
+    exports.ResultAsync = ResultAsync2;
+    exports.err = err2;
+    exports.errAsync = errAsync2;
+    exports.fromAsyncThrowable = fromAsyncThrowable;
+    exports.fromPromise = fromPromise;
+    exports.fromSafePromise = fromSafePromise;
+    exports.fromThrowable = fromThrowable2;
+    exports.ok = ok2;
+    exports.okAsync = okAsync2;
+    exports.safeTry = safeTry;
+  }
+});
+
+// src/consumer-neverthrow.ts
+var import_neverthrow = __toESM(require_index_cjs(), 1);
+var export_Result = import_neverthrow.Result;
+var export_ResultAsync = import_neverthrow.ResultAsync;
+var export_err = import_neverthrow.err;
+var export_errAsync = import_neverthrow.errAsync;
+var export_fromThrowable = import_neverthrow.fromThrowable;
+var export_ok = import_neverthrow.ok;
+var export_okAsync = import_neverthrow.okAsync;
+export {
+  export_Result as Result,
+  export_ResultAsync as ResultAsync,
+  export_err as err,
+  export_errAsync as errAsync,
+  export_fromThrowable as fromThrowable,
+  export_ok as ok,
+  export_okAsync as okAsync
+};