@botpress/webchat-client 0.1.0

package/dist/webchat-client.js

@@ -0,0 +1,5 @@
+import { createClient as t, createUser as a } from "./webchat-client2.js";
+export {
+  t as createClient,
+  a as createUser
+};

package/dist/webchat-client2.js

@@ -0,0 +1,84 @@
+import { createUser as g, getEvent as m, createEvent as C, deleteUser as U, updateUser as f, getUser as M, createFile as b, deleteMessage as y, getMessage as E, updateMessage as P, createMessage as $, listParticipants as q, getParticipant as w, removeParticipant as x, addParticipant as S, listConversationMessages as F, listConversations as J, deleteConversation as O, getConversation as k, createConversation as D } from "./webchat-client3.js";
+import { client as l } from "./webchat-client4.js";
+import { EventSource as N } from "./webchat-client5.js";
+import { EventEmitter as _ } from "./webchat-client6.js";
+const n = (a) => a.data, v = {
+  throwOnError: !0
+}, I = ({ clientId: a, apiUrl: h }) => {
+  const d = `${h || l.getConfig().baseUrl}/${a}`, t = {
+    ...v,
+    baseUrl: d
+  };
+  return g({ ...t, body: {} }).then(n);
+}, K = ({
+  userKey: a,
+  clientId: h,
+  apiUrl: d
+}) => {
+  const t = {
+    "x-user-key": a
+  }, p = `${d || l.getConfig().baseUrl}/${h}`, r = {
+    ...v,
+    baseUrl: p
+  };
+  return {
+    createConversation: () => D({ ...r, headers: t, body: {} }).then(n),
+    getConversation: ({ conversationId: e }) => k({ ...r, headers: t, path: { id: e } }).then(n),
+    deleteConversation: ({ conversationId: e }) => O({ ...r, headers: t, path: { id: e } }).then(n),
+    listConversations: ({ nextToken: e }) => J({ ...r, headers: t, query: { nextToken: e } }).then(n),
+    listConversationMessages: ({ conversationId: e, nextToken: s }) => F({
+      ...r,
+      headers: t,
+      path: { id: e },
+      query: { nextToken: s }
+    }).then(n),
+    addParticipant: ({ conversationId: e, userId: s }) => S({ ...r, headers: t, path: { id: e }, body: { userId: s } }).then(n),
+    removeParticipant: ({ conversationId: e, userId: s }) => x({ ...r, headers: t, path: { id: e, userId: s } }).then(n),
+    getParticipant: ({ conversationId: e, userId: s }) => w({ ...r, headers: t, path: { id: e, userId: s } }).then(n),
+    listParticipants: ({ conversationId: e, nextToken: s }) => q({ ...r, headers: t, path: { id: e }, query: { nextToken: s } }).then(n),
+    createMessage: (e) => $({ ...r, headers: t, body: e }).then(n),
+    updateMessage: ({ messageId: e, ...s }) => P({ ...r, headers: t, path: { id: e }, body: s }).then(n),
+    getMessage: ({ messageId: e }) => E({ ...r, headers: t, path: { id: e } }).then(n),
+    deleteMessage: ({ messageId: e }) => y({ ...r, headers: t, path: { id: e } }).then(n),
+    createFile: (e) => b({ ...r, headers: t, body: e }).then(n),
+    createUser: (e) => g({ ...r, headers: t, body: e }).then(n),
+    getUser: () => M({ ...r, headers: t }).then(n),
+    updateUser: (e) => f({ ...r, headers: t, body: e }).then(n),
+    deleteUser: () => U({ ...r, headers: t }).then(n),
+    createEvent: (e) => C({ ...r, headers: t, body: e }).then(n),
+    getEvent: ({ eventId: e }) => m({ ...r, headers: t, path: { id: e } }).then(n),
+    listenConversation: ({ conversationId: e }) => {
+      let s = null;
+      const i = new _();
+      return (() => {
+        s && s.close();
+        const u = `${p}/conversations/${e}/listen`;
+        s = new N(u, {
+          fetch: (c, o) => fetch(c, {
+            ...o,
+            headers: {
+              ...o == null ? void 0 : o.headers,
+              ...t,
+              timeout: "60_000"
+            }
+          })
+        }), s.onopen = () => i.emit("open"), s.onerror = (c) => {
+          i.emit("error", c);
+        }, s.onmessage = (c) => {
+          const o = j(c.data);
+          i.emit(o.type, o.data);
+        };
+      })(), i.on.bind(i);
+    }
+  };
+}, j = (a) => {
+  try {
+    return JSON.parse(a);
+  } catch {
+    return a;
+  }
+};
+export {
+  K as createClient,
+  I as createUser
+};

