https://amsterdamspanishfilmfestival.com/_nuxt/BYeOgJcG.js

1import { g as getDefaultExportFromCjs } from "./CUmg6egw.js";
2function _mergeNamespaces(n, m) {
3  for (var i = 0; i < m.length; i++) {
4    const e = m[i];
5    if (typeof e !== "string" && !Array.isArray(e)) {
6      for (const k in e) {
7        if (k !== "default" && !(k in n)) {
8          const d = Object.getOwnPropertyDescriptor(e, k);
9          if (d) {
10            Object.defineProperty(n, k, d.get ? d : {
11              enumerable: true,
12              get: () => e[k]
13            });
14          }
15        }
16      }
17    }
18  }
19  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
20}
21var eventsource$1 = { exports: {} };
22var eventsource = eventsource$1.exports;
23var hasRequiredEventsource;
24function requireEventsource() {
25  if (hasRequiredEventsource) return eventsource$1.exports;
26  hasRequiredEventsource = 1;
27  (function(module, exports) {
28    (function(global) {
29      var setTimeout = global.setTimeout;
30      var clearTimeout = global.clearTimeout;
31      var XMLHttpRequest = global.XMLHttpRequest;
32      var XDomainRequest = global.XDomainRequest;
33      var ActiveXObject = global.ActiveXObject;
34      var NativeEventSource = global.EventSource;
35      var document = global.document;
36      var Promise2 = global.Promise;
37      var fetch = global.fetch;
38      var Response = global.Response;
39      var TextDecoder = global.TextDecoder;
40      var TextEncoder = global.TextEncoder;
41      var AbortController = global.AbortController;
42      if (typeof window !== "undefined" && typeof document !== "undefined" && !("readyState" in document) && document.body == null) {
43        document.readyState = "loading";
44        window.addEventListener("load", function(event) {
45          document.readyState = "complete";
46        }, false);
47      }
48      if (XMLHttpRequest == null && ActiveXObject != null) {
49        XMLHttpRequest = function() {
50          return new ActiveXObject("Microsoft.XMLHTTP");
51        };
52      }
53      if (Object.create == void 0) {
54        Object.create = function(C) {
55          function F() {
56          }
57          F.prototype = C;
58          return new F();
59        };
60      }
61      if (!Date.now) {
62        Date.now = function now() {
63          return (/* @__PURE__ */ new Date()).getTime();
64        };
65      }
66      if (AbortController == void 0) {
67        var originalFetch2 = fetch;
68        fetch = function(url, options) {
69          var signal = options.signal;
70          return originalFetch2(url, { headers: options.headers, credentials: options.credentials, cache: options.cache }).then(function(response) {
71            var reader = response.body.getReader();
72            signal._reader = reader;
73            if (signal._aborted) {
74              signal._reader.cancel();
75            }
76            return {
77              status: response.status,
78              statusText: response.statusText,
79              headers: response.headers,
80              body: {
81                getReader: function() {
82                  return reader;
83                }
84              }
85            };
86          });
87        };
88        AbortController = function() {
89          this.signal = {
90            _reader: null,
91            _aborted: false
92          };
93          this.abort = function() {
94            if (this.signal._reader != null) {
95              this.signal._reader.cancel();
96            }
97            this.signal._aborted = true;
98          };
99        };
100      }
101      function TextDecoderPolyfill() {
102        this.bitsNeeded = 0;
103        this.codePoint = 0;
104      }
105      TextDecoderPolyfill.prototype.decode = function(octets) {
106        function valid(codePoint2, shift, octetsCount2) {
107          if (octetsCount2 === 1) {
108            return codePoint2 >= 128 >> shift && codePoint2 << shift <= 2047;
109          }
110          if (octetsCount2 === 2) {
111            return codePoint2 >= 2048 >> shift && codePoint2 << shift <= 55295 || codePoint2 >= 57344 >> shift && codePoint2 << shift <= 65535;
112          }
113          if (octetsCount2 === 3) {
114            return codePoint2 >= 65536 >> shift && codePoint2 << shift <= 1114111;
115          }
116          throw new Error();
117        }
118        function octetsCount(bitsNeeded2, codePoint2) {
119          if (bitsNeeded2 === 6 * 1) {
120            return codePoint2 >> 6 > 15 ? 3 : codePoint2 > 31 ? 2 : 1;
121          }
122          if (bitsNeeded2 === 6 * 2) {
123            return codePoint2 > 15 ? 3 : 2;
124          }
125          if (bitsNeeded2 === 6 * 3) {
126            return 3;
127          }
128          throw new Error();
129        }
130        var REPLACER = 65533;
131        var string = "";
132        var bitsNeeded = this.bitsNeeded;

133        var codePoint = this.codePoint;
134        for (var i = 0; i < octets.length; i += 1) {
135          var octet = octets[i];
136          if (bitsNeeded !== 0) {
137            if (octet < 128 || octet > 191 || !valid(codePoint << 6 | octet & 63, bitsNeeded - 6, octetsCount(bitsNeeded, codePoint))) {
138              bitsNeeded = 0;
139              codePoint = REPLACER;
140              string += String.fromCharCode(codePoint);
141            }
142          }
143          if (bitsNeeded === 0) {
144            if (octet >= 0 && octet <= 127) {
145              bitsNeeded = 0;
146              codePoint = octet;
147            } else if (octet >= 192 && octet <= 223) {
148              bitsNeeded = 6 * 1;
149              codePoint = octet & 31;
150            } else if (octet >= 224 && octet <= 239) {
151              bitsNeeded = 6 * 2;
152              codePoint = octet & 15;
153            } else if (octet >= 240 && octet <= 247) {
154              bitsNeeded = 6 * 3;
155              codePoint = octet & 7;
156            } else {
157              bitsNeeded = 0;
158              codePoint = REPLACER;
159            }
160            if (bitsNeeded !== 0 && !valid(codePoint, bitsNeeded, octetsCount(bitsNeeded, codePoint))) {
161              bitsNeeded = 0;
162              codePoint = REPLACER;
163            }
164          } else {
165            bitsNeeded -= 6;
166            codePoint = codePoint << 6 | octet & 63;
167          }
168          if (bitsNeeded === 0) {
169            if (codePoint <= 65535) {
170              string += String.fromCharCode(codePoint);
171            } else {
172              string += String.fromCharCode(55296 + (codePoint - 65535 - 1 >> 10));
173              string += String.fromCharCode(56320 + (codePoint - 65535 - 1 & 1023));
174            }
175          }
176        }
177        this.bitsNeeded = bitsNeeded;
178        this.codePoint = codePoint;
179        return string;
180      };
181      var supportsStreamOption = function() {
182        try {
183          return new TextDecoder().decode(new TextEncoder().encode("test"), { stream: true }) === "test";
184        } catch (error) {
185          console.debug("TextDecoder does not support streaming option. Using polyfill instead: " + error);
186        }
187        return false;
188      };
189      if (TextDecoder == void 0 || TextEncoder == void 0 || !supportsStreamOption()) {
190        TextDecoder = TextDecoderPolyfill;
191      }
192      var k = function() {
193      };
194      function XHRWrapper(xhr) {
195        this.withCredentials = false;
196        this.readyState = 0;
197        this.status = 0;
198        this.statusText = "";
199        this.responseText = "";
200        this.onprogress = k;
201        this.onload = k;
202        this.onerror = k;
203        this.onreadystatechange = k;
204        this._contentType = "";
205        this._xhr = xhr;
206        this._sendTimeout = 0;
207        this._abort = k;
208      }
209      XHRWrapper.prototype.open = function(method, url) {
210        this._abort(true);
211        var that = this;
212        var xhr = this._xhr;
213        var state = 1;
214        var timeout = 0;
215        this._abort = function(silent) {
216          if (that._sendTimeout !== 0) {
217            clearTimeout(that._sendTimeout);
218            that._sendTimeout = 0;
219          }
220          if (state === 1 || state === 2 || state === 3) {
221            state = 4;
222            xhr.onload = k;
223            xhr.onerror = k;
224            xhr.onabort = k;
225            xhr.onprogress = k;
226            xhr.onreadystatechange = k;
227            xhr.abort();
228            if (timeout !== 0) {
229              clearTimeout(timeout);
230              timeout = 0;
231            }
232            if (!silent) {
233              that.readyState = 4;
234              that.onabort(null);
235              that.onreadystatechange();
236            }
237          }
238          state = 0;
239        };
240        var onStart = function() {
241          if (state === 1) {
242            var status = 0;
243            var statusText = "";
244            var contentType = void 0;
245            if (!("contentType" in xhr)) {
246              try {
247                status = xhr.status;
248                statusText = xhr.statusText;
249                contentType = xhr.getResponseHeader("Content-Type");
250              } catch (error) {
251                status = 0;
252                statusText = "";
253                contentType = void 0;
254              }
255            } else {
256              status = 200;
257              statusText = "OK";
258              contentType = xhr.contentType;
259            }
260            if (status !== 0) {
261              state = 2;
262              that.readyState = 2;
263              that.status = status;
264              that.statusText = statusText;
265              that._contentType = contentType;
266              that.onreadystatechange();
267            }
268          }
269        };
270        var onProgress = function() {
271          onStart();
272          if (state === 2 || state === 3) {
273            state = 3;
274            var responseText = "";
275            try {
276              responseText = xhr.responseText;
277            } catch (error) {
278            }
279            that.readyState = 3;
280            that.responseText = responseText;
281            that.onprogress();
282          }
283        };
284        var onFinish = function(type, event) {
285          if (event == null || event.preventDefault == null) {
286            event = {
287              preventDefault: k
288            };
289          }
290          onProgress();
291          if (state === 1 || state === 2 || state === 3) {
292            state = 4;
293            if (timeout !== 0) {
294              clearTimeout(timeout);
295              timeout = 0;
296            }
297            that.readyState = 4;
298            if (type === "load") {
299              that.onload(event);
300            } else if (type === "error") {
301              that.onerror(event);
302            } else if (type === "abort") {
303              that.onabort(event);
304            } else {
305              throw new TypeError();
306            }
307            that.onreadystatechange();
308          }
309        };
310        var onReadyStateChange = function(event) {
311          if (xhr != void 0) {
312            if (xhr.readyState === 4) {
313              if (!("onload" in xhr) || !("onerror" in xhr) || !("onabort" in xhr)) {
314                onFinish(xhr.responseText === "" ? "error" : "load", event);
315              }
316            } else if (xhr.readyState === 3) {
317              if (!("onprogress" in xhr)) {
318                onProgress();
319              }
320            } else if (xhr.readyState === 2) {
321              onStart();
322            }
323          }
324        };
325        var onTimeout = function() {
326          timeout = setTimeout(function() {
327            onTimeout();
328          }, 500);
329          if (xhr.readyState === 3) {
330            onProgress();
331          }
332        };
333        if ("onload" in xhr) {
334          xhr.onload = function(event) {
335            onFinish("load", event);
336          };
337        }
338        if ("onerror" in xhr) {
339          xhr.onerror = function(event) {
340            onFinish("error", event);
341          };
342        }
343        if ("onabort" in xhr) {
344          xhr.onabort = function(event) {
345            onFinish("abort", event);
346          };
347        }
348        if ("onprogress" in xhr) {
349          xhr.onprogress = onProgress;
350        }
351        if ("onreadystatechange" in xhr) {
352          xhr.onreadystatechange = function(event) {
353            onReadyStateChange(event);
354          };
355        }
356        if ("contentType" in xhr || !("ontimeout" in XMLHttpRequest.prototype)) {
357          url += (url.indexOf("?") === -1 ? "?" : "&") + "padding=true";
358        }
359        xhr.open(method, url, true);
360        if ("readyState" in xhr) {
361          timeout = setTimeout(function() {
362            onTimeout();
363          }, 0);
364        }
365      };
366      XHRWrapper.prototype.abort = function() {
367        this._abort(false);
368      };
369      XHRWrapper.prototype.getResponseHeader = function(name) {
370        return this._contentType;
371      };
372      XHRWrapper.prototype.setRequestHeader = function(name, value) {
373        var xhr = this._xhr;
374        if ("setRequestHeader" in xhr) {
375          xhr.setRequestHeader(name, value);
376        }
377      };
378      XHRWrapper.prototype.getAllResponseHeaders = function() {
379        return this._xhr.getAllResponseHeaders != void 0 ? this._xhr.getAllResponseHeaders() || "" : "";
380      };
381      XHRWrapper.prototype.send = function() {
382        if ((!("ontimeout" in XMLHttpRequest.prototype) || !("sendAsBinary" in XMLHttpRequest.prototype) && !("mozAnon" in XMLHttpRequest.prototype)) && document != void 0 && document.readyState != void 0 && document.readyState !== "complete") {
383          var that = this;
384          that._sendTimeout = setTimeout(function() {
385            that._sendTimeout = 0;
386            that.send();
387          }, 4);
388          return;
389        }
390        var xhr = this._xhr;
391        if ("withCredentials" in xhr) {
392          xhr.withCredentials = this.withCredentials;
393        }
394        try {
395          xhr.send(void 0);
396        } catch (error1) {
397          throw error1;
398        }
399      };
400      function toLowerCase(name) {
401        return name.replace(/[A-Z]/g, function(c) {
402          return String.fromCharCode(c.charCodeAt(0) + 32);
403        });
404      }
405      function HeadersPolyfill(all) {
406        var map = /* @__PURE__ */ Object.create(null);
407        var array = all.split("\r\n");
408        for (var i = 0; i < array.length; i += 1) {
409          var line = array[i];
410          var parts = line.split(": ");
411          var name = parts.shift();
412          var value = parts.join(": ");
413          map[toLowerCase(name)] = value;
414        }
415        this._map = map;
416      }
417      HeadersPolyfill.prototype.get = function(name) {
418        return this._map[toLowerCase(name)];
419      };
420      if (XMLHttpRequest != null && XMLHttpRequest.HEADERS_RECEIVED == null) {
421        XMLHttpRequest.HEADERS_RECEIVED = 2;
422      }
423      function XHRTransport() {
424      }
425      XHRTransport.prototype.open = function(xhr, onStartCallback, onProgressCallback, onFinishCallback, url, withCredentials, headers) {
426        xhr.open("GET", url);
427        var offset = 0;
428        xhr.onprogress = function() {
429          var responseText = xhr.responseText;
430          var chunk = responseText.slice(offset);
431          offset += chunk.length;
432          onProgressCallback(chunk);
433        };
434        xhr.onerror = function(event) {
435          event.preventDefault();
436          onFinishCallback(new Error("NetworkError"));
437        };
438        xhr.onload = function() {
439          onFinishCallback(null);
440        };
441        xhr.onabort = function() {
442          onFinishCallback(null);
443        };
444        xhr.onreadystatechange = function() {
445          if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
446            var status = xhr.status;
447            var statusText = xhr.statusText;
448            var contentType = xhr.getResponseHeader("Content-Type");
449            var headers2 = xhr.getAllResponseHeaders();
450            onStartCallback(status, statusText, contentType, new HeadersPolyfill(headers2));
451          }
452        };
453        xhr.withCredentials = withCredentials;
454        for (var name in headers) {
455          if (Object.prototype.hasOwnProperty.call(headers, name)) {
456            xhr.setRequestHeader(name, headers[name]);
457          }
458        }
459        xhr.send();
460        return xhr;
461      };
462      function HeadersWrapper(headers) {
463        this._headers = headers;
464      }
465      HeadersWrapper.prototype.get = function(name) {
466        return this._headers.get(name);
467      };
468      function FetchTransport() {
469      }
470      FetchTransport.prototype.open = function(xhr, onStartCallback, onProgressCallback, onFinishCallback, url, withCredentials, headers) {
471        var reader = null;
472        var controller = new AbortController();
473        var signal = controller.signal;
474        var textDecoder = new TextDecoder();
475        fetch(url, {
476          headers,
477          credentials: withCredentials ? "include" : "same-origin",
478          signal,
479          cache: "no-store"
480        }).then(function(response) {
481          reader = response.body.getReader();
482          onStartCallback(response.status, response.statusText, response.headers.get("Content-Type"), new HeadersWrapper(response.headers));
483          return new Promise2(function(resolve, reject) {
484            var readNextChunk = function() {
485              reader.read().then(function(result) {
486                if (result.done) {
487                  resolve(void 0);
488                } else {
489                  var chunk = textDecoder.decode(result.value, { stream: true });
490                  onProgressCallback(chunk);
491                  readNextChunk();
492                }
493              })["catch"](function(error) {
494                reject(error);
495              });
496            };
497            readNextChunk();
498          });
499        })["catch"](function(error) {
500          if (error.name === "AbortError") {
501            return void 0;
502          } else {
503            return error;
504          }
505        }).then(function(error) {
506          onFinishCallback(error);
507        });
508        return {
509          abort: function() {
510            if (reader != null) {
511              reader.cancel();
512            }
513            controller.abort();
514          }
515        };
516      };
517      function EventTarget() {
518        this._listeners = /* @__PURE__ */ Object.create(null);
519      }
520      function throwError(e) {
521        setTimeout(function() {
522          throw e;
523        }, 0);
524      }
525      EventTarget.prototype.dispatchEvent = function(event) {
526        event.target = this;
527        var typeListeners = this._listeners[event.type];
528        if (typeListeners != void 0) {
529          var length = typeListeners.length;
530          for (var i = 0; i < length; i += 1) {
531            var listener = typeListeners[i];
532            try {
533              if (typeof listener.handleEvent === "function") {
534                listener.handleEvent(event);
535              } else {
536                listener.call(this, event);
537              }
538            } catch (e) {
539              throwError(e);
540            }
541          }
542        }
543      };
544      EventTarget.prototype.addEventListener = function(type, listener) {
545        type = String(type);
546        var listeners = this._listeners;
547        var typeListeners = listeners[type];
548        if (typeListeners == void 0) {
549          typeListeners = [];
550          listeners[type] = typeListeners;
551        }
552        var found = false;

553        for (var i = 0; i < typeListeners.length; i += 1) {
554          if (typeListeners[i] === listener) {
555            found = true;
556          }
557        }
558        if (!found) {
559          typeListeners.push(listener);
560        }
561      };
562      EventTarget.prototype.removeEventListener = function(type, listener) {
563        type = String(type);
564        var listeners = this._listeners;
565        var typeListeners = listeners[type];
566        if (typeListeners != void 0) {
567          var filtered = [];
568          for (var i = 0; i < typeListeners.length; i += 1) {
569            if (typeListeners[i] !== listener) {
570              filtered.push(typeListeners[i]);
571            }
572          }
573          if (filtered.length === 0) {
574            delete listeners[type];
575          } else {
576            listeners[type] = filtered;
577          }
578        }
579      };
580      function Event(type) {
581        this.type = type;
582        this.target = void 0;
583      }
584      function MessageEvent(type, options) {
585        Event.call(this, type);
586        this.data = options.data;
587        this.lastEventId = options.lastEventId;
588      }
589      MessageEvent.prototype = Object.create(Event.prototype);
590      function ConnectionEvent(type, options) {
591        Event.call(this, type);
592        this.status = options.status;
593        this.statusText = options.statusText;
594        this.headers = options.headers;
595      }
596      ConnectionEvent.prototype = Object.create(Event.prototype);
597      function ErrorEvent(type, options) {
598        Event.call(this, type);
599        this.error = options.error;
600      }
601      ErrorEvent.prototype = Object.create(Event.prototype);
602      var WAITING = -1;
603      var CONNECTING = 0;
604      var OPEN = 1;
605      var CLOSED = 2;
606      var AFTER_CR = -1;
607      var FIELD_START = 0;
608      var FIELD = 1;
609      var VALUE_START = 2;
610      var VALUE = 3;
611      var contentTypeRegExp = /^text\/event\-stream(;.*)?$/i;
612      var MINIMUM_DURATION = 1e3;
613      var MAXIMUM_DURATION = 18e6;
614      var parseDuration = function(value, def) {
615        var n = value == null ? def : parseInt(value, 10);
616        if (n !== n) {
617          n = def;
618        }
619        return clampDuration(n);
620      };
621      var clampDuration = function(n) {
622        return Math.min(Math.max(n, MINIMUM_DURATION), MAXIMUM_DURATION);
623      };
624      var fire = function(that, f, event) {
625        try {
626          if (typeof f === "function") {
627            f.call(that, event);
628          }
629        } catch (e) {
630          throwError(e);
631        }
632      };
633      function EventSourcePolyfill(url, options) {
634        EventTarget.call(this);
635        options = options || {};
636        this.onopen = void 0;
637        this.onmessage = void 0;
638        this.onerror = void 0;
639        this.url = void 0;
640        this.readyState = void 0;
641        this.withCredentials = void 0;
642        this.headers = void 0;
643        this._close = void 0;
644        start(this, url, options);
645      }
646      function getBestXHRTransport() {
647        return XMLHttpRequest != void 0 && "withCredentials" in XMLHttpRequest.prototype || XDomainRequest == void 0 ? new XMLHttpRequest() : new XDomainRequest();
648      }
649      var isFetchSupported = fetch != void 0 && Response != void 0 && "body" in Response.prototype;
650      function start(es, url, options) {
651        url = String(url);
652        var withCredentials = Boolean(options.withCredentials);
653        var lastEventIdQueryParameterName = options.lastEventIdQueryParameterName || "lastEventId";
654        var initialRetry = clampDuration(1e3);
655        var heartbeatTimeout = parseDuration(options.heartbeatTimeout, 45e3);
656        var lastEventId = "";
657        var retry = initialRetry;
658        var wasActivity = false;
659        var textLength = 0;
660        var headers = options.headers || {};
661        var TransportOption = options.Transport;
662        var xhr = isFetchSupported && TransportOption == void 0 ? void 0 : new XHRWrapper(TransportOption != void 0 ? new TransportOption() : getBestXHRTransport());
663        var transport = TransportOption != null && typeof TransportOption !== "string" ? new TransportOption() : xhr == void 0 ? new FetchTransport() : new XHRTransport();
664        var abortController = void 0;
665        var timeout = 0;
666        var currentState = WAITING;
667        var dataBuffer = "";
668        var lastEventIdBuffer = "";
669        var eventTypeBuffer = "";
670        var textBuffer = "";
671        var state = FIELD_START;
672        var fieldStart = 0;
673        var valueStart = 0;
674        var onStart = function(status, statusText, contentType, headers2) {
675          if (currentState === CONNECTING) {
676            if (status === 200 && contentType != void 0 && contentTypeRegExp.test(contentType)) {
677              currentState = OPEN;
678              wasActivity = Date.now();
679              retry = initialRetry;
680              es.readyState = OPEN;
681              var event = new ConnectionEvent("open", {
682                status,
683                statusText,
684                headers: headers2
685              });
686              es.dispatchEvent(event);
687              fire(es, es.onopen, event);
688            } else {
689              var message = "";
690              if (status !== 200) {
691                if (statusText) {
692                  statusText = statusText.replace(/\s+/g, " ");
693                }
694                message = "EventSource's response has a status " + status + " " + statusText + " that is not 200. Aborting the connection.";
695              } else {
696                message = "EventSource's response has a Content-Type specifying an unsupported type: " + (contentType == void 0 ? "-" : contentType.replace(/\s+/g, " ")) + ". Aborting the connection.";
697              }
698              close();
699              var event = new ConnectionEvent("error", {
700                status,
701                statusText,
702                headers: headers2
703              });
704              es.dispatchEvent(event);
705              fire(es, es.onerror, event);
706              console.error(message);
707            }
708          }
709        };
710        var onProgress = function(textChunk) {
711          if (currentState === OPEN) {
712            var n = -1;
713            for (var i = 0; i < textChunk.length; i += 1) {
714              var c = textChunk.charCodeAt(i);
715              if (c === "\n".charCodeAt(0) || c === "\r".charCodeAt(0)) {
716                n = i;
717              }
718            }
719            var chunk = (n !== -1 ? textBuffer : "") + textChunk.slice(0, n + 1);
720            textBuffer = (n === -1 ? textBuffer : "") + textChunk.slice(n + 1);
721            if (textChunk !== "") {
722              wasActivity = Date.now();
723              textLength += textChunk.length;
724            }
725            for (var position = 0; position < chunk.length; position += 1) {
726              var c = chunk.charCodeAt(position);
727              if (state === AFTER_CR && c === "\n".charCodeAt(0)) {
728                state = FIELD_START;
729              } else {
730                if (state === AFTER_CR) {
731                  state = FIELD_START;
732                }
733                if (c === "\r".charCodeAt(0) || c === "\n".charCodeAt(0)) {
734                  if (state !== FIELD_START) {
735                    if (state === FIELD) {
736                      valueStart = position + 1;
737                    }
738                    var field = chunk.slice(fieldStart, valueStart - 1);
739                    var value = chunk.slice(valueStart + (valueStart < position && chunk.charCodeAt(valueStart) === " ".charCodeAt(0) ? 1 : 0), position);
740                    if (field === "data") {
741                      dataBuffer += "\n";
742                      dataBuffer += value;
743                    } else if (field === "id") {
744                      lastEventIdBuffer = value;
745                    } else if (field === "event") {
746                      eventTypeBuffer = value;
747                    } else if (field === "retry") {
748                      initialRetry = parseDuration(value, initialRetry);
749                      retry = initialRetry;
750                    } else if (field === "heartbeatTimeout") {
751                      heartbeatTimeout = parseDuration(value, heartbeatTimeout);
752                      if (timeout !== 0) {
753                        clearTimeout(timeout);
754                        timeout = setTimeout(function() {
755                          onTimeout();
756                        }, heartbeatTimeout);
757                      }
758                    }
759                  }
760                  if (state === FIELD_START) {
761                    if (dataBuffer !== "") {
762                      lastEventId = lastEventIdBuffer;
763                      if (eventTypeBuffer === "") {
764                        eventTypeBuffer = "message";
765                      }
766                      var event = new MessageEvent(eventTypeBuffer, {
767                        data: dataBuffer.slice(1),
768                        lastEventId: lastEventIdBuffer
769                      });
770                      es.dispatchEvent(event);
771                      if (eventTypeBuffer === "open") {
772                        fire(es, es.onopen, event);
773                      } else if (eventTypeBuffer === "message") {
774                        fire(es, es.onmessage, event);
775                      } else if (eventTypeBuffer === "error") {
776                        fire(es, es.onerror, event);
777                      }
778                      if (currentState === CLOSED) {
779                        return;
780                      }
781                    }
782                    dataBuffer = "";
783                    eventTypeBuffer = "";
784                  }
785                  state = c === "\r".charCodeAt(0) ? AFTER_CR : FIELD_START;
786                } else {
787                  if (state === FIELD_START) {
788                    fieldStart = position;
789                    state = FIELD;
790                  }
791                  if (state === FIELD) {
792                    if (c === ":".charCodeAt(0)) {
793                      valueStart = position + 1;
794                      state = VALUE_START;
795                    }
796                  } else if (state === VALUE_START) {
797                    state = VALUE;
798                  }
799                }
800              }
801            }
802          }
803        };
804        var onFinish = function(error) {
805          if (currentState === OPEN || currentState === CONNECTING) {
806            currentState = WAITING;
807            if (timeout !== 0) {
808              clearTimeout(timeout);
809              timeout = 0;
810            }
811            timeout = setTimeout(function() {
812              onTimeout();
813            }, retry);
814            retry = clampDuration(Math.min(initialRetry * 16, retry * 2));
815            es.readyState = CONNECTING;
816            var event = new ErrorEvent("error", { error });
817            es.dispatchEvent(event);
818            fire(es, es.onerror, event);
819            if (error != void 0) {
820              console.error(error);
821            }
822          }
823        };
824        var close = function() {
825          currentState = CLOSED;
826          if (abortController != void 0) {
827            abortController.abort();
828            abortController = void 0;
829          }
830          if (timeout !== 0) {
831            clearTimeout(timeout);
832            timeout = 0;
833          }
834          es.readyState = CLOSED;
835        };
836        var onTimeout = function() {
837          timeout = 0;
838          if (currentState !== WAITING) {
839            if (!wasActivity && abortController != void 0) {
840              onFinish(new Error("No activity within " + heartbeatTimeout + " milliseconds. " + (currentState === CONNECTING ? "No response received." : textLength + " chars received.") + " Reconnecting."));
841              if (abortController != void 0) {
842                abortController.abort();
843                abortController = void 0;
844              }
845            } else {
846              var nextHeartbeat = Math.max((wasActivity || Date.now()) + heartbeatTimeout - Date.now(), 1);
847              wasActivity = false;

848              timeout = setTimeout(function() {
849                onTimeout();
850              }, nextHeartbeat);
851            }
852            return;
853          }
854          wasActivity = false;
855          textLength = 0;
856          timeout = setTimeout(function() {
857            onTimeout();
858          }, heartbeatTimeout);
859          currentState = CONNECTING;
860          dataBuffer = "";
861          eventTypeBuffer = "";
862          lastEventIdBuffer = lastEventId;
863          textBuffer = "";
864          fieldStart = 0;
865          valueStart = 0;
866          state = FIELD_START;
867          var requestURL = url;
868          if (url.slice(0, 5) !== "data:" && url.slice(0, 5) !== "blob:") {
869            if (lastEventId !== "") {
870              var i = url.indexOf("?");
871              requestURL = i === -1 ? url : url.slice(0, i + 1) + url.slice(i + 1).replace(/(?:^|&)([^=&]*)(?:=[^&]*)?/g, function(p, paramName) {
872                return paramName === lastEventIdQueryParameterName ? "" : p;
873              });
874              requestURL += (url.indexOf("?") === -1 ? "?" : "&") + lastEventIdQueryParameterName + "=" + encodeURIComponent(lastEventId);
875            }
876          }
877          var withCredentials2 = es.withCredentials;
878          var requestHeaders = {};
879          requestHeaders["Accept"] = "text/event-stream";
880          var headers2 = es.headers;
881          if (headers2 != void 0) {
882            for (var name in headers2) {
883              if (Object.prototype.hasOwnProperty.call(headers2, name)) {
884                requestHeaders[name] = headers2[name];
885              }
886            }
887          }
888          try {
889            abortController = transport.open(xhr, onStart, onProgress, onFinish, requestURL, withCredentials2, requestHeaders);
890          } catch (error) {
891            close();
892            throw error;
893          }
894        };
895        es.url = url;
896        es.readyState = CONNECTING;
897        es.withCredentials = withCredentials;
898        es.headers = headers;
899        es._close = close;
900        onTimeout();
901      }
902      EventSourcePolyfill.prototype = Object.create(EventTarget.prototype);
903      EventSourcePolyfill.prototype.CONNECTING = CONNECTING;
904      EventSourcePolyfill.prototype.OPEN = OPEN;
905      EventSourcePolyfill.prototype.CLOSED = CLOSED;
906      EventSourcePolyfill.prototype.close = function() {
907        this._close();
908      };
909      EventSourcePolyfill.CONNECTING = CONNECTING;
910      EventSourcePolyfill.OPEN = OPEN;
911      EventSourcePolyfill.CLOSED = CLOSED;
912      EventSourcePolyfill.prototype.withCredentials = void 0;
913      var R = NativeEventSource;
914      if (XMLHttpRequest != void 0 && (NativeEventSource == void 0 || !("withCredentials" in NativeEventSource.prototype))) {
915        R = EventSourcePolyfill;
916      }
917      (function(factory) {
918        {
919          var v = factory(exports);
920          if (v !== void 0) module.exports = v;
921        }
922      })(function(exports2) {
923        exports2.EventSourcePolyfill = EventSourcePolyfill;
924        exports2.NativeEventSource = NativeEventSource;
925        exports2.EventSource = R;
926      });
927    })(typeof globalThis === "undefined" ? typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : eventsource : globalThis);
928  })(eventsource$1, eventsource$1.exports);
929  return eventsource$1.exports;
930}
931var browser$2;
932var hasRequiredBrowser;
933function requireBrowser() {
934  if (hasRequiredBrowser) return browser$2;
935  hasRequiredBrowser = 1;
936  browser$2 = requireEventsource().EventSourcePolyfill;
937  return browser$2;
938}
939var browserExports = /* @__PURE__ */ requireBrowser();
940const browser = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
941const browser$1 = /* @__PURE__ */ _mergeNamespaces({
942  __proto__: null,
943  default: browser
944}, [browserExports]);
945export {
946  browser$1 as b
947};