vue-streaming 2.0.1 → 2.0.2

package/dist/WebSocketStream.vue_vue_type_script_setup_true_lang-BzBWoH8H.js

@@ -1,1083 +0,0 @@
-import { defineComponent as T, ref as H, watch as L, computed as O, onMounted as U, createElementBlock as b, openBlock as w, createElementVNode as _, createCommentVNode as E, normalizeClass as G, unref as t, toDisplayString as x, Fragment as J, renderList as Q, onUnmounted as Z, normalizeStyle as ee, renderSlot as M, toRefs as I } from "vue";
-import { a as te, g as ne, u as oe, b as se, c as re, d as ae, f as ie, e as le, h as ce } from "./useWebSocket-D1Rqm0H7.js";
-const ue = { class: "hls-player" }, de = { class: "hls-player__video-container" }, pe = ["controls", "muted", "loop", "poster"], me = {
-  key: 0,
-  class: "hls-player__overlay"
-}, fe = {
-  key: 1,
-  class: "hls-player__overlay hls-player__overlay--error"
-}, ve = { class: "hls-player__error" }, _e = {
-  key: 0,
-  class: "hls-player__controls"
-}, ye = { class: "hls-player__quality" }, he = ["value"], ge = ["value"], be = { class: "hls-player__stats" }, we = { key: 0 }, Ce = /* @__PURE__ */ T({
-  __name: "HLSPlayer",
-  props: {
-    src: {},
-    autoPlay: { type: Boolean, default: !0 },
-    controls: { type: Boolean, default: !0 },
-    muted: { type: Boolean, default: !1 },
-    loop: { type: Boolean, default: !1 },
-    poster: {},
-    lowLatency: { type: Boolean, default: !1 },
-    startLevel: { default: -1 },
-    videoClass: {}
-  },
-  emits: ["ready", "play", "pause", "ended", "error", "levelChange", "timeUpdate", "stateChange"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, v = H(null), y = {
-      url: e.src,
-      autoPlay: e.autoPlay,
-      lowLatencyMode: e.lowLatency,
-      startLevel: e.startLevel
-    }, g = {
-      onManifestLoaded: (k) => {
-        o("ready");
-      },
-      onLevelSwitched: (k) => {
-        o("levelChange", k);
-      },
-      onPlaybackStarted: () => {
-        o("play");
-      },
-      onPlaybackEnded: () => {
-        o("ended");
-      },
-      onError: (k) => {
-        o("error", k);
-      }
-    }, {
-      state: i,
-      isPlaying: d,
-      isBuffering: f,
-      levels: r,
-      currentLevel: l,
-      autoLevelEnabled: c,
-      currentTime: p,
-      duration: u,
-      buffered: n,
-      volume: s,
-      muted: a,
-      stats: B,
-      error: m,
-      isSupported: h,
-      attach: A,
-      play: j,
-      pause: P,
-      stop: $,
-      seek: D,
-      setLevel: q,
-      setVolume: K,
-      toggleMute: X,
-      destroy: Y
-    } = te(y, g);
-    L(i, (k) => {
-      o("stateChange", k);
-    }), L(p, (k) => {
-      o("timeUpdate", k);
-    });
-    function N(k) {
-      if (!isFinite(k)) return "0:00";
-      const F = Math.floor(k / 60), z = Math.floor(k % 60);
-      return `${F}:${z.toString().padStart(2, "0")}`;
-    }
-    const V = O(() => l.value < 0 || l.value >= r.value.length ? null : r.value[l.value]);
-    return U(async () => {
-      if (v.value)
-        try {
-          await A(v.value);
-        } catch (k) {
-          console.error("[HLSPlayer] Failed to attach:", k);
-        }
-    }), L(
-      () => e.src,
-      async (k) => {
-        v.value && k && (Y(), y.url = k, await A(v.value));
-      }
-    ), R({
-      play: j,
-      pause: P,
-      stop: $,
-      seek: D,
-      setLevel: q,
-      setVolume: K,
-      toggleMute: X,
-      state: i,
-      levels: r,
-      currentLevel: l,
-      stats: B
-    }), (k, F) => (w(), b("div", ue, [
-      _("div", de, [
-        _("video", {
-          ref_key: "videoRef",
-          ref: v,
-          class: G(["hls-player__video", k.videoClass]),
-          controls: k.controls,
-          muted: k.muted,
-          loop: k.loop,
-          poster: k.poster,
-          playsinline: ""
-        }, null, 10, pe),
-        t(f) ? (w(), b("div", me, [...F[1] || (F[1] = [
-          _("div", { class: "hls-player__spinner" }, null, -1)
-        ])])) : E("", !0),
-        t(m) ? (w(), b("div", fe, [
-          _("div", ve, [
-            _("span", null, "⚠️ " + x(t(m).message), 1)
-          ])
-        ])) : E("", !0)
-      ]),
-      t(r).length > 1 ? (w(), b("div", _e, [
-        _("div", ye, [
-          F[3] || (F[3] = _("label", null, "Quality:", -1)),
-          _("select", {
-            value: t(l),
-            onChange: F[0] || (F[0] = (z) => t(q)(Number(z.target.value)))
-          }, [
-            F[2] || (F[2] = _("option", { value: -1 }, "Auto", -1)),
-            (w(!0), b(J, null, Q(t(r), (z) => (w(), b("option", {
-              key: z.index,
-              value: z.index
-            }, x(z.height) + "p (" + x(Math.round(z.bitrate / 1e3)) + "kbps) ", 9, ge))), 128))
-          ], 40, he)
-        ]),
-        _("div", be, [
-          V.value ? (w(), b("span", we, x(V.value.width) + "x" + x(V.value.height), 1)) : E("", !0),
-          _("span", null, x(Math.round(t(B).bandwidth / 1e6 * 10) / 10) + " Mbps", 1),
-          _("span", null, x(N(t(p))) + " / " + x(N(t(u))), 1)
-        ])
-      ])) : E("", !0)
-    ]));
-  }
-}), W = (C, R) => {
-  const S = C.__vccOpts || C;
-  for (const [e, o] of R)
-    S[e] = o;
-  return S;
-}, nt = /* @__PURE__ */ W(Ce, [["__scopeId", "data-v-b04c54da"]]), Se = { class: "pointcloud-viewer" }, Re = {
-  key: 0,
-  class: "pointcloud-viewer__overlay"
-}, ke = {
-  key: 1,
-  class: "pointcloud-viewer__overlay pointcloud-viewer__overlay--error"
-}, xe = { class: "pointcloud-viewer__stats" }, Pe = { key: 0 }, Be = /* @__PURE__ */ T({
-  __name: "PointCloudViewer",
-  props: {
-    points: {},
-    pointSize: { default: 0.02 },
-    pointColor: { default: 65280 },
-    usePointColors: { type: Boolean, default: !0 },
-    cameraPosition: { default: () => ({ x: 5, y: 5, z: 5 }) },
-    autoRotate: { type: Boolean, default: !1 },
-    autoRotateSpeed: { default: 1 },
-    backgroundColor: { default: 1973790 },
-    showAxes: { type: Boolean, default: !1 },
-    showGrid: { type: Boolean, default: !0 },
-    bounds: {}
-  },
-  emits: ["ready", "click", "error"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, v = H(null), y = H(!0), g = H(null);
-    let i = null, d = null, f = null, r = null, l = null, c = null, p = null;
-    async function u() {
-      if (v.value)
-        try {
-          i = await import("three");
-          const { OrbitControls: m } = await import("three/examples/jsm/controls/OrbitControls.js"), h = v.value, A = h.clientWidth, j = h.clientHeight;
-          if (d = new i.Scene(), d.background = new i.Color(e.backgroundColor), f = new i.PerspectiveCamera(75, A / j, 0.1, 1e3), f.position.set(
-            e.cameraPosition.x,
-            e.cameraPosition.y,
-            e.cameraPosition.z
-          ), r = new i.WebGLRenderer({ antialias: !0 }), r.setSize(A, j), r.setPixelRatio(window.devicePixelRatio), h.appendChild(r.domElement), l = new m(f, r.domElement), l.autoRotate = e.autoRotate, l.autoRotateSpeed = e.autoRotateSpeed, e.showGrid) {
-            const $ = new i.GridHelper(10, 10, 4473924, 3355443);
-            d.add($);
-          }
-          if (e.showAxes) {
-            const $ = new i.AxesHelper(5);
-            d.add($);
-          }
-          new ResizeObserver(() => {
-            if (!f || !r || !v.value) return;
-            const $ = v.value.clientWidth, D = v.value.clientHeight;
-            f.aspect = $ / D, f.updateProjectionMatrix(), r.setSize($, D);
-          }).observe(h), s(), y.value = !1, o("ready");
-        } catch (m) {
-          const h = m instanceof Error ? m : new Error(String(m));
-          g.value = h, o("error", h), console.error("[PointCloudViewer] Failed to initialize:", m);
-        }
-    }
-    function n() {
-      if (!i || !d || (c && (d.remove(c), c.geometry.dispose(), c.material.dispose(), c = null), e.points.length === 0)) return;
-      const m = new i.BufferGeometry(), h = new Float32Array(e.points.length * 3), A = new Float32Array(e.points.length * 3);
-      for (let P = 0; P < e.points.length; P++) {
-        const $ = e.points[P];
-        if (h[P * 3] = $.x, h[P * 3 + 1] = $.y, h[P * 3 + 2] = $.z, e.usePointColors && $.r !== void 0)
-          A[P * 3] = $.r, A[P * 3 + 1] = $.g ?? 0, A[P * 3 + 2] = $.b ?? 0;
-        else {
-          const D = new i.Color(e.pointColor);
-          A[P * 3] = D.r, A[P * 3 + 1] = D.g, A[P * 3 + 2] = D.b;
-        }
-      }
-      m.setAttribute("position", new i.BufferAttribute(h, 3)), m.setAttribute("color", new i.BufferAttribute(A, 3));
-      const j = new i.PointsMaterial({
-        size: e.pointSize,
-        vertexColors: !0,
-        sizeAttenuation: !0
-      });
-      if (c = new i.Points(m, j), d.add(c), e.bounds && f) {
-        const P = {
-          x: (e.bounds.min.x + e.bounds.max.x) / 2,
-          y: (e.bounds.min.y + e.bounds.max.y) / 2,
-          z: (e.bounds.min.z + e.bounds.max.z) / 2
-        }, $ = Math.max(
-          e.bounds.max.x - e.bounds.min.x,
-          e.bounds.max.y - e.bounds.min.y,
-          e.bounds.max.z - e.bounds.min.z
-        );
-        f.position.set(
-          P.x + $ * 1.5,
-          P.y + $ * 1.5,
-          P.z + $ * 1.5
-        ), f.lookAt(P.x, P.y, P.z);
-      }
-    }
-    function s() {
-      p = requestAnimationFrame(s), l && l.update(), r && d && f && r.render(d, f);
-    }
-    function a() {
-      p && (cancelAnimationFrame(p), p = null), c && d && (d.remove(c), c.geometry.dispose(), c.material.dispose()), l && l.dispose(), r && (r.dispose(), v.value && r.domElement.parentNode && v.value.removeChild(r.domElement)), d = null, f = null, r = null, l = null, c = null;
-    }
-    L(() => e.points, n, { deep: !0 }), L(
-      [() => e.pointSize, () => e.pointColor, () => e.usePointColors],
-      n
-    ), L(
-      () => e.autoRotate,
-      (m) => {
-        l && (l.autoRotate = m);
-      }
-    ), L(
-      () => e.autoRotateSpeed,
-      (m) => {
-        l && (l.autoRotateSpeed = m);
-      }
-    ), U(() => {
-      u();
-    }), Z(() => {
-      a();
-    });
-    const B = O(() => ({
-      pointCount: e.points.length,
-      hasColors: e.points.length > 0 && e.points[0].r !== void 0
-    }));
-    return R({
-      updatePointCloud: n,
-      stats: B
-    }), (m, h) => (w(), b("div", Se, [
-      _("div", {
-        ref_key: "containerRef",
-        ref: v,
-        class: "pointcloud-viewer__canvas"
-      }, null, 512),
-      y.value ? (w(), b("div", Re, [...h[0] || (h[0] = [
-        _("div", { class: "pointcloud-viewer__spinner" }, null, -1),
-        _("span", null, "Loading viewer...", -1)
-      ])])) : E("", !0),
-      g.value ? (w(), b("div", ke, [
-        _("span", null, "⚠️ " + x(g.value.message), 1),
-        h[1] || (h[1] = _("small", null, "Make sure 'three' package is installed", -1))
-      ])) : E("", !0),
-      _("div", xe, [
-        _("span", null, "Points: " + x(B.value.pointCount.toLocaleString()), 1),
-        B.value.hasColors ? (w(), b("span", Pe, "🎨 Colored")) : E("", !0)
-      ])
-    ]));
-  }
-}), ot = /* @__PURE__ */ W(Be, [["__scopeId", "data-v-7f487135"]]), $e = { class: "stream-viewer" }, Ae = { class: "stream-viewer__header" }, Ee = { class: "stream-viewer__stats" }, Le = {
-  key: 0,
-  class: "stream-viewer__errors"
-}, Te = { class: "stream-viewer__actions" }, Fe = {
-  key: 0,
-  class: "stream-viewer__timestamp"
-}, De = { class: "stream-viewer__data" }, ze = {
-  key: 0,
-  class: "stream-viewer__empty"
-}, Me = /* @__PURE__ */ T({
-  __name: "StreamViewer",
-  props: {
-    data: {},
-    type: { default: "auto" },
-    maxLines: { default: 100 },
-    autoScroll: { type: Boolean, default: !0 },
-    showTimestamps: { type: Boolean, default: !0 },
-    paused: { type: Boolean, default: !1 },
-    formatter: {}
-  },
-  emits: ["clear", "pause"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, v = H([]), y = H(null);
-    let g = 0;
-    function i(n) {
-      if (e.formatter)
-        return e.formatter(n);
-      if (n == null)
-        return String(n);
-      switch (e.type === "auto" ? d(n) : e.type) {
-        case "json":
-          try {
-            return JSON.stringify(n, null, 2);
-          } catch {
-            return String(n);
-          }
-        case "binary":
-          return n instanceof ArrayBuffer ? `Binary: ${new Uint8Array(n).length} bytes` : String(n);
-        default:
-          return String(n);
-      }
-    }
-    function d(n) {
-      return n instanceof ArrayBuffer || n instanceof Uint8Array ? "binary" : typeof n == "object" ? "json" : "text";
-    }
-    function f(n, s = "data") {
-      if (e.paused) return;
-      const a = {
-        id: g++,
-        timestamp: /* @__PURE__ */ new Date(),
-        data: i(n),
-        type: s
-      };
-      v.value = [...v.value, a].slice(-e.maxLines), e.autoScroll && r();
-    }
-    function r() {
-      requestAnimationFrame(() => {
-        y.value && (y.value.scrollTop = y.value.scrollHeight);
-      });
-    }
-    function l() {
-      v.value = [], o("clear");
-    }
-    function c() {
-      o("pause", !e.paused);
-    }
-    function p(n) {
-      return n.toLocaleTimeString("en-US", {
-        hour12: !1,
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-        fractionalSecondDigits: 3
-      });
-    }
-    L(
-      () => e.data,
-      (n) => {
-        n !== void 0 && f(n);
-      }
-    );
-    const u = O(() => ({
-      total: v.value.length,
-      errors: v.value.filter((n) => n.type === "error").length
-    }));
-    return R({
-      addLog: f,
-      clear: l,
-      logs: v,
-      stats: u
-    }), (n, s) => (w(), b("div", $e, [
-      _("div", Ae, [
-        _("div", Ee, [
-          _("span", null, "Lines: " + x(u.value.total), 1),
-          u.value.errors > 0 ? (w(), b("span", Le, " Errors: " + x(u.value.errors), 1)) : E("", !0)
-        ]),
-        _("div", Te, [
-          _("button", {
-            onClick: c,
-            class: G(["stream-viewer__btn", { "stream-viewer__btn--active": n.paused }])
-          }, x(n.paused ? "▶ Resume" : "⏸ Pause"), 3),
-          _("button", {
-            onClick: l,
-            class: "stream-viewer__btn"
-          }, "🗑 Clear")
-        ])
-      ]),
-      _("div", {
-        ref_key: "containerRef",
-        ref: y,
-        class: "stream-viewer__content"
-      }, [
-        (w(!0), b(J, null, Q(v.value, (a) => (w(), b("div", {
-          key: a.id,
-          class: G(["stream-viewer__entry", `stream-viewer__entry--${a.type}`])
-        }, [
-          n.showTimestamps ? (w(), b("span", Fe, x(p(a.timestamp)), 1)) : E("", !0),
-          _("pre", De, x(a.data), 1)
-        ], 2))), 128)),
-        v.value.length === 0 ? (w(), b("div", ze, " Waiting for data... ")) : E("", !0)
-      ], 512)
-    ]));
-  }
-}), st = /* @__PURE__ */ W(Me, [["__scopeId", "data-v-06dc8d20"]]), He = { class: "webrtc-viewer" }, Ie = {
-  key: 0,
-  class: "webrtc-viewer__header"
-}, je = { class: "webrtc-viewer__status" }, Oe = { class: "webrtc-viewer__controls" }, Ue = { class: "webrtc-viewer__content" }, We = { class: "webrtc-viewer__default" }, Ve = {
-  key: 0,
-  class: "webrtc-viewer__placeholder"
-}, Ge = {
-  key: 1,
-  class: "webrtc-viewer__loading"
-}, qe = {
-  key: 2,
-  class: "webrtc-viewer__error"
-}, Ne = {
-  key: 3,
-  class: "webrtc-viewer__info"
-}, Je = { key: 0 }, Qe = { key: 1 }, Ke = {
-  key: 1,
-  class: "webrtc-viewer__footer"
-}, Xe = { key: 0 }, Ye = { key: 1 }, Ze = /* @__PURE__ */ T({
-  __name: "WebRTCViewer",
-  props: {
-    signalingUrl: {},
-    iceServers: { default: () => [{ urls: "stun:stun.l.google.com:19302" }] },
-    enablePointCloud: { type: Boolean, default: !0 },
-    enableDetections: { type: Boolean, default: !0 },
-    autoConnect: { type: Boolean, default: !0 },
-    autoReconnect: { type: Boolean, default: !0 },
-    maxReconnectAttempts: { default: 5 },
-    showStatus: { type: Boolean, default: !0 },
-    showStats: { type: Boolean, default: !0 }
-  },
-  emits: ["connected", "disconnected", "error", "pointcloud", "detections", "boundingboxes", "status"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, v = H("Idle"), y = {
-      signalingUrl: e.signalingUrl,
-      iceServers: e.iceServers,
-      enablePointCloud: e.enablePointCloud,
-      enableDetections: e.enableDetections,
-      autoReconnect: e.autoReconnect,
-      maxReconnectAttempts: e.maxReconnectAttempts
-    }, g = {
-      onStatus: (m) => {
-        v.value = m, o("status", m);
-      },
-      onConnectionState: (m) => {
-        m === "connected" ? o("connected") : (m === "disconnected" || m === "closed" || m === "failed") && o("disconnected");
-      },
-      onPointCloudFrame: (m) => {
-        o("pointcloud", m);
-      },
-      onDetectionFrame: (m) => {
-        o("detections", m);
-      },
-      onBoundingBoxData: (m) => {
-        o("boundingboxes", m);
-      },
-      onError: (m) => {
-        o("error", m);
-      }
-    }, {
-      isRunning: i,
-      connectionState: d,
-      dataChannels: f,
-      lastPointCloudFrame: r,
-      lastDetectionFrame: l,
-      lastBoundingBoxes: c,
-      error: p,
-      start: u,
-      stop: n,
-      sendControl: s
-    } = ne(y, g), a = O(() => {
-      var m, h;
-      return {
-        channels: f.value.size,
-        pointCount: ((m = r.value) == null ? void 0 : m.points.length) ?? 0,
-        detectionCount: ((h = l.value) == null ? void 0 : h.detections.length) ?? 0,
-        bboxCount: c.value.length
-      };
-    }), B = O(() => {
-      switch (d.value) {
-        case "connected":
-          return "#4caf50";
-        case "connecting":
-          return "#ff9800";
-        case "reconnecting":
-          return "#ff9800";
-        case "error":
-          return "#f44336";
-        default:
-          return "#9e9e9e";
-      }
-    });
-    return U(() => {
-      e.autoConnect && u();
-    }), L(
-      () => e.signalingUrl,
-      () => {
-        i.value && (n(), y.signalingUrl = e.signalingUrl, u());
-      }
-    ), R({
-      isRunning: i,
-      connectionState: d,
-      start: u,
-      stop: n,
-      sendControl: s,
-      lastPointCloudFrame: r,
-      lastDetectionFrame: l,
-      lastBoundingBoxes: c,
-      stats: a
-    }), (m, h) => (w(), b("div", He, [
-      m.showStatus ? (w(), b("div", Ie, [
-        _("div", je, [
-          _("span", {
-            class: "webrtc-viewer__indicator",
-            style: ee({ backgroundColor: B.value })
-          }, null, 4),
-          _("span", null, x(t(d)), 1)
-        ]),
-        _("div", Oe, [
-          t(i) ? (w(), b("button", {
-            key: 1,
-            onClick: h[1] || (h[1] = //@ts-ignore
-            (...A) => t(n) && t(n)(...A)),
-            class: "webrtc-viewer__btn webrtc-viewer__btn--disconnect"
-          }, " ⏹ Disconnect ")) : (w(), b("button", {
-            key: 0,
-            onClick: h[0] || (h[0] = //@ts-ignore
-            (...A) => t(u) && t(u)(...A)),
-            class: "webrtc-viewer__btn webrtc-viewer__btn--connect"
-          }, " ▶ Connect "))
-        ])
-      ])) : E("", !0),
-      _("div", Ue, [
-        M(m.$slots, "default", {
-          isRunning: t(i),
-          connectionState: t(d),
-          pointCloudFrame: t(r),
-          detectionFrame: t(l),
-          boundingBoxes: t(c),
-          error: t(p),
-          start: t(u),
-          stop: t(n),
-          sendControl: t(s)
-        }, () => [
-          _("div", We, [
-            t(i) ? t(d) === "connecting" ? (w(), b("div", Ge, [
-              h[3] || (h[3] = _("div", { class: "webrtc-viewer__spinner" }, null, -1)),
-              _("span", null, x(v.value), 1)
-            ])) : t(p) ? (w(), b("div", qe, [
-              _("span", null, "⚠️ " + x(t(p).message), 1)
-            ])) : (w(), b("div", Ne, [
-              h[4] || (h[4] = _("p", null, "WebRTC Connected", -1)),
-              a.value.pointCount > 0 ? (w(), b("p", Je, " Points: " + x(a.value.pointCount.toLocaleString()), 1)) : E("", !0),
-              a.value.bboxCount > 0 ? (w(), b("p", Qe, " Bounding Boxes: " + x(a.value.bboxCount), 1)) : E("", !0)
-            ])) : (w(), b("div", Ve, [...h[2] || (h[2] = [
-              _("span", null, "Click Connect to start WebRTC stream", -1)
-            ])]))
-          ])
-        ], !0)
-      ]),
-      m.showStats && t(i) ? (w(), b("div", Ke, [
-        _("span", null, "Channels: " + x(a.value.channels), 1),
-        e.enablePointCloud ? (w(), b("span", Xe, " Points: " + x(a.value.pointCount.toLocaleString()), 1)) : E("", !0),
-        e.enableDetections ? (w(), b("span", Ye, " Detections: " + x(a.value.detectionCount), 1)) : E("", !0)
-      ])) : E("", !0)
-    ]));
-  }
-}), rt = /* @__PURE__ */ W(Ze, [["__scopeId", "data-v-3f83a728"]]), at = /* @__PURE__ */ T({
-  __name: "DataStreamView",
-  props: {
-    config: { default: () => ({}) },
-    autoStart: { type: Boolean, default: !0 }
-  },
-  emits: ["data", "batch", "error"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, { config: v } = I(e), {
-      data: y,
-      buffer: g,
-      bufferSize: i,
-      isStreaming: d,
-      itemsPerSecond: f,
-      totalItems: r,
-      error: l,
-      start: c,
-      stop: p,
-      push: u,
-      clear: n,
-      getBuffer: s,
-      subscribe: a
-    } = oe(e.config, {
-      onData: (B) => o("data", B),
-      onBatch: (B) => o("batch", B),
-      onError: (B) => o("error", B)
-    });
-    return U(() => {
-      e.autoStart && c();
-    }), L(
-      v,
-      () => {
-        p(), c();
-      },
-      { deep: !0 }
-    ), R({
-      data: y,
-      buffer: g,
-      bufferSize: i,
-      isStreaming: d,
-      itemsPerSecond: f,
-      totalItems: r,
-      error: l,
-      start: c,
-      stop: p,
-      push: u,
-      clear: n,
-      getBuffer: s,
-      subscribe: a
-    }), (B, m) => M(B.$slots, "default", {
-      data: t(y),
-      buffer: t(g),
-      bufferSize: t(i),
-      isStreaming: t(d),
-      itemsPerSecond: t(f),
-      totalItems: t(r),
-      error: t(l),
-      start: t(c),
-      stop: t(p),
-      push: t(u),
-      clear: t(n)
-    });
-  }
-}), it = /* @__PURE__ */ T({
-  __name: "HTTPStream",
-  props: {
-    url: {},
-    method: { default: "GET" },
-    headers: { default: () => ({}) },
-    body: { default: void 0 },
-    credentials: { default: "same-origin" },
-    autoConnect: { type: Boolean, default: !0 },
-    autoReconnect: { type: Boolean, default: !0 },
-    maxReconnectAttempts: { default: 5 },
-    reconnectDelay: { default: 1e3 },
-    ndjson: { type: Boolean, default: !0 }
-  },
-  emits: ["open", "chunk", "complete", "error", "progress", "reconnecting", "reconnected", "reconnectFailed"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, { url: v } = I(e), {
-      isConnected: y,
-      isStreaming: g,
-      connectionState: i,
-      lastChunk: d,
-      chunks: f,
-      bytesReceived: r,
-      error: l,
-      reconnectAttempts: c,
-      connect: p,
-      disconnect: u,
-      clearChunks: n
-    } = se(
-      {
-        url: e.url,
-        method: e.method,
-        headers: e.headers,
-        body: e.body,
-        credentials: e.credentials,
-        autoConnect: e.autoConnect,
-        autoReconnect: e.autoReconnect,
-        maxReconnectAttempts: e.maxReconnectAttempts,
-        reconnectDelay: e.reconnectDelay,
-        ndjson: e.ndjson
-      },
-      {
-        onOpen: () => o("open"),
-        onChunk: (s, a) => o("chunk", s, a),
-        onComplete: () => o("complete"),
-        onError: (s) => o("error", s),
-        onProgress: (s) => o("progress", s),
-        onReconnecting: (s, a) => o("reconnecting", s, a),
-        onReconnected: () => o("reconnected"),
-        onReconnectFailed: () => o("reconnectFailed")
-      }
-    );
-    return L(v, () => {
-      u(), p();
-    }), R({
-      isConnected: y,
-      isStreaming: g,
-      connectionState: i,
-      lastChunk: d,
-      chunks: f,
-      bytesReceived: r,
-      error: l,
-      reconnectAttempts: c,
-      connect: p,
-      disconnect: u,
-      clearChunks: n
-    }), (s, a) => M(s.$slots, "default", {
-      isConnected: t(y),
-      isStreaming: t(g),
-      connectionState: t(i),
-      lastChunk: t(d),
-      chunks: t(f),
-      bytesReceived: t(r),
-      error: t(l),
-      reconnectAttempts: t(c),
-      connect: t(p),
-      disconnect: t(u),
-      clearChunks: t(n)
-    });
-  }
-}), lt = /* @__PURE__ */ T({
-  __name: "LaravelEchoStream",
-  props: {
-    config: {},
-    channel: { default: void 0 },
-    channelType: { default: "public" },
-    events: { default: () => [] },
-    autoSubscribe: { type: Boolean, default: !0 }
-  },
-  emits: ["connected", "event", "error", "subscribed", "unsubscribed", "here", "joining", "leaving"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, { channel: v } = I(e), {
-      isConnected: y,
-      channels: g,
-      channel: i,
-      privateChannel: d,
-      presenceChannel: f,
-      leave: r,
-      leaveAll: l,
-      connect: c
-    } = re(e.config, {
-      onConnected: (n) => o("connected", n),
-      onError: (n) => o("error", n)
-    });
-    let p = null;
-    function u() {
-      if (e.channel) {
-        if (e.channelType === "private")
-          p = d(e.channel);
-        else if (e.channelType === "presence") {
-          const n = f(e.channel);
-          p = n, n.here((s) => o("here", s)), n.joining((s) => o("joining", s)), n.leaving((s) => o("leaving", s));
-        } else
-          p = i(e.channel);
-        e.events.forEach((n) => {
-          p == null || p.listen(n, (s) => {
-            o("event", n, s);
-          });
-        }), o("subscribed", e.channel);
-      }
-    }
-    return U(async () => {
-      await c(), e.autoSubscribe && e.channel && u();
-    }), L(v, (n, s) => {
-      s && (r(s), o("unsubscribed", s)), n && e.autoSubscribe && u();
-    }), R({
-      isConnected: y,
-      channels: g,
-      subscribePublic: i,
-      privateChannel: d,
-      presenceChannel: f,
-      leave: r,
-      leaveAll: l,
-      connect: c
-    }), (n, s) => M(n.$slots, "default", {
-      isConnected: t(y),
-      channels: t(g),
-      subscribePublic: t(i),
-      privateChannel: t(d),
-      presenceChannel: t(f),
-      leave: t(r),
-      leaveAll: t(l)
-    });
-  }
-}), ct = /* @__PURE__ */ T({
-  __name: "LongPollingStream",
-  props: {
-    url: {},
-    method: { default: "GET" },
-    headers: { default: () => ({}) },
-    body: { default: void 0 },
-    credentials: { default: "same-origin" },
-    interval: { default: 0 },
-    timeout: { default: 3e4 },
-    autoStart: { type: Boolean, default: !0 },
-    autoRestart: { type: Boolean, default: !0 },
-    maxRestartAttempts: { default: 5 },
-    restartDelay: { default: 1e3 },
-    includeTimestamp: { type: Boolean, default: !1 },
-    timestampParam: { default: "since" }
-  },
-  emits: ["start", "data", "error", "stop", "restarting", "restarted", "restartFailed"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, { url: v } = I(e), {
-      isPolling: y,
-      connectionState: g,
-      lastData: i,
-      dataHistory: d,
-      requestCount: f,
-      error: r,
-      restartAttempts: l,
-      start: c,
-      stop: p,
-      poll: u,
-      clearHistory: n
-    } = ae(
-      {
-        url: e.url,
-        method: e.method,
-        headers: e.headers,
-        body: e.body,
-        credentials: e.credentials,
-        interval: e.interval,
-        timeout: e.timeout,
-        autoStart: e.autoStart,
-        autoRestart: e.autoRestart,
-        maxRestartAttempts: e.maxRestartAttempts,
-        restartDelay: e.restartDelay,
-        includeTimestamp: e.includeTimestamp,
-        timestampParam: e.timestampParam
-      },
-      {
-        onStart: () => o("start"),
-        onData: (s) => o("data", s),
-        onError: (s) => o("error", s),
-        onStop: () => o("stop"),
-        onRestarting: (s, a) => o("restarting", s, a),
-        onRestarted: () => o("restarted"),
-        onRestartFailed: () => o("restartFailed")
-      }
-    );
-    return L(v, () => {
-      p(), c();
-    }), R({
-      isPolling: y,
-      connectionState: g,
-      lastData: i,
-      dataHistory: d,
-      requestCount: f,
-      error: r,
-      restartAttempts: l,
-      start: c,
-      stop: p,
-      poll: u,
-      clearHistory: n
-    }), (s, a) => M(s.$slots, "default", {
-      isPolling: t(y),
-      connectionState: t(g),
-      lastData: t(i),
-      dataHistory: t(d),
-      requestCount: t(f),
-      error: t(r),
-      restartAttempts: t(l),
-      start: t(c),
-      stop: t(p),
-      poll: t(u),
-      clearHistory: t(n)
-    });
-  }
-}), ut = /* @__PURE__ */ T({
-  __name: "SocketIOStream",
-  props: {
-    config: {},
-    autoConnect: { type: Boolean, default: !0 },
-    events: { default: () => [] }
-  },
-  emits: ["connect", "disconnect", "error", "event", "reconnecting", "reconnected", "reconnectFailed"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, { config: v } = I(e), {
-      isConnected: y,
-      connectionState: g,
-      socketId: i,
-      rooms: d,
-      error: f,
-      connect: r,
-      disconnect: l,
-      emit: c,
-      on: p,
-      off: u,
-      join: n,
-      leave: s
-    } = ie(e.config, {
-      onConnect: (a) => o("connect", a),
-      onDisconnect: (a) => o("disconnect", a),
-      onError: (a) => o("error", a),
-      onReconnecting: (a) => o("reconnecting", a),
-      onReconnectFailed: () => o("reconnectFailed")
-    });
-    return e.events.forEach((a) => {
-      p(a, (B) => {
-        o("event", a, B);
-      });
-    }), L(
-      () => v.value.url,
-      () => {
-        l(), r();
-      }
-    ), R({
-      isConnected: y,
-      connectionState: g,
-      socketId: i,
-      rooms: d,
-      error: f,
-      connect: r,
-      disconnect: l,
-      emit: c,
-      on: p,
-      off: u,
-      join: n,
-      leave: s
-    }), (a, B) => M(a.$slots, "default", {
-      isConnected: t(y),
-      connectionState: t(g),
-      socketId: t(i),
-      rooms: t(d),
-      error: t(f),
-      connect: t(r),
-      disconnect: t(l),
-      emit: t(c),
-      on: t(p),
-      off: t(u),
-      join: t(n),
-      leave: t(s)
-    });
-  }
-}), dt = /* @__PURE__ */ T({
-  __name: "SSEStream",
-  props: {
-    url: {},
-    withCredentials: { type: Boolean, default: !1 },
-    autoConnect: { type: Boolean, default: !0 },
-    autoReconnect: { type: Boolean, default: !0 },
-    maxReconnectAttempts: { default: 5 },
-    reconnectDelay: { default: 1e3 },
-    eventTypes: { default: () => ["message"] }
-  },
-  emits: ["open", "error", "message", "event", "reconnecting", "reconnected", "reconnectFailed"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, { url: v } = I(e), {
-      isConnected: y,
-      connectionState: g,
-      lastMessage: i,
-      lastEventType: d,
-      lastEventId: f,
-      error: r,
-      reconnectAttempts: l,
-      connect: c,
-      disconnect: p,
-      addEventListener: u,
-      removeEventListener: n
-    } = le(
-      {
-        url: e.url,
-        withCredentials: e.withCredentials,
-        autoConnect: e.autoConnect,
-        autoReconnect: e.autoReconnect,
-        maxReconnectAttempts: e.maxReconnectAttempts,
-        reconnectDelay: e.reconnectDelay,
-        eventTypes: e.eventTypes
-      },
-      {
-        onOpen: () => o("open"),
-        onError: (s) => o("error", s),
-        onMessage: (s, a) => o("message", s, a),
-        onEvent: (s, a, B) => o("event", s, a, B),
-        onReconnecting: (s, a) => o("reconnecting", s, a),
-        onReconnected: () => o("reconnected"),
-        onReconnectFailed: () => o("reconnectFailed")
-      }
-    );
-    return L(v, () => {
-      p(), c();
-    }), R({
-      isConnected: y,
-      connectionState: g,
-      lastMessage: i,
-      lastEventType: d,
-      lastEventId: f,
-      error: r,
-      reconnectAttempts: l,
-      connect: c,
-      disconnect: p,
-      addEventListener: u,
-      removeEventListener: n
-    }), (s, a) => M(s.$slots, "default", {
-      isConnected: t(y),
-      connectionState: t(g),
-      lastMessage: t(i),
-      lastEventType: t(d),
-      lastEventId: t(f),
-      error: t(r),
-      reconnectAttempts: t(l),
-      connect: t(c),
-      disconnect: t(p),
-      addEventListener: t(u),
-      removeEventListener: t(n)
-    });
-  }
-}), pt = /* @__PURE__ */ T({
-  __name: "WebSocketStream",
-  props: {
-    config: {},
-    autoConnect: { type: Boolean, default: !0 }
-  },
-  emits: ["open", "close", "error", "message", "reconnecting", "reconnected", "reconnectFailed"],
-  setup(C, { expose: R, emit: S }) {
-    const e = C, o = S, { config: v } = I(e), {
-      isConnected: y,
-      connectionState: g,
-      lastMessage: i,
-      error: d,
-      reconnectAttempts: f,
-      connect: r,
-      disconnect: l,
-      send: c,
-      sendJSON: p
-    } = ce(e.config, {
-      onOpen: () => o("open"),
-      onClose: (u, n) => o("close", u, n),
-      onError: (u) => o("error", u),
-      onMessage: (u, n) => o("message", u, n),
-      onReconnecting: (u, n) => o("reconnecting", u, n),
-      onReconnected: () => o("reconnected"),
-      onReconnectFailed: () => o("reconnectFailed")
-    });
-    return L(
-      () => v.value.url,
-      () => {
-        l(), r();
-      }
-    ), R({
-      isConnected: y,
-      connectionState: g,
-      lastMessage: i,
-      error: d,
-      reconnectAttempts: f,
-      connect: r,
-      disconnect: l,
-      send: c,
-      sendJSON: p
-    }), (u, n) => M(u.$slots, "default", {
-      isConnected: t(y),
-      connectionState: t(g),
-      lastMessage: t(i),
-      error: t(d),
-      reconnectAttempts: t(f),
-      connect: t(r),
-      disconnect: t(l),
-      send: t(c),
-      sendJson: t(p)
-    });
-  }
-});
-export {
-  nt as H,
-  ot as P,
-  st as S,
-  rt as W,
-  at as _,
-  it as a,
-  lt as b,
-  ct as c,
-  dt as d,
-  ut as e,
-  pt as f
-};
-//# sourceMappingURL=WebSocketStream.vue_vue_type_script_setup_true_lang-BzBWoH8H.js.map