package/dist/webchat-client3.js

@@ -0,0 +1,116 @@
+import { client as r } from "./webchat-client4.js";
+const a = (e) => (e.client ?? r).delete({
+  url: "/conversations/{id}",
+  ...e
+}), c = (e) => (e.client ?? r).get({
+  url: "/conversations/{id}",
+  ...e
+}), n = (e) => (e.client ?? r).get({
+  url: "/conversations",
+  ...e
+}), l = (e) => (e.client ?? r).post({
+  url: "/conversations",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+}), s = (e) => (e.client ?? r).get({
+  url: "/conversations/{id}/messages",
+  ...e
+}), u = (e) => (e.client ?? r).get({
+  url: "/conversations/{id}/participants",
+  ...e
+}), d = (e) => (e.client ?? r).post({
+  url: "/conversations/{id}/participants",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+}), g = (e) => (e.client ?? r).delete({
+  url: "/conversations/{id}/participants/{userId}",
+  ...e
+}), i = (e) => (e.client ?? r).get({
+  url: "/conversations/{id}/participants/{userId}",
+  ...e
+}), v = (e) => (e.client ?? r).delete({
+  url: "/messages/{id}",
+  ...e
+}), h = (e) => (e.client ?? r).get({
+  url: "/messages/{id}",
+  ...e
+}), C = (e) => (e.client ?? r).put({
+  url: "/messages/{id}",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+}), m = (e) => (e.client ?? r).post({
+  url: "/messages",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+}), j = (e) => (e.client ?? r).delete({
+  url: "/users/me",
+  ...e
+}), y = (e) => (e.client ?? r).get({
+  url: "/users/me",
+  ...e
+}), T = (e) => (e.client ?? r).put({
+  url: "/users/me",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+}), M = (e) => ((e == null ? void 0 : e.client) ?? r).post({
+  url: "/users",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+}), P = (e) => (e.client ?? r).get({
+  url: "/events/{id}",
+  ...e
+}), U = (e) => (e.client ?? r).post({
+  url: "/events",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+}), f = (e) => (e.client ?? r).post({
+  url: "/files",
+  ...e,
+  headers: {
+    "Content-Type": "application/json",
+    ...e == null ? void 0 : e.headers
+  }
+});
+export {
+  d as addParticipant,
+  l as createConversation,
+  U as createEvent,
+  f as createFile,
+  m as createMessage,
+  M as createUser,
+  a as deleteConversation,
+  v as deleteMessage,
+  j as deleteUser,
+  c as getConversation,
+  P as getEvent,
+  h as getMessage,
+  i as getParticipant,
+  y as getUser,
+  s as listConversationMessages,
+  n as listConversations,
+  u as listParticipants,
+  g as removeParticipant,
+  C as updateMessage,
+  T as updateUser
+};

package/dist/webchat-client4.js

@@ -0,0 +1,8 @@
+import { createClient as t, createConfig as e } from "./webchat-client9.js";
+import { createClientConfig as o } from "./webchat-client7.js";
+const i = /* @__PURE__ */ t(/* @__PURE__ */ o(/* @__PURE__ */ e({
+  baseUrl: "https://webchat.botpress.cloud/"
+})));
+export {
+  i as client
+};

package/dist/webchat-client5.js

