@upstash/qstash 2.7.9 → 2.7.11-canary

package/nextjs.js

@@ -1,25 +1,4588 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js
+var require_detect_domain_locale = __commonJS({
+  "node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "detectDomainLocale", {
+      enumerable: true,
+      get: function() {
+        return detectDomainLocale;
+      }
+    });
+    function detectDomainLocale(domainItems, hostname, detectedLocale) {
+      if (!domainItems)
+        return;
+      if (detectedLocale) {
+        detectedLocale = detectedLocale.toLowerCase();
+      }
+      for (const item of domainItems) {
+        var _item_domain, _item_locales;
+        const domainHostname = (_item_domain = item.domain) == null ? void 0 : _item_domain.split(":", 1)[0].toLowerCase();
+        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || ((_item_locales = item.locales) == null ? void 0 : _item_locales.some((locale) => locale.toLowerCase() === detectedLocale))) {
+          return item;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js
+var require_remove_trailing_slash = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "removeTrailingSlash", {
+      enumerable: true,
+      get: function() {
+        return removeTrailingSlash;
+      }
+    });
+    function removeTrailingSlash(route) {
+      return route.replace(/\/$/, "") || "/";
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/parse-path.js
+var require_parse_path = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/parse-path.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "parsePath", {
+      enumerable: true,
+      get: function() {
+        return parsePath;
+      }
+    });
+    function parsePath(path) {
+      const hashIndex = path.indexOf("#");
+      const queryIndex = path.indexOf("?");
+      const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+      if (hasQuery || hashIndex > -1) {
+        return {
+          pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+          query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : void 0) : "",
+          hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+        };
+      }
+      return {
+        pathname: path,
+        query: "",
+        hash: ""
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js
+var require_add_path_prefix = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "addPathPrefix", {
+      enumerable: true,
+      get: function() {
+        return addPathPrefix;
+      }
+    });
+    var _parsepath = require_parse_path();
+    function addPathPrefix(path, prefix) {
+      if (!path.startsWith("/") || !prefix) {
+        return path;
+      }
+      const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+      return "" + prefix + pathname + query + hash;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/add-path-suffix.js
+var require_add_path_suffix = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/add-path-suffix.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "addPathSuffix", {
+      enumerable: true,
+      get: function() {
+        return addPathSuffix;
+      }
+    });
+    var _parsepath = require_parse_path();
+    function addPathSuffix(path, suffix) {
+      if (!path.startsWith("/") || !suffix) {
+        return path;
+      }
+      const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+      return "" + pathname + suffix + query + hash;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js
+var require_path_has_prefix = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "pathHasPrefix", {
+      enumerable: true,
+      get: function() {
+        return pathHasPrefix;
+      }
+    });
+    var _parsepath = require_parse_path();
+    function pathHasPrefix(path, prefix) {
+      if (typeof path !== "string") {
+        return false;
+      }
+      const { pathname } = (0, _parsepath.parsePath)(path);
+      return pathname === prefix || pathname.startsWith(prefix + "/");
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/add-locale.js
+var require_add_locale = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/add-locale.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "addLocale", {
+      enumerable: true,
+      get: function() {
+        return addLocale;
+      }
+    });
+    var _addpathprefix = require_add_path_prefix();
+    var _pathhasprefix = require_path_has_prefix();
+    function addLocale(path, locale, defaultLocale, ignorePrefix) {
+      if (!locale || locale === defaultLocale)
+        return path;
+      const lower = path.toLowerCase();
+      if (!ignorePrefix) {
+        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/api"))
+          return path;
+        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/" + locale.toLowerCase()))
+          return path;
+      }
+      return (0, _addpathprefix.addPathPrefix)(path, "/" + locale);
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/format-next-pathname-info.js
+var require_format_next_pathname_info = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/format-next-pathname-info.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "formatNextPathnameInfo", {
+      enumerable: true,
+      get: function() {
+        return formatNextPathnameInfo;
+      }
+    });
+    var _removetrailingslash = require_remove_trailing_slash();
+    var _addpathprefix = require_add_path_prefix();
+    var _addpathsuffix = require_add_path_suffix();
+    var _addlocale = require_add_locale();
+    function formatNextPathnameInfo(info) {
+      let pathname = (0, _addlocale.addLocale)(info.pathname, info.locale, info.buildId ? void 0 : info.defaultLocale, info.ignorePrefix);
+      if (info.buildId || !info.trailingSlash) {
+        pathname = (0, _removetrailingslash.removeTrailingSlash)(pathname);
+      }
+      if (info.buildId) {
+        pathname = (0, _addpathsuffix.addPathSuffix)((0, _addpathprefix.addPathPrefix)(pathname, "/_next/data/" + info.buildId), info.pathname === "/" ? "index.json" : ".json");
+      }
+      pathname = (0, _addpathprefix.addPathPrefix)(pathname, info.basePath);
+      return !info.buildId && info.trailingSlash ? !pathname.endsWith("/") ? (0, _addpathsuffix.addPathSuffix)(pathname, "/") : pathname : (0, _removetrailingslash.removeTrailingSlash)(pathname);
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/get-hostname.js
+var require_get_hostname = __commonJS({
+  "node_modules/next/dist/shared/lib/get-hostname.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "getHostname", {
+      enumerable: true,
+      get: function() {
+        return getHostname;
+      }
+    });
+    function getHostname(parsed, headers) {
+      let hostname;
+      if ((headers == null ? void 0 : headers.host) && !Array.isArray(headers.host)) {
+        hostname = headers.host.toString().split(":", 1)[0];
+      } else if (parsed.hostname) {
+        hostname = parsed.hostname;
+      } else
+        return;
+      return hostname.toLowerCase();
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js
+var require_normalize_locale_path = __commonJS({
+  "node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "normalizeLocalePath", {
+      enumerable: true,
+      get: function() {
+        return normalizeLocalePath;
+      }
+    });
+    function normalizeLocalePath(pathname, locales) {
+      let detectedLocale;
+      const pathnameParts = pathname.split("/");
+      (locales || []).some((locale) => {
+        if (pathnameParts[1] && pathnameParts[1].toLowerCase() === locale.toLowerCase()) {
+          detectedLocale = locale;
+          pathnameParts.splice(1, 1);
+          pathname = pathnameParts.join("/") || "/";
+          return true;
+        }
+        return false;
+      });
+      return {
+        pathname,
+        detectedLocale
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/remove-path-prefix.js
+var require_remove_path_prefix = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/remove-path-prefix.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "removePathPrefix", {
+      enumerable: true,
+      get: function() {
+        return removePathPrefix;
+      }
+    });
+    var _pathhasprefix = require_path_has_prefix();
+    function removePathPrefix(path, prefix) {
+      if (!(0, _pathhasprefix.pathHasPrefix)(path, prefix)) {
+        return path;
+      }
+      const withoutPrefix = path.slice(prefix.length);
+      if (withoutPrefix.startsWith("/")) {
+        return withoutPrefix;
+      }
+      return "/" + withoutPrefix;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/get-next-pathname-info.js
+var require_get_next_pathname_info = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/get-next-pathname-info.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "getNextPathnameInfo", {
+      enumerable: true,
+      get: function() {
+        return getNextPathnameInfo;
+      }
+    });
+    var _normalizelocalepath = require_normalize_locale_path();
+    var _removepathprefix = require_remove_path_prefix();
+    var _pathhasprefix = require_path_has_prefix();
+    function getNextPathnameInfo(pathname, options) {
+      var _options_nextConfig;
+      const { basePath, i18n, trailingSlash } = (_options_nextConfig = options.nextConfig) != null ? _options_nextConfig : {};
+      const info = {
+        pathname,
+        trailingSlash: pathname !== "/" ? pathname.endsWith("/") : trailingSlash
+      };
+      if (basePath && (0, _pathhasprefix.pathHasPrefix)(info.pathname, basePath)) {
+        info.pathname = (0, _removepathprefix.removePathPrefix)(info.pathname, basePath);
+        info.basePath = basePath;
+      }
+      let pathnameNoDataPrefix = info.pathname;
+      if (info.pathname.startsWith("/_next/data/") && info.pathname.endsWith(".json")) {
+        const paths = info.pathname.replace(/^\/_next\/data\//, "").replace(/\.json$/, "").split("/");
+        const buildId = paths[0];
+        info.buildId = buildId;
+        pathnameNoDataPrefix = paths[1] !== "index" ? "/" + paths.slice(1).join("/") : "/";
+        if (options.parseData === true) {
+          info.pathname = pathnameNoDataPrefix;
+        }
+      }
+      if (i18n) {
+        let result = options.i18nProvider ? options.i18nProvider.analyze(info.pathname) : (0, _normalizelocalepath.normalizeLocalePath)(info.pathname, i18n.locales);
+        info.locale = result.detectedLocale;
+        var _result_pathname;
+        info.pathname = (_result_pathname = result.pathname) != null ? _result_pathname : info.pathname;
+        if (!result.detectedLocale && info.buildId) {
+          result = options.i18nProvider ? options.i18nProvider.analyze(pathnameNoDataPrefix) : (0, _normalizelocalepath.normalizeLocalePath)(pathnameNoDataPrefix, i18n.locales);
+          if (result.detectedLocale) {
+            info.locale = result.detectedLocale;
+          }
+        }
+      }
+      return info;
+    }
+  }
+});
+
+// node_modules/next/dist/server/web/next-url.js
+var require_next_url = __commonJS({
+  "node_modules/next/dist/server/web/next-url.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "NextURL", {
+      enumerable: true,
+      get: function() {
+        return NextURL;
+      }
+    });
+    var _detectdomainlocale = require_detect_domain_locale();
+    var _formatnextpathnameinfo = require_format_next_pathname_info();
+    var _gethostname = require_get_hostname();
+    var _getnextpathnameinfo = require_get_next_pathname_info();
+    var REGEX_LOCALHOST_HOSTNAME = /(?!^https?:\/\/)(127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}|\[::1\]|localhost)/;
+    function parseURL(url, base) {
+      return new URL(String(url).replace(REGEX_LOCALHOST_HOSTNAME, "localhost"), base && String(base).replace(REGEX_LOCALHOST_HOSTNAME, "localhost"));
+    }
+    var Internal = Symbol("NextURLInternal");
+    var NextURL = class _NextURL {
+      constructor(input, baseOrOpts, opts) {
+        let base;
+        let options;
+        if (typeof baseOrOpts === "object" && "pathname" in baseOrOpts || typeof baseOrOpts === "string") {
+          base = baseOrOpts;
+          options = opts || {};
+        } else {
+          options = opts || baseOrOpts || {};
+        }
+        this[Internal] = {
+          url: parseURL(input, base ?? options.base),
+          options,
+          basePath: ""
+        };
+        this.analyze();
+      }
+      analyze() {
+        var _this_Internal_options_nextConfig_i18n, _this_Internal_options_nextConfig, _this_Internal_domainLocale, _this_Internal_options_nextConfig_i18n1, _this_Internal_options_nextConfig1;
+        const info = (0, _getnextpathnameinfo.getNextPathnameInfo)(this[Internal].url.pathname, {
+          nextConfig: this[Internal].options.nextConfig,
+          parseData: !process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE,
+          i18nProvider: this[Internal].options.i18nProvider
+        });
+        const hostname = (0, _gethostname.getHostname)(this[Internal].url, this[Internal].options.headers);
+        this[Internal].domainLocale = this[Internal].options.i18nProvider ? this[Internal].options.i18nProvider.detectDomainLocale(hostname) : (0, _detectdomainlocale.detectDomainLocale)((_this_Internal_options_nextConfig = this[Internal].options.nextConfig) == null ? void 0 : (_this_Internal_options_nextConfig_i18n = _this_Internal_options_nextConfig.i18n) == null ? void 0 : _this_Internal_options_nextConfig_i18n.domains, hostname);
+        const defaultLocale = ((_this_Internal_domainLocale = this[Internal].domainLocale) == null ? void 0 : _this_Internal_domainLocale.defaultLocale) || ((_this_Internal_options_nextConfig1 = this[Internal].options.nextConfig) == null ? void 0 : (_this_Internal_options_nextConfig_i18n1 = _this_Internal_options_nextConfig1.i18n) == null ? void 0 : _this_Internal_options_nextConfig_i18n1.defaultLocale);
+        this[Internal].url.pathname = info.pathname;
+        this[Internal].defaultLocale = defaultLocale;
+        this[Internal].basePath = info.basePath ?? "";
+        this[Internal].buildId = info.buildId;
+        this[Internal].locale = info.locale ?? defaultLocale;
+        this[Internal].trailingSlash = info.trailingSlash;
+      }
+      formatPathname() {
+        return (0, _formatnextpathnameinfo.formatNextPathnameInfo)({
+          basePath: this[Internal].basePath,
+          buildId: this[Internal].buildId,
+          defaultLocale: !this[Internal].options.forceLocale ? this[Internal].defaultLocale : void 0,
+          locale: this[Internal].locale,
+          pathname: this[Internal].url.pathname,
+          trailingSlash: this[Internal].trailingSlash
+        });
+      }
+      formatSearch() {
+        return this[Internal].url.search;
+      }
+      get buildId() {
+        return this[Internal].buildId;
+      }
+      set buildId(buildId) {
+        this[Internal].buildId = buildId;
+      }
+      get locale() {
+        return this[Internal].locale ?? "";
+      }
+      set locale(locale) {
+        var _this_Internal_options_nextConfig_i18n, _this_Internal_options_nextConfig;
+        if (!this[Internal].locale || !((_this_Internal_options_nextConfig = this[Internal].options.nextConfig) == null ? void 0 : (_this_Internal_options_nextConfig_i18n = _this_Internal_options_nextConfig.i18n) == null ? void 0 : _this_Internal_options_nextConfig_i18n.locales.includes(locale))) {
+          throw new TypeError(`The NextURL configuration includes no locale "${locale}"`);
+        }
+        this[Internal].locale = locale;
+      }
+      get defaultLocale() {
+        return this[Internal].defaultLocale;
+      }
+      get domainLocale() {
+        return this[Internal].domainLocale;
+      }
+      get searchParams() {
+        return this[Internal].url.searchParams;
+      }
+      get host() {
+        return this[Internal].url.host;
+      }
+      set host(value) {
+        this[Internal].url.host = value;
+      }
+      get hostname() {
+        return this[Internal].url.hostname;
+      }
+      set hostname(value) {
+        this[Internal].url.hostname = value;
+      }
+      get port() {
+        return this[Internal].url.port;
+      }
+      set port(value) {
+        this[Internal].url.port = value;
+      }
+      get protocol() {
+        return this[Internal].url.protocol;
+      }
+      set protocol(value) {
+        this[Internal].url.protocol = value;
+      }
+      get href() {
+        const pathname = this.formatPathname();
+        const search = this.formatSearch();
+        return `${this.protocol}//${this.host}${pathname}${search}${this.hash}`;
+      }
+      set href(url) {
+        this[Internal].url = parseURL(url);
+        this.analyze();
+      }
+      get origin() {
+        return this[Internal].url.origin;
+      }
+      get pathname() {
+        return this[Internal].url.pathname;
+      }
+      set pathname(value) {
+        this[Internal].url.pathname = value;
+      }
+      get hash() {
+        return this[Internal].url.hash;
+      }
+      set hash(value) {
+        this[Internal].url.hash = value;
+      }
+      get search() {
+        return this[Internal].url.search;
+      }
+      set search(value) {
+        this[Internal].url.search = value;
+      }
+      get password() {
+        return this[Internal].url.password;
+      }
+      set password(value) {
+        this[Internal].url.password = value;
+      }
+      get username() {
+        return this[Internal].url.username;
+      }
+      set username(value) {
+        this[Internal].url.username = value;
+      }
+      get basePath() {
+        return this[Internal].basePath;
+      }
+      set basePath(value) {
+        this[Internal].basePath = value.startsWith("/") ? value : `/${value}`;
+      }
+      toString() {
+        return this.href;
+      }
+      toJSON() {
+        return this.href;
+      }
+      [Symbol.for("edge-runtime.inspect.custom")]() {
+        return {
+          href: this.href,
+          origin: this.origin,
+          protocol: this.protocol,
+          username: this.username,
+          password: this.password,
+          host: this.host,
+          hostname: this.hostname,
+          port: this.port,
+          pathname: this.pathname,
+          search: this.search,
+          searchParams: this.searchParams,
+          hash: this.hash
+        };
+      }
+      clone() {
+        return new _NextURL(String(this), this[Internal].options);
+      }
+    };
+  }
+});
+
+// node_modules/next/dist/server/web/utils.js
+var require_utils = __commonJS({
+  "node_modules/next/dist/server/web/utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports2, {
+      fromNodeOutgoingHttpHeaders: function() {
+        return fromNodeOutgoingHttpHeaders;
+      },
+      splitCookiesString: function() {
+        return splitCookiesString;
+      },
+      toNodeOutgoingHttpHeaders: function() {
+        return toNodeOutgoingHttpHeaders;
+      },
+      validateURL: function() {
+        return validateURL;
+      }
+    });
+    function fromNodeOutgoingHttpHeaders(nodeHeaders) {
+      const headers = new Headers();
+      for (let [key, value] of Object.entries(nodeHeaders)) {
+        const values = Array.isArray(value) ? value : [
+          value
+        ];
+        for (let v of values) {
+          if (typeof v === "undefined")
+            continue;
+          if (typeof v === "number") {
+            v = v.toString();
+          }
+          headers.append(key, v);
+        }
+      }
+      return headers;
+    }
+    function splitCookiesString(cookiesString) {
+      var cookiesStrings = [];
+      var pos = 0;
+      var start;
+      var ch;
+      var lastComma;
+      var nextStart;
+      var cookiesSeparatorFound;
+      function skipWhitespace() {
+        while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+          pos += 1;
+        }
+        return pos < cookiesString.length;
+      }
+      function notSpecialChar() {
+        ch = cookiesString.charAt(pos);
+        return ch !== "=" && ch !== ";" && ch !== ",";
+      }
+      while (pos < cookiesString.length) {
+        start = pos;
+        cookiesSeparatorFound = false;
+        while (skipWhitespace()) {
+          ch = cookiesString.charAt(pos);
+          if (ch === ",") {
+            lastComma = pos;
+            pos += 1;
+            skipWhitespace();
+            nextStart = pos;
+            while (pos < cookiesString.length && notSpecialChar()) {
+              pos += 1;
+            }
+            if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+              cookiesSeparatorFound = true;
+              pos = nextStart;
+              cookiesStrings.push(cookiesString.substring(start, lastComma));
+              start = pos;
+            } else {
+              pos = lastComma + 1;
+            }
+          } else {
+            pos += 1;
+          }
+        }
+        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+        }
+      }
+      return cookiesStrings;
+    }
+    function toNodeOutgoingHttpHeaders(headers) {
+      const nodeHeaders = {};
+      const cookies = [];
+      if (headers) {
+        for (const [key, value] of headers.entries()) {
+          if (key.toLowerCase() === "set-cookie") {
+            cookies.push(...splitCookiesString(value));
+            nodeHeaders[key] = cookies.length === 1 ? cookies[0] : cookies;
+          } else {
+            nodeHeaders[key] = value;
+          }
+        }
+      }
+      return nodeHeaders;
+    }
+    function validateURL(url) {
+      try {
+        return String(new URL(String(url)));
+      } catch (error) {
+        throw new Error(`URL is malformed "${String(url)}". Please use only absolute URLs - https://nextjs.org/docs/messages/middleware-relative-urls`, {
+          cause: error
+        });
+      }
+    }
+  }
+});
+
+// node_modules/next/dist/server/web/error.js
+var require_error = __commonJS({
+  "node_modules/next/dist/server/web/error.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports2, {
+      PageSignatureError: function() {
+        return PageSignatureError;
+      },
+      RemovedPageError: function() {
+        return RemovedPageError;
+      },
+      RemovedUAError: function() {
+        return RemovedUAError;
+      }
+    });
+    var PageSignatureError = class extends Error {
+      constructor({ page }) {
+        super(`The middleware "${page}" accepts an async API directly with the form:
+  
+  export function middleware(request, event) {
+    return NextResponse.redirect('/new-location')
+  }
+  
+  Read more: https://nextjs.org/docs/messages/middleware-new-signature
+  `);
+      }
+    };
+    var RemovedPageError = class extends Error {
+      constructor() {
+        super(`The request.page has been deprecated in favour of \`URLPattern\`.
+  Read more: https://nextjs.org/docs/messages/middleware-request-page
+  `);
+      }
+    };
+    var RemovedUAError = class extends Error {
+      constructor() {
+        super(`The request.ua has been removed in favour of \`userAgent\` function.
+  Read more: https://nextjs.org/docs/messages/middleware-parse-user-agent
+  `);
+      }
+    };
+  }
+});
+
+// node_modules/next/dist/compiled/@edge-runtime/cookies/index.js
+var require_cookies = __commonJS({
+  "node_modules/next/dist/compiled/@edge-runtime/cookies/index.js"(exports2, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export2(src_exports, {
+      RequestCookies: () => RequestCookies,
+      ResponseCookies: () => ResponseCookies,
+      parseCookie: () => parseCookie,
+      parseSetCookie: () => parseSetCookie,
+      stringifyCookie: () => stringifyCookie
+    });
+    module2.exports = __toCommonJS2(src_exports);
+    function stringifyCookie(c) {
+      var _a;
+      const attrs = [
+        "path" in c && c.path && `Path=${c.path}`,
+        "expires" in c && (c.expires || c.expires === 0) && `Expires=${(typeof c.expires === "number" ? new Date(c.expires) : c.expires).toUTCString()}`,
+        "maxAge" in c && typeof c.maxAge === "number" && `Max-Age=${c.maxAge}`,
+        "domain" in c && c.domain && `Domain=${c.domain}`,
+        "secure" in c && c.secure && "Secure",
+        "httpOnly" in c && c.httpOnly && "HttpOnly",
+        "sameSite" in c && c.sameSite && `SameSite=${c.sameSite}`,
+        "partitioned" in c && c.partitioned && "Partitioned",
+        "priority" in c && c.priority && `Priority=${c.priority}`
+      ].filter(Boolean);
+      const stringified = `${c.name}=${encodeURIComponent((_a = c.value) != null ? _a : "")}`;
+      return attrs.length === 0 ? stringified : `${stringified}; ${attrs.join("; ")}`;
+    }
+    function parseCookie(cookie) {
+      const map = /* @__PURE__ */ new Map();
+      for (const pair of cookie.split(/; */)) {
+        if (!pair)
+          continue;
+        const splitAt = pair.indexOf("=");
+        if (splitAt === -1) {
+          map.set(pair, "true");
+          continue;
+        }
+        const [key, value] = [pair.slice(0, splitAt), pair.slice(splitAt + 1)];
+        try {
+          map.set(key, decodeURIComponent(value != null ? value : "true"));
+        } catch {
+        }
+      }
+      return map;
+    }
+    function parseSetCookie(setCookie) {
+      if (!setCookie) {
+        return void 0;
+      }
+      const [[name, value], ...attributes] = parseCookie(setCookie);
+      const {
+        domain,
+        expires,
+        httponly,
+        maxage,
+        path,
+        samesite,
+        secure,
+        partitioned,
+        priority
+      } = Object.fromEntries(
+        attributes.map(([key, value2]) => [key.toLowerCase(), value2])
+      );
+      const cookie = {
+        name,
+        value: decodeURIComponent(value),
+        domain,
+        ...expires && { expires: new Date(expires) },
+        ...httponly && { httpOnly: true },
+        ...typeof maxage === "string" && { maxAge: Number(maxage) },
+        path,
+        ...samesite && { sameSite: parseSameSite(samesite) },
+        ...secure && { secure: true },
+        ...priority && { priority: parsePriority(priority) },
+        ...partitioned && { partitioned: true }
+      };
+      return compact(cookie);
+    }
+    function compact(t) {
+      const newT = {};
+      for (const key in t) {
+        if (t[key]) {
+          newT[key] = t[key];
+        }
+      }
+      return newT;
+    }
+    var SAME_SITE = ["strict", "lax", "none"];
+    function parseSameSite(string) {
+      string = string.toLowerCase();
+      return SAME_SITE.includes(string) ? string : void 0;
+    }
+    var PRIORITY = ["low", "medium", "high"];
+    function parsePriority(string) {
+      string = string.toLowerCase();
+      return PRIORITY.includes(string) ? string : void 0;
+    }
+    function splitCookiesString(cookiesString) {
+      if (!cookiesString)
+        return [];
+      var cookiesStrings = [];
+      var pos = 0;
+      var start;
+      var ch;
+      var lastComma;
+      var nextStart;
+      var cookiesSeparatorFound;
+      function skipWhitespace() {
+        while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+          pos += 1;
+        }
+        return pos < cookiesString.length;
+      }
+      function notSpecialChar() {
+        ch = cookiesString.charAt(pos);
+        return ch !== "=" && ch !== ";" && ch !== ",";
+      }
+      while (pos < cookiesString.length) {
+        start = pos;
+        cookiesSeparatorFound = false;
+        while (skipWhitespace()) {
+          ch = cookiesString.charAt(pos);
+          if (ch === ",") {
+            lastComma = pos;
+            pos += 1;
+            skipWhitespace();
+            nextStart = pos;
+            while (pos < cookiesString.length && notSpecialChar()) {
+              pos += 1;
+            }
+            if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+              cookiesSeparatorFound = true;
+              pos = nextStart;
+              cookiesStrings.push(cookiesString.substring(start, lastComma));
+              start = pos;
+            } else {
+              pos = lastComma + 1;
+            }
+          } else {
+            pos += 1;
+          }
+        }
+        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+        }
+      }
+      return cookiesStrings;
+    }
+    var RequestCookies = class {
+      constructor(requestHeaders) {
+        this._parsed = /* @__PURE__ */ new Map();
+        this._headers = requestHeaders;
+        const header = requestHeaders.get("cookie");
+        if (header) {
+          const parsed = parseCookie(header);
+          for (const [name, value] of parsed) {
+            this._parsed.set(name, { name, value });
+          }
+        }
+      }
+      [Symbol.iterator]() {
+        return this._parsed[Symbol.iterator]();
+      }
+      /**
+       * The amount of cookies received from the client
+       */
+      get size() {
+        return this._parsed.size;
+      }
+      get(...args) {
+        const name = typeof args[0] === "string" ? args[0] : args[0].name;
+        return this._parsed.get(name);
+      }
+      getAll(...args) {
+        var _a;
+        const all = Array.from(this._parsed);
+        if (!args.length) {
+          return all.map(([_, value]) => value);
+        }
+        const name = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+        return all.filter(([n]) => n === name).map(([_, value]) => value);
+      }
+      has(name) {
+        return this._parsed.has(name);
+      }
+      set(...args) {
+        const [name, value] = args.length === 1 ? [args[0].name, args[0].value] : args;
+        const map = this._parsed;
+        map.set(name, { name, value });
+        this._headers.set(
+          "cookie",
+          Array.from(map).map(([_, value2]) => stringifyCookie(value2)).join("; ")
+        );
+        return this;
+      }
+      /**
+       * Delete the cookies matching the passed name or names in the request.
+       */
+      delete(names) {
+        const map = this._parsed;
+        const result = !Array.isArray(names) ? map.delete(names) : names.map((name) => map.delete(name));
+        this._headers.set(
+          "cookie",
+          Array.from(map).map(([_, value]) => stringifyCookie(value)).join("; ")
+        );
+        return result;
+      }
+      /**
+       * Delete all the cookies in the cookies in the request.
+       */
+      clear() {
+        this.delete(Array.from(this._parsed.keys()));
+        return this;
+      }
+      /**
+       * Format the cookies in the request as a string for logging
+       */
+      [Symbol.for("edge-runtime.inspect.custom")]() {
+        return `RequestCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+      }
+      toString() {
+        return [...this._parsed.values()].map((v) => `${v.name}=${encodeURIComponent(v.value)}`).join("; ");
+      }
+    };
+    var ResponseCookies = class {
+      constructor(responseHeaders) {
+        this._parsed = /* @__PURE__ */ new Map();
+        var _a, _b, _c;
+        this._headers = responseHeaders;
+        const setCookie = (_c = (_b = (_a = responseHeaders.getSetCookie) == null ? void 0 : _a.call(responseHeaders)) != null ? _b : responseHeaders.get("set-cookie")) != null ? _c : [];
+        const cookieStrings = Array.isArray(setCookie) ? setCookie : splitCookiesString(setCookie);
+        for (const cookieString of cookieStrings) {
+          const parsed = parseSetCookie(cookieString);
+          if (parsed)
+            this._parsed.set(parsed.name, parsed);
+        }
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+       */
+      get(...args) {
+        const key = typeof args[0] === "string" ? args[0] : args[0].name;
+        return this._parsed.get(key);
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+       */
+      getAll(...args) {
+        var _a;
+        const all = Array.from(this._parsed.values());
+        if (!args.length) {
+          return all;
+        }
+        const key = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+        return all.filter((c) => c.name === key);
+      }
+      has(name) {
+        return this._parsed.has(name);
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+       */
+      set(...args) {
+        const [name, value, cookie] = args.length === 1 ? [args[0].name, args[0].value, args[0]] : args;
+        const map = this._parsed;
+        map.set(name, normalizeCookie({ name, value, ...cookie }));
+        replace(map, this._headers);
+        return this;
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+       */
+      delete(...args) {
+        const [name, path, domain] = typeof args[0] === "string" ? [args[0]] : [args[0].name, args[0].path, args[0].domain];
+        return this.set({ name, path, domain, value: "", expires: /* @__PURE__ */ new Date(0) });
+      }
+      [Symbol.for("edge-runtime.inspect.custom")]() {
+        return `ResponseCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+      }
+      toString() {
+        return [...this._parsed.values()].map(stringifyCookie).join("; ");
+      }
+    };
+    function replace(bag, headers) {
+      headers.delete("set-cookie");
+      for (const [, value] of bag) {
+        const serialized = stringifyCookie(value);
+        headers.append("set-cookie", serialized);
+      }
+    }
+    function normalizeCookie(cookie = { name: "", value: "" }) {
+      if (typeof cookie.expires === "number") {
+        cookie.expires = new Date(cookie.expires);
+      }
+      if (cookie.maxAge) {
+        cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
+      }
+      if (cookie.path === null || cookie.path === void 0) {
+        cookie.path = "/";
+      }
+      return cookie;
+    }
+  }
+});
+
+// node_modules/next/dist/server/web/spec-extension/cookies.js
+var require_cookies2 = __commonJS({
+  "node_modules/next/dist/server/web/spec-extension/cookies.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports2, {
+      RequestCookies: function() {
+        return _cookies.RequestCookies;
+      },
+      ResponseCookies: function() {
+        return _cookies.ResponseCookies;
+      }
+    });
+    var _cookies = require_cookies();
+  }
+});
+
+// node_modules/next/dist/server/web/spec-extension/request.js
+var require_request = __commonJS({
+  "node_modules/next/dist/server/web/spec-extension/request.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports2, {
+      INTERNALS: function() {
+        return INTERNALS;
+      },
+      NextRequest: function() {
+        return NextRequest;
+      }
+    });
+    var _nexturl = require_next_url();
+    var _utils = require_utils();
+    var _error = require_error();
+    var _cookies = require_cookies2();
+    var INTERNALS = Symbol("internal request");
+    var NextRequest = class extends Request {
+      constructor(input, init = {}) {
+        const url = typeof input !== "string" && "url" in input ? input.url : String(input);
+        (0, _utils.validateURL)(url);
+        if (input instanceof Request)
+          super(input, init);
+        else
+          super(url, init);
+        const nextUrl = new _nexturl.NextURL(url, {
+          headers: (0, _utils.toNodeOutgoingHttpHeaders)(this.headers),
+          nextConfig: init.nextConfig
+        });
+        this[INTERNALS] = {
+          cookies: new _cookies.RequestCookies(this.headers),
+          geo: init.geo || {},
+          ip: init.ip,
+          nextUrl,
+          url: process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE ? url : nextUrl.toString()
+        };
+      }
+      [Symbol.for("edge-runtime.inspect.custom")]() {
+        return {
+          cookies: this.cookies,
+          geo: this.geo,
+          ip: this.ip,
+          nextUrl: this.nextUrl,
+          url: this.url,
+          // rest of props come from Request
+          bodyUsed: this.bodyUsed,
+          cache: this.cache,
+          credentials: this.credentials,
+          destination: this.destination,
+          headers: Object.fromEntries(this.headers),
+          integrity: this.integrity,
+          keepalive: this.keepalive,
+          method: this.method,
+          mode: this.mode,
+          redirect: this.redirect,
+          referrer: this.referrer,
+          referrerPolicy: this.referrerPolicy,
+          signal: this.signal
+        };
+      }
+      get cookies() {
+        return this[INTERNALS].cookies;
+      }
+      get geo() {
+        return this[INTERNALS].geo;
+      }
+      get ip() {
+        return this[INTERNALS].ip;
+      }
+      get nextUrl() {
+        return this[INTERNALS].nextUrl;
+      }
+      /**
+      * @deprecated
+      * `page` has been deprecated in favour of `URLPattern`.
+      * Read more: https://nextjs.org/docs/messages/middleware-request-page
+      */
+      get page() {
+        throw new _error.RemovedPageError();
+      }
+      /**
+      * @deprecated
+      * `ua` has been removed in favour of \`userAgent\` function.
+      * Read more: https://nextjs.org/docs/messages/middleware-parse-user-agent
+      */
+      get ua() {
+        throw new _error.RemovedUAError();
+      }
+      get url() {
+        return this[INTERNALS].url;
+      }
+    };
+  }
+});
+
+// node_modules/next/dist/server/web/spec-extension/response.js
+var require_response = __commonJS({
+  "node_modules/next/dist/server/web/spec-extension/response.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "NextResponse", {
+      enumerable: true,
+      get: function() {
+        return NextResponse2;
+      }
+    });
+    var _nexturl = require_next_url();
+    var _utils = require_utils();
+    var _cookies = require_cookies2();
+    var INTERNALS = Symbol("internal response");
+    var REDIRECTS = /* @__PURE__ */ new Set([
+      301,
+      302,
+      303,
+      307,
+      308
+    ]);
+    function handleMiddlewareField(init, headers) {
+      var _init_request;
+      if (init == null ? void 0 : (_init_request = init.request) == null ? void 0 : _init_request.headers) {
+        if (!(init.request.headers instanceof Headers)) {
+          throw new Error("request.headers must be an instance of Headers");
+        }
+        const keys = [];
+        for (const [key, value] of init.request.headers) {
+          headers.set("x-middleware-request-" + key, value);
+          keys.push(key);
+        }
+        headers.set("x-middleware-override-headers", keys.join(","));
+      }
+    }
+    var NextResponse2 = class _NextResponse extends Response {
+      constructor(body, init = {}) {
+        super(body, init);
+        this[INTERNALS] = {
+          cookies: new _cookies.ResponseCookies(this.headers),
+          url: init.url ? new _nexturl.NextURL(init.url, {
+            headers: (0, _utils.toNodeOutgoingHttpHeaders)(this.headers),
+            nextConfig: init.nextConfig
+          }) : void 0
+        };
+      }
+      [Symbol.for("edge-runtime.inspect.custom")]() {
+        return {
+          cookies: this.cookies,
+          url: this.url,
+          // rest of props come from Response
+          body: this.body,
+          bodyUsed: this.bodyUsed,
+          headers: Object.fromEntries(this.headers),
+          ok: this.ok,
+          redirected: this.redirected,
+          status: this.status,
+          statusText: this.statusText,
+          type: this.type
+        };
+      }
+      get cookies() {
+        return this[INTERNALS].cookies;
+      }
+      static json(body, init) {
+        const response = Response.json(body, init);
+        return new _NextResponse(response.body, response);
+      }
+      static redirect(url, init) {
+        const status = typeof init === "number" ? init : (init == null ? void 0 : init.status) ?? 307;
+        if (!REDIRECTS.has(status)) {
+          throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+        }
+        const initObj = typeof init === "object" ? init : {};
+        const headers = new Headers(initObj == null ? void 0 : initObj.headers);
+        headers.set("Location", (0, _utils.validateURL)(url));
+        return new _NextResponse(null, {
+          ...initObj,
+          headers,
+          status
+        });
+      }
+      static rewrite(destination, init) {
+        const headers = new Headers(init == null ? void 0 : init.headers);
+        headers.set("x-middleware-rewrite", (0, _utils.validateURL)(destination));
+        handleMiddlewareField(init, headers);
+        return new _NextResponse(null, {
+          ...init,
+          headers
+        });
+      }
+      static next(init) {
+        const headers = new Headers(init == null ? void 0 : init.headers);
+        headers.set("x-middleware-next", "1");
+        handleMiddlewareField(init, headers);
+        return new _NextResponse(null, {
+          ...init,
+          headers
+        });
+      }
+    };
+  }
+});
+
+// node_modules/next/dist/server/web/spec-extension/image-response.js
+var require_image_response = __commonJS({
+  "node_modules/next/dist/server/web/spec-extension/image-response.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "ImageResponse", {
+      enumerable: true,
+      get: function() {
+        return ImageResponse;
+      }
+    });
+    function ImageResponse() {
+      throw new Error('ImageResponse moved from "next/server" to "next/og" since Next.js 14, please import from "next/og" instead');
+    }
+  }
+});
+
+// node_modules/next/dist/compiled/ua-parser-js/ua-parser.js
+var require_ua_parser = __commonJS({
+  "node_modules/next/dist/compiled/ua-parser-js/ua-parser.js"(exports2, module2) {
+    "use strict";
+    (() => {
+      var i = { 226: function(i2, e2) {
+        (function(o2, a) {
+          "use strict";
+          var r = "1.0.35", t = "", n = "?", s = "function", b = "undefined", w = "object", l = "string", d = "major", c = "model", u = "name", p = "type", m = "vendor", f = "version", h = "architecture", v = "console", g = "mobile", k = "tablet", x = "smarttv", _ = "wearable", y = "embedded", q = 350;
+          var T = "Amazon", S = "Apple", z = "ASUS", N = "BlackBerry", A = "Browser", C = "Chrome", E = "Edge", O = "Firefox", U = "Google", j = "Huawei", P = "LG", R = "Microsoft", M = "Motorola", B = "Opera", V = "Samsung", D = "Sharp", I = "Sony", W = "Viera", F = "Xiaomi", G = "Zebra", H = "Facebook", L = "Chromium OS", Z = "Mac OS";
+          var extend = function(i3, e3) {
+            var o3 = {};
+            for (var a2 in i3) {
+              if (e3[a2] && e3[a2].length % 2 === 0) {
+                o3[a2] = e3[a2].concat(i3[a2]);
+              } else {
+                o3[a2] = i3[a2];
+              }
+            }
+            return o3;
+          }, enumerize = function(i3) {
+            var e3 = {};
+            for (var o3 = 0; o3 < i3.length; o3++) {
+              e3[i3[o3].toUpperCase()] = i3[o3];
+            }
+            return e3;
+          }, has = function(i3, e3) {
+            return typeof i3 === l ? lowerize(e3).indexOf(lowerize(i3)) !== -1 : false;
+          }, lowerize = function(i3) {
+            return i3.toLowerCase();
+          }, majorize = function(i3) {
+            return typeof i3 === l ? i3.replace(/[^\d\.]/g, t).split(".")[0] : a;
+          }, trim = function(i3, e3) {
+            if (typeof i3 === l) {
+              i3 = i3.replace(/^\s\s*/, t);
+              return typeof e3 === b ? i3 : i3.substring(0, q);
+            }
+          };
+          var rgxMapper = function(i3, e3) {
+            var o3 = 0, r2, t2, n2, b2, l2, d2;
+            while (o3 < e3.length && !l2) {
+              var c2 = e3[o3], u2 = e3[o3 + 1];
+              r2 = t2 = 0;
+              while (r2 < c2.length && !l2) {
+                if (!c2[r2]) {
+                  break;
+                }
+                l2 = c2[r2++].exec(i3);
+                if (!!l2) {
+                  for (n2 = 0; n2 < u2.length; n2++) {
+                    d2 = l2[++t2];
+                    b2 = u2[n2];
+                    if (typeof b2 === w && b2.length > 0) {
+                      if (b2.length === 2) {
+                        if (typeof b2[1] == s) {
+                          this[b2[0]] = b2[1].call(this, d2);
+                        } else {
+                          this[b2[0]] = b2[1];
+                        }
+                      } else if (b2.length === 3) {
+                        if (typeof b2[1] === s && !(b2[1].exec && b2[1].test)) {
+                          this[b2[0]] = d2 ? b2[1].call(this, d2, b2[2]) : a;
+                        } else {
+                          this[b2[0]] = d2 ? d2.replace(b2[1], b2[2]) : a;
+                        }
+                      } else if (b2.length === 4) {
+                        this[b2[0]] = d2 ? b2[3].call(this, d2.replace(b2[1], b2[2])) : a;
+                      }
+                    } else {
+                      this[b2] = d2 ? d2 : a;
+                    }
+                  }
+                }
+              }
+              o3 += 2;
+            }
+          }, strMapper = function(i3, e3) {
+            for (var o3 in e3) {
+              if (typeof e3[o3] === w && e3[o3].length > 0) {
+                for (var r2 = 0; r2 < e3[o3].length; r2++) {
+                  if (has(e3[o3][r2], i3)) {
+                    return o3 === n ? a : o3;
+                  }
+                }
+              } else if (has(e3[o3], i3)) {
+                return o3 === n ? a : o3;
+              }
+            }
+            return i3;
+          };
+          var $ = { "1.0": "/8", 1.2: "/1", 1.3: "/3", "2.0": "/412", "2.0.2": "/416", "2.0.3": "/417", "2.0.4": "/419", "?": "/" }, X = { ME: "4.90", "NT 3.11": "NT3.51", "NT 4.0": "NT4.0", 2e3: "NT 5.0", XP: ["NT 5.1", "NT 5.2"], Vista: "NT 6.0", 7: "NT 6.1", 8: "NT 6.2", 8.1: "NT 6.3", 10: ["NT 6.4", "NT 10.0"], RT: "ARM" };
+          var K = { browser: [[/\b(?:crmo|crios)\/([\w\.]+)/i], [f, [u, "Chrome"]], [/edg(?:e|ios|a)?\/([\w\.]+)/i], [f, [u, "Edge"]], [/(opera mini)\/([-\w\.]+)/i, /(opera [mobiletab]{3,6})\b.+version\/([-\w\.]+)/i, /(opera)(?:.+version\/|[\/ ]+)([\w\.]+)/i], [u, f], [/opios[\/ ]+([\w\.]+)/i], [f, [u, B + " Mini"]], [/\bopr\/([\w\.]+)/i], [f, [u, B]], [/(kindle)\/([\w\.]+)/i, /(lunascape|maxthon|netfront|jasmine|blazer)[\/ ]?([\w\.]*)/i, /(avant |iemobile|slim)(?:browser)?[\/ ]?([\w\.]*)/i, /(ba?idubrowser)[\/ ]?([\w\.]+)/i, /(?:ms|\()(ie) ([\w\.]+)/i, /(flock|rockmelt|midori|epiphany|silk|skyfire|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon|rekonq|puffin|brave|whale(?!.+naver)|qqbrowserlite|qq|duckduckgo)\/([-\w\.]+)/i, /(heytap|ovi)browser\/([\d\.]+)/i, /(weibo)__([\d\.]+)/i], [u, f], [/(?:\buc? ?browser|(?:juc.+)ucweb)[\/ ]?([\w\.]+)/i], [f, [u, "UC" + A]], [/microm.+\bqbcore\/([\w\.]+)/i, /\bqbcore\/([\w\.]+).+microm/i], [f, [u, "WeChat(Win) Desktop"]], [/micromessenger\/([\w\.]+)/i], [f, [u, "WeChat"]], [/konqueror\/([\w\.]+)/i], [f, [u, "Konqueror"]], [/trident.+rv[: ]([\w\.]{1,9})\b.+like gecko/i], [f, [u, "IE"]], [/ya(?:search)?browser\/([\w\.]+)/i], [f, [u, "Yandex"]], [/(avast|avg)\/([\w\.]+)/i], [[u, /(.+)/, "$1 Secure " + A], f], [/\bfocus\/([\w\.]+)/i], [f, [u, O + " Focus"]], [/\bopt\/([\w\.]+)/i], [f, [u, B + " Touch"]], [/coc_coc\w+\/([\w\.]+)/i], [f, [u, "Coc Coc"]], [/dolfin\/([\w\.]+)/i], [f, [u, "Dolphin"]], [/coast\/([\w\.]+)/i], [f, [u, B + " Coast"]], [/miuibrowser\/([\w\.]+)/i], [f, [u, "MIUI " + A]], [/fxios\/([-\w\.]+)/i], [f, [u, O]], [/\bqihu|(qi?ho?o?|360)browser/i], [[u, "360 " + A]], [/(oculus|samsung|sailfish|huawei)browser\/([\w\.]+)/i], [[u, /(.+)/, "$1 " + A], f], [/(comodo_dragon)\/([\w\.]+)/i], [[u, /_/g, " "], f], [/(electron)\/([\w\.]+) safari/i, /(tesla)(?: qtcarbrowser|\/(20\d\d\.[-\w\.]+))/i, /m?(qqbrowser|baiduboxapp|2345Explorer)[\/ ]?([\w\.]+)/i], [u, f], [/(metasr)[\/ ]?([\w\.]+)/i, /(lbbrowser)/i, /\[(linkedin)app\]/i], [u], [/((?:fban\/fbios|fb_iab\/fb4a)(?!.+fbav)|;fbav\/([\w\.]+);)/i], [[u, H], f], [/(kakao(?:talk|story))[\/ ]([\w\.]+)/i, /(naver)\(.*?(\d+\.[\w\.]+).*\)/i, /safari (line)\/([\w\.]+)/i, /\b(line)\/([\w\.]+)\/iab/i, /(chromium|instagram)[\/ ]([-\w\.]+)/i], [u, f], [/\bgsa\/([\w\.]+) .*safari\//i], [f, [u, "GSA"]], [/musical_ly(?:.+app_?version\/|_)([\w\.]+)/i], [f, [u, "TikTok"]], [/headlesschrome(?:\/([\w\.]+)| )/i], [f, [u, C + " Headless"]], [/ wv\).+(chrome)\/([\w\.]+)/i], [[u, C + " WebView"], f], [/droid.+ version\/([\w\.]+)\b.+(?:mobile safari|safari)/i], [f, [u, "Android " + A]], [/(chrome|omniweb|arora|[tizenoka]{5} ?browser)\/v?([\w\.]+)/i], [u, f], [/version\/([\w\.\,]+) .*mobile\/\w+ (safari)/i], [f, [u, "Mobile Safari"]], [/version\/([\w(\.|\,)]+) .*(mobile ?safari|safari)/i], [f, u], [/webkit.+?(mobile ?safari|safari)(\/[\w\.]+)/i], [u, [f, strMapper, $]], [/(webkit|khtml)\/([\w\.]+)/i], [u, f], [/(navigator|netscape\d?)\/([-\w\.]+)/i], [[u, "Netscape"], f], [/mobile vr; rv:([\w\.]+)\).+firefox/i], [f, [u, O + " Reality"]], [/ekiohf.+(flow)\/([\w\.]+)/i, /(swiftfox)/i, /(icedragon|iceweasel|camino|chimera|fennec|maemo browser|minimo|conkeror|klar)[\/ ]?([\w\.\+]+)/i, /(seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\/([-\w\.]+)$/i, /(firefox)\/([\w\.]+)/i, /(mozilla)\/([\w\.]+) .+rv\:.+gecko\/\d+/i, /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir|obigo|mosaic|(?:go|ice|up)[\. ]?browser)[-\/ ]?v?([\w\.]+)/i, /(links) \(([\w\.]+)/i, /panasonic;(viera)/i], [u, f], [/(cobalt)\/([\w\.]+)/i], [u, [f, /master.|lts./, ""]]], cpu: [[/(?:(amd|x(?:(?:86|64)[-_])?|wow|win)64)[;\)]/i], [[h, "amd64"]], [/(ia32(?=;))/i], [[h, lowerize]], [/((?:i[346]|x)86)[;\)]/i], [[h, "ia32"]], [/\b(aarch64|arm(v?8e?l?|_?64))\b/i], [[h, "arm64"]], [/\b(arm(?:v[67])?ht?n?[fl]p?)\b/i], [[h, "armhf"]], [/windows (ce|mobile); ppc;/i], [[h, "arm"]], [/((?:ppc|powerpc)(?:64)?)(?: mac|;|\))/i], [[h, /ower/, t, lowerize]], [/(sun4\w)[;\)]/i], [[h, "sparc"]], [/((?:avr32|ia64(?=;))|68k(?=\))|\barm(?=v(?:[1-7]|[5-7]1)l?|;|eabi)|(?=atmel )avr|(?:irix|mips|sparc)(?:64)?\b|pa-risc)/i], [[h, lowerize]]], device: [[/\b(sch-i[89]0\d|shw-m380s|sm-[ptx]\w{2,4}|gt-[pn]\d{2,4}|sgh-t8[56]9|nexus 10)/i], [c, [m, V], [p, k]], [/\b((?:s[cgp]h|gt|sm)-\w+|sc[g-]?[\d]+a?|galaxy nexus)/i, /samsung[- ]([-\w]+)/i, /sec-(sgh\w+)/i], [c, [m, V], [p, g]], [/(?:\/|\()(ip(?:hone|od)[\w, ]*)(?:\/|;)/i], [c, [m, S], [p, g]], [/\((ipad);[-\w\),; ]+apple/i, /applecoremedia\/[\w\.]+ \((ipad)/i, /\b(ipad)\d\d?,\d\d?[;\]].+ios/i], [c, [m, S], [p, k]], [/(macintosh);/i], [c, [m, S]], [/\b(sh-?[altvz]?\d\d[a-ekm]?)/i], [c, [m, D], [p, g]], [/\b((?:ag[rs][23]?|bah2?|sht?|btv)-a?[lw]\d{2})\b(?!.+d\/s)/i], [c, [m, j], [p, k]], [/(?:huawei|honor)([-\w ]+)[;\)]/i, /\b(nexus 6p|\w{2,4}e?-[atu]?[ln][\dx][012359c][adn]?)\b(?!.+d\/s)/i], [c, [m, j], [p, g]], [/\b(poco[\w ]+)(?: bui|\))/i, /\b; (\w+) build\/hm\1/i, /\b(hm[-_ ]?note?[_ ]?(?:\d\w)?) bui/i, /\b(redmi[\-_ ]?(?:note|k)?[\w_ ]+)(?: bui|\))/i, /\b(mi[-_ ]?(?:a\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\d?\w?)[_ ]?(?:plus|se|lite)?)(?: bui|\))/i], [[c, /_/g, " "], [m, F], [p, g]], [/\b(mi[-_ ]?(?:pad)(?:[\w_ ]+))(?: bui|\))/i], [[c, /_/g, " "], [m, F], [p, k]], [/; (\w+) bui.+ oppo/i, /\b(cph[12]\d{3}|p(?:af|c[al]|d\w|e[ar])[mt]\d0|x9007|a101op)\b/i], [c, [m, "OPPO"], [p, g]], [/vivo (\w+)(?: bui|\))/i, /\b(v[12]\d{3}\w?[at])(?: bui|;)/i], [c, [m, "Vivo"], [p, g]], [/\b(rmx[12]\d{3})(?: bui|;|\))/i], [c, [m, "Realme"], [p, g]], [/\b(milestone|droid(?:[2-4x]| (?:bionic|x2|pro|razr))?:?( 4g)?)\b[\w ]+build\//i, /\bmot(?:orola)?[- ](\w*)/i, /((?:moto[\w\(\) ]+|xt\d{3,4}|nexus 6)(?= bui|\)))/i], [c, [m, M], [p, g]], [/\b(mz60\d|xoom[2 ]{0,2}) build\//i], [c, [m, M], [p, k]], [/((?=lg)?[vl]k\-?\d{3}) bui| 3\.[-\w; ]{10}lg?-([06cv9]{3,4})/i], [c, [m, P], [p, k]], [/(lm(?:-?f100[nv]?|-[\w\.]+)(?= bui|\))|nexus [45])/i, /\blg[-e;\/ ]+((?!browser|netcast|android tv)\w+)/i, /\blg-?([\d\w]+) bui/i], [c, [m, P], [p, g]], [/(ideatab[-\w ]+)/i, /lenovo ?(s[56]000[-\w]+|tab(?:[\w ]+)|yt[-\d\w]{6}|tb[-\d\w]{6})/i], [c, [m, "Lenovo"], [p, k]], [/(?:maemo|nokia).*(n900|lumia \d+)/i, /nokia[-_ ]?([-\w\.]*)/i], [[c, /_/g, " "], [m, "Nokia"], [p, g]], [/(pixel c)\b/i], [c, [m, U], [p, k]], [/droid.+; (pixel[\daxl ]{0,6})(?: bui|\))/i], [c, [m, U], [p, g]], [/droid.+ (a?\d[0-2]{2}so|[c-g]\d{4}|so[-gl]\w+|xq-a\w[4-7][12])(?= bui|\).+chrome\/(?![1-6]{0,1}\d\.))/i], [c, [m, I], [p, g]], [/sony tablet [ps]/i, /\b(?:sony)?sgp\w+(?: bui|\))/i], [[c, "Xperia Tablet"], [m, I], [p, k]], [/ (kb2005|in20[12]5|be20[12][59])\b/i, /(?:one)?(?:plus)? (a\d0\d\d)(?: b|\))/i], [c, [m, "OnePlus"], [p, g]], [/(alexa)webm/i, /(kf[a-z]{2}wi|aeo[c-r]{2})( bui|\))/i, /(kf[a-z]+)( bui|\)).+silk\//i], [c, [m, T], [p, k]], [/((?:sd|kf)[0349hijorstuw]+)( bui|\)).+silk\//i], [[c, /(.+)/g, "Fire Phone $1"], [m, T], [p, g]], [/(playbook);[-\w\),; ]+(rim)/i], [c, m, [p, k]], [/\b((?:bb[a-f]|st[hv])100-\d)/i, /\(bb10; (\w+)/i], [c, [m, N], [p, g]], [/(?:\b|asus_)(transfo[prime ]{4,10} \w+|eeepc|slider \w+|nexus 7|padfone|p00[cj])/i], [c, [m, z], [p, k]], [/ (z[bes]6[027][012][km][ls]|zenfone \d\w?)\b/i], [c, [m, z], [p, g]], [/(nexus 9)/i], [c, [m, "HTC"], [p, k]], [/(htc)[-;_ ]{1,2}([\w ]+(?=\)| bui)|\w+)/i, /(zte)[- ]([\w ]+?)(?: bui|\/|\))/i, /(alcatel|geeksphone|nexian|panasonic(?!(?:;|\.))|sony(?!-bra))[-_ ]?([-\w]*)/i], [m, [c, /_/g, " "], [p, g]], [/droid.+; ([ab][1-7]-?[0178a]\d\d?)/i], [c, [m, "Acer"], [p, k]], [/droid.+; (m[1-5] note) bui/i, /\bmz-([-\w]{2,})/i], [c, [m, "Meizu"], [p, g]], [/(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron)[-_ ]?([-\w]*)/i, /(hp) ([\w ]+\w)/i, /(asus)-?(\w+)/i, /(microsoft); (lumia[\w ]+)/i, /(lenovo)[-_ ]?([-\w]+)/i, /(jolla)/i, /(oppo) ?([\w ]+) bui/i], [m, c, [p, g]], [/(kobo)\s(ereader|touch)/i, /(archos) (gamepad2?)/i, /(hp).+(touchpad(?!.+tablet)|tablet)/i, /(kindle)\/([\w\.]+)/i, /(nook)[\w ]+build\/(\w+)/i, /(dell) (strea[kpr\d ]*[\dko])/i, /(le[- ]+pan)[- ]+(\w{1,9}) bui/i, /(trinity)[- ]*(t\d{3}) bui/i, /(gigaset)[- ]+(q\w{1,9}) bui/i, /(vodafone) ([\w ]+)(?:\)| bui)/i], [m, c, [p, k]], [/(surface duo)/i], [c, [m, R], [p, k]], [/droid [\d\.]+; (fp\du?)(?: b|\))/i], [c, [m, "Fairphone"], [p, g]], [/(u304aa)/i], [c, [m, "AT&T"], [p, g]], [/\bsie-(\w*)/i], [c, [m, "Siemens"], [p, g]], [/\b(rct\w+) b/i], [c, [m, "RCA"], [p, k]], [/\b(venue[\d ]{2,7}) b/i], [c, [m, "Dell"], [p, k]], [/\b(q(?:mv|ta)\w+) b/i], [c, [m, "Verizon"], [p, k]], [/\b(?:barnes[& ]+noble |bn[rt])([\w\+ ]*) b/i], [c, [m, "Barnes & Noble"], [p, k]], [/\b(tm\d{3}\w+) b/i], [c, [m, "NuVision"], [p, k]], [/\b(k88) b/i], [c, [m, "ZTE"], [p, k]], [/\b(nx\d{3}j) b/i], [c, [m, "ZTE"], [p, g]], [/\b(gen\d{3}) b.+49h/i], [c, [m, "Swiss"], [p, g]], [/\b(zur\d{3}) b/i], [c, [m, "Swiss"], [p, k]], [/\b((zeki)?tb.*\b) b/i], [c, [m, "Zeki"], [p, k]], [/\b([yr]\d{2}) b/i, /\b(dragon[- ]+touch |dt)(\w{5}) b/i], [[m, "Dragon Touch"], c, [p, k]], [/\b(ns-?\w{0,9}) b/i], [c, [m, "Insignia"], [p, k]], [/\b((nxa|next)-?\w{0,9}) b/i], [c, [m, "NextBook"], [p, k]], [/\b(xtreme\_)?(v(1[045]|2[015]|[3469]0|7[05])) b/i], [[m, "Voice"], c, [p, g]], [/\b(lvtel\-)?(v1[12]) b/i], [[m, "LvTel"], c, [p, g]], [/\b(ph-1) /i], [c, [m, "Essential"], [p, g]], [/\b(v(100md|700na|7011|917g).*\b) b/i], [c, [m, "Envizen"], [p, k]], [/\b(trio[-\w\. ]+) b/i], [c, [m, "MachSpeed"], [p, k]], [/\btu_(1491) b/i], [c, [m, "Rotor"], [p, k]], [/(shield[\w ]+) b/i], [c, [m, "Nvidia"], [p, k]], [/(sprint) (\w+)/i], [m, c, [p, g]], [/(kin\.[onetw]{3})/i], [[c, /\./g, " "], [m, R], [p, g]], [/droid.+; (cc6666?|et5[16]|mc[239][23]x?|vc8[03]x?)\)/i], [c, [m, G], [p, k]], [/droid.+; (ec30|ps20|tc[2-8]\d[kx])\)/i], [c, [m, G], [p, g]], [/smart-tv.+(samsung)/i], [m, [p, x]], [/hbbtv.+maple;(\d+)/i], [[c, /^/, "SmartTV"], [m, V], [p, x]], [/(nux; netcast.+smarttv|lg (netcast\.tv-201\d|android tv))/i], [[m, P], [p, x]], [/(apple) ?tv/i], [m, [c, S + " TV"], [p, x]], [/crkey/i], [[c, C + "cast"], [m, U], [p, x]], [/droid.+aft(\w)( bui|\))/i], [c, [m, T], [p, x]], [/\(dtv[\);].+(aquos)/i, /(aquos-tv[\w ]+)\)/i], [c, [m, D], [p, x]], [/(bravia[\w ]+)( bui|\))/i], [c, [m, I], [p, x]], [/(mitv-\w{5}) bui/i], [c, [m, F], [p, x]], [/Hbbtv.*(technisat) (.*);/i], [m, c, [p, x]], [/\b(roku)[\dx]*[\)\/]((?:dvp-)?[\d\.]*)/i, /hbbtv\/\d+\.\d+\.\d+ +\([\w\+ ]*; *([\w\d][^;]*);([^;]*)/i], [[m, trim], [c, trim], [p, x]], [/\b(android tv|smart[- ]?tv|opera tv|tv; rv:)\b/i], [[p, x]], [/(ouya)/i, /(nintendo) ([wids3utch]+)/i], [m, c, [p, v]], [/droid.+; (shield) bui/i], [c, [m, "Nvidia"], [p, v]], [/(playstation [345portablevi]+)/i], [c, [m, I], [p, v]], [/\b(xbox(?: one)?(?!; xbox))[\); ]/i], [c, [m, R], [p, v]], [/((pebble))app/i], [m, c, [p, _]], [/(watch)(?: ?os[,\/]|\d,\d\/)[\d\.]+/i], [c, [m, S], [p, _]], [/droid.+; (glass) \d/i], [c, [m, U], [p, _]], [/droid.+; (wt63?0{2,3})\)/i], [c, [m, G], [p, _]], [/(quest( 2| pro)?)/i], [c, [m, H], [p, _]], [/(tesla)(?: qtcarbrowser|\/[-\w\.]+)/i], [m, [p, y]], [/(aeobc)\b/i], [c, [m, T], [p, y]], [/droid .+?; ([^;]+?)(?: bui|\) applew).+? mobile safari/i], [c, [p, g]], [/droid .+?; ([^;]+?)(?: bui|\) applew).+?(?! mobile) safari/i], [c, [p, k]], [/\b((tablet|tab)[;\/]|focus\/\d(?!.+mobile))/i], [[p, k]], [/(phone|mobile(?:[;\/]| [ \w\/\.]*safari)|pda(?=.+windows ce))/i], [[p, g]], [/(android[-\w\. ]{0,9});.+buil/i], [c, [m, "Generic"]]], engine: [[/windows.+ edge\/([\w\.]+)/i], [f, [u, E + "HTML"]], [/webkit\/537\.36.+chrome\/(?!27)([\w\.]+)/i], [f, [u, "Blink"]], [/(presto)\/([\w\.]+)/i, /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna)\/([\w\.]+)/i, /ekioh(flow)\/([\w\.]+)/i, /(khtml|tasman|links)[\/ ]\(?([\w\.]+)/i, /(icab)[\/ ]([23]\.[\d\.]+)/i, /\b(libweb)/i], [u, f], [/rv\:([\w\.]{1,9})\b.+(gecko)/i], [f, u]], os: [[/microsoft (windows) (vista|xp)/i], [u, f], [/(windows) nt 6\.2; (arm)/i, /(windows (?:phone(?: os)?|mobile))[\/ ]?([\d\.\w ]*)/i, /(windows)[\/ ]?([ntce\d\. ]+\w)(?!.+xbox)/i], [u, [f, strMapper, X]], [/(win(?=3|9|n)|win 9x )([nt\d\.]+)/i], [[u, "Windows"], [f, strMapper, X]], [/ip[honead]{2,4}\b(?:.*os ([\w]+) like mac|; opera)/i, /ios;fbsv\/([\d\.]+)/i, /cfnetwork\/.+darwin/i], [[f, /_/g, "."], [u, "iOS"]], [/(mac os x) ?([\w\. ]*)/i, /(macintosh|mac_powerpc\b)(?!.+haiku)/i], [[u, Z], [f, /_/g, "."]], [/droid ([\w\.]+)\b.+(android[- ]x86|harmonyos)/i], [f, u], [/(android|webos|qnx|bada|rim tablet os|maemo|meego|sailfish)[-\/ ]?([\w\.]*)/i, /(blackberry)\w*\/([\w\.]*)/i, /(tizen|kaios)[\/ ]([\w\.]+)/i, /\((series40);/i], [u, f], [/\(bb(10);/i], [f, [u, N]], [/(?:symbian ?os|symbos|s60(?=;)|series60)[-\/ ]?([\w\.]*)/i], [f, [u, "Symbian"]], [/mozilla\/[\d\.]+ \((?:mobile|tablet|tv|mobile; [\w ]+); rv:.+ gecko\/([\w\.]+)/i], [f, [u, O + " OS"]], [/web0s;.+rt(tv)/i, /\b(?:hp)?wos(?:browser)?\/([\w\.]+)/i], [f, [u, "webOS"]], [/watch(?: ?os[,\/]|\d,\d\/)([\d\.]+)/i], [f, [u, "watchOS"]], [/crkey\/([\d\.]+)/i], [f, [u, C + "cast"]], [/(cros) [\w]+(?:\)| ([\w\.]+)\b)/i], [[u, L], f], [/panasonic;(viera)/i, /(netrange)mmh/i, /(nettv)\/(\d+\.[\w\.]+)/i, /(nintendo|playstation) ([wids345portablevuch]+)/i, /(xbox); +xbox ([^\);]+)/i, /\b(joli|palm)\b ?(?:os)?\/?([\w\.]*)/i, /(mint)[\/\(\) ]?(\w*)/i, /(mageia|vectorlinux)[; ]/i, /([kxln]?ubuntu|debian|suse|opensuse|gentoo|arch(?= linux)|slackware|fedora|mandriva|centos|pclinuxos|red ?hat|zenwalk|linpus|raspbian|plan 9|minix|risc os|contiki|deepin|manjaro|elementary os|sabayon|linspire)(?: gnu\/linux)?(?: enterprise)?(?:[- ]linux)?(?:-gnu)?[-\/ ]?(?!chrom|package)([-\w\.]*)/i, /(hurd|linux) ?([\w\.]*)/i, /(gnu) ?([\w\.]*)/i, /\b([-frentopcghs]{0,5}bsd|dragonfly)[\/ ]?(?!amd|[ix346]{1,2}86)([\w\.]*)/i, /(haiku) (\w+)/i], [u, f], [/(sunos) ?([\w\.\d]*)/i], [[u, "Solaris"], f], [/((?:open)?solaris)[-\/ ]?([\w\.]*)/i, /(aix) ((\d)(?=\.|\)| )[\w\.])*/i, /\b(beos|os\/2|amigaos|morphos|openvms|fuchsia|hp-ux|serenityos)/i, /(unix) ?([\w\.]*)/i], [u, f]] };
+          var UAParser = function(i3, e3) {
+            if (typeof i3 === w) {
+              e3 = i3;
+              i3 = a;
+            }
+            if (!(this instanceof UAParser)) {
+              return new UAParser(i3, e3).getResult();
+            }
+            var r2 = typeof o2 !== b && o2.navigator ? o2.navigator : a;
+            var n2 = i3 || (r2 && r2.userAgent ? r2.userAgent : t);
+            var v2 = r2 && r2.userAgentData ? r2.userAgentData : a;
+            var x2 = e3 ? extend(K, e3) : K;
+            var _2 = r2 && r2.userAgent == n2;
+            this.getBrowser = function() {
+              var i4 = {};
+              i4[u] = a;
+              i4[f] = a;
+              rgxMapper.call(i4, n2, x2.browser);
+              i4[d] = majorize(i4[f]);
+              if (_2 && r2 && r2.brave && typeof r2.brave.isBrave == s) {
+                i4[u] = "Brave";
+              }
+              return i4;
+            };
+            this.getCPU = function() {
+              var i4 = {};
+              i4[h] = a;
+              rgxMapper.call(i4, n2, x2.cpu);
+              return i4;
+            };
+            this.getDevice = function() {
+              var i4 = {};
+              i4[m] = a;
+              i4[c] = a;
+              i4[p] = a;
+              rgxMapper.call(i4, n2, x2.device);
+              if (_2 && !i4[p] && v2 && v2.mobile) {
+                i4[p] = g;
+              }
+              if (_2 && i4[c] == "Macintosh" && r2 && typeof r2.standalone !== b && r2.maxTouchPoints && r2.maxTouchPoints > 2) {
+                i4[c] = "iPad";
+                i4[p] = k;
+              }
+              return i4;
+            };
+            this.getEngine = function() {
+              var i4 = {};
+              i4[u] = a;
+              i4[f] = a;
+              rgxMapper.call(i4, n2, x2.engine);
+              return i4;
+            };
+            this.getOS = function() {
+              var i4 = {};
+              i4[u] = a;
+              i4[f] = a;
+              rgxMapper.call(i4, n2, x2.os);
+              if (_2 && !i4[u] && v2 && v2.platform != "Unknown") {
+                i4[u] = v2.platform.replace(/chrome os/i, L).replace(/macos/i, Z);
+              }
+              return i4;
+            };
+            this.getResult = function() {
+              return { ua: this.getUA(), browser: this.getBrowser(), engine: this.getEngine(), os: this.getOS(), device: this.getDevice(), cpu: this.getCPU() };
+            };
+            this.getUA = function() {
+              return n2;
+            };
+            this.setUA = function(i4) {
+              n2 = typeof i4 === l && i4.length > q ? trim(i4, q) : i4;
+              return this;
+            };
+            this.setUA(n2);
+            return this;
+          };
+          UAParser.VERSION = r;
+          UAParser.BROWSER = enumerize([u, f, d]);
+          UAParser.CPU = enumerize([h]);
+          UAParser.DEVICE = enumerize([c, m, p, v, g, x, k, _, y]);
+          UAParser.ENGINE = UAParser.OS = enumerize([u, f]);
+          if (typeof e2 !== b) {
+            if ("object" !== b && i2.exports) {
+              e2 = i2.exports = UAParser;
+            }
+            e2.UAParser = UAParser;
+          } else {
+            if (typeof define === s && define.amd) {
+              define(function() {
+                return UAParser;
+              });
+            } else if (typeof o2 !== b) {
+              o2.UAParser = UAParser;
+            }
+          }
+          var Q = typeof o2 !== b && (o2.jQuery || o2.Zepto);
+          if (Q && !Q.ua) {
+            var Y = new UAParser();
+            Q.ua = Y.getResult();
+            Q.ua.get = function() {
+              return Y.getUA();
+            };
+            Q.ua.set = function(i3) {
+              Y.setUA(i3);
+              var e3 = Y.getResult();
+              for (var o3 in e3) {
+                Q.ua[o3] = e3[o3];
+              }
+            };
+          }
+        })(typeof window === "object" ? window : this);
+      } };
+      var e = {};
+      function __nccwpck_require__(o2) {
+        var a = e[o2];
+        if (a !== void 0) {
+          return a.exports;
+        }
+        var r = e[o2] = { exports: {} };
+        var t = true;
+        try {
+          i[o2].call(r.exports, r, r.exports, __nccwpck_require__);
+          t = false;
+        } finally {
+          if (t)
+            delete e[o2];
+        }
+        return r.exports;
+      }
+      if (typeof __nccwpck_require__ !== "undefined")
+        __nccwpck_require__.ab = __dirname + "/";
+      var o = __nccwpck_require__(226);
+      module2.exports = o;
+    })();
+  }
+});
+
+// node_modules/next/dist/server/web/spec-extension/user-agent.js
+var require_user_agent = __commonJS({
+  "node_modules/next/dist/server/web/spec-extension/user-agent.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports2, {
+      isBot: function() {
+        return isBot;
+      },
+      userAgent: function() {
+        return userAgent;
+      },
+      userAgentFromString: function() {
+        return userAgentFromString;
+      }
+    });
+    var _uaparserjs = /* @__PURE__ */ _interop_require_default(require_ua_parser());
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    function isBot(input) {
+      return /Googlebot|Mediapartners-Google|AdsBot-Google|googleweblight|Storebot-Google|Google-PageRenderer|Google-InspectionTool|Bingbot|BingPreview|Slurp|DuckDuckBot|baiduspider|yandex|sogou|LinkedInBot|bitlybot|tumblr|vkShare|quora link preview|facebookexternalhit|facebookcatalog|Twitterbot|applebot|redditbot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|ia_archiver/i.test(input);
+    }
+    function userAgentFromString(input) {
+      return {
+        ...(0, _uaparserjs.default)(input),
+        isBot: input === void 0 ? false : isBot(input)
+      };
+    }
+    function userAgent({ headers }) {
+      return userAgentFromString(headers.get("user-agent") || void 0);
+    }
+  }
+});
+
+// node_modules/next/dist/server/web/spec-extension/url-pattern.js
+var require_url_pattern = __commonJS({
+  "node_modules/next/dist/server/web/spec-extension/url-pattern.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "URLPattern", {
+      enumerable: true,
+      get: function() {
+        return GlobalURLPattern;
+      }
+    });
+    var GlobalURLPattern = (
+      // @ts-expect-error: URLPattern is not available in Node.js
+      typeof URLPattern === "undefined" ? void 0 : URLPattern
+    );
+  }
+});
+
+// node_modules/next/server.js
+var require_server = __commonJS({
+  "node_modules/next/server.js"(exports2, module2) {
+    "use strict";
+    var serverExports = {
+      NextRequest: require_request().NextRequest,
+      NextResponse: require_response().NextResponse,
+      ImageResponse: require_image_response().ImageResponse,
+      userAgentFromString: require_user_agent().userAgentFromString,
+      userAgent: require_user_agent().userAgent,
+      URLPattern: require_url_pattern().URLPattern
+    };
+    module2.exports = serverExports;
+    exports2.NextRequest = serverExports.NextRequest;
+    exports2.NextResponse = serverExports.NextResponse;
+    exports2.ImageResponse = serverExports.ImageResponse;
+    exports2.userAgentFromString = serverExports.userAgentFromString;
+    exports2.userAgent = serverExports.userAgent;
+    exports2.URLPattern = serverExports.URLPattern;
+  }
+});
+
+// platforms/nextjs.ts
+var nextjs_exports = {};
+__export(nextjs_exports, {
+  serve: () => serve2,
+  servePagesRouter: () => servePagesRouter,
+  verifySignature: () => verifySignature,
+  verifySignatureAppRouter: () => verifySignatureAppRouter,
+  verifySignatureEdge: () => verifySignatureEdge
+});
+module.exports = __toCommonJS(nextjs_exports);
+var import_server = __toESM(require_server());
+
+// src/receiver.ts
+var jose = __toESM(require("jose"));
+var import_crypto_js = __toESM(require("crypto-js"));
+var SignatureError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SignatureError";
+  }
+};
+var Receiver = class {
+  currentSigningKey;
+  nextSigningKey;
+  constructor(config) {
+    this.currentSigningKey = config.currentSigningKey;
+    this.nextSigningKey = config.nextSigningKey;
+  }
+  /**
+   * Verify the signature of a request.
+   *
+   * Tries to verify the signature with the current signing key.
+   * If that fails, maybe because you have rotated the keys recently, it will
+   * try to verify the signature with the next signing key.
+   *
+   * If that fails, the signature is invalid and a `SignatureError` is thrown.
+   */
+  async verify(request) {
+    const isValid = await this.verifyWithKey(this.currentSigningKey, request);
+    if (isValid) {
+      return true;
+    }
+    return this.verifyWithKey(this.nextSigningKey, request);
+  }
+  /**
+   * Verify signature with a specific signing key
+   */
+  async verifyWithKey(key, request) {
+    const jwt = await jose.jwtVerify(request.signature, new TextEncoder().encode(key), {
+      issuer: "Upstash",
+      clockTolerance: request.clockTolerance
+    }).catch((error) => {
+      throw new SignatureError(error.message);
+    });
+    const p = jwt.payload;
+    if (request.url !== void 0 && p.sub !== request.url) {
+      throw new SignatureError(`invalid subject: ${p.sub}, want: ${request.url}`);
+    }
+    const bodyHash = import_crypto_js.default.SHA256(request.body).toString(import_crypto_js.default.enc.Base64url);
+    const padding = new RegExp(/=+$/);
+    if (p.body.replace(padding, "") !== bodyHash.replace(padding, "")) {
+      throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${bodyHash}`);
+    }
+    return true;
+  }
+};
+
+// src/client/dlq.ts
+var DLQ = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List messages in the dlq
+   */
+  async listMessages(options) {
+    const filterPayload = {
+      ...options?.filter,
+      topicName: options?.filter?.urlGroup
+    };
+    const messagesPayload = await this.http.request({
+      method: "GET",
+      path: ["v2", "dlq"],
+      query: {
+        cursor: options?.cursor,
+        count: options?.count,
+        ...filterPayload
+      }
+    });
+    return {
+      messages: messagesPayload.messages.map((message) => {
+        return {
+          ...message,
+          urlGroup: message.topicName
+        };
+      }),
+      cursor: messagesPayload.cursor
+    };
+  }
+  /**
+   * Remove a message from the dlq using it's `dlqId`
+   */
+  async delete(dlqMessageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq", dlqMessageId],
+      parseResponseAsJson: false
+      // there is no response
+    });
+  }
+  /**
+   * Remove multiple messages from the dlq using their `dlqId`s
+   */
+  async deleteMany(request) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "dlq"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ dlqIds: request.dlqIds })
+    });
+  }
+};
+
+// src/client/error.ts
+var QstashError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QstashError";
+  }
+};
+var QstashRatelimitError = class extends QstashError {
+  limit;
+  remaining;
+  reset;
+  constructor(args) {
+    super(`Exceeded burst rate limit. ${JSON.stringify(args)} `);
+    this.name = "QstashRatelimitError";
+    this.limit = args.limit;
+    this.remaining = args.remaining;
+    this.reset = args.reset;
+  }
+};
+var QstashChatRatelimitError = class extends QstashError {
+  limitRequests;
+  limitTokens;
+  remainingRequests;
+  remainingTokens;
+  resetRequests;
+  resetTokens;
+  constructor(args) {
+    super(`Exceeded chat rate limit. ${JSON.stringify(args)} `);
+    this.limitRequests = args["limit-requests"];
+    this.limitTokens = args["limit-tokens"];
+    this.remainingRequests = args["remaining-requests"];
+    this.remainingTokens = args["remaining-tokens"];
+    this.resetRequests = args["reset-requests"];
+    this.resetTokens = args["reset-tokens"];
+  }
+};
+var QstashDailyRatelimitError = class extends QstashError {
+  limit;
+  remaining;
+  reset;
+  constructor(args) {
+    super(`Exceeded daily rate limit. ${JSON.stringify(args)} `);
+    this.limit = args.limit;
+    this.remaining = args.remaining;
+    this.reset = args.reset;
+    this.name = "QstashChatRatelimitError";
+  }
+};
+var QStashWorkflowError = class extends QstashError {
+  constructor(message) {
+    super(message);
+    this.name = "QStashWorkflowError";
+  }
+};
+var QStashWorkflowAbort = class extends Error {
+  stepInfo;
+  stepName;
+  constructor(stepName, stepInfo) {
+    super(
+      `This is an QStash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
+    );
+    this.name = "QStashWorkflowAbort";
+    this.stepName = stepName;
+    this.stepInfo = stepInfo;
+  }
+};
+var formatWorkflowError = (error) => {
+  return error instanceof Error ? {
+    error: error.name,
+    message: error.message
+  } : {
+    error: "Error",
+    message: "An error occured while executing workflow."
+  };
+};
+
+// src/client/http.ts
+var HttpClient = class {
+  baseUrl;
+  authorization;
+  options;
+  retry;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.authorization = config.authorization;
+    this.retry = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typeof config.retry === "boolean" && !config.retry ? {
+      attempts: 1,
+      backoff: () => 0
+    } : {
+      attempts: config.retry?.retries ? config.retry.retries + 1 : 5,
+      backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
+    };
+  }
+  async request(request) {
+    const { response } = await this.requestWithBackoff(request);
+    if (request.parseResponseAsJson === false) {
+      return void 0;
+    }
+    return await response.json();
+  }
+  async *requestStream(request) {
+    const { response } = await this.requestWithBackoff(request);
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const body = response.body;
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        const chunkText = decoder.decode(value, { stream: true });
+        const chunks = chunkText.split("\n").filter(Boolean);
+        for (const chunk of chunks) {
+          if (chunk.startsWith("data: ")) {
+            const data = chunk.slice(6);
+            if (data === "[DONE]") {
+              break;
+            }
+            yield JSON.parse(data);
+          }
+        }
+      }
+    } finally {
+      await reader.cancel();
+    }
+  }
+  requestWithBackoff = async (request) => {
+    const [url, requestOptions] = this.processRequest(request);
+    let response = void 0;
+    let error = void 0;
+    for (let index = 0; index < this.retry.attempts; index++) {
+      try {
+        response = await fetch(url.toString(), requestOptions);
+        break;
+      } catch (error_) {
+        error = error_;
+        await new Promise((r) => setTimeout(r, this.retry.backoff(index)));
+      }
+    }
+    if (!response) {
+      throw error ?? new Error("Exhausted all retries");
+    }
+    await this.checkResponse(response);
+    return {
+      response,
+      error
+    };
+  };
+  processRequest = (request) => {
+    const headers = new Headers(request.headers);
+    if (!headers.has("Authorization")) {
+      headers.set("Authorization", this.authorization);
+    }
+    const requestOptions = {
+      method: request.method,
+      headers,
+      body: request.body,
+      keepalive: request.keepalive
+    };
+    const url = new URL([request.baseUrl ?? this.baseUrl, ...request.path].join("/"));
+    if (request.query) {
+      for (const [key, value] of Object.entries(request.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value.toString());
+        }
+      }
+    }
+    return [url.toString(), requestOptions];
+  };
+  async checkResponse(response) {
+    if (response.status === 429) {
+      if (response.headers.get("x-ratelimit-limit-requests")) {
+        throw new QstashChatRatelimitError({
+          "limit-requests": response.headers.get("x-ratelimit-limit-requests"),
+          "limit-tokens": response.headers.get("x-ratelimit-limit-tokens"),
+          "remaining-requests": response.headers.get("x-ratelimit-remaining-requests"),
+          "remaining-tokens": response.headers.get("x-ratelimit-remaining-tokens"),
+          "reset-requests": response.headers.get("x-ratelimit-reset-requests"),
+          "reset-tokens": response.headers.get("x-ratelimit-reset-tokens")
+        });
+      } else if (response.headers.get("RateLimit-Limit")) {
+        throw new QstashDailyRatelimitError({
+          limit: response.headers.get("RateLimit-Limit"),
+          remaining: response.headers.get("RateLimit-Remaining"),
+          reset: response.headers.get("RateLimit-Reset")
+        });
+      }
+      throw new QstashRatelimitError({
+        limit: response.headers.get("Burst-RateLimit-Limit"),
+        remaining: response.headers.get("Burst-RateLimit-Remaining"),
+        reset: response.headers.get("Burst-RateLimit-Reset")
+      });
+    }
+    if (response.status < 200 || response.status >= 300) {
+      const body = await response.text();
+      throw new QstashError(body.length > 0 ? body : `Error: status=${response.status}`);
+    }
+  }
+};
+
+// src/client/llm/providers.ts
+var setupAnalytics = (analytics, providerApiKey, providerBaseUrl, provider) => {
+  if (!analytics)
+    return {};
+  switch (analytics.name) {
+    case "helicone": {
+      switch (provider) {
+        case "upstash": {
+          return {
+            baseURL: "https://qstash.helicone.ai/llm/v1/chat/completions",
+            defaultHeaders: {
+              "Helicone-Auth": `Bearer ${analytics.token}`,
+              Authorization: `Bearer ${providerApiKey}`
+            }
+          };
+        }
+        default: {
+          return {
+            baseURL: "https://gateway.helicone.ai/v1/chat/completions",
+            defaultHeaders: {
+              "Helicone-Auth": `Bearer ${analytics.token}`,
+              "Helicone-Target-Url": providerBaseUrl,
+              Authorization: `Bearer ${providerApiKey}`
+            }
+          };
+        }
+      }
+    }
+    default: {
+      throw new Error("Unknown analytics provider");
+    }
+  }
+};
+
+// src/client/llm/chat.ts
+var Chat = class _Chat {
+  http;
+  token;
+  constructor(http, token) {
+    this.http = http;
+    this.token = token;
+  }
+  static toChatRequest(request) {
+    const messages = [];
+    messages.push(
+      { role: "system", content: request.system },
+      { role: "user", content: request.user }
+    );
+    const chatRequest = { ...request, messages };
+    return chatRequest;
+  }
+  /**
+   * Calls the Upstash completions api given a ChatRequest.
+   *
+   * Returns a ChatCompletion or a stream of ChatCompletionChunks
+   * if stream is enabled.
+   *
+   * @param request ChatRequest with messages
+   * @returns Chat completion or stream
+   */
+  create = async (request) => {
+    if (request.provider.owner != "upstash")
+      return this.createThirdParty(request);
+    const body = JSON.stringify(request);
+    let baseUrl = void 0;
+    let headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.token}`,
+      ..."stream" in request && request.stream ? {
+        Connection: "keep-alive",
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache"
+      } : {}
+    };
+    if (request.analytics) {
+      const { baseURL, defaultHeaders } = setupAnalytics(
+        { name: "helicone", token: request.analytics.token },
+        this.getAuthorizationToken(),
+        request.provider.baseUrl,
+        "upstash"
+      );
+      headers = { ...headers, ...defaultHeaders };
+      baseUrl = baseURL;
+    }
+    const path = request.analytics ? [] : ["llm", "v1", "chat", "completions"];
+    return "stream" in request && request.stream ? this.http.requestStream({
+      path,
+      method: "POST",
+      headers,
+      baseUrl,
+      body
+    }) : this.http.request({
+      path,
+      method: "POST",
+      headers,
+      baseUrl,
+      body
+    });
+  };
+  /**
+   * Calls the Upstash completions api given a ChatRequest.
+   *
+   * Returns a ChatCompletion or a stream of ChatCompletionChunks
+   * if stream is enabled.
+   *
+   * @param request ChatRequest with messages
+   * @returns Chat completion or stream
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  createThirdParty = async (request) => {
+    const { baseUrl, token, owner } = request.provider;
+    if (owner === "upstash")
+      throw new Error("Upstash is not 3rd party provider!");
+    delete request.provider;
+    delete request.system;
+    const analytics = request.analytics;
+    delete request.analytics;
+    const body = JSON.stringify(request);
+    const isAnalyticsEnabled = analytics?.name && analytics.token;
+    const analyticsConfig = analytics?.name && analytics.token ? setupAnalytics({ name: analytics.name, token: analytics.token }, token, baseUrl, owner) : { defaultHeaders: void 0, baseURL: baseUrl };
+    const isStream = "stream" in request && request.stream;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      ...isStream ? {
+        Connection: "keep-alive",
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache"
+      } : {},
+      ...analyticsConfig.defaultHeaders
+    };
+    const response = await this.http[isStream ? "requestStream" : "request"]({
+      path: isAnalyticsEnabled ? [] : ["v1", "chat", "completions"],
+      method: "POST",
+      headers,
+      body,
+      baseUrl: analyticsConfig.baseURL
+    });
+    return response;
+  };
+  // Helper method to get the authorization token
+  getAuthorizationToken() {
+    const authHeader = String(this.http.authorization);
+    const match = /Bearer (.+)/.exec(authHeader);
+    if (!match) {
+      throw new Error("Invalid authorization header format");
+    }
+    return match[1];
+  }
+  /**
+   * Calls the Upstash completions api given a PromptRequest.
+   *
+   * Returns a ChatCompletion or a stream of ChatCompletionChunks
+   * if stream is enabled.
+   *
+   * @param request PromptRequest with system and user messages.
+   *    Note that system parameter shouldn't be passed in the case of
+   *    mistralai/Mistral-7B-Instruct-v0.2 model.
+   * @returns Chat completion or stream
+   */
+  prompt = async (request) => {
+    const chatRequest = _Chat.toChatRequest(request);
+    return this.create(chatRequest);
+  };
+};
+
+// src/client/llm/utils.ts
+function appendLLMOptionsIfNeeded(request, headers, http) {
+  if (!request.api)
+    return;
+  const provider = request.api.provider;
+  const analytics = request.api.analytics;
+  if (provider?.owner === "upstash") {
+    handleUpstashProvider(request, headers, http, analytics);
+    return;
+  }
+  if (!("provider" in request.api))
+    return;
+  const { baseUrl, token } = validateProviderConfig(provider);
+  const analyticsConfig = analytics ? setupAnalytics({ name: analytics.name, token: analytics.token }, token, baseUrl, "custom") : void 0;
+  if (analyticsConfig) {
+    setAnalyticsHeaders(headers, analyticsConfig);
+    request.url = analyticsConfig.baseURL;
+  } else {
+    request.url = `${baseUrl}/v1/chat/completions`;
+    headers.set("Authorization", `Bearer ${token}`);
+  }
+}
+function handleUpstashProvider(request, headers, http, analytics) {
+  if (analytics) {
+    const analyticsConfig = setupAnalytics(
+      { name: analytics.name, token: analytics.token },
+      //@ts-expect-error hacky way to get bearer token
+      String(http.authorization).split("Bearer ")[1],
+      request.api?.provider?.baseUrl,
+      "upstash"
+    );
+    setAnalyticsHeaders(headers, analyticsConfig);
+    request.url = analyticsConfig.baseURL;
+  } else {
+    request.api = { name: "llm" };
+  }
+}
+function validateProviderConfig(provider) {
+  if (!provider?.baseUrl)
+    throw new Error("baseUrl cannot be empty or undefined!");
+  if (!provider.token)
+    throw new Error("token cannot be empty or undefined!");
+  return { baseUrl: provider.baseUrl, token: provider.token };
+}
+function setAnalyticsHeaders(headers, analyticsConfig) {
+  headers.set("Helicone-Auth", analyticsConfig.defaultHeaders?.["Helicone-Auth"] ?? "");
+  headers.set("Authorization", analyticsConfig.defaultHeaders?.Authorization ?? "");
+  if (analyticsConfig.defaultHeaders?.["Helicone-Target-Url"]) {
+    headers.set("Helicone-Target-Url", analyticsConfig.defaultHeaders["Helicone-Target-Url"]);
+  }
+}
+function ensureCallbackPresent(request) {
+  if (request.api?.name === "llm" && !request.callback) {
+    throw new TypeError("Callback cannot be undefined when using LLM");
+  }
+}
+
+// src/client/messages.ts
+var Messages = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a message
+   */
+  async get(messageId) {
+    const messagePayload = await this.http.request({
+      method: "GET",
+      path: ["v2", "messages", messageId]
+    });
+    const message = {
+      ...messagePayload,
+      urlGroup: messagePayload.topicName
+    };
+    return message;
+  }
+  /**
+   * Cancel a message
+   */
+  async delete(messageId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages", messageId],
+      parseResponseAsJson: false
+    });
+  }
+  async deleteMany(messageIds) {
+    const result = await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ messageIds })
+    });
+    return result.cancelled;
+  }
+  async deleteAll() {
+    const result = await this.http.request({
+      method: "DELETE",
+      path: ["v2", "messages"]
+    });
+    return result.cancelled;
+  }
+};
+
+// src/client/utils.ts
+var isIgnoredHeader = (header) => {
+  const lowerCaseHeader = header.toLowerCase();
+  return lowerCaseHeader.startsWith("content-type") || lowerCaseHeader.startsWith("upstash-");
+};
+function prefixHeaders(headers) {
+  const keysToBePrefixed = [...headers.keys()].filter((key) => !isIgnoredHeader(key));
+  for (const key of keysToBePrefixed) {
+    const value = headers.get(key);
+    if (value !== null) {
+      headers.set(`Upstash-Forward-${key}`, value);
+    }
+    headers.delete(key);
+  }
+  return headers;
+}
+function processHeaders(request) {
+  const headers = prefixHeaders(new Headers(request.headers));
+  headers.set("Upstash-Method", request.method ?? "POST");
+  if (request.delay !== void 0) {
+    if (typeof request.delay === "string") {
+      headers.set("Upstash-Delay", request.delay);
+    } else {
+      headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
+    }
+  }
+  if (request.notBefore !== void 0) {
+    headers.set("Upstash-Not-Before", request.notBefore.toFixed(0));
+  }
+  if (request.deduplicationId !== void 0) {
+    headers.set("Upstash-Deduplication-Id", request.deduplicationId);
+  }
+  if (request.contentBasedDeduplication !== void 0) {
+    headers.set("Upstash-Content-Based-Deduplication", "true");
+  }
+  if (request.retries !== void 0) {
+    headers.set("Upstash-Retries", request.retries.toFixed(0));
+  }
+  if (request.callback !== void 0) {
+    headers.set("Upstash-Callback", request.callback);
+  }
+  if (request.failureCallback !== void 0) {
+    headers.set("Upstash-Failure-Callback", request.failureCallback);
+  }
+  if (request.timeout !== void 0) {
+    if (typeof request.timeout === "string") {
+      headers.set("Upstash-Timeout", request.timeout);
+    } else {
+      headers.set("Upstash-Timeout", `${request.timeout}s`);
+    }
+  }
+  return headers;
+}
+function getRequestPath(request) {
+  return request.url ?? request.urlGroup ?? request.topic ?? `api/${request.api?.name}`;
+}
+var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+var NANOID_LENGTH = 21;
+function nanoid() {
+  return [...crypto.getRandomValues(new Uint8Array(NANOID_LENGTH))].map((x) => NANOID_CHARS[x % NANOID_CHARS.length]).join("");
+}
+function decodeBase64(base64) {
+  try {
+    const binString = atob(base64);
+    const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
+    return new TextDecoder().decode(intArray);
+  } catch (error) {
+    console.warn(
+      `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. Error: ${error}`
+    );
+    return atob(base64);
+  }
+}
+
+// src/client/queue.ts
+var Queue = class {
+  http;
+  queueName;
+  constructor(http, queueName) {
+    this.http = http;
+    this.queueName = queueName;
+  }
+  /**
+   * Create or update the queue
+   */
+  async upsert(request) {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    const body = {
+      queueName: this.queueName,
+      parallelism: request.parallelism ?? 1,
+      paused: request.paused ?? false
+    };
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "queues"],
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Get the queue details
+   */
+  async get() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "queues", this.queueName]
+    });
+  }
+  /**
+   * List queues
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "queues"]
+    });
+  }
+  /**
+   * Delete the queue
+   */
+  async delete() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    await this.http.request({
+      method: "DELETE",
+      path: ["v2", "queues", this.queueName],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Enqueue a message to a queue.
+   */
+  async enqueue(request) {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    const headers = processHeaders(request);
+    const destination = getRequestPath(request);
+    const response = await this.http.request({
+      path: ["v2", "enqueue", this.queueName, destination],
+      body: request.body,
+      headers,
+      method: "POST"
+    });
+    return response;
+  }
+  /**
+   * Enqueue a message to a queue, serializing the body to JSON.
+   */
+  async enqueueJSON(request) {
+    const headers = prefixHeaders(new Headers(request.headers));
+    headers.set("Content-Type", "application/json");
+    ensureCallbackPresent(request);
+    appendLLMOptionsIfNeeded(request, headers, this.http);
+    const response = await this.enqueue({
+      ...request,
+      body: JSON.stringify(request.body),
+      headers
+    });
+    return response;
+  }
+  /**
+   * Pauses the queue.
+   *
+   * A paused queue will not deliver messages until
+   * it is resumed.
+   */
+  async pause() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "queues", this.queueName, "pause"],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Resumes the queue.
+   */
+  async resume() {
+    if (!this.queueName) {
+      throw new Error("Please provide a queue name to the Queue constructor");
+    }
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "queues", this.queueName, "resume"],
+      parseResponseAsJson: false
+    });
+  }
+};
+
+// src/client/schedules.ts
+var Schedules = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a schedule
+   */
+  async create(request) {
+    const headers = prefixHeaders(new Headers(request.headers));
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    headers.set("Upstash-Cron", request.cron);
+    if (request.method !== void 0) {
+      headers.set("Upstash-Method", request.method);
+    }
+    if (request.delay !== void 0) {
+      if (typeof request.delay === "string") {
+        headers.set("Upstash-Delay", request.delay);
+      } else {
+        headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
+      }
+    }
+    if (request.retries !== void 0) {
+      headers.set("Upstash-Retries", request.retries.toFixed(0));
+    }
+    if (request.callback !== void 0) {
+      headers.set("Upstash-Callback", request.callback);
+    }
+    if (request.failureCallback !== void 0) {
+      headers.set("Upstash-Failure-Callback", request.failureCallback);
+    }
+    if (request.timeout !== void 0) {
+      if (typeof request.timeout === "string") {
+        headers.set("Upstash-Timeout", request.timeout);
+      } else {
+        headers.set("Upstash-Timeout", `${request.timeout}s`);
+      }
+    }
+    if (request.scheduleId !== void 0) {
+      headers.set("Upstash-Schedule-Id", request.scheduleId);
+    }
+    return await this.http.request({
+      method: "POST",
+      headers,
+      path: ["v2", "schedules", request.destination],
+      body: request.body
+    });
+  }
+  /**
+   * Get a schedule
+   */
+  async get(scheduleId) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "schedules", scheduleId]
+    });
+  }
+  /**
+   * List your schedules
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "schedules"]
+    });
+  }
+  /**
+   * Delete a schedule
+   */
+  async delete(scheduleId) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "schedules", scheduleId],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Pauses the schedule.
+   *
+   * A paused schedule will not deliver messages until
+   * it is resumed.
+   */
+  async pause({ schedule }) {
+    await this.http.request({
+      method: "PATCH",
+      path: ["v2", "schedules", schedule, "pause"],
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Resumes the schedule.
+   */
+  async resume({ schedule }) {
+    await this.http.request({
+      method: "PATCH",
+      path: ["v2", "schedules", schedule, "resume"],
+      parseResponseAsJson: false
+    });
+  }
+};
+
+// src/client/url-groups.ts
+var UrlGroups = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new url group with the given name and endpoints
+   */
+  async addEndpoints(request) {
+    await this.http.request({
+      method: "POST",
+      path: ["v2", "topics", request.name, "endpoints"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoints: request.endpoints }),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Remove endpoints from a url group.
+   */
+  async removeEndpoints(request) {
+    await this.http.request({
+      method: "DELETE",
+      path: ["v2", "topics", request.name, "endpoints"],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoints: request.endpoints }),
+      parseResponseAsJson: false
+    });
+  }
+  /**
+   * Get a list of all url groups.
+   */
+  async list() {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "topics"]
+    });
+  }
+  /**
+   * Get a single url group
+   */
+  async get(name) {
+    return await this.http.request({
+      method: "GET",
+      path: ["v2", "topics", name]
+    });
+  }
+  /**
+   * Delete a url group
+   */
+  async delete(name) {
+    return await this.http.request({
+      method: "DELETE",
+      path: ["v2", "topics", name],
+      parseResponseAsJson: false
+    });
+  }
+};
+
+// src/client/client.ts
+var Client = class {
+  http;
+  token;
+  constructor(config) {
+    this.http = new HttpClient({
+      retry: config.retry,
+      baseUrl: config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "https://qstash.upstash.io",
+      authorization: `Bearer ${config.token}`
+    });
+    this.token = config.token;
+  }
+  /**
+   * Access the urlGroup API.
+   *
+   * Create, read, update or delete urlGroups.
+   */
+  get urlGroups() {
+    return new UrlGroups(this.http);
+  }
+  /**
+   * Deprecated. Use urlGroups instead.
+   *
+   * Access the topic API.
+   *
+   * Create, read, update or delete topics.
+   */
+  get topics() {
+    return this.urlGroups;
+  }
+  /**
+   * Access the dlq API.
+   *
+   * List or remove messages from the DLQ.
+   */
+  get dlq() {
+    return new DLQ(this.http);
+  }
+  /**
+   * Access the message API.
+   *
+   * Read or cancel messages.
+   */
+  get messages() {
+    return new Messages(this.http);
+  }
+  /**
+   * Access the schedule API.
+   *
+   * Create, read or delete schedules.
+   */
+  get schedules() {
+    return new Schedules(this.http);
+  }
+  /**
+   * Access the workflow API.
+   *
+   * cancel workflows.
+   */
+  get workflow() {
+    return new Workflow(this.http);
+  }
+  /**
+   * Access the queue API.
+   *
+   * Create, read, update or delete queues.
+   */
+  queue(request) {
+    return new Queue(this.http, request?.queueName);
+  }
+  /**
+   * Access the Chat API
+   *
+   * Call the create or prompt methods
+   */
+  chat() {
+    return new Chat(this.http, this.token);
+  }
+  async publish(request) {
+    const headers = processHeaders(request);
+    const response = await this.http.request({
+      path: ["v2", "publish", getRequestPath(request)],
+      body: request.body,
+      headers,
+      method: "POST"
+    });
+    return response;
+  }
+  /**
+   * publishJSON is a utility wrapper around `publish` that automatically serializes the body
+   * and sets the `Content-Type` header to `application/json`.
+   */
+  async publishJSON(request) {
+    const headers = prefixHeaders(new Headers(request.headers));
+    headers.set("Content-Type", "application/json");
+    ensureCallbackPresent(request);
+    appendLLMOptionsIfNeeded(request, headers, this.http);
+    const response = await this.publish({
+      ...request,
+      headers,
+      body: JSON.stringify(request.body)
+    });
+    return response;
+  }
+  /**
+   * Batch publish messages to QStash.
+   */
+  async batch(request) {
+    const messages = [];
+    for (const message of request) {
+      const headers = processHeaders(message);
+      const headerEntries = Object.fromEntries(headers.entries());
+      messages.push({
+        destination: getRequestPath(message),
+        headers: headerEntries,
+        body: message.body,
+        ...message.queueName && { queue: message.queueName }
+      });
+    }
+    const response = await this.http.request({
+      path: ["v2", "batch"],
+      body: JSON.stringify(messages),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    const arrayResposne = Array.isArray(response) ? response : [response];
+    return arrayResposne;
+  }
+  /**
+   * Batch publish messages to QStash, serializing each body to JSON.
+   */
+  async batchJSON(request) {
+    for (const message of request) {
+      if ("body" in message) {
+        message.body = JSON.stringify(message.body);
+      }
+      message.headers = new Headers(message.headers);
+      ensureCallbackPresent(message);
+      appendLLMOptionsIfNeeded(message, message.headers, this.http);
+      message.headers.set("Content-Type", "application/json");
+    }
+    const response = await this.batch(request);
+    return response;
+  }
+  /**
+   * Retrieve your logs.
+   *
+   * The logs endpoint is paginated and returns only 100 logs at a time.
+   * If you want to receive more logs, you can use the cursor to paginate.
+   *
+   * The cursor is a unix timestamp with millisecond precision
+   *
+   * @example
+   * ```ts
+   * let cursor = Date.now()
+   * const logs: Log[] = []
+   * while (cursor > 0) {
+   *   const res = await qstash.logs({ cursor })
+   *   logs.push(...res.logs)
+   *   cursor = res.cursor ?? 0
+   * }
+   * ```
+   */
+  async events(request) {
+    const query = {};
+    if (typeof request?.cursor === "number" && request.cursor > 0) {
+      query.cursor = request.cursor.toString();
+    } else if (typeof request?.cursor === "string" && request.cursor !== "") {
+      query.cursor = request.cursor;
+    }
+    for (const [key, value] of Object.entries(request?.filter ?? {})) {
+      if (typeof value === "number" && value < 0) {
+        continue;
+      }
+      if (key === "urlGroup") {
+        query.topicName = value.toString();
+      } else if (typeof value !== "undefined") {
+        query[key] = value.toString();
+      }
+    }
+    const responsePayload = await this.http.request({
+      path: ["v2", "events"],
+      method: "GET",
+      query
+    });
+    return {
+      cursor: responsePayload.cursor,
+      events: responsePayload.events.map((event) => {
+        return {
+          ...event,
+          urlGroup: event.topicName
+        };
+      })
+    };
+  }
+};
+
+// src/client/workflow/constants.ts
+var WORKFLOW_ID_HEADER = "Upstash-Workflow-RunId";
+var WORKFLOW_INIT_HEADER = "Upstash-Workflow-Init";
+var WORKFLOW_URL_HEADER = "Upstash-Workflow-Url";
+var WORKFLOW_FAILURE_HEADER = "Upstash-Workflow-Is-Failure";
+var WORKFLOW_PROTOCOL_VERSION = "1";
+var WORKFLOW_PROTOCOL_VERSION_HEADER = "Upstash-Workflow-Sdk-Version";
+var DEFAULT_CONTENT_TYPE = "application/json";
+var NO_CONCURRENCY = 1;
+var DEFAULT_RETRIES = 3;
+
+// node_modules/neverthrow/dist/index.es.js
+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, [])).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 = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n])
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+  }
+  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: n === "return" } : 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 ResultAsync = 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));
+    })));
+  }
+  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(ok2, _err) {
+    return this._promise.then((res) => res.match(ok2, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * 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);
+  }
+};
+var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var fromAsyncThrowable = ResultAsync.fromThrowable;
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable2(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable2;
+  function combine(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+var ok = (value) => new Ok(value);
+var err = (err2) => new Err(err2);
+var Ok = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  mapErr(_f) {
+    return ok(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
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.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(ok2, _err) {
+    return ok2(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);
+  }
+};
+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 err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(_f) {
+    return err(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 errAsync(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err2) {
+    return err2(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return function* () {
+      yield err(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;
+  }
+};
+var fromThrowable = Result.fromThrowable;
+
+// src/client/workflow/types.ts
+var StepTypes = ["Initial", "Run", "SleepFor", "SleepUntil", "Call"];
+
+// src/client/workflow/workflow-requests.ts
+var triggerFirstInvocation = async (workflowContext, retries, debug) => {
+  const headers = getHeaders(
+    "true",
+    workflowContext.workflowRunId,
+    workflowContext.url,
+    workflowContext.headers,
+    void 0,
+    workflowContext.failureUrl,
+    retries
+  );
+  await debug?.log("SUBMIT", "SUBMIT_FIRST_INVOCATION", {
+    headers,
+    requestPayload: workflowContext.requestPayload,
+    url: workflowContext.url
+  });
+  try {
+    await workflowContext.qstashClient.publishJSON({
+      headers,
+      method: "POST",
+      body: workflowContext.requestPayload,
+      url: workflowContext.url
+    });
+    return ok("success");
+  } catch (error) {
+    const error_ = error;
+    return err(error_);
+  }
+};
+var triggerRouteFunction = async ({
+  onCleanup,
+  onStep
+}) => {
+  try {
+    await onStep();
+    await onCleanup();
+    return ok("workflow-finished");
+  } catch (error) {
+    const error_ = error;
+    return error_ instanceof QStashWorkflowAbort ? ok("step-finished") : err(error_);
+  }
+};
+var triggerWorkflowDelete = async (workflowContext, debug, cancel = false) => {
+  await debug?.log("SUBMIT", "SUBMIT_CLEANUP", {
+    deletedWorkflowRunId: workflowContext.workflowRunId
+  });
+  const result = await workflowContext.qstashClient.http.request({
+    path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
+    method: "DELETE",
+    parseResponseAsJson: false
+  });
+  await debug?.log("SUBMIT", "SUBMIT_CLEANUP", result);
+};
+var recreateUserHeaders = (headers) => {
+  const filteredHeaders = new Headers();
+  const pairs = headers.entries();
+  for (const [header, value] of pairs) {
+    const headerLowerCase = header.toLowerCase();
+    if (!headerLowerCase.startsWith("upstash-workflow-") && !headerLowerCase.startsWith("x-vercel-") && !headerLowerCase.startsWith("x-forwarded-") && headerLowerCase !== "cf-connecting-ip") {
+      filteredHeaders.append(header, value);
+    }
+  }
+  return filteredHeaders;
+};
+var handleThirdPartyCallResult = async (request, requestPayload, client, workflowUrl, failureUrl, retries, debug) => {
+  try {
+    if (request.headers.get("Upstash-Workflow-Callback")) {
+      const callbackMessage = JSON.parse(requestPayload);
+      if (!(callbackMessage.status >= 200 && callbackMessage.status < 300)) {
+        await debug?.log("WARN", "SUBMIT_THIRD_PARTY_RESULT", {
+          status: callbackMessage.status,
+          body: decodeBase64(callbackMessage.body)
+        });
+        console.warn(
+          `Workflow Warning: "context.call" failed with status ${callbackMessage.status} and will retry (if there are retries remaining). Error Message:
+${decodeBase64(callbackMessage.body)}`
+        );
+        return ok("call-will-retry");
+      }
+      const workflowRunId = request.headers.get(WORKFLOW_ID_HEADER);
+      const stepIdString = request.headers.get("Upstash-Workflow-StepId");
+      const stepName = request.headers.get("Upstash-Workflow-StepName");
+      const stepType = request.headers.get("Upstash-Workflow-StepType");
+      const concurrentString = request.headers.get("Upstash-Workflow-Concurrent");
+      const contentType = request.headers.get("Upstash-Workflow-ContentType");
+      if (!(workflowRunId && stepIdString && stepName && StepTypes.includes(stepType) && concurrentString && contentType)) {
+        throw new Error(
+          `Missing info in callback message source header: ${JSON.stringify({
+            workflowRunId,
+            stepIdString,
+            stepName,
+            stepType,
+            concurrentString,
+            contentType
+          })}`
+        );
+      }
+      const userHeaders = recreateUserHeaders(request.headers);
+      const requestHeaders = getHeaders(
+        "false",
+        workflowRunId,
+        workflowUrl,
+        userHeaders,
+        void 0,
+        failureUrl,
+        retries
+      );
+      const callResultStep = {
+        stepId: Number(stepIdString),
+        stepName,
+        stepType,
+        out: decodeBase64(callbackMessage.body),
+        concurrent: Number(concurrentString)
+      };
+      await debug?.log("SUBMIT", "SUBMIT_THIRD_PARTY_RESULT", {
+        step: callResultStep,
+        headers: requestHeaders,
+        url: workflowUrl
+      });
+      const result = await client.publishJSON({
+        headers: requestHeaders,
+        method: "POST",
+        body: callResultStep,
+        url: workflowUrl
+      });
+      await debug?.log("SUBMIT", "SUBMIT_THIRD_PARTY_RESULT", {
+        messageId: result.messageId
+      });
+      return ok("is-call-return");
+    } else {
+      return ok("continue-workflow");
+    }
+  } catch (error) {
+    const isCallReturn = request.headers.get("Upstash-Workflow-Callback");
+    return err(
+      new QStashWorkflowError(
+        `Error when handling call return (isCallReturn=${isCallReturn}): ${error}`
+      )
+    );
+  }
+};
+var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step, failureUrl, retries) => {
+  const baseHeaders = {
+    [WORKFLOW_INIT_HEADER]: initHeaderValue,
+    [WORKFLOW_ID_HEADER]: workflowRunId,
+    [WORKFLOW_URL_HEADER]: workflowUrl,
+    [`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`]: WORKFLOW_PROTOCOL_VERSION,
+    ...failureUrl ? {
+      [`Upstash-Failure-Callback-Forward-${WORKFLOW_FAILURE_HEADER}`]: "true",
+      "Upstash-Failure-Callback": failureUrl
+    } : {},
+    ...retries === void 0 ? {} : {
+      "Upstash-Retries": retries.toString()
+    }
+  };
+  if (userHeaders) {
+    for (const header of userHeaders.keys()) {
+      if (step?.callHeaders) {
+        baseHeaders[`Upstash-Callback-Forward-${header}`] = userHeaders.get(header);
+      } else {
+        baseHeaders[`Upstash-Forward-${header}`] = userHeaders.get(header);
+      }
+    }
+  }
+  if (step?.callHeaders) {
+    const forwardedHeaders = Object.fromEntries(
+      Object.entries(step.callHeaders).map(([header, value]) => [
+        `Upstash-Forward-${header}`,
+        value
+      ])
+    );
+    const contentType = step.callHeaders["Content-Type"];
+    return {
+      ...baseHeaders,
+      ...forwardedHeaders,
+      "Upstash-Callback": workflowUrl,
+      "Upstash-Callback-Workflow-RunId": workflowRunId,
+      "Upstash-Callback-Workflow-CallType": "fromCallback",
+      "Upstash-Callback-Workflow-Init": "false",
+      "Upstash-Callback-Workflow-Url": workflowUrl,
+      "Upstash-Callback-Forward-Upstash-Workflow-Callback": "true",
+      "Upstash-Callback-Forward-Upstash-Workflow-StepId": step.stepId.toString(),
+      "Upstash-Callback-Forward-Upstash-Workflow-StepName": step.stepName,
+      "Upstash-Callback-Forward-Upstash-Workflow-StepType": step.stepType,
+      "Upstash-Callback-Forward-Upstash-Workflow-Concurrent": step.concurrent.toString(),
+      "Upstash-Callback-Forward-Upstash-Workflow-ContentType": contentType ?? DEFAULT_CONTENT_TYPE,
+      "Upstash-Workflow-CallType": "toCallback"
+    };
+  }
+  return baseHeaders;
+};
+var verifyRequest = async (body, signature, verifier) => {
+  if (!verifier) {
+    return;
+  }
+  try {
+    if (!signature) {
+      throw new Error("`Upstash-Signature` header is not passed.");
+    }
+    const isValid = await verifier.verify({
+      body,
+      signature
+    });
+    if (!isValid) {
+      throw new Error("Signature in `Upstash-Signature` header is not valid");
+    }
+  } catch (error) {
+    throw new QStashWorkflowError(
+      `Failed to verify that the Workflow request comes from QStash: ${error}
+
+If signature is missing, trigger the workflow endpoint by publishing your request to QStash instead of calling it directly.
+
+If you want to disable QStash Verification, you should clear env variables QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY`
+    );
+  }
+};
+
+// src/client/workflow/auto-executor.ts
+var AutoExecutor = class _AutoExecutor {
+  context;
+  promises = /* @__PURE__ */ new WeakMap();
+  activeLazyStepList;
+  debug;
+  nonPlanStepCount;
+  steps;
+  indexInCurrentList = 0;
+  stepCount = 0;
+  planStepCount = 0;
+  executingStep = false;
+  constructor(context, steps, debug) {
+    this.context = context;
+    this.debug = debug;
+    this.steps = steps;
+    this.nonPlanStepCount = this.steps.filter((step) => !step.targetStep).length;
+  }
+  /**
+   * Adds the step function to the list of step functions to run in
+   * parallel. After adding the function, defers the execution, so
+   * that if there is another step function to be added, it's also
+   * added.
+   *
+   * After all functions are added, list of functions are executed.
+   * If there is a single function, it's executed by itself. If there
+   * are multiple, they are run in parallel.
+   *
+   * If a function is already executing (this.executingStep), this
+   * means that there is a nested step which is not allowed. In this
+   * case, addStep throws QStashWorkflowError.
+   *
+   * @param stepInfo step plan to add
+   * @returns result of the step function
+   */
+  async addStep(stepInfo) {
+    if (this.executingStep) {
+      throw new QStashWorkflowError(
+        `A step can not be run inside another step. Tried to run '${stepInfo.stepName}' inside '${this.executingStep}'`
+      );
+    }
+    this.stepCount += 1;
+    const lazyStepList = this.activeLazyStepList ?? [];
+    if (!this.activeLazyStepList) {
+      this.activeLazyStepList = lazyStepList;
+      this.indexInCurrentList = 0;
+    }
+    lazyStepList.push(stepInfo);
+    const index = this.indexInCurrentList++;
+    const requestComplete = this.deferExecution().then(async () => {
+      if (!this.promises.has(lazyStepList)) {
+        const promise2 = this.getExecutionPromise(lazyStepList);
+        this.promises.set(lazyStepList, promise2);
+        this.activeLazyStepList = void 0;
+        this.planStepCount += lazyStepList.length > 1 ? lazyStepList.length : 0;
+      }
+      const promise = this.promises.get(lazyStepList);
+      return promise;
+    });
+    const result = await requestComplete;
+    return _AutoExecutor.getResult(lazyStepList, result, index);
+  }
+  /**
+   * Wraps a step function to set this.executingStep to step name
+   * before running and set this.executingStep to False after execution
+   * ends.
+   *
+   * this.executingStep allows us to detect nested steps which are not
+   * allowed.
+   *
+   * @param stepName name of the step being wrapped
+   * @param stepFunction step function to wrap
+   * @returns wrapped step function
+   */
+  wrapStep(stepName, stepFunction) {
+    this.executingStep = stepName;
+    const result = stepFunction();
+    this.executingStep = false;
+    return result;
+  }
+  /**
+   * Executes a step:
+   * - If the step result is available in the steps, returns the result
+   * - If the result is not avaiable, runs the function
+   * - Sends the result to QStash
+   *
+   * @param lazyStep lazy step to execute
+   * @returns step result
+   */
+  async runSingle(lazyStep) {
+    if (this.stepCount < this.nonPlanStepCount) {
+      const step = this.steps[this.stepCount + this.planStepCount];
+      validateStep(lazyStep, step);
+      await this.debug?.log("INFO", "RUN_SINGLE", {
+        fromRequest: true,
+        step,
+        stepCount: this.stepCount
+      });
+      return step.out;
+    }
+    const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
+    await this.debug?.log("INFO", "RUN_SINGLE", {
+      fromRequest: false,
+      step: resultStep,
+      stepCount: this.stepCount
+    });
+    await this.submitStepsToQStash([resultStep]);
+    return resultStep.out;
+  }
+  /**
+   * Runs steps in parallel.
+   *
+   * @param stepName parallel step name
+   * @param stepFunctions list of async functions to run in parallel
+   * @returns results of the functions run in parallel
+   */
+  async runParallel(parallelSteps) {
+    const initialStepCount = this.stepCount - (parallelSteps.length - 1);
+    const parallelCallState = this.getParallelCallState(parallelSteps.length, initialStepCount);
+    const sortedSteps = sortSteps(this.steps);
+    const plannedParallelStepCount = sortedSteps[initialStepCount + this.planStepCount]?.concurrent;
+    if (parallelCallState !== "first" && plannedParallelStepCount !== parallelSteps.length) {
+      throw new QStashWorkflowError(
+        `Incompatible number of parallel steps when call state was '${parallelCallState}'. Expected ${parallelSteps.length}, got ${plannedParallelStepCount} from the request.`
+      );
+    }
+    await this.debug?.log("INFO", "RUN_PARALLEL", {
+      parallelCallState,
+      initialStepCount,
+      plannedParallelStepCount,
+      stepCount: this.stepCount,
+      planStepCount: this.planStepCount
+    });
+    switch (parallelCallState) {
+      case "first": {
+        const planSteps = parallelSteps.map(
+          (parallelStep, index) => parallelStep.getPlanStep(parallelSteps.length, initialStepCount + index)
+        );
+        await this.submitStepsToQStash(planSteps);
+        break;
+      }
+      case "partial": {
+        const planStep = this.steps.at(-1);
+        if (!planStep || planStep.targetStep === void 0) {
+          throw new QStashWorkflowError(
+            `There must be a last step and it should have targetStep larger than 0.Received: ${JSON.stringify(planStep)}`
+          );
+        }
+        const stepIndex = planStep.targetStep - initialStepCount;
+        validateStep(parallelSteps[stepIndex], planStep);
+        try {
+          const resultStep = await parallelSteps[stepIndex].getResultStep(
+            parallelSteps.length,
+            planStep.targetStep
+          );
+          await this.submitStepsToQStash([resultStep]);
+        } catch (error) {
+          if (error instanceof QStashWorkflowAbort) {
+            throw error;
+          }
+          throw new QStashWorkflowError(
+            `Error submitting steps to QStash in partial parallel step execution: ${error}`
+          );
+        }
+        break;
+      }
+      case "discard": {
+        throw new QStashWorkflowAbort("discarded parallel");
+      }
+      case "last": {
+        const parallelResultSteps = sortedSteps.filter((step) => step.stepId >= initialStepCount).slice(0, parallelSteps.length);
+        validateParallelSteps(parallelSteps, parallelResultSteps);
+        return parallelResultSteps.map((step) => step.out);
+      }
+    }
+    const fillValue = void 0;
+    return Array.from({ length: parallelSteps.length }).fill(fillValue);
+  }
+  /**
+   * Determines the parallel call state
+   *
+   * First filters the steps to get the steps which are after `initialStepCount` parameter.
+   *
+   * Depending on the remaining steps, decides the parallel state:
+   * - "first": If there are no steps
+   * - "last" If there are equal to or more than `2 * parallelStepCount`. We multiply by two
+   *   because each step in a parallel execution will have 2 steps: a plan step and a result
+   *   step.
+   * - "partial": If the last step is a plan step
+   * - "discard": If the last step is not a plan step. This means that the parallel execution
+   *   is in progress (there are still steps to run) and one step has finished and submitted
+   *   its result to QStash
+   *
+   * @param parallelStepCount number of steps to run in parallel
+   * @param initialStepCount steps after the parallel invocation
+   * @returns parallel call state
+   */
+  getParallelCallState(parallelStepCount, initialStepCount) {
+    const remainingSteps = this.steps.filter(
+      (step) => (step.targetStep ?? step.stepId) >= initialStepCount
+    );
+    if (remainingSteps.length === 0) {
+      return "first";
+    } else if (remainingSteps.length >= 2 * parallelStepCount) {
+      return "last";
+    } else if (remainingSteps.at(-1)?.targetStep) {
+      return "partial";
+    } else {
+      return "discard";
+    }
+  }
+  /**
+   * sends the steps to QStash as batch
+   *
+   * @param steps steps to send
+   */
+  async submitStepsToQStash(steps) {
+    if (steps.length === 0) {
+      throw new QStashWorkflowError(
+        `Unable to submit steps to QStash. Provided list is empty. Current step: ${this.stepCount}`
+      );
+    }
+    await this.debug?.log("SUBMIT", "SUBMIT_STEP", { length: steps.length, steps });
+    const result = await this.context.qstashClient.batchJSON(
+      steps.map((singleStep) => {
+        const headers = getHeaders(
+          "false",
+          this.context.workflowRunId,
+          this.context.url,
+          this.context.headers,
+          singleStep,
+          this.context.failureUrl,
+          this.context.retries
+        );
+        const willWait = singleStep.concurrent === NO_CONCURRENCY || singleStep.stepId === 0;
+        return singleStep.callUrl ? (
+          // if the step is a third party call, we call the third party
+          // url (singleStep.callUrl) and pass information about the workflow
+          // in the headers (handled in getHeaders). QStash makes the request
+          // to callUrl and returns the result to Workflow endpoint.
+          // handleThirdPartyCallResult method sends the result of the third
+          // party call to QStash.
+          {
+            headers,
+            method: singleStep.callMethod,
+            body: singleStep.callBody,
+            url: singleStep.callUrl
+          }
+        ) : (
+          // if the step is not a third party call, we use workflow
+          // endpoint (context.url) as URL when calling QStash. QStash
+          // calls us back with the updated steps list.
+          {
+            headers,
+            method: "POST",
+            body: singleStep,
+            url: this.context.url,
+            notBefore: willWait ? singleStep.sleepUntil : void 0,
+            delay: willWait ? singleStep.sleepFor : void 0
+          }
+        );
+      })
+    );
+    await this.debug?.log("INFO", "SUBMIT_STEP", {
+      messageIds: result.map((message) => {
+        return {
+          message: message.messageId
+        };
+      })
+    });
+    throw new QStashWorkflowAbort(steps[0].stepName, steps[0]);
+  }
+  /**
+   * Get the promise by executing the lazt steps list. If there is a single
+   * step, we call `runSingle`. Otherwise `runParallel` is called.
+   *
+   * @param lazyStepList steps list to execute
+   * @returns promise corresponding to the execution
+   */
+  getExecutionPromise(lazyStepList) {
+    return lazyStepList.length === 1 ? this.runSingle(lazyStepList[0]) : this.runParallel(lazyStepList);
+  }
+  /**
+   * @param lazyStepList steps we executed
+   * @param result result of the promise from `getExecutionPromise`
+   * @param index index of the current step
+   * @returns result[index] if lazyStepList > 1, otherwise result
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  static getResult(lazyStepList, result, index) {
+    if (lazyStepList.length === 1) {
+      return result;
+    } else if (Array.isArray(result) && lazyStepList.length === result.length && index < lazyStepList.length) {
+      return result[index];
+    } else {
+      throw new QStashWorkflowError(
+        `Unexpected parallel call result while executing step ${index}: '${result}'. Expected ${lazyStepList.length} many items`
+      );
+    }
+  }
+  async deferExecution() {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+};
+var validateStep = (lazyStep, stepFromRequest) => {
+  if (lazyStep.stepName !== stepFromRequest.stepName) {
+    throw new QStashWorkflowError(
+      `Incompatible step name. Expected '${lazyStep.stepName}', got '${stepFromRequest.stepName}' from the request`
+    );
+  }
+  if (lazyStep.stepType !== stepFromRequest.stepType) {
+    throw new QStashWorkflowError(
+      `Incompatible step type. Expected '${lazyStep.stepType}', got '${stepFromRequest.stepType}' from the request`
+    );
+  }
+};
+var validateParallelSteps = (lazySteps, stepsFromRequest) => {
+  try {
+    for (const [index, stepFromRequest] of stepsFromRequest.entries()) {
+      validateStep(lazySteps[index], stepFromRequest);
+    }
+  } catch (error) {
+    if (error instanceof QStashWorkflowError) {
+      const lazyStepNames = lazySteps.map((lazyStep) => lazyStep.stepName);
+      const lazyStepTypes = lazySteps.map((lazyStep) => lazyStep.stepType);
+      const requestStepNames = stepsFromRequest.map((step) => step.stepName);
+      const requestStepTypes = stepsFromRequest.map((step) => step.stepType);
+      throw new QStashWorkflowError(
+        `Incompatible steps detected in parallel execution: ${error.message}
+  > Step Names from the request: ${JSON.stringify(requestStepNames)}
+    Step Types from the request: ${JSON.stringify(requestStepTypes)}
+  > Step Names expected: ${JSON.stringify(lazyStepNames)}
+    Step Types expected: ${JSON.stringify(lazyStepTypes)}`
+      );
+    }
+    throw error;
+  }
+};
+var sortSteps = (steps) => {
+  const getStepId = (step) => step.targetStep ?? step.stepId;
+  return steps.toSorted((step, stepOther) => getStepId(step) - getStepId(stepOther));
+};
+
+// src/client/workflow/steps.ts
+var BaseLazyStep = class {
+  stepName;
+  // will be set in the subclasses
+  constructor(stepName) {
+    this.stepName = stepName;
+  }
+};
+var LazyFunctionStep = class extends BaseLazyStep {
+  stepFunction;
+  stepType = "Run";
+  constructor(stepName, stepFunction) {
+    super(stepName);
+    this.stepFunction = stepFunction;
+  }
+  getPlanStep(concurrent, targetStep) {
+    {
+      return {
+        stepId: 0,
+        stepName: this.stepName,
+        stepType: this.stepType,
+        concurrent,
+        targetStep
+      };
+    }
+  }
+  async getResultStep(concurrent, stepId) {
+    let result = this.stepFunction();
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    return {
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      out: result,
+      concurrent
+    };
+  }
+};
+var LazySleepStep = class extends BaseLazyStep {
+  sleep;
+  stepType = "SleepFor";
+  constructor(stepName, sleep) {
+    super(stepName);
+    this.sleep = sleep;
+  }
+  getPlanStep(concurrent, targetStep) {
+    {
+      return {
+        stepId: 0,
+        stepName: this.stepName,
+        stepType: this.stepType,
+        sleepFor: this.sleep,
+        concurrent,
+        targetStep
+      };
+    }
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepFor: this.sleep,
+      concurrent
+    });
+  }
+};
+var LazySleepUntilStep = class extends BaseLazyStep {
+  sleepUntil;
+  stepType = "SleepUntil";
+  constructor(stepName, sleepUntil) {
+    super(stepName);
+    this.sleepUntil = sleepUntil;
+  }
+  getPlanStep(concurrent, targetStep) {
+    {
+      return {
+        stepId: 0,
+        stepName: this.stepName,
+        stepType: this.stepType,
+        sleepUntil: this.sleepUntil,
+        concurrent,
+        targetStep
+      };
+    }
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepUntil: this.sleepUntil,
+      concurrent
+    });
+  }
+};
+var LazyCallStep = class extends BaseLazyStep {
+  url;
+  method;
+  body;
+  headers;
+  stepType = "Call";
+  constructor(stepName, url, method, body, headers) {
+    super(stepName);
+    this.url = url;
+    this.method = method;
+    this.body = body;
+    this.headers = headers;
+  }
+  getPlanStep(concurrent, targetStep) {
+    {
+      return {
+        stepId: 0,
+        stepName: this.stepName,
+        stepType: this.stepType,
+        concurrent,
+        targetStep
+      };
+    }
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      callUrl: this.url,
+      callMethod: this.method,
+      callBody: this.body,
+      callHeaders: this.headers
+    });
+  }
+};
+
+// src/client/workflow/context.ts
+var WorkflowContext = class {
+  executor;
+  steps;
+  /**
+   * QStash client of the workflow
+   *
+   * Can be overwritten by passing `qstashClient` parameter in `serve`:
+   *
+   * ```ts
+   * import { Client } from "@upstash/qstash"
+   *
+   * export const POST = serve(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     qstashClient: new Client({...})
+   *   }
+   * )
+   * ```
+   */
+  qstashClient;
+  /**
+   * Run id of the workflow
+   */
+  workflowRunId;
+  /**
+   * URL of the workflow
+   *
+   * Can be overwritten by passing a `url` parameter in `serve`:
+   *
+   * ```ts
+   * export const POST = serve(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     url: "new-url-value"
+   *   }
+   * )
+   * ```
+   */
+  url;
+  /**
+   * URL to call in case of workflow failure with QStash failure callback
+   *
+   * https://upstash.com/docs/qstash/features/callbacks#what-is-a-failure-callback
+   *
+   * Can be overwritten by passing a `failureUrl` parameter in `serve`:
+   *
+   * ```ts
+   * export const POST = serve(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     failureUrl: "new-url-value"
+   *   }
+   * )
+   * ```
+   */
+  failureUrl;
+  /**
+   * Payload of the request which started the workflow.
+   *
+   * To specify its type, you can define `serve` as follows:
+   *
+   * ```ts
+   * // set requestPayload type to MyPayload:
+   * export const POST = serve<MyPayload>(
+   *   async (context) => {
+   *     ...
+   *   }
+   * )
+   * ```
+   *
+   * By default, `serve` tries to apply `JSON.parse` to the request payload.
+   * If your payload is encoded in a format other than JSON, you can utilize
+   * the `initialPayloadParser` parameter:
+   *
+   * ```ts
+   * export const POST = serve<MyPayload>(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     initialPayloadParser: (initialPayload) => {return doSomething(initialPayload)}
+   *   }
+   * )
+   * ```
+   */
+  requestPayload;
+  /**
+   * headers of the initial request
+   */
+  headers;
+  /**
+   * initial payload as a raw string
+   */
+  rawInitialPayload;
+  /**
+   * Map of environment variables and their values.
+   *
+   * Can be set using the `env` option of serve:
+   *
+   * ```ts
+   * export const POST = serve<MyPayload>(
+   *   async (context) => {
+   *     const key = context.env["API_KEY"];
+   *   },
+   *   {
+   *     env: {
+   *       "API_KEY": "*****";
+   *     }
+   *   }
+   * )
+   * ```
+   *
+   * Default value is set to `process.env`.
+   */
+  env;
+  /**
+   * Number of retries
+   */
+  retries;
+  constructor({
+    qstashClient,
+    workflowRunId,
+    headers,
+    steps,
+    url,
+    failureUrl,
+    debug,
+    initialPayload,
+    rawInitialPayload,
+    env,
+    retries
+  }) {
+    this.qstashClient = qstashClient;
+    this.workflowRunId = workflowRunId;
+    this.steps = steps;
+    this.url = url;
+    this.failureUrl = failureUrl;
+    this.headers = headers;
+    this.requestPayload = initialPayload;
+    this.rawInitialPayload = rawInitialPayload ?? JSON.stringify(this.requestPayload);
+    this.env = env ?? {};
+    this.retries = retries ?? DEFAULT_RETRIES;
+    this.executor = new AutoExecutor(this, this.steps, debug);
+  }
+  /**
+   * Executes a workflow step
+   *
+   * ```typescript
+   * const result = await context.run("step 1", () => {
+   *   return "result"
+   * })
+   * ```
+   *
+   * Can also be called in parallel and the steps will be executed
+   * simulatenously:
+   *
+   * ```typescript
+   * const [result1, result2] = await Promise.all([
+   *   context.run("step 1", () => {
+   *     return "result1"
+   *   })
+   *   context.run("step 2", async () => {
+   *     return await fetchResults()
+   *   })
+   * ])
+   * ```
+   *
+   * @param stepName name of the step
+   * @param stepFunction step function to be executed
+   * @returns result of the step function
+   */
+  async run(stepName, stepFunction) {
+    const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
+    return this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
+  }
+  /**
+   * Stops the execution for the duration provided.
+   *
+   * @param stepName
+   * @param duration sleep duration in seconds
+   * @returns undefined
+   */
+  async sleep(stepName, duration) {
+    await this.addStep(new LazySleepStep(stepName, duration));
+  }
+  /**
+   * Stops the execution until the date time provided.
+   *
+   * @param stepName
+   * @param datetime time to sleep until. Can be provided as a number (in unix seconds),
+   *   as a Date object or a string (passed to `new Date(datetimeString)`)
+   * @returns undefined
+   */
+  async sleepUntil(stepName, datetime) {
+    let time;
+    if (typeof datetime === "number") {
+      time = datetime;
+    } else {
+      datetime = typeof datetime === "string" ? new Date(datetime) : datetime;
+      time = Math.round(datetime.getTime() / 1e3);
+    }
+    await this.addStep(new LazySleepUntilStep(stepName, time));
+  }
+  /**
+   * Makes a third party call through QStash in order to make a
+   * network call without consuming any runtime.
+   *
+   * ```ts
+   * const postResult = await context.call<string>(
+   *   "post call step",
+   *   `https://www.some-endpoint.com/api`,
+   *   "POST",
+   *   "my-payload"
+   * );
+   * ```
+   *
+   * tries to parse the result of the request as JSON. If it's
+   * not a JSON which can be parsed, simply returns the response
+   * body as it is.
+   *
+   * @param stepName
+   * @param url url to call
+   * @param method call method
+   * @param body call body
+   * @param headers call headers
+   * @returns call result (parsed as JSON if possible)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  async call(stepName, url, method, body, headers) {
+    const result = await this.addStep(
+      new LazyCallStep(stepName, url, method, body, headers ?? {})
+    );
+    try {
+      return JSON.parse(result);
+    } catch {
+      return result;
+    }
+  }
+  /**
+   * Adds steps to the executor. Needed so that it can be overwritten in
+   * DisabledWorkflowContext.
+   */
+  async addStep(step) {
+    return await this.executor.addStep(step);
+  }
+};
+var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowContext {
+  static disabledMessage = "disabled-qstash-worklfow-run";
+  /**
+   * overwrite the WorkflowContext.addStep method to always raise QStashWorkflowAbort
+   * error in order to stop the execution whenever we encounter a step.
+   *
+   * @param _step
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async addStep(_step) {
+    throw new QStashWorkflowAbort(_DisabledWorkflowContext.disabledMessage);
+  }
+  /**
+   * copies the passed context to create a DisabledWorkflowContext. Then, runs the
+   * route function with the new context.
+   *
+   * - returns "run-ended" if there are no steps found or
+   *      if the auth failed and user called `return`
+   * - returns "step-found" if DisabledWorkflowContext.addStep is called.
+   * - if there is another error, returns the error.
+   *
+   * @param routeFunction
+   */
+  static async tryAuthentication(routeFunction, context) {
+    const disabledContext = new _DisabledWorkflowContext({
+      qstashClient: new Client({ baseUrl: "disabled-client", token: "disabled-client" }),
+      workflowRunId: context.workflowRunId,
+      headers: context.headers,
+      steps: [],
+      url: context.url,
+      failureUrl: context.failureUrl,
+      initialPayload: context.requestPayload,
+      rawInitialPayload: context.rawInitialPayload,
+      env: context.env,
+      retries: context.retries
+    });
+    try {
+      await routeFunction(disabledContext);
+    } catch (error) {
+      if (error instanceof QStashWorkflowAbort && error.stepName === this.disabledMessage) {
+        return ok("step-found");
+      }
+      return err(error);
+    }
+    return ok("run-ended");
+  }
+};
+
+// src/client/workflow/logger.ts
+var LOG_LEVELS = ["DEBUG", "INFO", "SUBMIT", "WARN", "ERROR"];
+var WorkflowLogger = class _WorkflowLogger {
+  logs = [];
+  options;
+  workflowRunId = void 0;
+  constructor(options) {
+    this.options = options;
+  }
+  async log(level, eventType, details) {
+    if (this.shouldLog(level)) {
+      const timestamp = Date.now();
+      const logEntry = {
+        timestamp,
+        workflowRunId: this.workflowRunId ?? "",
+        logLevel: level,
+        eventType,
+        details
+      };
+      this.logs.push(logEntry);
+      if (this.options.logOutput === "console") {
+        this.writeToConsole(logEntry);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  setWorkflowRunId(workflowRunId) {
+    this.workflowRunId = workflowRunId;
+  }
+  writeToConsole(logEntry) {
+    const JSON_SPACING = 2;
+    console.log(JSON.stringify(logEntry, void 0, JSON_SPACING));
+  }
+  shouldLog(level) {
+    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(this.options.logLevel);
+  }
+  static getLogger(verbose) {
+    if (typeof verbose === "object") {
+      return verbose;
+    } else {
+      return verbose ? new _WorkflowLogger({
+        logLevel: "INFO",
+        logOutput: "console"
+      }) : void 0;
+    }
+  }
+};
+
+// src/client/workflow/workflow-parser.ts
+var getPayload = async (request) => {
+  try {
+    return await request.text();
+  } catch {
+    return;
+  }
+};
+var parsePayload = (rawPayload) => {
+  const [encodedInitialPayload, ...encodedSteps] = JSON.parse(rawPayload);
+  const rawInitialPayload = decodeBase64(encodedInitialPayload.body);
+  const initialStep = {
+    stepId: 0,
+    stepName: "init",
+    stepType: "Initial",
+    out: rawInitialPayload,
+    concurrent: NO_CONCURRENCY
+  };
+  const stepsToDecode = encodedSteps.filter((step) => step.callType === "step");
+  const otherSteps = stepsToDecode.map((rawStep) => {
+    return JSON.parse(decodeBase64(rawStep.body));
+  });
+  const steps = [initialStep, ...otherSteps];
+  return {
+    rawInitialPayload,
+    steps
+  };
+};
+var deduplicateSteps = (steps) => {
+  const targetStepIds = [];
+  const stepIds = [];
+  const deduplicatedSteps = [];
+  for (const step of steps) {
+    if (step.stepId === 0) {
+      if (!targetStepIds.includes(step.targetStep ?? 0)) {
+        deduplicatedSteps.push(step);
+        targetStepIds.push(step.targetStep ?? 0);
+      }
+    } else {
+      if (!stepIds.includes(step.stepId)) {
+        deduplicatedSteps.push(step);
+        stepIds.push(step.stepId);
+      }
+    }
+  }
+  return deduplicatedSteps;
+};
+var checkIfLastOneIsDuplicate = async (steps, debug) => {
+  if (steps.length < 2) {
+    return false;
+  }
+  const lastStep = steps.at(-1);
+  const lastStepId = lastStep.stepId;
+  const lastTargetStepId = lastStep.targetStep;
+  for (let index = 0; index < steps.length - 1; index++) {
+    const step = steps[index];
+    if (step.stepId === lastStepId && step.targetStep === lastTargetStepId) {
+      const message = `QStash Workflow: The step '${step.stepName}' with id '${step.stepId}'  has run twice during workflow execution. Rest of the workflow will continue running as usual.`;
+      await debug?.log("WARN", "RESPONSE_DEFAULT", message);
+      console.warn(message);
+      return true;
+    }
+  }
+  return false;
+};
+var validateRequest = (request) => {
+  const versionHeader = request.headers.get(WORKFLOW_PROTOCOL_VERSION_HEADER);
+  const isFirstInvocation = !versionHeader;
+  if (!isFirstInvocation && versionHeader !== WORKFLOW_PROTOCOL_VERSION) {
+    throw new QStashWorkflowError(
+      `Incompatible workflow sdk protocol version. Expected ${WORKFLOW_PROTOCOL_VERSION}, got ${versionHeader} from the request.`
+    );
+  }
+  const workflowRunId = isFirstInvocation ? `wfr_${nanoid()}` : request.headers.get(WORKFLOW_ID_HEADER) ?? "";
+  if (workflowRunId.length === 0) {
+    throw new QStashWorkflowError("Couldn't get workflow id from header");
+  }
+  return {
+    isFirstInvocation,
+    workflowRunId
+  };
+};
+var parseRequest = async (requestPayload, isFirstInvocation, debug) => {
+  if (isFirstInvocation) {
+    return {
+      rawInitialPayload: requestPayload ?? "",
+      steps: [],
+      isLastDuplicate: false
+    };
+  } else {
+    if (!requestPayload) {
+      throw new QStashWorkflowError("Only first call can have an empty body");
+    }
+    const { rawInitialPayload, steps } = parsePayload(requestPayload);
+    const isLastDuplicate = await checkIfLastOneIsDuplicate(steps, debug);
+    const deduplicatedSteps = deduplicateSteps(steps);
+    return {
+      rawInitialPayload,
+      steps: deduplicatedSteps,
+      isLastDuplicate
+    };
+  }
+};
+var handleFailure = async (request, requestPayload, qstashClient, initialPayloadParser, failureFunction, debug) => {
+  if (request.headers.get(WORKFLOW_FAILURE_HEADER) !== "true") {
+    return ok("not-failure-callback");
+  }
+  if (!failureFunction) {
+    return err(
+      new QStashWorkflowError(
+        "Workflow endpoint is called to handle a failure, but a failureFunction is not provided in serve options. Either provide a failureUrl or a failureFunction."
+      )
+    );
+  }
+  try {
+    const { status, header, body, url, sourceHeader, sourceBody, workflowRunId } = JSON.parse(
+      requestPayload
+    );
+    const decodedBody = body ? decodeBase64(body) : "{}";
+    const errorPayload = JSON.parse(decodedBody);
+    const {
+      rawInitialPayload,
+      steps,
+      isLastDuplicate: _isLastDuplicate
+    } = await parseRequest(decodeBase64(sourceBody), false, debug);
+    const workflowContext = new WorkflowContext({
+      qstashClient,
+      workflowRunId,
+      initialPayload: initialPayloadParser(rawInitialPayload),
+      rawInitialPayload,
+      headers: recreateUserHeaders(new Headers(sourceHeader)),
+      steps,
+      url,
+      failureUrl: url,
+      debug
+    });
+    await failureFunction(workflowContext, status, errorPayload.message, header);
+  } catch (error) {
+    return err(error);
+  }
+  return ok("is-failure-callback");
+};
 
+// src/client/workflow/serve.ts
+var processOptions = (options) => {
+  const environment = options?.env ?? (typeof process === "undefined" ? {} : process.env);
+  const receiverEnvironmentVariablesSet = Boolean(
+    environment.QSTASH_CURRENT_SIGNING_KEY && environment.QSTASH_NEXT_SIGNING_KEY
+  );
+  return {
+    qstashClient: new Client({
+      baseUrl: environment.QSTASH_URL,
+      token: environment.QSTASH_TOKEN
+    }),
+    onStepFinish: (workflowRunId, _finishCondition) => new Response(JSON.stringify({ workflowRunId }), {
+      status: 200
+    }),
+    initialPayloadParser: (initialRequest) => {
+      if (!initialRequest) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(initialRequest);
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          return initialRequest;
+        }
+        throw error;
+      }
+    },
+    receiver: receiverEnvironmentVariablesSet ? new Receiver({
+      currentSigningKey: environment.QSTASH_CURRENT_SIGNING_KEY,
+      nextSigningKey: environment.QSTASH_NEXT_SIGNING_KEY
+    }) : void 0,
+    baseUrl: environment.UPSTASH_WORKFLOW_URL,
+    env: environment,
+    retries: DEFAULT_RETRIES,
+    ...options
+  };
+};
+var serve = (routeFunction, options) => {
+  const {
+    qstashClient,
+    onStepFinish,
+    initialPayloadParser,
+    url,
+    verbose,
+    receiver,
+    failureUrl,
+    failureFunction,
+    baseUrl,
+    env,
+    retries
+  } = processOptions(options);
+  const debug = WorkflowLogger.getLogger(verbose);
+  const handler = async (request) => {
+    const initialWorkflowUrl = url ?? request.url;
+    const workflowUrl = baseUrl ? initialWorkflowUrl.replace(/^(https?:\/\/[^/]+)(\/.*)?$/, (_, matchedBaseUrl, path) => {
+      return baseUrl + (path || "");
+    }) : initialWorkflowUrl;
+    if (workflowUrl !== initialWorkflowUrl) {
+      await debug?.log("WARN", "ENDPOINT_START", {
+        warning: `QStash Workflow: replacing the base of the url with "${baseUrl}" and using it as workflow endpoint.`,
+        originalURL: initialWorkflowUrl,
+        updatedURL: workflowUrl
+      });
+    }
+    const workflowFailureUrl = failureFunction ? workflowUrl : failureUrl;
+    const requestPayload = await getPayload(request) ?? "";
+    await verifyRequest(requestPayload, request.headers.get("upstash-signature"), receiver);
+    await debug?.log("INFO", "ENDPOINT_START");
+    const failureCheck = await handleFailure(
+      request,
+      requestPayload,
+      qstashClient,
+      initialPayloadParser,
+      failureFunction
+    );
+    if (failureCheck.isErr()) {
+      throw failureCheck.error;
+    } else if (failureCheck.value === "is-failure-callback") {
+      await debug?.log("WARN", "RESPONSE_DEFAULT", "failureFunction executed");
+      return onStepFinish("no-workflow-id", "failure-callback");
+    }
+    const { isFirstInvocation, workflowRunId } = validateRequest(request);
+    debug?.setWorkflowRunId(workflowRunId);
+    const { rawInitialPayload, steps, isLastDuplicate } = await parseRequest(
+      requestPayload,
+      isFirstInvocation,
+      debug
+    );
+    if (isLastDuplicate) {
+      return onStepFinish("no-workflow-id", "duplicate-step");
+    }
+    const workflowContext = new WorkflowContext({
+      qstashClient,
+      workflowRunId,
+      initialPayload: initialPayloadParser(rawInitialPayload),
+      rawInitialPayload,
+      headers: recreateUserHeaders(request.headers),
+      steps,
+      url: workflowUrl,
+      failureUrl: workflowFailureUrl,
+      debug,
+      env
+    });
+    const authCheck = await DisabledWorkflowContext.tryAuthentication(
+      routeFunction,
+      workflowContext
+    );
+    if (authCheck.isErr()) {
+      await debug?.log("ERROR", "ERROR", { error: authCheck.error.message });
+      throw authCheck.error;
+    } else if (authCheck.value === "run-ended") {
+      return onStepFinish("no-workflow-id", "auth-fail");
+    }
+    const callReturnCheck = await handleThirdPartyCallResult(
+      request,
+      rawInitialPayload,
+      qstashClient,
+      workflowUrl,
+      workflowFailureUrl,
+      retries,
+      debug
+    );
+    if (callReturnCheck.isErr()) {
+      await debug?.log("ERROR", "SUBMIT_THIRD_PARTY_RESULT", {
+        error: callReturnCheck.error.message
+      });
+      throw callReturnCheck.error;
+    } else if (callReturnCheck.value === "continue-workflow") {
+      const result = isFirstInvocation ? await triggerFirstInvocation(workflowContext, retries, debug) : await triggerRouteFunction({
+        onStep: async () => routeFunction(workflowContext),
+        onCleanup: async () => {
+          await triggerWorkflowDelete(workflowContext, debug);
+        }
+      });
+      if (result.isErr()) {
+        await debug?.log("ERROR", "ERROR", { error: result.error.message });
+        throw result.error;
+      }
+      await debug?.log("INFO", "RESPONSE_WORKFLOW");
+      return onStepFinish(workflowContext.workflowRunId, "success");
+    }
+    await debug?.log("INFO", "RESPONSE_DEFAULT");
+    return onStepFinish("no-workflow-id", "fromCallback");
+  };
+  return async (request) => {
+    try {
+      return await handler(request);
+    } catch (error) {
+      console.error(error);
+      return new Response(JSON.stringify(formatWorkflowError(error)), { status: 500 });
+    }
+  };
+};
 
-var _chunkR5CZPV7Hjs = require('./chunk-R5CZPV7H.js');
+// src/client/workflow/index.ts
+var Workflow = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Cancel an ongoing workflow
+   *
+   * @param workflowRunId run id of the workflow to delete
+   * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
+   */
+  async cancel(workflowRunId) {
+    const result = await this.http.request({
+      path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
+      method: "DELETE",
+      parseResponseAsJson: false
+    });
+    return result ?? true;
+  }
+};
 
 // platforms/nextjs.ts
-var _server = require('next/server');
 var BAD_REQUEST = 400;
 function verifySignature(handler, config) {
-  const currentSigningKey = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.currentSigningKey]), () => ( process.env.QSTASH_CURRENT_SIGNING_KEY));
+  const currentSigningKey = config?.currentSigningKey ?? process.env.QSTASH_CURRENT_SIGNING_KEY;
   if (!currentSigningKey) {
     throw new Error(
       "currentSigningKey is required, either in the config or as env variable QSTASH_CURRENT_SIGNING_KEY"
     );
   }
-  const nextSigningKey = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _2 => _2.nextSigningKey]), () => ( process.env.QSTASH_NEXT_SIGNING_KEY));
+  const nextSigningKey = config?.nextSigningKey ?? process.env.QSTASH_NEXT_SIGNING_KEY;
   if (!nextSigningKey) {
     throw new Error(
       "nextSigningKey is required, either in the config or as env variable QSTASH_NEXT_SIGNING_KEY"
     );
   }
-  const receiver = new (0, _chunkR5CZPV7Hjs.Receiver)({
+  const receiver = new Receiver({
     currentSigningKey,
     nextSigningKey
   });
@@ -42,7 +4605,7 @@ function verifySignature(handler, config) {
     const isValid = await receiver.verify({
       signature,
       body,
-      clockTolerance: _optionalChain([config, 'optionalAccess', _3 => _3.clockTolerance])
+      clockTolerance: config?.clockTolerance
     });
     if (!isValid) {
       response.status(BAD_REQUEST);
@@ -52,26 +4615,26 @@ function verifySignature(handler, config) {
     }
     try {
       request.body = request.headers["content-type"] === "application/json" ? JSON.parse(body) : body;
-    } catch (e) {
+    } catch {
       request.body = body;
     }
     return handler(request, response);
   };
 }
 function verifySignatureEdge(handler, config) {
-  const currentSigningKey = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _4 => _4.currentSigningKey]), () => ( process.env.QSTASH_CURRENT_SIGNING_KEY));
+  const currentSigningKey = config?.currentSigningKey ?? process.env.QSTASH_CURRENT_SIGNING_KEY;
   if (!currentSigningKey) {
     throw new Error(
       "currentSigningKey is required, either in the config or as env variable QSTASH_CURRENT_SIGNING_KEY"
     );
   }
-  const nextSigningKey = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _5 => _5.nextSigningKey]), () => ( process.env.QSTASH_NEXT_SIGNING_KEY));
+  const nextSigningKey = config?.nextSigningKey ?? process.env.QSTASH_NEXT_SIGNING_KEY;
   if (!nextSigningKey) {
     throw new Error(
       "nextSigningKey is required, either in the config or as env variable QSTASH_NEXT_SIGNING_KEY"
     );
   }
-  const receiver = new (0, _chunkR5CZPV7Hjs.Receiver)({
+  const receiver = new Receiver({
     currentSigningKey,
     nextSigningKey
   });
@@ -79,7 +4642,7 @@ function verifySignatureEdge(handler, config) {
     const requestClone = request.clone();
     const signature = request.headers.get("upstash-signature");
     if (!signature) {
-      return new (0, _server.NextResponse)(new TextEncoder().encode("`Upstash-Signature` header is missing"), {
+      return new import_server.NextResponse(new TextEncoder().encode("`Upstash-Signature` header is missing"), {
         status: 403
       });
     }
@@ -90,28 +4653,28 @@ function verifySignatureEdge(handler, config) {
     const isValid = await receiver.verify({
       signature,
       body,
-      clockTolerance: _optionalChain([config, 'optionalAccess', _6 => _6.clockTolerance])
+      clockTolerance: config?.clockTolerance
     });
     if (!isValid) {
-      return new (0, _server.NextResponse)(new TextEncoder().encode("invalid signature"), { status: 403 });
+      return new import_server.NextResponse(new TextEncoder().encode("invalid signature"), { status: 403 });
     }
     return handler(request, nfe);
   };
 }
 function verifySignatureAppRouter(handler, config) {
-  const currentSigningKey = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _7 => _7.currentSigningKey]), () => ( process.env.QSTASH_CURRENT_SIGNING_KEY));
+  const currentSigningKey = config?.currentSigningKey ?? process.env.QSTASH_CURRENT_SIGNING_KEY;
   if (!currentSigningKey) {
     throw new Error(
       "currentSigningKey is required, either in the config or as env variable QSTASH_CURRENT_SIGNING_KEY"
     );
   }
-  const nextSigningKey = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _8 => _8.nextSigningKey]), () => ( process.env.QSTASH_NEXT_SIGNING_KEY));
+  const nextSigningKey = config?.nextSigningKey ?? process.env.QSTASH_NEXT_SIGNING_KEY;
   if (!nextSigningKey) {
     throw new Error(
       "nextSigningKey is required, either in the config or as env variable QSTASH_NEXT_SIGNING_KEY"
     );
   }
-  const receiver = new (0, _chunkR5CZPV7Hjs.Receiver)({
+  const receiver = new Receiver({
     currentSigningKey,
     nextSigningKey
   });
@@ -119,7 +4682,7 @@ function verifySignatureAppRouter(handler, config) {
     const requestClone = request.clone();
     const signature = request.headers.get("upstash-signature");
     if (!signature) {
-      return new (0, _server.NextResponse)(new TextEncoder().encode("`Upstash-Signature` header is missing"), {
+      return new import_server.NextResponse(new TextEncoder().encode("`Upstash-Signature` header is missing"), {
         status: 403
       });
     }
@@ -130,17 +4693,17 @@ function verifySignatureAppRouter(handler, config) {
     const isValid = await receiver.verify({
       signature,
       body,
-      clockTolerance: _optionalChain([config, 'optionalAccess', _9 => _9.clockTolerance])
+      clockTolerance: config?.clockTolerance
     });
     if (!isValid) {
-      return new (0, _server.NextResponse)(new TextEncoder().encode("invalid signature"), { status: 403 });
+      return new import_server.NextResponse(new TextEncoder().encode("invalid signature"), { status: 403 });
     }
     return handler(request, params);
   };
 }
 var serve2 = (routeFunction, options) => {
-  const handler = _chunkR5CZPV7Hjs.serve.call(void 0, routeFunction, {
-    onStepFinish: (workflowRunId) => new (0, _server.NextResponse)(JSON.stringify({ workflowRunId }), { status: 200 }),
+  const handler = serve(routeFunction, {
+    onStepFinish: (workflowRunId) => new import_server.NextResponse(JSON.stringify({ workflowRunId }), { status: 200 }),
     ...options
   });
   return async (request) => {
@@ -148,9 +4711,9 @@ var serve2 = (routeFunction, options) => {
   };
 };
 var servePagesRouter = (routeFunction, options) => {
-  const handler = _chunkR5CZPV7Hjs.serve.call(void 0, routeFunction, options);
+  const handler = serve(routeFunction, options);
   return async (req, res) => {
-    if (_optionalChain([req, 'access', _10 => _10.method, 'optionalAccess', _11 => _11.toUpperCase, 'call', _12 => _12()]) !== "POST") {
+    if (req.method?.toUpperCase() !== "POST") {
       res.status(405).json("Only POST requests are allowed in worklfows");
       return;
     } else if (!req.url) {
@@ -158,10 +4721,10 @@ var servePagesRouter = (routeFunction, options) => {
       return;
     }
     const protocol = req.headers["x-forwarded-proto"];
-    const baseUrl = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.baseUrl]), () => ( `${protocol}://${req.headers.host}`));
-    const request = new Request(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.url]), () => ( `${baseUrl}${req.url}`)), {
+    const baseUrl = options?.baseUrl ?? `${protocol}://${req.headers.host}`;
+    const request = new Request(options?.url ?? `${baseUrl}${req.url}`, {
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      body: _nullishCoalesce(JSON.stringify(req.body), () => ( "")),
+      body: JSON.stringify(req.body) ?? "",
       headers: new Headers(req.headersDistinct),
       method: "POST"
     });
@@ -169,10 +4732,11 @@ var servePagesRouter = (routeFunction, options) => {
     res.status(response.status).json(await response.json());
   };
 };
-
-
-
-
-
-
-exports.serve = serve2; exports.servePagesRouter = servePagesRouter; exports.verifySignature = verifySignature; exports.verifySignatureAppRouter = verifySignatureAppRouter; exports.verifySignatureEdge = verifySignatureEdge;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serve,
+  servePagesRouter,
+  verifySignature,
+  verifySignatureAppRouter,
+  verifySignatureEdge
+});