@nil-/xit 0.2.3 → 0.2.4

package/assets/index.js

@@ -0,0 +1,2536 @@
+var ne = Object.defineProperty;
+var kt = (s) => {
+  throw TypeError(s);
+};
+var ae = (s, t, e) => t in s ? ne(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var n = (s, t, e) => ae(s, typeof t != "symbol" ? t + "" : t, e), It = (s, t, e) => t.has(s) || kt("Cannot " + e);
+var u = (s, t, e) => (It(s, t, "read from private field"), e ? e.call(s) : t.get(s)), W = (s, t, e) => t.has(s) ? kt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(s) : t.set(s, e), w = (s, t, e, i) => (It(s, t, "write to private field"), i ? i.call(s, e) : t.set(s, e), e), wt = (s, t, e) => (It(s, t, "access private method"), e);
+import { w as et, g as At } from "./svelte/store.js";
+const mt = 2500;
+var _t, Ft, v, rt, ot, lt, x, g;
+class ft {
+  constructor(t) {
+    W(this, _t);
+    W(this, v);
+    // 0 idle, 1 has connected, 2 keep reconnecting, 3 stopped
+    W(this, rt);
+    W(this, ot);
+    W(this, lt);
+    W(this, x);
+    W(this, g);
+    w(this, x, t), w(this, v, 0), w(this, rt, null), w(this, ot, null), w(this, lt, null), w(this, g, null);
+  }
+  on_message(t) {
+    w(this, lt, t);
+  }
+  on_connect(t) {
+    w(this, rt, t);
+  }
+  on_disconnect(t) {
+    w(this, ot, t);
+  }
+  // non-blocking (run is blocking in c++)
+  // calling it again should not do anything
+  start() {
+    u(this, g) == null && u(this, v) !== 1 && u(this, v) !== 3 && (w(this, g, new WebSocket(`ws://${u(this, x)}`)), u(this, g).binaryType = "arraybuffer", u(this, g).onopen = () => {
+      u(this, v) == 3 ? this.stop() : (w(this, v, 1), u(this, rt) && u(this, rt).call(this, u(this, x)));
+    }, u(this, g).onclose = () => {
+      u(this, v) === 1 && (u(this, ot) && u(this, ot).call(this, u(this, x)), w(this, v, 2), wt(this, _t, Ft).call(this));
+    }, u(this, g).onerror = () => {
+      u(this, v) !== 1 && u(this, v) !== 3 ? (w(this, v, 2), wt(this, _t, Ft).call(this)) : u(this, v) === 3 && this.stop();
+    }, u(this, g).onmessage = (t) => {
+      u(this, lt) && u(this, lt).call(this, u(this, x), new Uint8Array(t.data));
+    });
+  }
+  stop() {
+    w(this, v, 3), u(this, g) != null && u(this, g).readyState !== WebSocket.CONNECTING && (u(this, g).close(), w(this, g, null));
+  }
+  restart() {
+    w(this, v, 0);
+  }
+  publish(t) {
+    u(this, g) != null && u(this, v) == 1 && u(this, g).send(t);
+  }
+  send(t, e) {
+    t === u(this, x) && this.publish(e);
+  }
+}
+_t = new WeakSet(), Ft = function() {
+  u(this, g) != null && (u(this, g).close(), w(this, g, null)), setTimeout(() => this.start(), 1e3);
+}, v = new WeakMap(), rt = new WeakMap(), ot = new WeakMap(), lt = new WeakMap(), x = new WeakMap(), g = new WeakMap();
+const ht = (s) => {
+  const t = new Uint8Array(4);
+  return new DataView(t.buffer).setUint32(0, s, !1), t;
+}, dt = (s) => {
+  const t = new Uint8Array(s.reduce((i, a) => i + a.length, 0));
+  let e = 0;
+  for (const i of s)
+    t.set(i, e), e += i.length;
+  return t;
+}, re = async (s) => new Promise((t, e) => {
+  const i = new ft(s), a = setTimeout(() => {
+    i.stop(), e("connection failed... stopping");
+  }, mt);
+  i.on_connect(() => {
+    clearTimeout(a), i.stop(), t();
+  }), i.start();
+}), jt = async (s, t, e, i) => new Promise((a, r) => {
+  const o = new ft(s), h = setTimeout(() => {
+    o.stop(), r("timed out, cancelled");
+  }, mt), c = dt([ht(t), e]);
+  o.on_connect(() => o.publish(c)), o.on_message((d, b) => {
+    const F = new DataView(b.buffer).getUint32(0, !1), O = b.slice(4), V = i(F, O);
+    V != null && (clearTimeout(h), o.stop(), a(V));
+  }), o.start();
+}), St = (s, t, e) => {
+  const i = new ft(s), a = setTimeout(() => {
+    i.stop();
+  }, mt);
+  i.on_connect(() => {
+    clearTimeout(a);
+    const r = dt([ht(t), e]);
+    i.publish(r), i.stop();
+  }), i.start();
+};
+function oe(s) {
+  return new Worker(
+    "/assets/bundler.js",
+    {
+      name: s == null ? void 0 : s.name
+    }
+  );
+}
+const vt = 2, L = 4, E = 4, f = 4, H = new Int32Array(2), yt = new Float32Array(H.buffer), Nt = new Float64Array(H.buffer), bt = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+var Vt;
+(function(s) {
+  s[s.UTF8_BYTES = 1] = "UTF8_BYTES", s[s.UTF16_STRING = 2] = "UTF16_STRING";
+})(Vt || (Vt = {}));
+class P {
+  /**
+   * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
+   */
+  constructor(t) {
+    this.bytes_ = t, this.position_ = 0, this.text_decoder_ = new TextDecoder();
+  }
+  /**
+   * Create and allocate a new ByteBuffer with a given size.
+   */
+  static allocate(t) {
+    return new P(new Uint8Array(t));
+  }
+  clear() {
+    this.position_ = 0;
+  }
+  /**
+   * Get the underlying `Uint8Array`.
+   */
+  bytes() {
+    return this.bytes_;
+  }
+  /**
+   * Get the buffer's position.
+   */
+  position() {
+    return this.position_;
+  }
+  /**
+   * Set the buffer's position.
+   */
+  setPosition(t) {
+    this.position_ = t;
+  }
+  /**
+   * Get the buffer's capacity.
+   */
+  capacity() {
+    return this.bytes_.length;
+  }
+  readInt8(t) {
+    return this.readUint8(t) << 24 >> 24;
+  }
+  readUint8(t) {
+    return this.bytes_[t];
+  }
+  readInt16(t) {
+    return this.readUint16(t) << 16 >> 16;
+  }
+  readUint16(t) {
+    return this.bytes_[t] | this.bytes_[t + 1] << 8;
+  }
+  readInt32(t) {
+    return this.bytes_[t] | this.bytes_[t + 1] << 8 | this.bytes_[t + 2] << 16 | this.bytes_[t + 3] << 24;
+  }
+  readUint32(t) {
+    return this.readInt32(t) >>> 0;
+  }
+  readInt64(t) {
+    return BigInt.asIntN(64, BigInt(this.readUint32(t)) + (BigInt(this.readUint32(t + 4)) << BigInt(32)));
+  }
+  readUint64(t) {
+    return BigInt.asUintN(64, BigInt(this.readUint32(t)) + (BigInt(this.readUint32(t + 4)) << BigInt(32)));
+  }
+  readFloat32(t) {
+    return H[0] = this.readInt32(t), yt[0];
+  }
+  readFloat64(t) {
+    return H[bt ? 0 : 1] = this.readInt32(t), H[bt ? 1 : 0] = this.readInt32(t + 4), Nt[0];
+  }
+  writeInt8(t, e) {
+    this.bytes_[t] = e;
+  }
+  writeUint8(t, e) {
+    this.bytes_[t] = e;
+  }
+  writeInt16(t, e) {
+    this.bytes_[t] = e, this.bytes_[t + 1] = e >> 8;
+  }
+  writeUint16(t, e) {
+    this.bytes_[t] = e, this.bytes_[t + 1] = e >> 8;
+  }
+  writeInt32(t, e) {
+    this.bytes_[t] = e, this.bytes_[t + 1] = e >> 8, this.bytes_[t + 2] = e >> 16, this.bytes_[t + 3] = e >> 24;
+  }
+  writeUint32(t, e) {
+    this.bytes_[t] = e, this.bytes_[t + 1] = e >> 8, this.bytes_[t + 2] = e >> 16, this.bytes_[t + 3] = e >> 24;
+  }
+  writeInt64(t, e) {
+    this.writeInt32(t, Number(BigInt.asIntN(32, e))), this.writeInt32(t + 4, Number(BigInt.asIntN(32, e >> BigInt(32))));
+  }
+  writeUint64(t, e) {
+    this.writeUint32(t, Number(BigInt.asUintN(32, e))), this.writeUint32(t + 4, Number(BigInt.asUintN(32, e >> BigInt(32))));
+  }
+  writeFloat32(t, e) {
+    yt[0] = e, this.writeInt32(t, H[0]);
+  }
+  writeFloat64(t, e) {
+    Nt[0] = e, this.writeInt32(t, H[bt ? 0 : 1]), this.writeInt32(t + 4, H[bt ? 1 : 0]);
+  }
+  /**
+   * Return the file identifier.   Behavior is undefined for FlatBuffers whose
+   * schema does not include a file_identifier (likely points at padding or the
+   * start of a the root vtable).
+   */
+  getBufferIdentifier() {
+    if (this.bytes_.length < this.position_ + L + E)
+      throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
+    let t = "";
+    for (let e = 0; e < E; e++)
+      t += String.fromCharCode(this.readInt8(this.position_ + L + e));
+    return t;
+  }
+  /**
+   * Look up a field in the vtable, return an offset into the object, or 0 if the
+   * field is not present.
+   */
+  __offset(t, e) {
+    const i = t - this.readInt32(t);
+    return e < this.readInt16(i) ? this.readInt16(i + e) : 0;
+  }
+  /**
+   * Initialize any Table-derived type to point to the union at the given offset.
+   */
+  __union(t, e) {
+    return t.bb_pos = e + this.readInt32(e), t.bb = this, t;
+  }
+  /**
+   * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+   * This allocates a new string and converts to wide chars upon each access.
+   *
+   * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the
+   * "optionalEncoding" argument. This is useful for avoiding conversion when
+   * the data will just be packaged back up in another FlatBuffer later on.
+   *
+   * @param offset
+   * @param opt_encoding Defaults to UTF16_STRING
+   */
+  __string(t, e) {
+    t += this.readInt32(t);
+    const i = this.readInt32(t);
+    t += L;
+    const a = this.bytes_.subarray(t, t + i);
+    return e === Vt.UTF8_BYTES ? a : this.text_decoder_.decode(a);
+  }
+  /**
+   * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+   * if a string then return a new one
+   *
+   * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+   * makes the behaviour of __union_with_string different compared to __union
+   */
+  __union_with_string(t, e) {
+    return typeof t == "string" ? this.__string(e) : this.__union(t, e);
+  }
+  /**
+   * Retrieve the relative offset stored at "offset"
+   */
+  __indirect(t) {
+    return t + this.readInt32(t);
+  }
+  /**
+   * Get the start of data of a vector whose offset is stored at "offset" in this object.
+   */
+  __vector(t) {
+    return t + this.readInt32(t) + L;
+  }
+  /**
+   * Get the length of a vector whose offset is stored at "offset" in this object.
+   */
+  __vector_len(t) {
+    return this.readInt32(t + this.readInt32(t));
+  }
+  __has_identifier(t) {
+    if (t.length != E)
+      throw new Error("FlatBuffers: file identifier must be length " + E);
+    for (let e = 0; e < E; e++)
+      if (t.charCodeAt(e) != this.readInt8(this.position() + L + e))
+        return !1;
+    return !0;
+  }
+  /**
+   * A helper function for generating list for obj api
+   */
+  createScalarList(t, e) {
+    const i = [];
+    for (let a = 0; a < e; ++a) {
+      const r = t(a);
+      r !== null && i.push(r);
+    }
+    return i;
+  }
+  /**
+   * A helper function for generating list for obj api
+   * @param listAccessor function that accepts an index and return data at that index
+   * @param listLength listLength
+   * @param res result list
+   */
+  createObjList(t, e) {
+    const i = [];
+    for (let a = 0; a < e; ++a) {
+      const r = t(a);
+      r !== null && i.push(r.unpack());
+    }
+    return i;
+  }
+}
+class k {
+  /**
+   * Create a FlatBufferBuilder.
+   */
+  constructor(t) {
+    this.minalign = 1, this.vtable = null, this.vtable_in_use = 0, this.isNested = !1, this.object_start = 0, this.vtables = [], this.vector_num_elems = 0, this.force_defaults = !1, this.string_maps = null, this.text_encoder = new TextEncoder();
+    let e;
+    t ? e = t : e = 1024, this.bb = P.allocate(e), this.space = e;
+  }
+  clear() {
+    this.bb.clear(), this.space = this.bb.capacity(), this.minalign = 1, this.vtable = null, this.vtable_in_use = 0, this.isNested = !1, this.object_start = 0, this.vtables = [], this.vector_num_elems = 0, this.force_defaults = !1, this.string_maps = null;
+  }
+  /**
+   * In order to save space, fields that are set to their default value
+   * don't get serialized into the buffer. Forcing defaults provides a
+   * way to manually disable this optimization.
+   *
+   * @param forceDefaults true always serializes default values
+   */
+  forceDefaults(t) {
+    this.force_defaults = t;
+  }
+  /**
+   * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+   * called finish(). The actual data starts at the ByteBuffer's current position,
+   * not necessarily at 0.
+   */
+  dataBuffer() {
+    return this.bb;
+  }
+  /**
+   * Get the bytes representing the FlatBuffer. Only call this after you've
+   * called finish().
+   */
+  asUint8Array() {
+    return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+  }
+  /**
+   * Prepare to write an element of `size` after `additional_bytes` have been
+   * written, e.g. if you write a string, you need to align such the int length
+   * field is aligned to 4 bytes, and the string data follows it directly. If all
+   * you need to do is alignment, `additional_bytes` will be 0.
+   *
+   * @param size This is the of the new element to write
+   * @param additional_bytes The padding size
+   */
+  prep(t, e) {
+    t > this.minalign && (this.minalign = t);
+    const i = ~(this.bb.capacity() - this.space + e) + 1 & t - 1;
+    for (; this.space < i + t + e; ) {
+      const a = this.bb.capacity();
+      this.bb = k.growByteBuffer(this.bb), this.space += this.bb.capacity() - a;
+    }
+    this.pad(i);
+  }
+  pad(t) {
+    for (let e = 0; e < t; e++)
+      this.bb.writeInt8(--this.space, 0);
+  }
+  writeInt8(t) {
+    this.bb.writeInt8(this.space -= 1, t);
+  }
+  writeInt16(t) {
+    this.bb.writeInt16(this.space -= 2, t);
+  }
+  writeInt32(t) {
+    this.bb.writeInt32(this.space -= 4, t);
+  }
+  writeInt64(t) {
+    this.bb.writeInt64(this.space -= 8, t);
+  }
+  writeFloat32(t) {
+    this.bb.writeFloat32(this.space -= 4, t);
+  }
+  writeFloat64(t) {
+    this.bb.writeFloat64(this.space -= 8, t);
+  }
+  /**
+   * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int8` to add the buffer.
+   */
+  addInt8(t) {
+    this.prep(1, 0), this.writeInt8(t);
+  }
+  /**
+   * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int16` to add the buffer.
+   */
+  addInt16(t) {
+    this.prep(2, 0), this.writeInt16(t);
+  }
+  /**
+   * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int32` to add the buffer.
+   */
+  addInt32(t) {
+    this.prep(4, 0), this.writeInt32(t);
+  }
+  /**
+   * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int64` to add the buffer.
+   */
+  addInt64(t) {
+    this.prep(8, 0), this.writeInt64(t);
+  }
+  /**
+   * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `float32` to add the buffer.
+   */
+  addFloat32(t) {
+    this.prep(4, 0), this.writeFloat32(t);
+  }
+  /**
+   * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `float64` to add the buffer.
+   */
+  addFloat64(t) {
+    this.prep(8, 0), this.writeFloat64(t);
+  }
+  addFieldInt8(t, e, i) {
+    (this.force_defaults || e != i) && (this.addInt8(e), this.slot(t));
+  }
+  addFieldInt16(t, e, i) {
+    (this.force_defaults || e != i) && (this.addInt16(e), this.slot(t));
+  }
+  addFieldInt32(t, e, i) {
+    (this.force_defaults || e != i) && (this.addInt32(e), this.slot(t));
+  }
+  addFieldInt64(t, e, i) {
+    (this.force_defaults || e !== i) && (this.addInt64(e), this.slot(t));
+  }
+  addFieldFloat32(t, e, i) {
+    (this.force_defaults || e != i) && (this.addFloat32(e), this.slot(t));
+  }
+  addFieldFloat64(t, e, i) {
+    (this.force_defaults || e != i) && (this.addFloat64(e), this.slot(t));
+  }
+  addFieldOffset(t, e, i) {
+    (this.force_defaults || e != i) && (this.addOffset(e), this.slot(t));
+  }
+  /**
+   * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+   */
+  addFieldStruct(t, e, i) {
+    e != i && (this.nested(e), this.slot(t));
+  }
+  /**
+   * Structures are always stored inline, they need to be created right
+   * where they're used.  You'll get this assertion failure if you
+   * created it elsewhere.
+   */
+  nested(t) {
+    if (t != this.offset())
+      throw new TypeError("FlatBuffers: struct must be serialized inline.");
+  }
+  /**
+   * Should not be creating any other object, string or vector
+   * while an object is being constructed
+   */
+  notNested() {
+    if (this.isNested)
+      throw new TypeError("FlatBuffers: object serialization must not be nested.");
+  }
+  /**
+   * Set the current vtable at `voffset` to the current location in the buffer.
+   */
+  slot(t) {
+    this.vtable !== null && (this.vtable[t] = this.offset());
+  }
+  /**
+   * @returns Offset relative to the end of the buffer.
+   */
+  offset() {
+    return this.bb.capacity() - this.space;
+  }
+  /**
+   * Doubles the size of the backing ByteBuffer and copies the old data towards
+   * the end of the new buffer (since we build the buffer backwards).
+   *
+   * @param bb The current buffer with the existing data
+   * @returns A new byte buffer with the old data copied
+   * to it. The data is located at the end of the buffer.
+   *
+   * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+   * it a uint8Array we need to suppress the type check:
+   * @suppress {checkTypes}
+   */
+  static growByteBuffer(t) {
+    const e = t.capacity();
+    if (e & 3221225472)
+      throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+    const i = e << 1, a = P.allocate(i);
+    return a.setPosition(i - e), a.bytes().set(t.bytes(), i - e), a;
+  }
+  /**
+   * Adds on offset, relative to where it will be written.
+   *
+   * @param offset The offset to add.
+   */
+  addOffset(t) {
+    this.prep(L, 0), this.writeInt32(this.offset() - t + L);
+  }
+  /**
+   * Start encoding a new object in the buffer.  Users will not usually need to
+   * call this directly. The FlatBuffers compiler will generate helper methods
+   * that call this method internally.
+   */
+  startObject(t) {
+    this.notNested(), this.vtable == null && (this.vtable = []), this.vtable_in_use = t;
+    for (let e = 0; e < t; e++)
+      this.vtable[e] = 0;
+    this.isNested = !0, this.object_start = this.offset();
+  }
+  /**
+   * Finish off writing the object that is under construction.
+   *
+   * @returns The offset to the object inside `dataBuffer`
+   */
+  endObject() {
+    if (this.vtable == null || !this.isNested)
+      throw new Error("FlatBuffers: endObject called without startObject");
+    this.addInt32(0);
+    const t = this.offset();
+    let e = this.vtable_in_use - 1;
+    for (; e >= 0 && this.vtable[e] == 0; e--)
+      ;
+    const i = e + 1;
+    for (; e >= 0; e--)
+      this.addInt16(this.vtable[e] != 0 ? t - this.vtable[e] : 0);
+    const a = 2;
+    this.addInt16(t - this.object_start);
+    const r = (i + a) * vt;
+    this.addInt16(r);
+    let o = 0;
+    const h = this.space;
+    t: for (e = 0; e < this.vtables.length; e++) {
+      const c = this.bb.capacity() - this.vtables[e];
+      if (r == this.bb.readInt16(c)) {
+        for (let d = vt; d < r; d += vt)
+          if (this.bb.readInt16(h + d) != this.bb.readInt16(c + d))
+            continue t;
+        o = this.vtables[e];
+        break;
+      }
+    }
+    return o ? (this.space = this.bb.capacity() - t, this.bb.writeInt32(this.space, o - t)) : (this.vtables.push(this.offset()), this.bb.writeInt32(this.bb.capacity() - t, this.offset() - t)), this.isNested = !1, t;
+  }
+  /**
+   * Finalize a buffer, poiting to the given `root_table`.
+   */
+  finish(t, e, i) {
+    const a = i ? f : 0;
+    if (e) {
+      const r = e;
+      if (this.prep(this.minalign, L + E + a), r.length != E)
+        throw new TypeError("FlatBuffers: file identifier must be length " + E);
+      for (let o = E - 1; o >= 0; o--)
+        this.writeInt8(r.charCodeAt(o));
+    }
+    this.prep(this.minalign, L + a), this.addOffset(t), a && this.addInt32(this.bb.capacity() - this.space), this.bb.setPosition(this.space);
+  }
+  /**
+   * Finalize a size prefixed buffer, pointing to the given `root_table`.
+   */
+  finishSizePrefixed(t, e) {
+    this.finish(t, e, !0);
+  }
+  /**
+   * This checks a required field has been set in a given table that has
+   * just been constructed.
+   */
+  requiredField(t, e) {
+    const i = this.bb.capacity() - t, a = i - this.bb.readInt32(i);
+    if (!(e < this.bb.readInt16(a) && this.bb.readInt16(a + e) != 0))
+      throw new TypeError("FlatBuffers: field " + e + " must be set");
+  }
+  /**
+   * Start a new array/vector of objects.  Users usually will not call
+   * this directly. The FlatBuffers compiler will create a start/end
+   * method for vector types in generated code.
+   *
+   * @param elem_size The size of each element in the array
+   * @param num_elems The number of elements in the array
+   * @param alignment The alignment of the array
+   */
+  startVector(t, e, i) {
+    this.notNested(), this.vector_num_elems = e, this.prep(L, t * e), this.prep(i, t * e);
+  }
+  /**
+   * Finish off the creation of an array and all its elements. The array must be
+   * created with `startVector`.
+   *
+   * @returns The offset at which the newly created array
+   * starts.
+   */
+  endVector() {
+    return this.writeInt32(this.vector_num_elems), this.offset();
+  }
+  /**
+   * Encode the string `s` in the buffer using UTF-8. If the string passed has
+   * already been seen, we return the offset of the already written string
+   *
+   * @param s The string to encode
+   * @return The offset in the buffer where the encoded string starts
+   */
+  createSharedString(t) {
+    if (!t)
+      return 0;
+    if (this.string_maps || (this.string_maps = /* @__PURE__ */ new Map()), this.string_maps.has(t))
+      return this.string_maps.get(t);
+    const e = this.createString(t);
+    return this.string_maps.set(t, e), e;
+  }
+  /**
+   * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+   * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+   *
+   * @param s The string to encode
+   * @return The offset in the buffer where the encoded string starts
+   */
+  createString(t) {
+    if (t == null)
+      return 0;
+    let e;
+    return t instanceof Uint8Array ? e = t : e = this.text_encoder.encode(t), this.addInt8(0), this.startVector(1, e.length, 1), this.bb.setPosition(this.space -= e.length), this.bb.bytes().set(e, this.space), this.endVector();
+  }
+  /**
+   * Create a byte vector.
+   *
+   * @param v The bytes to add
+   * @returns The offset in the buffer where the byte vector starts
+   */
+  createByteVector(t) {
+    return t == null ? 0 : (this.startVector(1, t.length, 1), this.bb.setPosition(this.space -= t.length), this.bb.bytes().set(t, this.space), this.endVector());
+  }
+  /**
+   * A helper function to pack an object
+   *
+   * @returns offset of obj
+   */
+  createObjectOffset(t) {
+    return t === null ? 0 : typeof t == "string" ? this.createString(t) : t.pack(this);
+  }
+  /**
+   * A helper function to pack a list of object
+   *
+   * @returns list of offsets of each non null object
+   */
+  createObjectOffsetList(t) {
+    const e = [];
+    for (let i = 0; i < t.length; ++i) {
+      const a = t[i];
+      if (a !== null)
+        e.push(this.createObjectOffset(a));
+      else
+        throw new TypeError("FlatBuffers: Argument for createObjectOffsetList cannot contain null.");
+    }
+    return e;
+  }
+  createStructOffsetList(t, e) {
+    return e(this, t.length), this.createObjectOffsetList(t.slice().reverse()), this.endVector();
+  }
+}
+class A {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsFileInfo(t, e) {
+    return (e || new A()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsFileInfo(t, e) {
+    return t.setPosition(t.position() + f), (e || new A()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  target(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  metadata(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.readUint8(this.bb.__vector(this.bb_pos + e) + t) : 0;
+  }
+  metadataLength() {
+    const t = this.bb.__offset(this.bb_pos, 6);
+    return t ? this.bb.__vector_len(this.bb_pos + t) : 0;
+  }
+  metadataArray() {
+    const t = this.bb.__offset(this.bb_pos, 6);
+    return t ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t), this.bb.__vector_len(this.bb_pos + t)) : null;
+  }
+  static startFileInfo(t) {
+    t.startObject(2);
+  }
+  static addTarget(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addMetadata(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static createMetadataVector(t, e) {
+    t.startVector(1, e.length, 1);
+    for (let i = e.length - 1; i >= 0; i--)
+      t.addInt8(e[i]);
+    return t.endVector();
+  }
+  static startMetadataVector(t, e) {
+    t.startVector(1, e, 1);
+  }
+  static endFileInfo(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createFileInfo(t, e, i) {
+    return A.startFileInfo(t), A.addTarget(t, e), A.addMetadata(t, i), A.endFileInfo(t);
+  }
+  unpack() {
+    return new Bt(this.target(), this.bb.createScalarList(this.metadata.bind(this), this.metadataLength()));
+  }
+  unpackTo(t) {
+    t.target = this.target(), t.metadata = this.bb.createScalarList(this.metadata.bind(this), this.metadataLength());
+  }
+}
+class Bt {
+  constructor(t = null, e = []) {
+    n(this, "target");
+    n(this, "metadata");
+    this.target = t, this.metadata = e;
+  }
+  pack(t) {
+    const e = this.target !== null ? t.createString(this.target) : 0, i = A.createMetadataVector(t, this.metadata);
+    return A.createFileInfo(t, e, i);
+  }
+}
+class N {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsFrameCache(t, e) {
+    return (e || new N()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsFrameCache(t, e) {
+    return t.setPosition(t.position() + f), (e || new N()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  content(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  files(t, e) {
+    const i = this.bb.__offset(this.bb_pos, 8);
+    return i ? (e || new A()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + i) + t * 4), this.bb) : null;
+  }
+  filesLength() {
+    const t = this.bb.__offset(this.bb_pos, 8);
+    return t ? this.bb.__vector_len(this.bb_pos + t) : 0;
+  }
+  static startFrameCache(t) {
+    t.startObject(3);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addContent(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static addFiles(t, e) {
+    t.addFieldOffset(2, e, 0);
+  }
+  static createFilesVector(t, e) {
+    t.startVector(4, e.length, 4);
+    for (let i = e.length - 1; i >= 0; i--)
+      t.addOffset(e[i]);
+    return t.endVector();
+  }
+  static startFilesVector(t, e) {
+    t.startVector(4, e, 4);
+  }
+  static endFrameCache(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), t.requiredField(e, 8), e;
+  }
+  static createFrameCache(t, e, i, a) {
+    return N.startFrameCache(t), N.addId(t, e), N.addContent(t, i), N.addFiles(t, a), N.endFrameCache(t);
+  }
+  unpack() {
+    return new Ct(this.id(), this.content(), this.bb.createObjList(this.files.bind(this), this.filesLength()));
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.content = this.content(), t.files = this.bb.createObjList(this.files.bind(this), this.filesLength());
+  }
+}
+class Ct {
+  constructor(t = null, e = null, i = []) {
+    n(this, "id");
+    n(this, "content");
+    n(this, "files");
+    this.id = t, this.content = e, this.files = i;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.content !== null ? t.createString(this.content) : 0, a = N.createFilesVector(t, t.createObjectOffsetList(this.files));
+    return N.createFrameCache(t, e, i, a);
+  }
+}
+var _;
+(function(s) {
+  s[s.Client_Unique_FrameInfo_Request = 0] = "Client_Unique_FrameInfo_Request", s[s.Client_Tagged_FrameInfo_Request = 1] = "Client_Tagged_FrameInfo_Request", s[s.Server_Unique_FrameInfo_File_Response = 2] = "Server_Unique_FrameInfo_File_Response", s[s.Server_Tagged_FrameInfo_File_Response = 3] = "Server_Tagged_FrameInfo_File_Response", s[s.Server_Unique_FrameInfo_Content_Response = 4] = "Server_Unique_FrameInfo_Content_Response", s[s.Server_Tagged_FrameInfo_Content_Response = 5] = "Server_Tagged_FrameInfo_Content_Response", s[s.Client_File_Request = 6] = "Client_File_Request", s[s.Server_File_Response = 7] = "Server_File_Response", s[s.Client_Unique_FrameCache = 8] = "Client_Unique_FrameCache", s[s.Client_Tagged_FrameCache = 9] = "Client_Tagged_FrameCache", s[s.Client_Unique_Frame_Loaded = 10] = "Client_Unique_Frame_Loaded", s[s.Client_Tagged_Frame_Loaded = 11] = "Client_Tagged_Frame_Loaded", s[s.Client_Unique_Frame_Subscribe = 12] = "Client_Unique_Frame_Subscribe", s[s.Client_Tagged_Frame_Subscribe = 13] = "Client_Tagged_Frame_Subscribe", s[s.Client_Unique_Frame_Unsubscribe = 14] = "Client_Unique_Frame_Unsubscribe", s[s.Client_Tagged_Frame_Unsubscribe = 15] = "Client_Tagged_Frame_Unsubscribe", s[s.Client_Unique_Value_Request = 16] = "Client_Unique_Value_Request", s[s.Client_Tagged_Value_Request = 17] = "Client_Tagged_Value_Request", s[s.Server_Unique_Value_Response = 18] = "Server_Unique_Value_Response", s[s.Server_Tagged_Value_Response = 19] = "Server_Tagged_Value_Response", s[s.Unique_Value_Update = 20] = "Unique_Value_Update", s[s.Tagged_Value_Update = 21] = "Tagged_Value_Update", s[s.Client_Unique_Signal_Request = 22] = "Client_Unique_Signal_Request", s[s.Client_Tagged_Signal_Request = 23] = "Client_Tagged_Signal_Request", s[s.Server_Unique_Signal_Response = 24] = "Server_Unique_Signal_Response", s[s.Server_Tagged_Signal_Response = 25] = "Server_Tagged_Signal_Response", s[s.Client_Unique_Signal_Notify = 26] = "Client_Unique_Signal_Notify", s[s.Client_Tagged_Signal_Notify = 27] = "Client_Tagged_Signal_Notify";
+})(_ || (_ = {}));
+var q;
+(function(s) {
+  s[s.None = 0] = "None", s[s.Boolean = 1] = "Boolean", s[s.Number = 2] = "Number", s[s.Double = 3] = "Double", s[s.String = 4] = "String", s[s.Buffer = 5] = "Buffer";
+})(q || (q = {}));
+class j {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsSignal(t, e) {
+    return (e || new j()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsSignal(t, e) {
+    return t.setPosition(t.position() + f), (e || new j()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  type() {
+    const t = this.bb.__offset(this.bb_pos, 6);
+    return t ? this.bb.readInt32(this.bb_pos + t) : q.None;
+  }
+  static startSignal(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addType(t, e) {
+    t.addFieldInt32(1, e, q.None);
+  }
+  static endSignal(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), e;
+  }
+  static createSignal(t, e, i) {
+    return j.startSignal(t), j.addId(t, e), j.addType(t, i), j.endSignal(t);
+  }
+  unpack() {
+    return new le(this.id(), this.type());
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.type = this.type();
+  }
+}
+class le {
+  constructor(t = null, e = q.None) {
+    n(this, "id");
+    n(this, "type");
+    this.id = t, this.type = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0;
+    return j.createSignal(t, e, this.type);
+  }
+}
+class Y {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedFrameLoaded(t, e) {
+    return (e || new Y()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedFrameLoaded(t, e) {
+    return t.setPosition(t.position() + f), (e || new Y()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startTaggedFrameLoaded(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static endTaggedFrameLoaded(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createTaggedFrameLoaded(t, e, i) {
+    return Y.startTaggedFrameLoaded(t), Y.addId(t, e), Y.addTag(t, i), Y.endTaggedFrameLoaded(t);
+  }
+  unpack() {
+    return new Ot(this.id(), this.tag());
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.tag = this.tag();
+  }
+}
+class Ot {
+  constructor(t = null, e = null) {
+    n(this, "id");
+    n(this, "tag");
+    this.id = t, this.tag = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.tag !== null ? t.createString(this.tag) : 0;
+    return Y.createTaggedFrameLoaded(t, e, i);
+  }
+}
+class Z {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedFrameSubscribe(t, e) {
+    return (e || new Z()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedFrameSubscribe(t, e) {
+    return t.setPosition(t.position() + f), (e || new Z()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startTaggedFrameSubscribe(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static endTaggedFrameSubscribe(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createTaggedFrameSubscribe(t, e, i) {
+    return Z.startTaggedFrameSubscribe(t), Z.addId(t, e), Z.addTag(t, i), Z.endTaggedFrameSubscribe(t);
+  }
+  unpack() {
+    return new qt(this.id(), this.tag());
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.tag = this.tag();
+  }
+}
+class qt {
+  constructor(t = null, e = null) {
+    n(this, "id");
+    n(this, "tag");
+    this.id = t, this.tag = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.tag !== null ? t.createString(this.tag) : 0;
+    return Z.createTaggedFrameSubscribe(t, e, i);
+  }
+}
+class J {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsValueBoolean(t, e) {
+    return (e || new J()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsValueBoolean(t, e) {
+    return t.setPosition(t.position() + f), (e || new J()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  value() {
+    const t = this.bb.__offset(this.bb_pos, 4);
+    return t ? !!this.bb.readInt8(this.bb_pos + t) : !1;
+  }
+  static startValueBoolean(t) {
+    t.startObject(1);
+  }
+  static addValue(t, e) {
+    t.addFieldInt8(0, +e, 0);
+  }
+  static endValueBoolean(t) {
+    return t.endObject();
+  }
+  static createValueBoolean(t, e) {
+    return J.startValueBoolean(t), J.addValue(t, e), J.endValueBoolean(t);
+  }
+  unpack() {
+    return new Lt(this.value());
+  }
+  unpackTo(t) {
+    t.value = this.value();
+  }
+}
+class Lt {
+  constructor(t = !1) {
+    n(this, "value");
+    this.value = t;
+  }
+  pack(t) {
+    return J.createValueBoolean(t, this.value);
+  }
+}
+class z {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsValueBuffer(t, e) {
+    return (e || new z()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsValueBuffer(t, e) {
+    return t.setPosition(t.position() + f), (e || new z()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  value(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.readUint8(this.bb.__vector(this.bb_pos + e) + t) : 0;
+  }
+  valueLength() {
+    const t = this.bb.__offset(this.bb_pos, 4);
+    return t ? this.bb.__vector_len(this.bb_pos + t) : 0;
+  }
+  valueArray() {
+    const t = this.bb.__offset(this.bb_pos, 4);
+    return t ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t), this.bb.__vector_len(this.bb_pos + t)) : null;
+  }
+  static startValueBuffer(t) {
+    t.startObject(1);
+  }
+  static addValue(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static createValueVector(t, e) {
+    t.startVector(1, e.length, 1);
+    for (let i = e.length - 1; i >= 0; i--)
+      t.addInt8(e[i]);
+    return t.endVector();
+  }
+  static startValueVector(t, e) {
+    t.startVector(1, e, 1);
+  }
+  static endValueBuffer(t) {
+    return t.endObject();
+  }
+  static createValueBuffer(t, e) {
+    return z.startValueBuffer(t), z.addValue(t, e), z.endValueBuffer(t);
+  }
+  unpack() {
+    return new Pt(this.bb.createScalarList(this.value.bind(this), this.valueLength()));
+  }
+  unpackTo(t) {
+    t.value = this.bb.createScalarList(this.value.bind(this), this.valueLength());
+  }
+}
+class Pt {
+  constructor(t = []) {
+    n(this, "value");
+    this.value = t;
+  }
+  pack(t) {
+    const e = z.createValueVector(t, this.value);
+    return z.createValueBuffer(t, e);
+  }
+}
+class K {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsValueDouble(t, e) {
+    return (e || new K()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsValueDouble(t, e) {
+    return t.setPosition(t.position() + f), (e || new K()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  value() {
+    const t = this.bb.__offset(this.bb_pos, 4);
+    return t ? this.bb.readFloat64(this.bb_pos + t) : 0;
+  }
+  static startValueDouble(t) {
+    t.startObject(1);
+  }
+  static addValue(t, e) {
+    t.addFieldFloat64(0, e, 0);
+  }
+  static endValueDouble(t) {
+    return t.endObject();
+  }
+  static createValueDouble(t, e) {
+    return K.startValueDouble(t), K.addValue(t, e), K.endValueDouble(t);
+  }
+  unpack() {
+    return new xt(this.value());
+  }
+  unpackTo(t) {
+    t.value = this.value();
+  }
+}
+class xt {
+  constructor(t = 0) {
+    n(this, "value");
+    this.value = t;
+  }
+  pack(t) {
+    return K.createValueDouble(t, this.value);
+  }
+}
+class Q {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsValueNumber(t, e) {
+    return (e || new Q()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsValueNumber(t, e) {
+    return t.setPosition(t.position() + f), (e || new Q()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  value() {
+    const t = this.bb.__offset(this.bb_pos, 4);
+    return t ? this.bb.readInt64(this.bb_pos + t) : BigInt("0");
+  }
+  static startValueNumber(t) {
+    t.startObject(1);
+  }
+  static addValue(t, e) {
+    t.addFieldInt64(0, e, BigInt("0"));
+  }
+  static endValueNumber(t) {
+    return t.endObject();
+  }
+  static createValueNumber(t, e) {
+    return Q.startValueNumber(t), Q.addValue(t, e), Q.endValueNumber(t);
+  }
+  unpack() {
+    return new Et(this.value());
+  }
+  unpackTo(t) {
+    t.value = this.value();
+  }
+}
+class Et {
+  constructor(t = BigInt("0")) {
+    n(this, "value");
+    this.value = t;
+  }
+  pack(t) {
+    return Q.createValueNumber(t, this.value);
+  }
+}
+class M {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsValueString(t, e) {
+    return (e || new M()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsValueString(t, e) {
+    return t.setPosition(t.position() + f), (e || new M()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  value(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startValueString(t) {
+    t.startObject(1);
+  }
+  static addValue(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static endValueString(t) {
+    return t.endObject();
+  }
+  static createValueString(t, e) {
+    return M.startValueString(t), M.addValue(t, e), M.endValueString(t);
+  }
+  unpack() {
+    return new zt(this.value());
+  }
+  unpackTo(t) {
+    t.value = this.value();
+  }
+}
+class zt {
+  constructor(t = null) {
+    n(this, "value");
+    this.value = t;
+  }
+  pack(t) {
+    const e = this.value !== null ? t.createString(this.value) : 0;
+    return M.createValueString(t, e);
+  }
+}
+var l;
+(function(s) {
+  s[s.NONE = 0] = "NONE", s[s.ValueBoolean = 1] = "ValueBoolean", s[s.ValueNumber = 2] = "ValueNumber", s[s.ValueDouble = 3] = "ValueDouble", s[s.ValueString = 4] = "ValueString", s[s.ValueBuffer = 5] = "ValueBuffer";
+})(l || (l = {}));
+function ut(s, t) {
+  switch (l[s]) {
+    case "NONE":
+      return null;
+    case "ValueBoolean":
+      return t(new J());
+    case "ValueNumber":
+      return t(new Q());
+    case "ValueDouble":
+      return t(new K());
+    case "ValueString":
+      return t(new M());
+    case "ValueBuffer":
+      return t(new z());
+    default:
+      return null;
+  }
+}
+class U {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedSignalNotify(t, e) {
+    return (e || new U()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedSignalNotify(t, e) {
+    return t.setPosition(t.position() + f), (e || new U()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  frameId(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  signalId(t) {
+    const e = this.bb.__offset(this.bb_pos, 8);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  valueType() {
+    const t = this.bb.__offset(this.bb_pos, 10);
+    return t ? this.bb.readUint8(this.bb_pos + t) : l.NONE;
+  }
+  value(t) {
+    const e = this.bb.__offset(this.bb_pos, 12);
+    return e ? this.bb.__union(t, this.bb_pos + e) : null;
+  }
+  static startTaggedSignalNotify(t) {
+    t.startObject(5);
+  }
+  static addFrameId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static addSignalId(t, e) {
+    t.addFieldOffset(2, e, 0);
+  }
+  static addValueType(t, e) {
+    t.addFieldInt8(3, e, l.NONE);
+  }
+  static addValue(t, e) {
+    t.addFieldOffset(4, e, 0);
+  }
+  static endTaggedSignalNotify(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), t.requiredField(e, 8), e;
+  }
+  static createTaggedSignalNotify(t, e, i, a, r, o) {
+    return U.startTaggedSignalNotify(t), U.addFrameId(t, e), U.addTag(t, i), U.addSignalId(t, a), U.addValueType(t, r), U.addValue(t, o), U.endTaggedSignalNotify(t);
+  }
+  unpack() {
+    return new Dt(this.frameId(), this.tag(), this.signalId(), this.valueType(), (() => {
+      const t = ut(this.valueType(), this.value.bind(this));
+      return t === null ? null : t.unpack();
+    })());
+  }
+  unpackTo(t) {
+    t.frameId = this.frameId(), t.tag = this.tag(), t.signalId = this.signalId(), t.valueType = this.valueType(), t.value = (() => {
+      const e = ut(this.valueType(), this.value.bind(this));
+      return e === null ? null : e.unpack();
+    })();
+  }
+}
+class Dt {
+  constructor(t = null, e = null, i = null, a = l.NONE, r = null) {
+    n(this, "frameId");
+    n(this, "tag");
+    n(this, "signalId");
+    n(this, "valueType");
+    n(this, "value");
+    this.frameId = t, this.tag = e, this.signalId = i, this.valueType = a, this.value = r;
+  }
+  pack(t) {
+    const e = this.frameId !== null ? t.createString(this.frameId) : 0, i = this.tag !== null ? t.createString(this.tag) : 0, a = this.signalId !== null ? t.createString(this.signalId) : 0, r = t.createObjectOffset(this.value);
+    return U.createTaggedSignalNotify(t, e, i, a, this.valueType, r);
+  }
+}
+class X {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedSignalRequest(t, e) {
+    return (e || new X()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedSignalRequest(t, e) {
+    return t.setPosition(t.position() + f), (e || new X()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startTaggedSignalRequest(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static endTaggedSignalRequest(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createTaggedSignalRequest(t, e, i) {
+    return X.startTaggedSignalRequest(t), X.addId(t, e), X.addTag(t, i), X.endTaggedSignalRequest(t);
+  }
+  unpack() {
+    return new Gt(this.id(), this.tag());
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.tag = this.tag();
+  }
+}
+class Gt {
+  constructor(t = null, e = null) {
+    n(this, "id");
+    n(this, "tag");
+    this.id = t, this.tag = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.tag !== null ? t.createString(this.tag) : 0;
+    return X.createTaggedSignalRequest(t, e, i);
+  }
+}
+class T {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedSignalResponse(t, e) {
+    return (e || new T()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedSignalResponse(t, e) {
+    return t.setPosition(t.position() + f), (e || new T()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  signals(t, e) {
+    const i = this.bb.__offset(this.bb_pos, 8);
+    return i ? (e || new j()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + i) + t * 4), this.bb) : null;
+  }
+  signalsLength() {
+    const t = this.bb.__offset(this.bb_pos, 8);
+    return t ? this.bb.__vector_len(this.bb_pos + t) : 0;
+  }
+  static startTaggedSignalResponse(t) {
+    t.startObject(3);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static addSignals(t, e) {
+    t.addFieldOffset(2, e, 0);
+  }
+  static createSignalsVector(t, e) {
+    t.startVector(4, e.length, 4);
+    for (let i = e.length - 1; i >= 0; i--)
+      t.addOffset(e[i]);
+    return t.endVector();
+  }
+  static startSignalsVector(t, e) {
+    t.startVector(4, e, 4);
+  }
+  static endTaggedSignalResponse(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), t.requiredField(e, 8), e;
+  }
+  static createTaggedSignalResponse(t, e, i, a) {
+    return T.startTaggedSignalResponse(t), T.addId(t, e), T.addTag(t, i), T.addSignals(t, a), T.endTaggedSignalResponse(t);
+  }
+  unpack() {
+    return new ce(this.id(), this.tag(), this.bb.createObjList(this.signals.bind(this), this.signalsLength()));
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.tag = this.tag(), t.signals = this.bb.createObjList(this.signals.bind(this), this.signalsLength());
+  }
+}
+class ce {
+  constructor(t = null, e = null, i = []) {
+    n(this, "id");
+    n(this, "tag");
+    n(this, "signals");
+    this.id = t, this.tag = e, this.signals = i;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.tag !== null ? t.createString(this.tag) : 0, a = T.createSignalsVector(t, t.createObjectOffsetList(this.signals));
+    return T.createTaggedSignalResponse(t, e, i, a);
+  }
+}
+class $ {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedValueRequest(t, e) {
+    return (e || new $()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedValueRequest(t, e) {
+    return t.setPosition(t.position() + f), (e || new $()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startTaggedValueRequest(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static endTaggedValueRequest(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createTaggedValueRequest(t, e, i) {
+    return $.startTaggedValueRequest(t), $.addId(t, e), $.addTag(t, i), $.endTaggedValueRequest(t);
+  }
+  unpack() {
+    return new Wt(this.id(), this.tag());
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.tag = this.tag();
+  }
+}
+class Wt {
+  constructor(t = null, e = null) {
+    n(this, "id");
+    n(this, "tag");
+    this.id = t, this.tag = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.tag !== null ? t.createString(this.tag) : 0;
+    return $.createTaggedValueRequest(t, e, i);
+  }
+}
+class S {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsValue(t, e) {
+    return (e || new S()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsValue(t, e) {
+    return t.setPosition(t.position() + f), (e || new S()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  valueType() {
+    const t = this.bb.__offset(this.bb_pos, 6);
+    return t ? this.bb.readUint8(this.bb_pos + t) : l.NONE;
+  }
+  value(t) {
+    const e = this.bb.__offset(this.bb_pos, 8);
+    return e ? this.bb.__union(t, this.bb_pos + e) : null;
+  }
+  static startValue(t) {
+    t.startObject(3);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addValueType(t, e) {
+    t.addFieldInt8(1, e, l.NONE);
+  }
+  static addValue(t, e) {
+    t.addFieldOffset(2, e, 0);
+  }
+  static endValue(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 8), e;
+  }
+  static createValue(t, e, i, a) {
+    return S.startValue(t), S.addId(t, e), S.addValueType(t, i), S.addValue(t, a), S.endValue(t);
+  }
+  unpack() {
+    return new Ht(this.id(), this.valueType(), (() => {
+      const t = ut(this.valueType(), this.value.bind(this));
+      return t === null ? null : t.unpack();
+    })());
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.valueType = this.valueType(), t.value = (() => {
+      const e = ut(this.valueType(), this.value.bind(this));
+      return e === null ? null : e.unpack();
+    })();
+  }
+}
+class Ht {
+  constructor(t = null, e = l.NONE, i = null) {
+    n(this, "id");
+    n(this, "valueType");
+    n(this, "value");
+    this.id = t, this.valueType = e, this.value = i;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = t.createObjectOffset(this.value);
+    return S.createValue(t, e, this.valueType, i);
+  }
+}
+class R {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedValueResponse(t, e) {
+    return (e || new R()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedValueResponse(t, e) {
+    return t.setPosition(t.position() + f), (e || new R()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  values(t, e) {
+    const i = this.bb.__offset(this.bb_pos, 8);
+    return i ? (e || new S()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + i) + t * 4), this.bb) : null;
+  }
+  valuesLength() {
+    const t = this.bb.__offset(this.bb_pos, 8);
+    return t ? this.bb.__vector_len(this.bb_pos + t) : 0;
+  }
+  static startTaggedValueResponse(t) {
+    t.startObject(3);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static addValues(t, e) {
+    t.addFieldOffset(2, e, 0);
+  }
+  static createValuesVector(t, e) {
+    t.startVector(4, e.length, 4);
+    for (let i = e.length - 1; i >= 0; i--)
+      t.addOffset(e[i]);
+    return t.endVector();
+  }
+  static startValuesVector(t, e) {
+    t.startVector(4, e, 4);
+  }
+  static endTaggedValueResponse(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), t.requiredField(e, 8), e;
+  }
+  static createTaggedValueResponse(t, e, i, a) {
+    return R.startTaggedValueResponse(t), R.addId(t, e), R.addTag(t, i), R.addValues(t, a), R.endTaggedValueResponse(t);
+  }
+  unpack() {
+    return new ue(this.id(), this.tag(), this.bb.createObjList(this.values.bind(this), this.valuesLength()));
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.tag = this.tag(), t.values = this.bb.createObjList(this.values.bind(this), this.valuesLength());
+  }
+}
+class ue {
+  constructor(t = null, e = null, i = []) {
+    n(this, "id");
+    n(this, "tag");
+    n(this, "values");
+    this.id = t, this.tag = e, this.values = i;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.tag !== null ? t.createString(this.tag) : 0, a = R.createValuesVector(t, t.createObjectOffsetList(this.values));
+    return R.createTaggedValueResponse(t, e, i, a);
+  }
+}
+class D {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsTaggedValueUpdate(t, e) {
+    return (e || new D()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsTaggedValueUpdate(t, e) {
+    return t.setPosition(t.position() + f), (e || new D()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  tag(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  value(t) {
+    const e = this.bb.__offset(this.bb_pos, 8);
+    return e ? (t || new S()).__init(this.bb.__indirect(this.bb_pos + e), this.bb) : null;
+  }
+  static startTaggedValueUpdate(t) {
+    t.startObject(3);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addTag(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static addValue(t, e) {
+    t.addFieldOffset(2, e, 0);
+  }
+  static endTaggedValueUpdate(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), t.requiredField(e, 8), e;
+  }
+  unpack() {
+    return new Yt(this.id(), this.tag(), this.value() !== null ? this.value().unpack() : null);
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.tag = this.tag(), t.value = this.value() !== null ? this.value().unpack() : null;
+  }
+}
+class Yt {
+  constructor(t = null, e = null, i = null) {
+    n(this, "id");
+    n(this, "tag");
+    n(this, "value");
+    this.id = t, this.tag = e, this.value = i;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.tag !== null ? t.createString(this.tag) : 0, a = this.value !== null ? this.value.pack(t) : 0;
+    return D.startTaggedValueUpdate(t), D.addId(t, e), D.addTag(t, i), D.addValue(t, a), D.endTaggedValueUpdate(t);
+  }
+}
+class st {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueFrameLoaded(t, e) {
+    return (e || new st()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueFrameLoaded(t, e) {
+    return t.setPosition(t.position() + f), (e || new st()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startUniqueFrameLoaded(t) {
+    t.startObject(1);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static endUniqueFrameLoaded(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), e;
+  }
+  static createUniqueFrameLoaded(t, e) {
+    return st.startUniqueFrameLoaded(t), st.addId(t, e), st.endUniqueFrameLoaded(t);
+  }
+  unpack() {
+    return new Ut(this.id());
+  }
+  unpackTo(t) {
+    t.id = this.id();
+  }
+}
+class Ut {
+  constructor(t = null) {
+    n(this, "id");
+    this.id = t;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0;
+    return st.createUniqueFrameLoaded(t, e);
+  }
+}
+class it {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueFrameSubscribe(t, e) {
+    return (e || new it()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueFrameSubscribe(t, e) {
+    return t.setPosition(t.position() + f), (e || new it()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startUniqueFrameSubscribe(t) {
+    t.startObject(1);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static endUniqueFrameSubscribe(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), e;
+  }
+  static createUniqueFrameSubscribe(t, e) {
+    return it.startUniqueFrameSubscribe(t), it.addId(t, e), it.endUniqueFrameSubscribe(t);
+  }
+  unpack() {
+    return new Tt(this.id());
+  }
+  unpackTo(t) {
+    t.id = this.id();
+  }
+}
+class Tt {
+  constructor(t = null) {
+    n(this, "id");
+    this.id = t;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0;
+    return it.createUniqueFrameSubscribe(t, e);
+  }
+}
+class y {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueSignalNotify(t, e) {
+    return (e || new y()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueSignalNotify(t, e) {
+    return t.setPosition(t.position() + f), (e || new y()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  frameId(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  signalId(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  valueType() {
+    const t = this.bb.__offset(this.bb_pos, 8);
+    return t ? this.bb.readUint8(this.bb_pos + t) : l.NONE;
+  }
+  value(t) {
+    const e = this.bb.__offset(this.bb_pos, 10);
+    return e ? this.bb.__union(t, this.bb_pos + e) : null;
+  }
+  static startUniqueSignalNotify(t) {
+    t.startObject(4);
+  }
+  static addFrameId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addSignalId(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static addValueType(t, e) {
+    t.addFieldInt8(2, e, l.NONE);
+  }
+  static addValue(t, e) {
+    t.addFieldOffset(3, e, 0);
+  }
+  static endUniqueSignalNotify(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createUniqueSignalNotify(t, e, i, a, r) {
+    return y.startUniqueSignalNotify(t), y.addFrameId(t, e), y.addSignalId(t, i), y.addValueType(t, a), y.addValue(t, r), y.endUniqueSignalNotify(t);
+  }
+  unpack() {
+    return new Zt(this.frameId(), this.signalId(), this.valueType(), (() => {
+      const t = ut(this.valueType(), this.value.bind(this));
+      return t === null ? null : t.unpack();
+    })());
+  }
+  unpackTo(t) {
+    t.frameId = this.frameId(), t.signalId = this.signalId(), t.valueType = this.valueType(), t.value = (() => {
+      const e = ut(this.valueType(), this.value.bind(this));
+      return e === null ? null : e.unpack();
+    })();
+  }
+}
+class Zt {
+  constructor(t = null, e = null, i = l.NONE, a = null) {
+    n(this, "frameId");
+    n(this, "signalId");
+    n(this, "valueType");
+    n(this, "value");
+    this.frameId = t, this.signalId = e, this.valueType = i, this.value = a;
+  }
+  pack(t) {
+    const e = this.frameId !== null ? t.createString(this.frameId) : 0, i = this.signalId !== null ? t.createString(this.signalId) : 0, a = t.createObjectOffset(this.value);
+    return y.createUniqueSignalNotify(t, e, i, this.valueType, a);
+  }
+}
+class nt {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueSignalRequest(t, e) {
+    return (e || new nt()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueSignalRequest(t, e) {
+    return t.setPosition(t.position() + f), (e || new nt()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startUniqueSignalRequest(t) {
+    t.startObject(1);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static endUniqueSignalRequest(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), e;
+  }
+  static createUniqueSignalRequest(t, e) {
+    return nt.startUniqueSignalRequest(t), nt.addId(t, e), nt.endUniqueSignalRequest(t);
+  }
+  unpack() {
+    return new Xt(this.id());
+  }
+  unpackTo(t) {
+    t.id = this.id();
+  }
+}
+class Xt {
+  constructor(t = null) {
+    n(this, "id");
+    this.id = t;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0;
+    return nt.createUniqueSignalRequest(t, e);
+  }
+}
+class B {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueSignalResponse(t, e) {
+    return (e || new B()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueSignalResponse(t, e) {
+    return t.setPosition(t.position() + f), (e || new B()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  signals(t, e) {
+    const i = this.bb.__offset(this.bb_pos, 6);
+    return i ? (e || new j()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + i) + t * 4), this.bb) : null;
+  }
+  signalsLength() {
+    const t = this.bb.__offset(this.bb_pos, 6);
+    return t ? this.bb.__vector_len(this.bb_pos + t) : 0;
+  }
+  static startUniqueSignalResponse(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addSignals(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static createSignalsVector(t, e) {
+    t.startVector(4, e.length, 4);
+    for (let i = e.length - 1; i >= 0; i--)
+      t.addOffset(e[i]);
+    return t.endVector();
+  }
+  static startSignalsVector(t, e) {
+    t.startVector(4, e, 4);
+  }
+  static endUniqueSignalResponse(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createUniqueSignalResponse(t, e, i) {
+    return B.startUniqueSignalResponse(t), B.addId(t, e), B.addSignals(t, i), B.endUniqueSignalResponse(t);
+  }
+  unpack() {
+    return new he(this.id(), this.bb.createObjList(this.signals.bind(this), this.signalsLength()));
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.signals = this.bb.createObjList(this.signals.bind(this), this.signalsLength());
+  }
+}
+class he {
+  constructor(t = null, e = []) {
+    n(this, "id");
+    n(this, "signals");
+    this.id = t, this.signals = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = B.createSignalsVector(t, t.createObjectOffsetList(this.signals));
+    return B.createUniqueSignalResponse(t, e, i);
+  }
+}
+class at {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueValueRequest(t, e) {
+    return (e || new at()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueValueRequest(t, e) {
+    return t.setPosition(t.position() + f), (e || new at()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  static startUniqueValueRequest(t) {
+    t.startObject(1);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static endUniqueValueRequest(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), e;
+  }
+  static createUniqueValueRequest(t, e) {
+    return at.startUniqueValueRequest(t), at.addId(t, e), at.endUniqueValueRequest(t);
+  }
+  unpack() {
+    return new $t(this.id());
+  }
+  unpackTo(t) {
+    t.id = this.id();
+  }
+}
+class $t {
+  constructor(t = null) {
+    n(this, "id");
+    this.id = t;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0;
+    return at.createUniqueValueRequest(t, e);
+  }
+}
+class C {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueValueResponse(t, e) {
+    return (e || new C()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueValueResponse(t, e) {
+    return t.setPosition(t.position() + f), (e || new C()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  values(t, e) {
+    const i = this.bb.__offset(this.bb_pos, 6);
+    return i ? (e || new S()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + i) + t * 4), this.bb) : null;
+  }
+  valuesLength() {
+    const t = this.bb.__offset(this.bb_pos, 6);
+    return t ? this.bb.__vector_len(this.bb_pos + t) : 0;
+  }
+  static startUniqueValueResponse(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addValues(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static createValuesVector(t, e) {
+    t.startVector(4, e.length, 4);
+    for (let i = e.length - 1; i >= 0; i--)
+      t.addOffset(e[i]);
+    return t.endVector();
+  }
+  static startValuesVector(t, e) {
+    t.startVector(4, e, 4);
+  }
+  static endUniqueValueResponse(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  static createUniqueValueResponse(t, e, i) {
+    return C.startUniqueValueResponse(t), C.addId(t, e), C.addValues(t, i), C.endUniqueValueResponse(t);
+  }
+  unpack() {
+    return new de(this.id(), this.bb.createObjList(this.values.bind(this), this.valuesLength()));
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.values = this.bb.createObjList(this.values.bind(this), this.valuesLength());
+  }
+}
+class de {
+  constructor(t = null, e = []) {
+    n(this, "id");
+    n(this, "values");
+    this.id = t, this.values = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = C.createValuesVector(t, t.createObjectOffsetList(this.values));
+    return C.createUniqueValueResponse(t, e, i);
+  }
+}
+class tt {
+  constructor() {
+    n(this, "bb", null);
+    n(this, "bb_pos", 0);
+  }
+  __init(t, e) {
+    return this.bb_pos = t, this.bb = e, this;
+  }
+  static getRootAsUniqueValueUpdate(t, e) {
+    return (e || new tt()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  static getSizePrefixedRootAsUniqueValueUpdate(t, e) {
+    return t.setPosition(t.position() + f), (e || new tt()).__init(t.readInt32(t.position()) + t.position(), t);
+  }
+  id(t) {
+    const e = this.bb.__offset(this.bb_pos, 4);
+    return e ? this.bb.__string(this.bb_pos + e, t) : null;
+  }
+  value(t) {
+    const e = this.bb.__offset(this.bb_pos, 6);
+    return e ? (t || new S()).__init(this.bb.__indirect(this.bb_pos + e), this.bb) : null;
+  }
+  static startUniqueValueUpdate(t) {
+    t.startObject(2);
+  }
+  static addId(t, e) {
+    t.addFieldOffset(0, e, 0);
+  }
+  static addValue(t, e) {
+    t.addFieldOffset(1, e, 0);
+  }
+  static endUniqueValueUpdate(t) {
+    const e = t.endObject();
+    return t.requiredField(e, 4), t.requiredField(e, 6), e;
+  }
+  unpack() {
+    return new Jt(this.id(), this.value() !== null ? this.value().unpack() : null);
+  }
+  unpackTo(t) {
+    t.id = this.id(), t.value = this.value() !== null ? this.value().unpack() : null;
+  }
+}
+class Jt {
+  constructor(t = null, e = null) {
+    n(this, "id");
+    n(this, "value");
+    this.id = t, this.value = e;
+  }
+  pack(t) {
+    const e = this.id !== null ? t.createString(this.id) : 0, i = this.value !== null ? this.value.pack(t) : 0;
+    return tt.startUniqueValueUpdate(t), tt.addId(t, e), tt.addValue(t, i), tt.endUniqueValueUpdate(t);
+  }
+}
+const _e = async (s) => new Promise((t, e) => {
+  const i = new oe();
+  i.postMessage({
+    type: "init",
+    host: s.host,
+    id: s.id,
+    cdn_url: s.cdn_url,
+    tag: s.tag
+  }), i.addEventListener("message", async (a) => {
+    if (a.data.ok) {
+      if (a.data.files) {
+        const r = new k(), o = new Ct(
+          s.id,
+          a.data.code,
+          a.data.files.map(
+            (h) => new Bt(h.target, h.metadata)
+          )
+        );
+        r.finish(o.pack(r)), St(
+          s.host,
+          s.tag != null ? _.Client_Tagged_FrameCache : _.Client_Unique_FrameCache,
+          r.asUint8Array()
+        );
+      }
+      t(await import(
+        /* @vite-ignore */
+        a.data.code
+      ));
+    } else
+      e(a.data.err);
+    i.terminate();
+  });
+}), ct = (s) => {
+}, fe = (s, t) => {
+  if (s == l.ValueBoolean)
+    return t;
+  if (s == l.ValueNumber)
+    return Number(t);
+  if (s == l.ValueDouble || s == l.ValueString)
+    return t;
+  if (s == l.ValueBuffer)
+    return new Uint8Array(t);
+}, Kt = (s, t) => {
+  if (s == l.ValueBoolean)
+    return new Lt(t);
+  if (s == l.ValueNumber)
+    return new Et(BigInt(t));
+  if (s == l.ValueDouble)
+    return new xt(t);
+  if (s == l.ValueString)
+    return new zt(t);
+  if (s == l.ValueBuffer)
+    return new Pt(Array.from(t));
+}, Qt = async ({
+  id: s,
+  tag: t,
+  host: e,
+  service: i
+}) => {
+  const a = await jt(
+    e,
+    t != null ? _.Client_Tagged_Value_Request : _.Client_Unique_Value_Request,
+    (() => {
+      const c = new k(), d = t != null ? new Wt(s, t) : new $t(s);
+      return c.finish(d.pack(c)), c.asUint8Array();
+    })(),
+    t != null ? (c, d) => {
+      if (c === _.Server_Tagged_Value_Response) {
+        const b = R.getRootAsTaggedValueResponse(
+          new P(d)
+        );
+        if (b.id() === s && t === b.tag())
+          return b;
+      }
+    } : (c, d) => {
+      if (c === _.Server_Unique_Value_Response) {
+        const b = C.getRootAsUniqueValueResponse(
+          new P(d)
+        );
+        if (b.id() === s)
+          return b;
+      }
+    }
+  ), r = {
+    [l.ValueBoolean]: /* @__PURE__ */ new Map(),
+    [l.ValueNumber]: /* @__PURE__ */ new Map(),
+    [l.ValueDouble]: /* @__PURE__ */ new Map(),
+    [l.ValueString]: /* @__PURE__ */ new Map(),
+    [l.ValueBuffer]: /* @__PURE__ */ new Map()
+  };
+  let o = !1;
+  const h = a.valuesLength();
+  for (let c = 0; c < h; ++c) {
+    const d = a.values(c), b = d.id(), F = d.valueType(), O = et(fe(F, d.unpack().value.value));
+    O.subscribe((V) => {
+      if (V == null || o)
+        return;
+      const m = new k(), p = t != null ? new Yt(s, t) : new Jt(s);
+      p.value = new Ht(
+        b,
+        F,
+        Kt(F, V)
+      ), m.finish(p.pack(m));
+      const I = t != null ? _.Tagged_Value_Update : _.Unique_Value_Update;
+      i.publish(dt([ht(I), m.asUint8Array()]));
+    }), F !== l.NONE && r[F].set(b, O);
+  }
+  return i.on_message((c, d) => {
+    var V;
+    const b = new DataView(d.buffer).getUint32(0, !1), F = d.slice(4), O = t != null ? _.Tagged_Value_Update : _.Unique_Value_Update;
+    if (b === O) {
+      const m = t !== null ? D.getRootAsTaggedValueUpdate(new P(F)) : tt.getRootAsUniqueValueUpdate(new P(F));
+      if (m.id() === s && (t == null || t === m.tag())) {
+        o = !0;
+        const p = m.value().valueType();
+        if (p !== l.NONE) {
+          const I = (V = r[p]) == null ? void 0 : V.get(m.value().id());
+          if (p === l.ValueBuffer) {
+            const G = new Uint8Array(
+              m.unpack().value.value.value
+            ), Rt = At(I);
+            let gt = !0;
+            if (G.length != Rt.length)
+              gt = !1;
+            else {
+              const ie = G.length;
+              for (let pt = 0; pt < ie; pt++)
+                if (G[pt] !== Rt[pt]) {
+                  gt = !1;
+                  break;
+                }
+            }
+            gt || I == null || I.set(G);
+          } else p === l.ValueNumber ? I == null || I.set(new Number(m.unpack().value.value.value)) : I == null || I.set(m.unpack().value.value.value);
+        }
+        o = !1;
+      }
+    }
+  }), r;
+}, Mt = async ({
+  id: s,
+  tag: t,
+  host: e,
+  service: i
+}) => {
+  const a = await jt(
+    e,
+    t != null ? _.Client_Tagged_Signal_Request : _.Client_Unique_Signal_Request,
+    (() => {
+      const h = new k(), c = t != null ? new Gt(s, t) : new Xt(s);
+      return h.finish(c.pack(h)), h.asUint8Array();
+    })(),
+    (h, c) => {
+      if (t != null) {
+        if (h === _.Server_Tagged_Signal_Response)
+          return T.getRootAsTaggedSignalResponse(new P(c));
+      } else if (h === _.Server_Unique_Signal_Response)
+        return B.getRootAsUniqueSignalResponse(new P(c));
+    }
+  ), r = [
+    /* @__PURE__ */ new Map(),
+    /* @__PURE__ */ new Map(),
+    /* @__PURE__ */ new Map(),
+    /* @__PURE__ */ new Map(),
+    /* @__PURE__ */ new Map(),
+    /* @__PURE__ */ new Map()
+  ], o = a.signalsLength();
+  for (let h = 0; h < o; ++h) {
+    const c = a.signals(h), { id: d, type: b } = { id: c.id(), type: c.type() };
+    r[b].set(d, (F) => {
+      const O = new k(), V = b, m = Kt(V, F), p = t != null ? new Dt(s, t, d, V, m) : new Zt(s, d, V, m);
+      O.finish(p.pack(O));
+      const I = t != null ? _.Client_Tagged_Signal_Notify : _.Client_Unique_Signal_Notify;
+      i.publish(dt([ht(I), O.asUint8Array()]));
+    });
+  }
+  return r;
+}, te = (s) => ({
+  boolean: (t, e) => s[l.ValueBoolean].get(t) ?? et(e),
+  double: (t, e) => s[l.ValueDouble].get(t) ?? et(e),
+  string: (t, e) => s[l.ValueString].get(t) ?? et(e),
+  number: (t, e) => s[l.ValueNumber].get(t) ?? et(e),
+  buffer: (t, e) => s[l.ValueBuffer].get(t) ?? et(e),
+  json: (t, e, i) => {
+    const a = s[l.ValueBuffer].get(t);
+    if (a != null) {
+      let r = At(a), o = i.decode(r);
+      return {
+        set: (h) => {
+          o = h, r = i.encode(o), a.set(r);
+        },
+        subscribe: (h) => a.subscribe((c) => {
+          c !== r && (r = c, o = i.decode(r)), h(o);
+        }),
+        update: (h) => {
+          a.update((c) => (o = h(o), r = i.encode(o), r));
+        }
+      };
+    }
+    return et(e);
+  }
+}), ee = (s) => ({
+  none: (t) => s[q.None].get(t) ?? (() => {
+  }),
+  boolean: (t) => s[q.Boolean].get(t) ?? ct,
+  double: (t) => s[q.Double].get(t) ?? ct,
+  number: (t) => s[q.Number].get(t) ?? ct,
+  string: (t) => s[q.String].get(t) ?? ct,
+  buffer: (t) => s[q.Buffer].get(t) ?? ct,
+  json: (t, e) => {
+    const i = s[q.Buffer].get(t);
+    return i != null ? (a) => i(e(a)) : ct;
+  }
+}), pe = async (s, t, e, i, a, r) => {
+  await re(s);
+  const o = new ft(s), [h, c, { nil_xit_fn: d }] = await Promise.all([
+    Qt({ id: t, tag: e, host: s, service: o }),
+    Mt({ id: t, tag: e, host: s, service: o }),
+    _e({ host: s, cdn_url: i, id: t, tag: e })
+  ]), b = {
+    svelte: () => import("./svelte/index.js").then((p) => p.bX),
+    "svelte/store": () => import("./svelte/store.js").then((p) => p.i),
+    "svelte/animate": () => import("./svelte/animate.js"),
+    "svelte/easing": () => import("./svelte/easing.js"),
+    "svelte/events": () => import("./svelte/events.js"),
+    "svelte/motion": () => import("./svelte/motion.js").then((p) => p.i),
+    "svelte/transition": () => import("./svelte/transition.js"),
+    // @ts-ignore
+    "svelte/internal/disclose-version": () => import("./svelte/internal/disclose-version.js"),
+    // @ts-ignore
+    "svelte/internal/client": () => import("./svelte/internal/client.js")
+  }, F = (p) => p in b ? b[p]() : import(
+    /* @vite-ignore */
+    p
+  ), { action: O } = await d(F);
+  o.on_connect(() => {
+    const p = new k(), I = e != null ? new qt(t, e) : new Tt(t);
+    p.finish(I.pack(p));
+    const G = e != null ? _.Client_Tagged_Frame_Subscribe : _.Client_Unique_Frame_Subscribe;
+    o.publish(dt([ht(G), p.asUint8Array()]));
+  }), o.start();
+  const V = new k(), m = e != null ? new Ot(t, e) : new Ut(t);
+  return V.finish(m.pack(V)), St(
+    s,
+    e != null ? _.Client_Tagged_Frame_Loaded : _.Client_Unique_Frame_Loaded,
+    V.asUint8Array()
+  ), (p) => {
+    const I = /* @__PURE__ */ new Map();
+    I.set("nil.xit", {
+      values: te(h),
+      signals: ee(c),
+      frame_ui: a,
+      frame: r,
+      resub: () => o.start(),
+      unsub: () => o.stop(),
+      id: t,
+      tag: e
+    });
+    const { destroy: G } = O(p, I);
+    return {
+      destroy: () => {
+        o.stop(), G();
+      }
+    };
+  };
+}, be = async ({
+  host: s,
+  frame: t,
+  tag: e
+}) => {
+  const i = new ft(s), [a, r] = await Promise.all([
+    Qt({ id: t, tag: e ?? null, host: s, service: i }),
+    Mt({ id: t, tag: e ?? null, host: s, service: i })
+  ]);
+  i.on_connect(() => {
+    const d = new k(), b = e != null ? new qt(t, e) : new Tt(t);
+    d.finish(b.pack(d));
+    const F = e != null ? _.Client_Tagged_Frame_Subscribe : _.Client_Unique_Frame_Subscribe;
+    i.publish(dt([ht(F), d.asUint8Array()]));
+  }), i.start();
+  const o = new k(), h = e != null ? new Ot(t, e) : new Ut(t);
+  o.finish(h.pack(o));
+  const c = e != null ? _.Client_Tagged_Frame_Loaded : _.Client_Unique_Frame_Loaded;
+  return St(s, c, o.asUint8Array()), {
+    values: te(a),
+    signals: ee(r),
+    resub: () => i.start(),
+    unsub: () => i.stop()
+  };
+}, se = async ({
+  host: s,
+  cdn_url: t,
+  frame: e,
+  tag: i
+}) => {
+  const a = async (r, o) => {
+    const h = await se({
+      host: s,
+      cdn_url: t,
+      frame: r,
+      tag: o
+    });
+    return (c) => h(c);
+  };
+  return pe(
+    s,
+    e,
+    i ?? null,
+    t,
+    async (r, o) => a(r, o),
+    async (r, o) => be({ host: s, frame: r, tag: o })
+  );
+}, we = async (s, t) => (await se(t))(s);
+export {
+  we as create_component,
+  be as create_frame,
+  se as create_frame_ui
+};