@@ -0,0 +1,272 @@
+import { createParser as X } from "./webchat-client8.js";
+class q extends Event {
+  /**
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
+   *
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
+   */
+  constructor(e, i) {
+    var r, c;
+    super(e), this.code = (r = i == null ? void 0 : i.code) != null ? r : void 0, this.message = (c = i == null ? void 0 : i.message) != null ? c : void 0;
+  }
+  /**
+   * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Node.js when you `console.log` an instance of this class.
+   *
+   * @param _depth - The current depth
+   * @param options - The options passed to `util.inspect`
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @returns A string representation of the error
+   */
+  [Symbol.for("nodejs.util.inspect.custom")](e, i, r) {
+    return r(B(this), i);
+  }
+  /**
+   * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Deno when you `console.log` an instance of this class.
+   *
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @param options - The options passed to `Deno.inspect`
+   * @returns A string representation of the error
+   */
+  [Symbol.for("Deno.customInspect")](e, i) {
+    return e(B(this), i);
+  }
+}
+function Y(t) {
+  const e = globalThis.DOMException;
+  return typeof e == "function" ? new e(t, "SyntaxError") : new SyntaxError(t);
+}
+function T(t) {
+  return t instanceof Error ? "errors" in t && Array.isArray(t.errors) ? t.errors.map(T).join(", ") : "cause" in t && t.cause instanceof Error ? `${t}: ${T(t.cause)}` : t.message : `${t}`;
+}
+function B(t) {
+  return {
+    type: t.type,
+    message: t.message,
+    code: t.code,
+    defaultPrevented: t.defaultPrevented,
+    cancelable: t.cancelable,
+    timeStamp: t.timeStamp
+  };
+}
+var z = (t) => {
+  throw TypeError(t);
+}, D = (t, e, i) => e.has(t) || z("Cannot " + i), s = (t, e, i) => (D(t, e, "read from private field"), i ? i.call(t) : e.get(t)), a = (t, e, i) => e.has(t) ? z("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, i), n = (t, e, i, r) => (D(t, e, "write to private field"), e.set(t, i), i), d = (t, e, i) => (D(t, e, "access private method"), i), h, u, E, W, O, M, _, N, p, f, g, w, C, l, L, b, R, H, x, I, y, U, A;
+class S extends EventTarget {
+  constructor(e, i) {
+    var r, c;
+    super(), a(this, l), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, a(this, h), a(this, u), a(this, E), a(this, W), a(this, O), a(this, M), a(this, _), a(this, N, null), a(this, p), a(this, f), a(this, g, null), a(this, w, null), a(this, C, null), a(this, b, async (o) => {
+      var m;
+      s(this, f).reset();
+      const { body: k, redirected: J, status: v, headers: K } = o;
+      if (v === 204) {
+        d(this, l, y).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+        return;
+      }
+      if (J ? n(this, E, new URL(o.url)) : n(this, E, void 0), v !== 200) {
+        d(this, l, y).call(this, `Non-200 status code (${v})`, v);
+        return;
+      }
+      if (!(K.get("content-type") || "").startsWith("text/event-stream")) {
+        d(this, l, y).call(this, 'Invalid content type, expected "text/event-stream"', v);
+        return;
+      }
+      if (s(this, h) === this.CLOSED)
+        return;
+      n(this, h, this.OPEN);
+      const G = new Event("open");
+      if ((m = s(this, C)) == null || m.call(this, G), this.dispatchEvent(G), typeof k != "object" || !k || !("getReader" in k)) {
+        d(this, l, y).call(this, "Invalid response body, expected a web ReadableStream", v), this.close();
+        return;
+      }
+      const Q = new TextDecoder(), V = k.getReader();
+      let P = !0;
+      do {
+        const { done: $, value: F } = await V.read();
+        F && s(this, f).feed(Q.decode(F, { stream: !$ })), $ && (P = !1, s(this, f).reset(), d(this, l, U).call(this));
+      } while (P);
+    }), a(this, R, (o) => {
+      n(this, p, void 0), !(o.name === "AbortError" || o.type === "aborted") && d(this, l, U).call(this, T(o));
+    }), a(this, x, (o) => {
+      typeof o.id == "string" && n(this, N, o.id);
+      const m = new MessageEvent(o.event || "message", {
+        data: o.data,
+        origin: s(this, E) ? s(this, E).origin : s(this, u).origin,
+        lastEventId: o.id || ""
+      });
+      s(this, w) && (!o.event || o.event === "message") && s(this, w).call(this, m), this.dispatchEvent(m);
+    }), a(this, I, (o) => {
+      n(this, M, o);
+    }), a(this, A, () => {
+      n(this, _, void 0), s(this, h) === this.CONNECTING && d(this, l, L).call(this);
+    });
+    try {
+      if (e instanceof URL)
+        n(this, u, e);
+      else if (typeof e == "string")
+        n(this, u, new URL(e, Z()));
+      else
+        throw new Error("Invalid URL");
+    } catch {
+      throw Y("An invalid or illegal string was specified");
+    }
+    n(this, f, X({
+      onEvent: s(this, x),
+      onRetry: s(this, I)
+    })), n(this, h, this.CONNECTING), n(this, M, 3e3), n(this, O, (r = i == null ? void 0 : i.fetch) != null ? r : globalThis.fetch), n(this, W, (c = i == null ? void 0 : i.withCredentials) != null ? c : !1), d(this, l, L).call(this);
+  }
+  /**
+   * 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
+   */
+  get readyState() {
+    return s(this, h);
+  }
+  /**
+   * Returns the URL providing the event stream.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+   *
+   * @public
+   */
+  get url() {
+    return s(this, u).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 s(this, W);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+  get onerror() {
+    return s(this, g);
+  }
+  set onerror(e) {
+    n(this, g, e);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+  get onmessage() {
+    return s(this, w);
+  }
+  set onmessage(e) {
+    n(this, w, e);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+  get onopen() {
+    return s(this, C);
+  }
+  set onopen(e) {
+    n(this, C, e);
+  }
+  addEventListener(e, i, r) {
+    const c = i;
+    super.addEventListener(e, c, r);
+  }
+  removeEventListener(e, i, r) {
+    const c = i;
+    super.removeEventListener(e, c, r);
+  }
+  /**
+   * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+   *
+   * @public
+   */
+  close() {
+    s(this, _) && clearTimeout(s(this, _)), s(this, h) !== this.CLOSED && (s(this, p) && s(this, p).abort(), n(this, h, this.CLOSED), n(this, p, void 0));
+  }
+}
+h = /* @__PURE__ */ new WeakMap(), u = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new WeakMap(), W = /* @__PURE__ */ new WeakMap(), O = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap(), _ = /* @__PURE__ */ new WeakMap(), N = /* @__PURE__ */ new WeakMap(), p = /* @__PURE__ */ new WeakMap(), f = /* @__PURE__ */ new WeakMap(), g = /* @__PURE__ */ new WeakMap(), w = /* @__PURE__ */ new WeakMap(), C = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakSet(), /**
+* Connect to the given URL and start receiving events
+*
+* @internal
+*/
+L = function() {
+  n(this, h, this.CONNECTING), n(this, p, new AbortController()), s(this, O)(s(this, u), d(this, l, H).call(this)).then(s(this, b)).catch(s(this, R));
+}, b = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap(), /**
+* Get request options for the `fetch()` request
+*
+* @returns The request options
+* @internal
+*/
+H = function() {
+  var t;
+  const e = {
+    // [spec] Let `corsAttributeState` be `Anonymous`…
+    // [spec] …will have their mode set to "cors"…
+    mode: "cors",
+    redirect: "follow",
+    headers: { Accept: "text/event-stream", ...s(this, N) ? { "Last-Event-ID": s(this, N) } : void 0 },
+    cache: "no-store",
+    signal: (t = s(this, p)) == null ? void 0 : t.signal
+  };
+  return "window" in globalThis && (e.credentials = this.withCredentials ? "include" : "same-origin"), e;
+}, x = /* @__PURE__ */ new WeakMap(), I = /* @__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
+*/
+y = function(t, e) {
+  var i;
+  s(this, h) !== this.CLOSED && n(this, h, this.CLOSED);
+  const r = new q("error", { code: e, message: t });
+  (i = s(this, g)) == null || i.call(this, r), this.dispatchEvent(r);
+}, /**
+* 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
+*/
+U = function(t, e) {
+  var i;
+  if (s(this, h) === this.CLOSED)
+    return;
+  n(this, h, this.CONNECTING);
+  const r = new q("error", { code: e, message: t });
+  (i = s(this, g)) == null || i.call(this, r), this.dispatchEvent(r), n(this, _, setTimeout(s(this, A), s(this, M)));
+}, A = /* @__PURE__ */ new WeakMap(), /**
+* ReadyState representing an EventSource currently trying to connect
+*
+* @public
+*/
+S.CONNECTING = 0, /**
+* ReadyState representing an EventSource connection that is open (eg connected)
+*
+* @public
+*/
+S.OPEN = 1, /**
+* ReadyState representing an EventSource connection that is closed (eg disconnected)
+*
+* @public
+*/
+S.CLOSED = 2;
+function Z() {
+  const t = "document" in globalThis ? globalThis.document : void 0;
+  return t && typeof t == "object" && "baseURI" in t && typeof t.baseURI == "string" ? t.baseURI : void 0;
+}
+export {
+  q as ErrorEvent,
+  S as EventSource
+};

package/dist/webchat-client6.js

@@ -0,0 +1,23 @@
+class h {
+  constructor() {
+    this.eventMap = {};
+  }
+  on(t, e) {
+    var a;
+    return this.eventMap[t] || (this.eventMap[t] = /* @__PURE__ */ new Set()), (a = this.eventMap[t]) == null || a.add(e), () => {
+      var i;
+      (i = this.eventMap[t]) == null || i.delete(e);
+    };
+  }
+  emit(t, e) {
+    var a, i;
+    (a = this.eventMap[t]) == null || a.forEach((p) => {
+      p(e);
+    }), (i = this.eventMap["*"]) == null || i.forEach((p) => {
+      p({ type: t, payload: e });
+    });
+  }
+}
+export {
+  h as EventEmitter
+};

package/dist/webchat-client7.js

@@ -0,0 +1,11 @@
+const e = (t) => ({
+  ...t,
+  withCredentials: !0,
+  timeout: 6e4,
+  maxBodyLength: 104857600,
+  maxContentLength: 104857600,
+  throwOnError: !0
+});
+export {
+  e as createClientConfig
+};

package/dist/webchat-client8.js

@@ -0,0 +1,105 @@
+class E extends Error {
+  constructor(d, s) {
+    super(d), this.name = "ParseError", this.type = s.type, this.field = s.field, this.value = s.value, this.line = s.line;
+  }
+}
+function x(n) {
+}
+function I(n) {
+  if (typeof n == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent: d = x, onError: s = x, onRetry: r = x, onComment: a } = n;
+  let i = "", o = !0, f, c = "", p = "";
+  function b(e) {
+    const t = o ? e.replace(/^\xEF\xBB\xBF/, "") : e, [l, u] = w(`${i}${t}`);
+    for (const h of l)
+      y(h);
+    i = u, o = !1;
+  }
+  function y(e) {
+    if (e === "") {
+      v();
+      return;
+    }
+    if (e.startsWith(":")) {
+      a && a(e.slice(e.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const t = e.indexOf(":");
+    if (t !== -1) {
+      const l = e.slice(0, t), u = e[t + 1] === " " ? 2 : 1, h = e.slice(t + u);
+      m(l, h, e);
+      return;
+    }
+    m(e, "", e);
+  }
+  function m(e, t, l) {
+    switch (e) {
+      case "event":
+        p = t;
+        break;
+      case "data":
+        c = `${c}${t}
+`;
+        break;
+      case "id":
+        f = t.includes("\0") ? void 0 : t;
+        break;
+      case "retry":
+        /^\d+$/.test(t) ? r(parseInt(t, 10)) : s(
+          new E(`Invalid \`retry\` value: "${t}"`, {
+            type: "invalid-retry",
+            value: t,
+            line: l
+          })
+        );
+        break;
+      default:
+        s(
+          new E(
+            `Unknown field "${e.length > 20 ? `${e.slice(0, 20)}…` : e}"`,
+            { type: "unknown-field", field: e, value: t, line: l }
+          )
+        );
+        break;
+    }
+  }
+  function v() {
+    c.length > 0 && d({
+      id: f,
+      event: p || 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: c.endsWith(`
+`) ? c.slice(0, -1) : c
+    }), f = void 0, c = "", p = "";
+  }
+  function $(e = {}) {
+    i && e.consume && y(i), o = !0, f = void 0, c = "", p = "", i = "";
+  }
+  return { feed: b, reset: $ };
+}
+function w(n) {
+  const d = [];
+  let s = "", r = 0;
+  for (; r < n.length; ) {
+    const a = n.indexOf("\r", r), i = n.indexOf(`
+`, r);
+    let o = -1;
+    if (a !== -1 && i !== -1 ? o = Math.min(a, i) : a !== -1 ? o = a : i !== -1 && (o = i), o === -1) {
+      s = n.slice(r);
+      break;
+    } else {
+      const f = n.slice(r, o);
+      d.push(f), r = o + 1, n[r - 1] === "\r" && n[r] === `
+` && r++;
+    }
+  }
+  return [d, s];
+}
+export {
+  E as ParseError,
+  I as createParser
+};