@uniformdev/next-app-router 20.63.1-alpha.12 → 20.63.1-alpha.21

package/dist/middleware.mjs

@@ -7,7 +7,6 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -27,25 +26,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
 
 // ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
 var require_yocto_queue = __commonJS({
   "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
     "use strict";
-    var Node2 = class {
+    var Node = class {
       /// value;
       /// next;
       constructor(value) {
@@ -53,7 +43,7 @@ var require_yocto_queue = __commonJS({
         this.next = void 0;
       }
     };
-    var Queue2 = class {
+    var Queue = class {
       // TODO: Use private class fields when targeting Node.js 12.
       // #_head;
       // #_tail;
@@ -62,7 +52,7 @@ var require_yocto_queue = __commonJS({
         this.clear();
       }
       enqueue(value) {
-        const node = new Node2(value);
+        const node = new Node(value);
         if (this._head) {
           this._tail.next = node;
           this._tail = node;
@@ -97,7 +87,7 @@ var require_yocto_queue = __commonJS({
         }
       }
     };
-    module.exports = Queue2;
+    module.exports = Queue;
   }
 });
 
@@ -105,12 +95,12 @@ var require_yocto_queue = __commonJS({
 var require_p_limit = __commonJS({
   "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
     "use strict";
-    var Queue2 = require_yocto_queue();
-    var pLimit3 = (concurrency) => {
+    var Queue = require_yocto_queue();
+    var pLimit2 = (concurrency) => {
       if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
         throw new TypeError("Expected `concurrency` to be a number from 1 and up");
       }
-      const queue = new Queue2();
+      const queue = new Queue();
       let activeCount = 0;
       const next = () => {
         activeCount--;
@@ -155,238 +145,7 @@ var require_p_limit = __commonJS({
       });
       return generator;
     };
-    module.exports = pLimit3;
-  }
-});
-
-// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS({
-  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
-    "use strict";
-    function RetryOperation(timeouts, options) {
-      if (typeof options === "boolean") {
-        options = { forever: options };
-      }
-      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-      this._timeouts = timeouts;
-      this._options = options || {};
-      this._maxRetryTime = options && options.maxRetryTime || Infinity;
-      this._fn = null;
-      this._errors = [];
-      this._attempts = 1;
-      this._operationTimeout = null;
-      this._operationTimeoutCb = null;
-      this._timeout = null;
-      this._operationStart = null;
-      this._timer = null;
-      if (this._options.forever) {
-        this._cachedTimeouts = this._timeouts.slice(0);
-      }
-    }
-    module.exports = RetryOperation;
-    RetryOperation.prototype.reset = function() {
-      this._attempts = 1;
-      this._timeouts = this._originalTimeouts.slice(0);
-    };
-    RetryOperation.prototype.stop = function() {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (this._timer) {
-        clearTimeout(this._timer);
-      }
-      this._timeouts = [];
-      this._cachedTimeouts = null;
-    };
-    RetryOperation.prototype.retry = function(err) {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (!err) {
-        return false;
-      }
-      var currentTime = (/* @__PURE__ */ new Date()).getTime();
-      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-        this._errors.push(err);
-        this._errors.unshift(new Error("RetryOperation timeout occurred"));
-        return false;
-      }
-      this._errors.push(err);
-      var timeout = this._timeouts.shift();
-      if (timeout === void 0) {
-        if (this._cachedTimeouts) {
-          this._errors.splice(0, this._errors.length - 1);
-          timeout = this._cachedTimeouts.slice(-1);
-        } else {
-          return false;
-        }
-      }
-      var self = this;
-      this._timer = setTimeout(function() {
-        self._attempts++;
-        if (self._operationTimeoutCb) {
-          self._timeout = setTimeout(function() {
-            self._operationTimeoutCb(self._attempts);
-          }, self._operationTimeout);
-          if (self._options.unref) {
-            self._timeout.unref();
-          }
-        }
-        self._fn(self._attempts);
-      }, timeout);
-      if (this._options.unref) {
-        this._timer.unref();
-      }
-      return true;
-    };
-    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-      this._fn = fn;
-      if (timeoutOps) {
-        if (timeoutOps.timeout) {
-          this._operationTimeout = timeoutOps.timeout;
-        }
-        if (timeoutOps.cb) {
-          this._operationTimeoutCb = timeoutOps.cb;
-        }
-      }
-      var self = this;
-      if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function() {
-          self._operationTimeoutCb();
-        }, self._operationTimeout);
-      }
-      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
-      this._fn(this._attempts);
-    };
-    RetryOperation.prototype.try = function(fn) {
-      console.log("Using RetryOperation.try() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = function(fn) {
-      console.log("Using RetryOperation.start() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = RetryOperation.prototype.try;
-    RetryOperation.prototype.errors = function() {
-      return this._errors;
-    };
-    RetryOperation.prototype.attempts = function() {
-      return this._attempts;
-    };
-    RetryOperation.prototype.mainError = function() {
-      if (this._errors.length === 0) {
-        return null;
-      }
-      var counts = {};
-      var mainError = null;
-      var mainErrorCount = 0;
-      for (var i = 0; i < this._errors.length; i++) {
-        var error = this._errors[i];
-        var message = error.message;
-        var count = (counts[message] || 0) + 1;
-        counts[message] = count;
-        if (count >= mainErrorCount) {
-          mainError = error;
-          mainErrorCount = count;
-        }
-      }
-      return mainError;
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
-var require_retry = __commonJS({
-  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
-    "use strict";
-    var RetryOperation = require_retry_operation();
-    exports.operation = function(options) {
-      var timeouts = exports.timeouts(options);
-      return new RetryOperation(timeouts, {
-        forever: options && (options.forever || options.retries === Infinity),
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-      });
-    };
-    exports.timeouts = function(options) {
-      if (options instanceof Array) {
-        return [].concat(options);
-      }
-      var opts = {
-        retries: 10,
-        factor: 2,
-        minTimeout: 1 * 1e3,
-        maxTimeout: Infinity,
-        randomize: false
-      };
-      for (var key in options) {
-        opts[key] = options[key];
-      }
-      if (opts.minTimeout > opts.maxTimeout) {
-        throw new Error("minTimeout is greater than maxTimeout");
-      }
-      var timeouts = [];
-      for (var i = 0; i < opts.retries; i++) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      if (options && options.forever && !timeouts.length) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      timeouts.sort(function(a, b) {
-        return a - b;
-      });
-      return timeouts;
-    };
-    exports.createTimeout = function(attempt, opts) {
-      var random = opts.randomize ? Math.random() + 1 : 1;
-      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
-      timeout = Math.min(timeout, opts.maxTimeout);
-      return timeout;
-    };
-    exports.wrap = function(obj, options, methods) {
-      if (options instanceof Array) {
-        methods = options;
-        options = null;
-      }
-      if (!methods) {
-        methods = [];
-        for (var key in obj) {
-          if (typeof obj[key] === "function") {
-            methods.push(key);
-          }
-        }
-      }
-      for (var i = 0; i < methods.length; i++) {
-        var method = methods[i];
-        var original = obj[method];
-        obj[method] = function retryWrapper(original2) {
-          var op = exports.operation(options);
-          var args = Array.prototype.slice.call(arguments, 1);
-          var callback = args.pop();
-          args.push(function(err) {
-            if (op.retry(err)) {
-              return;
-            }
-            if (err) {
-              arguments[0] = op.mainError();
-            }
-            callback.apply(this, arguments);
-          });
-          op.attempt(function() {
-            original2.apply(obj, args);
-          });
-        }.bind(obj, original);
-        obj[method].options = options;
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
-var require_retry2 = __commonJS({
-  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
-    "use strict";
-    module.exports = require_retry();
+    module.exports = pLimit2;
   }
 });
 
@@ -585,8 +344,8 @@ var __defProp2 = Object.defineProperty;
 var __typeError2 = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck2 = (obj, member, msg) => member.has(obj) || __typeError2("Cannot " + msg);
 var __privateGet2 = (obj, member, getter) => (__accessCheck2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd2 = (obj, member, value) => member.has(obj) ? __typeError2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
@@ -608,7 +367,7 @@ var ApiClientError = class _ApiClientError extends Error {
 };
 var ApiClient = class _ApiClient {
   constructor(options) {
-    __publicField2(this, "options");
+    __publicField(this, "options");
     var _a, _b, _c, _d, _e;
     if (!options.apiKey && !options.bearerToken) {
       throw new Error("You must provide an API key or a bearer token");
@@ -990,185 +749,391 @@ var _TestClient = class _TestClient2 extends ApiClient {
 _url7 = /* @__PURE__ */ new WeakMap();
 __privateAdd2(_TestClient, _url7, "/api/v2/test");
 
-// ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
-var Node = class {
-  constructor(value) {
-    __publicField(this, "value");
-    __publicField(this, "next");
-    this.value = value;
-  }
+// ../canvas/dist/index.mjs
+var __create2 = Object.create;
+var __defProp3 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __typeError3 = (msg) => {
+  throw TypeError(msg);
 };
-var _head, _tail, _size;
-var Queue = class {
-  constructor() {
-    __privateAdd(this, _head);
-    __privateAdd(this, _tail);
-    __privateAdd(this, _size);
-    this.clear();
-  }
-  enqueue(value) {
-    const node = new Node(value);
-    if (__privateGet(this, _head)) {
-      __privateGet(this, _tail).next = node;
-      __privateSet(this, _tail, node);
-    } else {
-      __privateSet(this, _head, node);
-      __privateSet(this, _tail, node);
-    }
-    __privateWrapper(this, _size)._++;
-  }
-  dequeue() {
-    const current = __privateGet(this, _head);
-    if (!current) {
-      return;
-    }
-    __privateSet(this, _head, __privateGet(this, _head).next);
-    __privateWrapper(this, _size)._--;
-    if (!__privateGet(this, _head)) {
-      __privateSet(this, _tail, void 0);
-    }
-    return current.value;
-  }
-  peek() {
-    if (!__privateGet(this, _head)) {
-      return;
-    }
-    return __privateGet(this, _head).value;
-  }
-  clear() {
-    __privateSet(this, _head, void 0);
-    __privateSet(this, _tail, void 0);
-    __privateSet(this, _size, 0);
+var __commonJS2 = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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)
+        __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
   }
-  get size() {
-    return __privateGet(this, _size);
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+  // 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 ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __accessCheck3 = (obj, member, msg) => member.has(obj) || __typeError3("Cannot " + msg);
+var __privateGet3 = (obj, member, getter) => (__accessCheck3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd3 = (obj, member, value) => member.has(obj) ? __typeError3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var require_yocto_queue2 = __commonJS2({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module.exports = Queue;
   }
-  *[Symbol.iterator]() {
-    let current = __privateGet(this, _head);
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
+});
+var require_p_limit2 = __commonJS2({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
+    "use strict";
+    var Queue = require_yocto_queue2();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module.exports = pLimit2;
   }
-  *drain() {
-    while (__privateGet(this, _head)) {
-      yield this.dequeue();
+});
+var require_retry_operation = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
     }
+    module.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      this._timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
   }
-};
-_head = new WeakMap();
-_tail = new WeakMap();
-_size = new WeakMap();
-
-// ../../node_modules/.pnpm/p-limit@6.2.0/node_modules/p-limit/index.js
-function pLimit2(concurrency) {
-  validateConcurrency(concurrency);
-  const queue = new Queue();
-  let activeCount = 0;
-  const resumeNext = () => {
-    if (activeCount < concurrency && queue.size > 0) {
-      queue.dequeue()();
-      activeCount++;
-    }
-  };
-  const next = () => {
-    activeCount--;
-    resumeNext();
-  };
-  const run = async (function_, resolve, arguments_) => {
-    const result = (async () => function_(...arguments_))();
-    resolve(result);
-    try {
-      await result;
-    } catch (e) {
-    }
-    next();
-  };
-  const enqueue = (function_, resolve, arguments_) => {
-    new Promise((internalResolve) => {
-      queue.enqueue(internalResolve);
-    }).then(
-      run.bind(void 0, function_, resolve, arguments_)
-    );
-    (async () => {
-      await Promise.resolve();
-      if (activeCount < concurrency) {
-        resumeNext();
+});
+var require_retry = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
       }
-    })();
-  };
-  const generator = (function_, ...arguments_) => new Promise((resolve) => {
-    enqueue(function_, resolve, arguments_);
-  });
-  Object.defineProperties(generator, {
-    activeCount: {
-      get: () => activeCount
-    },
-    pendingCount: {
-      get: () => queue.size
-    },
-    clearQueue: {
-      value() {
-        queue.clear();
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
       }
-    },
-    concurrency: {
-      get: () => concurrency,
-      set(newConcurrency) {
-        validateConcurrency(newConcurrency);
-        concurrency = newConcurrency;
-        queueMicrotask(() => {
-          while (activeCount < concurrency && queue.size > 0) {
-            resumeNext();
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
           }
-        });
+        }
       }
-    }
-  });
-  return generator;
-}
-function validateConcurrency(concurrency) {
-  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
   }
-}
-
-// ../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
-var import_retry = __toESM(require_retry2(), 1);
-
-// ../../node_modules/.pnpm/is-network-error@1.1.0/node_modules/is-network-error/index.js
-var objectToString = Object.prototype.toString;
-var isError = (value) => objectToString.call(value) === "[object Error]";
-var errorMessages = /* @__PURE__ */ new Set([
-  "network error",
-  // Chrome
+});
+var require_retry2 = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_retry();
+  }
+});
+var import_p_limit2 = __toESM2(require_p_limit2());
+var import_retry = __toESM2(require_retry2(), 1);
+var networkErrorMsgs = /* @__PURE__ */ new Set([
   "Failed to fetch",
   // Chrome
   "NetworkError when attempting to fetch resource.",
   // Firefox
   "The Internet connection appears to be offline.",
-  // Safari 16
-  "Load failed",
-  // Safari 17+
+  // Safari
   "Network request failed",
   // `cross-fetch`
-  "fetch failed",
-  // Undici (Node.js)
-  "terminated"
+  "fetch failed"
   // Undici (Node.js)
 ]);
-function isNetworkError(error) {
-  const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
-  if (!isValid) {
-    return false;
-  }
-  if (error.message === "Load failed") {
-    return error.stack === void 0;
-  }
-  return errorMessages.has(error.message);
-}
-
-// ../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
 var AbortError = class extends Error {
   constructor(message) {
     super();
@@ -1189,68 +1154,63 @@ var decorateErrorWithCounts = (error, attemptNumber, options) => {
   error.retriesLeft = retriesLeft;
   return error;
 };
+var isNetworkError = (errorMessage) => networkErrorMsgs.has(errorMessage);
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new Error(errorMessage) : new DOMException(errorMessage);
 async function pRetry(input, options) {
   return new Promise((resolve, reject) => {
-    var _a, _b, _c;
-    options = { ...options };
-    (_a = options.onFailedAttempt) != null ? _a : options.onFailedAttempt = () => {
+    options = {
+      onFailedAttempt() {
+      },
+      retries: 10,
+      ...options
     };
-    (_b = options.shouldRetry) != null ? _b : options.shouldRetry = () => true;
-    (_c = options.retries) != null ? _c : options.retries = 10;
     const operation = import_retry.default.operation(options);
-    const abortHandler = () => {
-      var _a2;
-      operation.stop();
-      reject((_a2 = options.signal) == null ? void 0 : _a2.reason);
-    };
-    if (options.signal && !options.signal.aborted) {
-      options.signal.addEventListener("abort", abortHandler, { once: true });
-    }
-    const cleanUp = () => {
-      var _a2;
-      (_a2 = options.signal) == null ? void 0 : _a2.removeEventListener("abort", abortHandler);
-      operation.stop();
-    };
     operation.attempt(async (attemptNumber) => {
       try {
-        const result = await input(attemptNumber);
-        cleanUp();
-        resolve(result);
+        resolve(await input(attemptNumber));
       } catch (error) {
-        try {
-          if (!(error instanceof Error)) {
-            throw new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
-          }
-          if (error instanceof AbortError) {
-            throw error.originalError;
-          }
-          if (error instanceof TypeError && !isNetworkError(error)) {
-            throw error;
-          }
+        if (!(error instanceof Error)) {
+          reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+          return;
+        }
+        if (error instanceof AbortError) {
+          operation.stop();
+          reject(error.originalError);
+        } else if (error instanceof TypeError && !isNetworkError(error.message)) {
+          operation.stop();
+          reject(error);
+        } else {
           decorateErrorWithCounts(error, attemptNumber, options);
-          if (!await options.shouldRetry(error)) {
-            operation.stop();
-            reject(error);
+          try {
+            await options.onFailedAttempt(error);
+          } catch (error2) {
+            reject(error2);
+            return;
           }
-          await options.onFailedAttempt(error);
           if (!operation.retry(error)) {
-            throw operation.mainError();
+            reject(operation.mainError());
           }
-        } catch (finalError) {
-          decorateErrorWithCounts(finalError, attemptNumber, options);
-          cleanUp();
-          reject(finalError);
         }
       }
     });
+    if (options.signal && !options.signal.aborted) {
+      options.signal.addEventListener("abort", () => {
+        operation.stop();
+        const reason = options.signal.reason === void 0 ? getDOMException("The operation was aborted.") : options.signal.reason;
+        reject(reason instanceof Error ? reason : getDOMException(reason));
+      }, {
+        once: true
+      });
+    }
   });
 }
-
-// ../../node_modules/.pnpm/p-throttle@7.0.0/node_modules/p-throttle/index.js
-var registry = new FinalizationRegistry(({ signal, aborted }) => {
-  signal == null ? void 0 : signal.removeEventListener("abort", aborted);
-});
-function pThrottle({ limit, interval, strict, signal, onDelay }) {
+var AbortError2 = class extends Error {
+  constructor() {
+    super("Throttled function aborted");
+    this.name = "AbortError";
+  }
+};
+function pThrottle({ limit, interval, strict }) {
   if (!Number.isFinite(limit)) {
     throw new TypeError("Expected `limit` to be a finite number");
   }
@@ -1278,75 +1238,53 @@ function pThrottle({ limit, interval, strict, signal, onDelay }) {
   const strictTicks = [];
   function strictDelay() {
     const now = Date.now();
-    if (strictTicks.length > 0 && now - strictTicks.at(-1) > interval) {
-      strictTicks.length = 0;
-    }
     if (strictTicks.length < limit) {
       strictTicks.push(now);
       return 0;
     }
-    const nextExecutionTime = strictTicks[0] + interval;
-    strictTicks.shift();
-    strictTicks.push(nextExecutionTime);
-    return Math.max(0, nextExecutionTime - now);
+    const earliestTime = strictTicks.shift() + interval;
+    if (now >= earliestTime) {
+      strictTicks.push(now);
+      return 0;
+    }
+    strictTicks.push(earliestTime);
+    return earliestTime - now;
   }
   const getDelay = strict ? strictDelay : windowedDelay;
   return (function_) => {
-    const throttled = function(...arguments_) {
+    const throttled = function(...args) {
       if (!throttled.isEnabled) {
-        return (async () => function_.apply(this, arguments_))();
+        return (async () => function_.apply(this, args))();
       }
-      let timeoutId;
+      let timeout;
       return new Promise((resolve, reject) => {
         const execute = () => {
-          resolve(function_.apply(this, arguments_));
-          queue.delete(timeoutId);
+          resolve(function_.apply(this, args));
+          queue.delete(timeout);
         };
-        const delay = getDelay();
-        if (delay > 0) {
-          timeoutId = setTimeout(execute, delay);
-          queue.set(timeoutId, reject);
-          onDelay == null ? void 0 : onDelay(...arguments_);
-        } else {
-          execute();
-        }
+        timeout = setTimeout(execute, getDelay());
+        queue.set(timeout, reject);
       });
     };
-    const aborted = () => {
+    throttled.abort = () => {
       for (const timeout of queue.keys()) {
         clearTimeout(timeout);
-        queue.get(timeout)(signal.reason);
+        queue.get(timeout)(new AbortError2());
       }
       queue.clear();
       strictTicks.splice(0, strictTicks.length);
     };
-    registry.register(throttled, { signal, aborted });
-    signal == null ? void 0 : signal.throwIfAborted();
-    signal == null ? void 0 : signal.addEventListener("abort", aborted, { once: true });
     throttled.isEnabled = true;
-    Object.defineProperty(throttled, "queueSize", {
-      get() {
-        return queue.size;
-      }
-    });
     return throttled;
   };
 }
-
-// ../canvas/dist/index.mjs
-var __typeError3 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck3 = (obj, member, msg) => member.has(obj) || __typeError3("Cannot " + msg);
-var __privateGet3 = (obj, member, getter) => (__accessCheck3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd3 = (obj, member, value) => member.has(obj) ? __typeError3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
-  retry: retry3 = { retries: 1, factor: 1.66 },
+  retry: retry2 = { retries: 1, factor: 1.66 },
   limit = 10
 }) {
   const throttler = throttle ? pThrottle(throttle) : null;
-  const limiter = limit ? pLimit2(limit) : null;
+  const limiter = limit ? (0, import_p_limit2.default)(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
     if (throttler) {
@@ -1357,13 +1295,13 @@ function createLimitPolicy({
       const limitFunc = currentFunc;
       currentFunc = () => limiter(limitFunc);
     }
-    if (retry3) {
+    if (retry2) {
       const retryFunc = currentFunc;
       currentFunc = () => pRetry(retryFunc, {
-        ...retry3,
+        ...retry2,
         onFailedAttempt: async (error) => {
-          if (retry3.onFailedAttempt) {
-            await retry3.onFailedAttempt(error);
+          if (retry2.onFailedAttempt) {
+            await retry2.onFailedAttempt(error);
           }
           if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
@@ -2554,7 +2492,7 @@ function createLimiter(concurrency) {
     });
   };
 }
-async function retry2(fn, options) {
+async function retry(fn, options) {
   let lastError;
   let delay = 1e3;
   for (let attempt = 1; attempt <= options.retries + 1; attempt++) {
@@ -2594,7 +2532,7 @@ function createLimitPolicy2({
     }
     if (retryOptions) {
       const retryFunc = currentFunc;
-      currentFunc = () => retry2(retryFunc, {
+      currentFunc = () => retry(retryFunc, {
         ...retryOptions,
         onFailedAttempt: async (error) => {
           if (retryOptions.onFailedAttempt) {
@@ -3337,12 +3275,12 @@ function mitt_default(n) {
 var import_rfdc = __toESM(require_rfdc(), 1);
 var import_rfdc2 = __toESM(require_rfdc(), 1);
 var import_rfdc3 = __toESM(require_rfdc(), 1);
-var __defProp3 = Object.defineProperty;
+var __defProp4 = Object.defineProperty;
 var __typeError4 = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck4 = (obj, member, msg) => member.has(obj) || __typeError4("Cannot " + msg);
 var __privateGet4 = (obj, member, getter) => (__accessCheck4(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd4 = (obj, member, value) => member.has(obj) ? __typeError4("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
@@ -3419,7 +3357,7 @@ var SignalInstance = class {
   constructor(data, evaluator, onLogMessage) {
     __privateAdd4(this, _evaluator);
     __privateAdd4(this, _onLogMessage);
-    __publicField3(this, "signal");
+    __publicField2(this, "signal");
     this.signal = data;
     __privateSet2(this, _evaluator, evaluator);
     __privateSet2(this, _onLogMessage, onLogMessage);
@@ -3477,7 +3415,7 @@ var ManifestInstance = class {
     onLogMessage = () => {
     }
   }) {
-    __publicField3(this, "data");
+    __publicField2(this, "data");
     __privateAdd4(this, _mf);
     __privateAdd4(this, _signalInstances);
     __privateAdd4(this, _goalEvaluators, []);
@@ -4264,7 +4202,7 @@ var TransitionDataStore = class {
     __privateAdd4(this, _data);
     __privateAdd4(this, _initialData);
     __privateAdd4(this, _mitt, mitt_default());
-    __publicField3(this, "events", {
+    __publicField2(this, "events", {
       on: __privateGet4(this, _mitt).on,
       off: __privateGet4(this, _mitt).off
     });
@@ -4629,8 +4567,8 @@ var LocalStorage = class {
   constructor(partitionKey) {
     this.partitionKey = partitionKey;
     __privateAdd4(this, _LocalStorage_instances);
-    __publicField3(this, "inMemoryFallback", {});
-    __publicField3(this, "hasLocalStorageObject", typeof document !== "undefined" && typeof localStorage !== "undefined");
+    __publicField2(this, "inMemoryFallback", {});
+    __publicField2(this, "hasLocalStorageObject", typeof document !== "undefined" && typeof localStorage !== "undefined");
   }
   get(key) {
     const keyValue = __privateMethod(this, _LocalStorage_instances, key_fn).call(this, key);
@@ -4691,7 +4629,7 @@ var VisitorDataStore = class {
     __privateAdd4(this, _persist);
     __privateAdd4(this, _visitTimeout);
     __privateAdd4(this, _options);
-    __publicField3(this, "events", {
+    __publicField2(this, "events", {
       on: __privateGet4(this, _mitt2).on,
       off: __privateGet4(this, _mitt2).off
     });
@@ -4892,7 +4830,7 @@ var calculateScores_fn;
 var Context = class {
   constructor(options) {
     __privateAdd4(this, _Context_instances);
-    __publicField3(this, "manifest");
+    __publicField2(this, "manifest");
     __privateAdd4(this, _personalizationSelectionAlgorithms);
     __privateAdd4(this, _serverTransitionState);
     __privateAdd4(this, _scores, {});
@@ -4902,11 +4840,11 @@ var Context = class {
     __privateAdd4(this, _commands);
     __privateAdd4(this, _requireConsentForPersonalization);
     __privateAdd4(this, _mitt3, mitt_default());
-    __publicField3(this, "events", {
+    __publicField2(this, "events", {
       on: __privateGet4(this, _mitt3).on,
       off: __privateGet4(this, _mitt3).off
     });
-    __publicField3(this, "storage");
+    __publicField2(this, "storage");
     var _a, _b, _c;
     const { manifest, ...storageOptions } = options;
     __privateSet2(this, _state, {});