n8n-nodes-pocketbase 2.3.25 → 2.3.26

package/dist/nodes/PocketbaseTrigger/PocketbaseTrigger.node.js

@@ -1,131 +1,78 @@
 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
   try {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   } catch (e) {
-    throw mod = 0, e;
+    throw err = [e], e;
   }
 };
-
-// node_modules/eventsource-parser/dist/index.cjs
-var require_dist = __commonJS({
-  "node_modules/eventsource-parser/dist/index.cjs"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    var ParseError = class extends Error {
-      constructor(message, options) {
-        super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
-      }
-    };
-    function noop(_arg) {
-    }
-    function createParser(callbacks) {
-      if (typeof callbacks == "function")
-        throw new TypeError(
-          "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
-        );
-      const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
-      let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
-      function feed(newChunk) {
-        const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
-        for (const line of complete)
-          parseLine(line);
-        incompleteLine = incomplete, isFirstChunk = false;
-      }
-      function parseLine(line) {
-        if (line === "") {
-          dispatchEvent();
-          return;
-        }
-        if (line.startsWith(":")) {
-          onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
-          return;
-        }
-        const fieldSeparatorIndex = line.indexOf(":");
-        if (fieldSeparatorIndex !== -1) {
-          const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
-          processField(field, value, line);
-          return;
-        }
-        processField(line, "", line);
-      }
-      function processField(field, value, line) {
-        switch (field) {
-          case "event":
-            eventType = value;
-            break;
-          case "data":
-            data = `${data}${value}
-`;
-            break;
-          case "id":
-            id = value.includes("\0") ? void 0 : value;
-            break;
-          case "retry":
-            /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
-              new ParseError(`Invalid \`retry\` value: "${value}"`, {
-                type: "invalid-retry",
-                value,
-                line
-              })
-            );
-            break;
-          default:
-            onError(
-              new ParseError(
-                `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
-                { type: "unknown-field", field, value, line }
-              )
-            );
-            break;
-        }
-      }
-      function dispatchEvent() {
-        data.length > 0 && onEvent({
-          id,
-          event: eventType || void 0,
-          // If the data buffer's last character is a U+000A LINE FEED (LF) character,
-          // then remove the last character from the data buffer.
-          data: data.endsWith(`
-`) ? data.slice(0, -1) : data
-        }), id = void 0, data = "", eventType = "";
-      }
-      function reset(options = {}) {
-        incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
-      }
-      return { feed, reset };
-    }
-    function splitLines(chunk) {
-      const lines = [];
-      let incompleteLine = "", searchIndex = 0;
-      for (; searchIndex < chunk.length; ) {
-        const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
-`, searchIndex);
-        let lineEnd = -1;
-        if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
-          incompleteLine = chunk.slice(searchIndex);
-          break;
-        } else {
-          const line = chunk.slice(searchIndex, lineEnd);
-          lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
-` && searchIndex++;
-        }
-      }
-      return [lines, incompleteLine];
-    }
-    exports2.ParseError = ParseError;
-    exports2.createParser = createParser;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/eventsource/dist/index.cjs
-var require_dist2 = __commonJS({
-  "node_modules/eventsource/dist/index.cjs"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    var eventsourceParser = require_dist();
-    var ErrorEvent = class extends Event {
+// node_modules/eventsource/dist/errors.js
+function syntaxError(message) {
+  const DomException = globalThis.DOMException;
+  if (typeof DomException === "function") {
+    return new DomException(message, "SyntaxError");
+  }
+  return new SyntaxError(message);
+}
+function flattenError(err) {
+  if (!(err instanceof Error)) {
+    return `${err}`;
+  }
+  if ("errors" in err && Array.isArray(err.errors)) {
+    return err.errors.map(flattenError).join(", ");
+  }
+  if ("cause" in err && err.cause instanceof Error) {
+    return `${err}: ${flattenError(err.cause)}`;
+  }
+  return err.message;
+}
+function inspectableError(err) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp
+  };
+}
+var ErrorEvent;
+var init_errors = __esm({
+  "node_modules/eventsource/dist/errors.js"() {
+    ErrorEvent = class extends Event {
+      /**
+       * HTTP status code, if this was triggered by an HTTP error
+       * Note: this is not part of the spec, but is included for better error handling.
+       *
+       * @public
+       */
+      code;
+      /**
+       * Optional message attached to the error.
+       * Note: this is not part of the spec, but is included for better error handling.
+       *
+       * @public
+       */
+      message;
       /**
        * Constructs a new `ErrorEvent` instance. This is typically not called directly,
        * but rather emitted by the `EventSource` object when an error occurs.
@@ -134,8 +81,9 @@ var require_dist2 = __commonJS({
        * @param errorEventInitDict - Optional properties to include in the error event
        */
       constructor(type, errorEventInitDict) {
-        var _a, _b;
-        super(type), this.code = (_a = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a : void 0, this.message = (_b = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b : void 0;
+        super(type);
+        this.code = errorEventInitDict?.code ?? void 0;
+        this.message = errorEventInitDict?.message ?? void 0;
       }
       /**
        * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
@@ -167,168 +115,433 @@ var require_dist2 = __commonJS({
         return inspect(inspectableError(this), options);
       }
     };
-    function syntaxError(message) {
-      const DomException = globalThis.DOMException;
-      return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
-    }
-    function flattenError(err) {
-      return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError(err.cause)}` : err.message : `${err}`;
-    }
-    function inspectableError(err) {
-      return {
-        type: err.type,
-        message: err.message,
-        code: err.code,
-        defaultPrevented: err.defaultPrevented,
-        cancelable: err.cancelable,
-        timeStamp: err.timeStamp
-      };
-    }
-    var __typeError = (msg) => {
-      throw TypeError(msg);
+  }
+});
+
+// node_modules/eventsource-parser/dist/errors.js
+var ParseError;
+var init_errors2 = __esm({
+  "node_modules/eventsource-parser/dist/errors.js"() {
+    ParseError = class extends Error {
+      constructor(message, options) {
+        super(message);
+        this.name = "ParseError";
+        this.type = options.type;
+        this.field = options.field;
+        this.value = options.value;
+        this.line = options.line;
+      }
     };
-    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"), member.set(obj, value), value);
-    var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-    var _readyState;
-    var _url;
-    var _redirectUrl;
-    var _withCredentials;
-    var _fetch;
-    var _reconnectInterval;
-    var _reconnectTimer;
-    var _lastEventId;
-    var _controller;
-    var _parser;
-    var _onError;
-    var _onMessage;
-    var _onOpen;
-    var _EventSource_instances;
-    var connect_fn;
-    var _onFetchResponse;
-    var _onFetchError;
-    var getRequestOptions_fn;
-    var _onEvent;
-    var _onRetryChange;
-    var failConnection_fn;
-    var scheduleReconnect_fn;
-    var _reconnect;
-    var EventSource = class extends EventTarget {
-      constructor(url, eventSourceInitDict) {
-        var _a, _b;
-        super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
-          var _a2;
-          __privateGet(this, _parser).reset();
-          const { body, redirected, status, headers } = response;
-          if (status === 204) {
-            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
-            return;
-          }
-          if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
-            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
-            return;
+  }
+});
+
+// node_modules/eventsource-parser/dist/parse.js
+function createParser(config) {
+  if (typeof config === "function") {
+    throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
+  }
+  const { maxBufferSize, onComment, onError, onEvent, onId, onRetry } = config;
+  const pendingFragments = [];
+  let pendingFragmentsLength = 0;
+  let isFirstChunk = true;
+  let id;
+  let data = "";
+  let dataLines = 0;
+  let eventType;
+  let terminated = false;
+  let skippingLine = false;
+  let skipNextLineFeed = false;
+  function feed(chunk) {
+    if (terminated) {
+      throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
+    }
+    if (isFirstChunk) {
+      isFirstChunk = false;
+      if (chunk.charCodeAt(0) === 65279) {
+        chunk = chunk.slice(1);
+      } else if (chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191) {
+        chunk = chunk.slice(3);
+      }
+    }
+    if (skippingLine || skipNextLineFeed) {
+      chunk = resumeAfterSkip(chunk);
+      if (!chunk) {
+        return;
+      }
+    }
+    if (!pendingFragments.length) {
+      const trailing = processLines(chunk);
+      if (trailing !== "") {
+        storeTrailing(trailing);
+      }
+      checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf("\n") === -1 && chunk.indexOf("\r") === -1) {
+      if (pendingFragmentsLength < MAX_FIELD_PREFIX_LENGTH) {
+        const head = pendingFragments.join("") + chunk.slice(0, MAX_FIELD_PREFIX_LENGTH - pendingFragmentsLength);
+        if (!shouldBufferTrailing(head)) {
+          pendingFragments.length = 0;
+          pendingFragmentsLength = 0;
+          skippingLine = true;
+          return;
+        }
+      }
+      pendingFragments.push(chunk);
+      pendingFragmentsLength += chunk.length;
+      checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    storeTrailing(processLines(input));
+    checkBufferSize();
+  }
+  function resumeAfterSkip(chunk) {
+    if (chunk.length === 0) {
+      return chunk;
+    }
+    if (skipNextLineFeed) {
+      skipNextLineFeed = false;
+      return chunk.charCodeAt(0) === LF ? chunk.slice(1) : chunk;
+    }
+    const crIndex = chunk.indexOf("\r");
+    const lfIndex = chunk.indexOf("\n");
+    const lineEnd = crIndex === -1 ? lfIndex : lfIndex === -1 ? crIndex : crIndex < lfIndex ? crIndex : lfIndex;
+    if (lineEnd === -1) {
+      return "";
+    }
+    if (lineEnd === chunk.length - 1 && chunk.charCodeAt(lineEnd) === CR) {
+      skippingLine = false;
+      skipNextLineFeed = true;
+      return "";
+    }
+    skippingLine = false;
+    return chunk.slice(lineEnd + (chunk.charCodeAt(lineEnd) === CR && chunk.charCodeAt(lineEnd + 1) === LF ? 2 : 1));
+  }
+  function storeTrailing(trailing) {
+    if (!trailing)
+      return;
+    if (trailing.charCodeAt(trailing.length - 1) === CR) {
+      parseLine(trailing, 0, trailing.length - 1);
+      skipNextLineFeed = true;
+      return;
+    }
+    if (shouldBufferTrailing(trailing)) {
+      pendingFragments.push(trailing);
+      pendingFragmentsLength = trailing.length;
+      return;
+    }
+    skippingLine = true;
+  }
+  function shouldBufferTrailing(trailing) {
+    const firstCharCode = trailing.charCodeAt(0);
+    return firstCharCode === 58 && !!onComment || firstCharCode === 100 && isPotentialField(trailing, "data") || firstCharCode === 101 && isPotentialField(trailing, "event") || firstCharCode === 105 && isPotentialField(trailing, "id") || firstCharCode === 114 && isPotentialField(trailing, "retry");
+  }
+  function checkBufferSize() {
+    if (maxBufferSize === void 0)
+      return;
+    if (pendingFragmentsLength + data.length <= maxBufferSize)
+      return;
+    terminated = true;
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    id = void 0;
+    data = "";
+    dataLines = 0;
+    eventType = void 0;
+    skippingLine = false;
+    skipNextLineFeed = false;
+    onError === null || onError === void 0 ? void 0 : onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+      type: "max-buffer-size-exceeded"
+    }));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf("\n", searchIndex);
+      while (lfIndex !== -1) {
+        if (searchIndex === lfIndex) {
+          if (id !== void 0) {
+            onId === null || onId === void 0 ? void 0 : onId(id);
           }
-          if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
-            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
-            return;
+          if (dataLines > 0) {
+            onEvent === null || onEvent === void 0 ? void 0 : onEvent({ id, event: eventType, data });
           }
-          if (__privateGet(this, _readyState) === this.CLOSED)
-            return;
-          __privateSet(this, _readyState, this.OPEN);
-          const openEvent = new Event("open");
-          if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
-            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
-            return;
+          id = void 0;
+          data = "";
+          dataLines = 0;
+          eventType = void 0;
+          searchIndex = lfIndex + 1;
+          lfIndex = chunk.indexOf("\n", searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5;
+          const value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            if (id !== void 0) {
+              onId === null || onId === void 0 ? void 0 : onId(id);
+            }
+            onEvent === null || onEvent === void 0 ? void 0 : onEvent({ id, event: eventType, data: value });
+            id = void 0;
+            data = "";
+            eventType = void 0;
+            searchIndex = lfIndex + 2;
+            lfIndex = chunk.indexOf("\n", searchIndex);
+            continue;
           }
-          const decoder = new TextDecoder(), reader = body.getReader();
-          let open = true;
-          do {
-            const { done, value } = await reader.read();
-            value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
-          } while (open);
-        }), __privateAdd(this, _onFetchError, (err) => {
-          __privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError(err));
-        }), __privateAdd(this, _onEvent, (event) => {
-          typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
-          const messageEvent = new MessageEvent(event.event || "message", {
-            data: event.data,
-            origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url).origin,
-            lastEventId: event.id || ""
-          });
-          __privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
-        }), __privateAdd(this, _onRetryChange, (value) => {
-          __privateSet(this, _reconnectInterval, value);
-        }), __privateAdd(this, _reconnect, () => {
-          __privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
-        });
-        try {
-          if (url instanceof URL)
-            __privateSet(this, _url, url);
-          else if (typeof url == "string")
-            __privateSet(this, _url, new URL(url, getBaseURL()));
-          else
-            throw new Error("Invalid URL");
-        } catch {
-          throw syntaxError("An invalid or illegal string was specified");
+          data = dataLines === 0 ? value : `${data}
+${value}`;
+          dataLines++;
+        } else if (isEventPrefix(chunk, searchIndex, firstCharCode)) {
+          eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || void 0;
+        } else {
+          parseLine(chunk, searchIndex, lfIndex);
         }
-        __privateSet(this, _parser, eventsourceParser.createParser({
-          onEvent: __privateGet(this, _onEvent),
-          onRetry: __privateGet(this, _onRetryChange)
-        })), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+        searchIndex = lfIndex + 1;
+        lfIndex = chunk.indexOf("\n", searchIndex);
       }
-      /**
-       * Returns the state of this EventSource object's connection. It can have the values described below.
-       *
-       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
-       *
-       * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
-       * defined in the TypeScript `dom` library.
-       *
-       * @public
-       */
+      return chunk.slice(searchIndex);
+    }
+    while (searchIndex < chunk.length) {
+      const crIndex = chunk.indexOf("\r", searchIndex);
+      const lfIndex = chunk.indexOf("\n", searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1) {
+        lineEnd = crIndex < lfIndex ? crIndex : lfIndex;
+      } else if (crIndex !== -1) {
+        if (crIndex === chunk.length - 1) {
+          lineEnd = -1;
+        } else {
+          lineEnd = crIndex;
+        }
+      } else if (lfIndex !== -1) {
+        lineEnd = lfIndex;
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      parseLine(chunk, searchIndex, lineEnd);
+      searchIndex = lineEnd + 1;
+      if (chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF) {
+        searchIndex++;
+      }
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5;
+      const value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`;
+      dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      if (!value2.includes("\0"))
+        id = value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end);
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex);
+    const offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
+    const value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`;
+        dataLines++;
+        break;
+      case "id":
+        if (!value.includes("\0"))
+          id = value;
+        break;
+      case "retry":
+        if (/^\d+$/.test(value)) {
+          onRetry === null || onRetry === void 0 ? void 0 : onRetry(parseInt(value, 10));
+        } else {
+          onError === null || onError === void 0 ? void 0 : onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          }));
+        }
+        break;
+      default:
+        onError === null || onError === void 0 ? void 0 : onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, { type: "unknown-field", field, value, line }));
+        break;
+    }
+  }
+  function dispatchEvent() {
+    if (id !== void 0) {
+      onId === null || onId === void 0 ? void 0 : onId(id);
+    }
+    if (dataLines > 0) {
+      onEvent === null || onEvent === void 0 ? void 0 : onEvent({
+        id,
+        event: eventType,
+        data
+      });
+    }
+    id = void 0;
+    data = "";
+    dataLines = 0;
+    eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true;
+    id = void 0;
+    data = "";
+    dataLines = 0;
+    eventType = void 0;
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    terminated = false;
+    skippingLine = false;
+    skipNextLineFeed = false;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+function isPotentialField(line, field) {
+  let i = 1;
+  while (i < line.length && i < field.length) {
+    if (line.charCodeAt(i) !== field.charCodeAt(i)) {
+      return false;
+    }
+    i++;
+  }
+  return line.length <= field.length || line.charCodeAt(field.length) === 58;
+}
+var LF, CR, SPACE, MAX_FIELD_PREFIX_LENGTH;
+var init_parse = __esm({
+  "node_modules/eventsource-parser/dist/parse.js"() {
+    init_errors2();
+    LF = 10;
+    CR = 13;
+    SPACE = 32;
+    MAX_FIELD_PREFIX_LENGTH = 6;
+  }
+});
+
+// node_modules/eventsource-parser/dist/index.js
+var init_dist = __esm({
+  "node_modules/eventsource-parser/dist/index.js"() {
+    init_parse();
+  }
+});
+
+// node_modules/eventsource/dist/EventSource.js
+function getBaseURL() {
+  const doc = "document" in globalThis ? globalThis.document : void 0;
+  return doc && typeof doc === "object" && "baseURI" in doc && typeof doc.baseURI === "string" ? doc.baseURI : void 0;
+}
+function defineEventProperty(event, property, value) {
+  Object.defineProperty(event, property, {
+    value,
+    enumerable: true,
+    configurable: true
+  });
+}
+var DEFAULT_MAX_BUFFER_SIZE, EventSourceImpl, EventSource;
+var init_EventSource = __esm({
+  "node_modules/eventsource/dist/EventSource.js"() {
+    init_dist();
+    init_errors();
+    DEFAULT_MAX_BUFFER_SIZE = 100 * 1024 * 1024;
+    EventSourceImpl = class extends EventTarget {
+      static CONNECTING = 0;
+      static OPEN = 1;
+      static CLOSED = 2;
+      CONNECTING = 0;
+      OPEN = 1;
+      CLOSED = 2;
       get readyState() {
-        return __privateGet(this, _readyState);
+        return this.#readyState;
       }
-      /**
-       * Returns the URL providing the event stream.
-       *
-       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
-       *
-       * @public
-       */
       get url() {
-        return __privateGet(this, _url).href;
+        return this.#url.href;
       }
-      /**
-       * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
-       *
-       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
-       */
       get withCredentials() {
-        return __privateGet(this, _withCredentials);
+        return this.#withCredentials;
       }
-      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
       get onerror() {
-        return __privateGet(this, _onError);
+        return this.#onError;
       }
       set onerror(value) {
-        __privateSet(this, _onError, value);
+        if (this.#onError) {
+          this.removeEventListener("error", this.#onError);
+        }
+        this.#onError = value;
+        if (value) {
+          this.addEventListener("error", value);
+        }
       }
-      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
       get onmessage() {
-        return __privateGet(this, _onMessage);
+        return this.#onMessage;
       }
       set onmessage(value) {
-        __privateSet(this, _onMessage, value);
+        if (this.#onMessage) {
+          this.removeEventListener("message", this.#onMessage);
+        }
+        this.#onMessage = value;
+        if (value) {
+          this.addEventListener("message", value);
+        }
       }
-      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
       get onopen() {
-        return __privateGet(this, _onOpen);
+        return this.#onOpen;
       }
       set onopen(value) {
-        __privateSet(this, _onOpen, value);
+        if (this.#onOpen) {
+          this.removeEventListener("open", this.#onOpen);
+        }
+        this.#onOpen = value;
+        if (value) {
+          this.addEventListener("open", value);
+        }
       }
       addEventListener(type, listener, options) {
         const listen = listener;
@@ -338,96 +551,356 @@ var require_dist2 = __commonJS({
         const listen = listener;
         super.removeEventListener(type, listen, options);
       }
+      constructor(url, eventSourceInitDict) {
+        super();
+        try {
+          if (url instanceof URL) {
+            this.#url = url;
+          } else if (typeof url === "string") {
+            this.#url = new URL(url, getBaseURL());
+          } else {
+            throw new Error("Invalid URL");
+          }
+        } catch {
+          throw syntaxError("An invalid or illegal string was specified");
+        }
+        this.#parser = createParser({
+          maxBufferSize: eventSourceInitDict?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE,
+          onEvent: this.#onEvent,
+          onError: this.#onParseError,
+          onId: this.#onIdChange,
+          onRetry: this.#onRetryChange
+        });
+        this.#readyState = this.CONNECTING;
+        this.#reconnectInterval = 3e3;
+        this.#fetch = eventSourceInitDict?.fetch ?? globalThis.fetch;
+        this.#withCredentials = eventSourceInitDict?.withCredentials ?? false;
+        this.#connect();
+      }
+      close() {
+        if (this.#reconnectTimer)
+          clearTimeout(this.#reconnectTimer);
+        if (this.#readyState === this.CLOSED)
+          return;
+        if (this.#controller)
+          this.#controller.abort();
+        this.#readyState = this.CLOSED;
+        this.#controller = void 0;
+      }
+      // PRIVATES FOLLOW
       /**
-       * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+       * Current connection state
        *
-       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+       * @internal
+       */
+      #readyState;
+      /**
+       * Original URL used to connect.
        *
-       * @public
+       * Note that this will stay the same even after a redirect.
+       *
+       * @internal
        */
-      close() {
-        __privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
+      #url;
+      /**
+       * The destination URL after a redirect. Is reset on reconnection.
+       *
+       * @internal
+       */
+      #redirectUrl;
+      /**
+       * Whether to include credentials in the request
+       *
+       * @internal
+       */
+      #withCredentials;
+      /**
+       * The fetch implementation to use
+       *
+       * @internal
+       */
+      #fetch;
+      /**
+       * The reconnection time in milliseconds
+       *
+       * @internal
+       */
+      #reconnectInterval;
+      /**
+       * Reference to an ongoing reconnect attempt, if any
+       *
+       * @internal
+       */
+      #reconnectTimer;
+      /**
+       * The last event ID seen by the EventSource, which will be sent as `Last-Event-ID` in the
+       * request headers on a reconnection attempt.
+       *
+       * @internal
+       */
+      #lastEventId = null;
+      /**
+       * The AbortController instance used to abort the fetch request
+       *
+       * @internal
+       */
+      #controller;
+      /**
+       * Instance of an EventSource parser (`eventsource-parser` npm module)
+       *
+       * @internal
+       */
+      #parser;
+      /**
+       * Holds the current error handler, attached through `onerror` property directly.
+       * Note that `addEventListener('error', …)` will not be stored here.
+       *
+       * @internal
+       */
+      #onError = null;
+      /**
+       * Holds the current message handler, attached through `onmessage` property directly.
+       * Note that `addEventListener('message', …)` will not be stored here.
+       *
+       * @internal
+       */
+      #onMessage = null;
+      /**
+       * Holds the current open handler, attached through `onopen` property directly.
+       * Note that `addEventListener('open', …)` will not be stored here.
+       *
+       * @internal
+       */
+      #onOpen = null;
+      /**
+       * Connect to the given URL and start receiving events
+       *
+       * @internal
+       */
+      #connect() {
+        this.#readyState = this.CONNECTING;
+        this.#controller = new AbortController();
+        const fetch = this.#fetch;
+        fetch(this.#url, this.#getRequestOptions()).then(this.#onFetchResponse).catch(this.#onFetchError);
       }
-    };
-    _readyState = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /**
-    * Connect to the given URL and start receiving events
-    *
-    * @internal
-    */
-    connect_fn = function() {
-      __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
-    }, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /**
-    * Get request options for the `fetch()` request
-    *
-    * @returns The request options
-    * @internal
-    */
-    getRequestOptions_fn = function() {
-      var _a;
-      const init = {
-        // [spec] Let `corsAttributeState` be `Anonymous`…
-        // [spec] …will have their mode set to "cors"…
-        mode: "cors",
-        redirect: "follow",
-        headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0 },
-        cache: "no-store",
-        signal: (_a = __privateGet(this, _controller)) == null ? void 0 : _a.signal
+      /**
+       * Handles the fetch response
+       *
+       * @param response - The Fetch(ish) response
+       * @internal
+       */
+      #onFetchResponse = async (response) => {
+        this.#parser.reset();
+        const { body, redirected, status, headers } = response;
+        if (status === 204) {
+          this.#failConnection("Server sent HTTP 204, not reconnecting", 204);
+          this.close();
+          return;
+        }
+        if (redirected) {
+          this.#redirectUrl = new URL(response.url);
+        } else {
+          this.#redirectUrl = void 0;
+        }
+        if (status !== 200) {
+          this.#failConnection(`Non-200 status code (${status})`, status);
+          return;
+        }
+        const contentType = headers.get("content-type") || "";
+        if (!contentType.startsWith("text/event-stream")) {
+          this.#failConnection('Invalid content type, expected "text/event-stream"', status);
+          return;
+        }
+        if (this.#readyState === this.CLOSED) {
+          return;
+        }
+        this.#readyState = this.OPEN;
+        const openEvent = new Event("open");
+        this.dispatchEvent(openEvent);
+        if (typeof body !== "object" || !body || !("getReader" in body)) {
+          this.#failConnection("Invalid response body, expected a web ReadableStream", status);
+          this.close();
+          return;
+        }
+        const decoder = new TextDecoder();
+        const reader = body.getReader();
+        let open = true;
+        do {
+          const { done, value } = await reader.read();
+          if (this.#readyState === this.CLOSED) {
+            open = false;
+            break;
+          }
+          if (value) {
+            this.#parser.feed(decoder.decode(value, { stream: !done }));
+          }
+          if (!done) {
+            continue;
+          }
+          open = false;
+          this.#parser.reset();
+          this.#scheduleReconnect();
+        } while (open);
       };
-      return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
-    }, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /**
-    * Handles the process referred to in the EventSource specification as "failing a connection".
-    *
-    * @param error - The error causing the connection to fail
-    * @param code - The HTTP status code, if available
-    * @internal
-    */
-    failConnection_fn = function(message, code) {
-      var _a;
-      __privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
-      const errorEvent = new ErrorEvent("error", { code, message });
-      (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
-    }, /**
-    * Schedules a reconnection attempt against the EventSource endpoint.
-    *
-    * @param message - The error causing the connection to fail
-    * @param code - The HTTP status code, if available
-    * @internal
-    */
-    scheduleReconnect_fn = function(message, code) {
-      var _a;
-      if (__privateGet(this, _readyState) === this.CLOSED)
-        return;
-      __privateSet(this, _readyState, this.CONNECTING);
-      const errorEvent = new ErrorEvent("error", { code, message });
-      (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
-    }, _reconnect = /* @__PURE__ */ new WeakMap(), /**
-    * ReadyState representing an EventSource currently trying to connect
-    *
-    * @public
-    */
-    EventSource.CONNECTING = 0, /**
-    * ReadyState representing an EventSource connection that is open (eg connected)
-    *
-    * @public
-    */
-    EventSource.OPEN = 1, /**
-    * ReadyState representing an EventSource connection that is closed (eg disconnected)
-    *
-    * @public
-    */
-    EventSource.CLOSED = 2;
-    Object.defineProperty(EventSource, /* @__PURE__ */ Symbol.for("eventsource.supports-fetch-override"), {
+      /**
+       * Handles rejected requests for the EventSource endpoint
+       *
+       * @param err - The error from `fetch()`
+       * @internal
+       */
+      #onFetchError = (err) => {
+        this.#controller = void 0;
+        if (err.name === "AbortError" || err.type === "aborted") {
+          return;
+        }
+        this.#scheduleReconnect(flattenError(err));
+      };
+      /**
+       * Get request options for the `fetch()` request
+       *
+       * @returns The request options
+       * @internal
+       */
+      #getRequestOptions() {
+        const lastEvent = this.#lastEventId ? { "Last-Event-ID": this.#lastEventId } : void 0;
+        const init = {
+          // [spec] Let `corsAttributeState` be `Anonymous`…
+          // [spec] …will have their mode set to "cors"…
+          mode: "cors",
+          redirect: "follow",
+          headers: { Accept: "text/event-stream", ...lastEvent },
+          cache: "no-store",
+          signal: this.#controller?.signal
+        };
+        if ("window" in globalThis) {
+          init.credentials = this.withCredentials ? "include" : "same-origin";
+        }
+        return init;
+      }
+      /**
+       * Called by EventSourceParser when a blank line ends a block containing a valid `id` field.
+       * This runs before `#onEvent` when the same block also contains data.
+       *
+       * @param value - The value of the `id` field
+       * @internal
+       */
+      #onIdChange = (value) => {
+        this.#lastEventId = value;
+      };
+      /**
+       * Called by EventSourceParser instance when an event has successfully been parsed
+       * and is ready to be processed.
+       *
+       * @param event - The parsed event
+       * @internal
+       */
+      #onEvent = (event) => {
+        const origin = this.#redirectUrl ? this.#redirectUrl.origin : this.#url.origin;
+        const lastEventId = this.#lastEventId ?? "";
+        const messageEvent = new MessageEvent(event.event || "message", {
+          data: event.data,
+          origin,
+          lastEventId
+        });
+        if (messageEvent.origin !== origin) {
+          defineEventProperty(messageEvent, "origin", origin);
+        }
+        if (messageEvent.lastEventId !== lastEventId) {
+          defineEventProperty(messageEvent, "lastEventId", lastEventId);
+        }
+        this.dispatchEvent(messageEvent);
+      };
+      /**
+       * Called by EventSourceParser instance when a new reconnection interval is received
+       * from the EventSource endpoint.
+       *
+       * @param value - The new reconnection interval in milliseconds
+       * @internal
+       */
+      #onRetryChange = (value) => {
+        this.#reconnectInterval = value;
+      };
+      /**
+       * Called by EventSourceParser instance when a parse error occurs.
+       *
+       * @param error - The parser error
+       * @internal
+       */
+      #onParseError = (error) => {
+        if (error.type !== "max-buffer-size-exceeded") {
+          return;
+        }
+        this.close();
+        this.#failConnection(error.message);
+      };
+      /**
+       * Handles the process referred to in the EventSource specification as "failing a connection".
+       *
+       * @param error - The error causing the connection to fail
+       * @param code - The HTTP status code, if available
+       * @internal
+       */
+      #failConnection(message, code) {
+        if (this.#readyState !== this.CLOSED) {
+          this.#readyState = this.CLOSED;
+        }
+        const errorEvent = new ErrorEvent("error", { code, message });
+        this.dispatchEvent(errorEvent);
+      }
+      /**
+       * Schedules a reconnection attempt against the EventSource endpoint.
+       *
+       * @param message - The error causing the connection to fail
+       * @param code - The HTTP status code, if available
+       * @internal
+       */
+      #scheduleReconnect(message, code) {
+        if (this.#readyState === this.CLOSED) {
+          return;
+        }
+        this.#readyState = this.CONNECTING;
+        const errorEvent = new ErrorEvent("error", { code, message });
+        this.dispatchEvent(errorEvent);
+        const timer = setTimeout(this.#reconnect, this.#reconnectInterval);
+        if (typeof timer === "object" && timer !== null && "unref" in timer) {
+          timer.unref();
+        }
+        this.#reconnectTimer = timer;
+      }
+      /**
+       * Reconnects to the EventSource endpoint after a disconnect/failure
+       *
+       * @internal
+       */
+      #reconnect = () => {
+        this.#reconnectTimer = void 0;
+        if (this.#readyState !== this.CONNECTING) {
+          return;
+        }
+        this.#connect();
+      };
+    };
+    Object.defineProperty(EventSourceImpl, "name", { value: "EventSource" });
+    Object.defineProperty(EventSourceImpl, /* @__PURE__ */ Symbol.for("eventsource.supports-fetch-override"), {
       value: true,
       writable: false,
       configurable: false,
       enumerable: false
     });
-    function getBaseURL() {
-      const doc = "document" in globalThis ? globalThis.document : void 0;
-      return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
-    }
-    exports2.ErrorEvent = ErrorEvent;
-    exports2.EventSource = EventSource;
+    EventSource = EventSourceImpl;
+  }
+});
+
+// node_modules/eventsource/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  ErrorEvent: () => ErrorEvent,
+  EventSource: () => EventSource
+});
+var init_dist2 = __esm({
+  "node_modules/eventsource/dist/index.js"() {
+    init_errors();
+    init_EventSource();
   }
 });
 
@@ -435,7 +908,7 @@ var require_dist2 = __commonJS({
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PocketbaseTrigger = void 0;
 var n8n_workflow_1 = require("n8n-workflow");
-var eventsource_1 = require_dist2();
+var eventsource_1 = (init_dist2(), __toCommonJS(dist_exports));
 var LoadOptions_1 = require("../Common/LoadOptions");
 var PocketbaseTrigger = class {
   constructor() {
@@ -492,8 +965,7 @@ var PocketbaseTrigger = class {
           required: true,
           description: "The events to trigger the node"
         }
-      ],
-      usableAsTool: true
+      ]
     };
     this.methods = {
       loadOptions: LoadOptions_1.LoadOptions