@omujs/omu 0.9.48 → 0.9.49

package/dist/esm/network/index.js

@@ -0,0 +1,1627 @@
+// @bun
+// src/const.ts
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+
+// src/serialize/bytebuffer.ts
+class Flags {
+  value;
+  length;
+  constructor(options) {
+    this.value = options.value ?? 0;
+    this.length = options.length ?? 32;
+  }
+  has(position) {
+    return (this.value & 1 << position) !== 0;
+  }
+  get(position) {
+    return (this.value & 1 << position) !== 0;
+  }
+  ifSet(position, callback) {
+    if (this.has(position)) {
+      return callback();
+    }
+    return;
+  }
+  set(position, value) {
+    if (value) {
+      this.value |= 1 << position;
+    } else {
+      this.value &= ~(1 << position);
+    }
+  }
+  write(writer) {
+    const bits = new Uint8Array((this.length + 7) / 8);
+    for (let i = 0;i < bits.length; i++) {
+      bits[i] = this.value >> i * 8 & 255;
+    }
+    writer.write(bits);
+  }
+  static read(reader, length) {
+    let value = 0;
+    for (let i = 0;i < (length + 7) / 8; i++) {
+      value |= reader.readUint8() << i * 8;
+    }
+    return new Flags({ value, length });
+  }
+}
+function readFloat16(dataView, offset) {
+  const sign = dataView.getUint16(offset) & 32768 ? -1 : 1;
+  const exponent = (dataView.getUint16(offset) & 31744) >> 10;
+  const mantissa = dataView.getUint16(offset) & 1023;
+  if (exponent === 0 && mantissa === 0) {
+    return 0;
+  } else if (exponent === 31) {
+    return mantissa === 0 ? Infinity * sign : NaN;
+  } else {
+    const normalizedExponent = exponent - 15;
+    const normalizedMantissa = mantissa / 1024;
+    return sign * Math.pow(2, normalizedExponent) * (1 + normalizedMantissa);
+  }
+}
+function writeFloat16(dataView, offset, value) {
+  if (value === 0) {
+    dataView.setUint16(offset, 0);
+    return;
+  }
+  const sign = value < 0 ? 1 : 0;
+  value = Math.abs(value);
+  if (!isFinite(value)) {
+    dataView.setUint16(offset, 31744 | sign << 15);
+    return;
+  }
+  const exponent = Math.floor(Math.log2(value));
+  const mantissa = value / Math.pow(2, exponent) - 1;
+  const normalizedExponent = exponent + 15;
+  const normalizedMantissa = Math.round(mantissa * 1024);
+  if (normalizedExponent <= 0) {
+    dataView.setUint16(offset, sign << 15);
+  } else if (normalizedExponent >= 31) {
+    dataView.setUint16(offset, 31744 | sign << 15);
+  } else {
+    dataView.setUint16(offset, sign << 15 | normalizedExponent << 10 | normalizedMantissa);
+  }
+}
+
+class ByteWriter {
+  dataView;
+  buffer;
+  offset = 0;
+  finished = false;
+  constructor(init, offset) {
+    this.offset = offset ?? 0;
+    this.buffer = init ?? new ArrayBuffer(1024);
+    this.dataView = new DataView(this.buffer);
+  }
+  static fromUint8Array(buffer) {
+    const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+    const uint8Array = new Uint8Array(arrayBuffer);
+    uint8Array.set(new Uint8Array(buffer));
+    return new ByteWriter(arrayBuffer, buffer.byteLength);
+  }
+  allocate(length) {
+    if (this.offset + length > this.buffer.byteLength) {
+      const newByteLength = Math.max(this.buffer.byteLength * 2, this.offset + length);
+      const newBuffer = new ArrayBuffer(newByteLength);
+      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+      this.buffer = newBuffer;
+      this.dataView = new DataView(this.buffer);
+    }
+  }
+  write(data) {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    this.allocate(data.length);
+    new Uint8Array(this.buffer).set(data, this.offset);
+    this.offset += data.length;
+    return this;
+  }
+  writeBoolean(value) {
+    this.allocate(1);
+    this.dataView.setInt8(this.offset, value ? 1 : 0);
+    this.offset += 1;
+    return this;
+  }
+  writeInt8(value) {
+    this.allocate(1);
+    this.dataView.setInt8(this.offset, value);
+    this.offset += 1;
+    return this;
+  }
+  writeUint8(value) {
+    this.allocate(1);
+    this.dataView.setUint8(this.offset, value);
+    this.offset += 1;
+    return this;
+  }
+  writeInt16(value) {
+    this.allocate(2);
+    this.dataView.setInt16(this.offset, value);
+    this.offset += 2;
+    return this;
+  }
+  writeUint16(value) {
+    this.allocate(2);
+    this.dataView.setUint16(this.offset, value);
+    this.offset += 2;
+    return this;
+  }
+  writeInt32(value) {
+    this.allocate(4);
+    this.dataView.setInt32(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeUint32(value) {
+    this.allocate(4);
+    this.dataView.setUint32(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeInt64(value) {
+    this.allocate(8);
+    this.dataView.setBigInt64(this.offset, value);
+    this.offset += 8;
+    return this;
+  }
+  writeUint64(value) {
+    this.allocate(8);
+    this.dataView.setBigUint64(this.offset, value);
+    this.offset += 8;
+    return this;
+  }
+  writeULEB128(value) {
+    if (value < 0) {
+      throw new Error("Value must be non-negative");
+    }
+    while (value > 127) {
+      this.allocate(1);
+      this.dataView.setUint8(this.offset, value & 127 | 128);
+      this.offset += 1;
+      value >>= 7;
+    }
+    this.allocate(1);
+    this.dataView.setUint8(this.offset, value & 127);
+    this.offset += 1;
+    return this;
+  }
+  writeFloat16(value) {
+    this.allocate(2);
+    writeFloat16(this.dataView, this.offset, value);
+    this.offset += 2;
+    return this;
+  }
+  writeFloat32(value) {
+    this.allocate(4);
+    this.dataView.setFloat32(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeFloat64(value) {
+    this.allocate(4);
+    this.dataView.setFloat64(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeUint8Array(value) {
+    this.writeULEB128(value.byteLength);
+    this.write(value);
+    return this;
+  }
+  writeString(value) {
+    this.writeUint8Array(textEncoder.encode(value));
+    return this;
+  }
+  writeJSON(value) {
+    this.writeString(JSON.stringify(value));
+    return this;
+  }
+  writeFlags(flags) {
+    flags.write(this);
+    return this;
+  }
+  finish() {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    this.finished = true;
+    return new Uint8Array(this.buffer, 0, this.offset);
+  }
+  toUint8Array() {
+    return new Uint8Array(this.buffer, 0, this.offset);
+  }
+  toArrayBuffer() {
+    return this.buffer.slice(0, this.offset);
+  }
+}
+
+class ByteReader {
+  dataView;
+  offset;
+  finished;
+  constructor(data) {
+    this.dataView = data;
+    this.offset = 0;
+    this.finished = false;
+  }
+  static fromUint8Array(buffer) {
+    const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+    const uint8Array = new Uint8Array(arrayBuffer);
+    uint8Array.set(new Uint8Array(buffer));
+    const dataView = new DataView(arrayBuffer);
+    return new ByteReader(dataView);
+  }
+  static fromArrayBuffer(buffer) {
+    const dataView = new DataView(buffer);
+    return new ByteReader(dataView);
+  }
+  static async fromBlob(blob) {
+    const arrayBuffer = await blob.arrayBuffer();
+    const dataView = new DataView(arrayBuffer);
+    return new ByteReader(dataView);
+  }
+  read(size) {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    if (size < 0) {
+      throw new Error("Size must be positive");
+    }
+    if (this.offset + size > this.dataView.byteLength) {
+      throw new Error("Buffer not fully read");
+    }
+    const value = new Uint8Array(this.dataView.buffer, this.offset, size);
+    this.offset += size;
+    return value;
+  }
+  readBoolean() {
+    const value = this.dataView.getInt8(this.offset);
+    this.offset += 1;
+    return value !== 0;
+  }
+  readInt8() {
+    const value = this.dataView.getInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readUint8() {
+    const value = this.dataView.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readInt16() {
+    const value = this.dataView.getInt16(this.offset);
+    this.offset += 2;
+    return value;
+  }
+  readUint16() {
+    const value = this.dataView.getUint16(this.offset);
+    this.offset += 2;
+    return value;
+  }
+  readInt32() {
+    const value = this.dataView.getInt32(this.offset);
+    this.offset += 4;
+    return value;
+  }
+  readUint32() {
+    const value = this.dataView.getUint32(this.offset);
+    this.offset += 4;
+    return value;
+  }
+  readInt64() {
+    const value = this.dataView.getBigInt64(this.offset);
+    this.offset += 8;
+    return value;
+  }
+  readUint64() {
+    const value = this.dataView.getBigUint64(this.offset);
+    this.offset += 8;
+    return value;
+  }
+  readULEB128() {
+    let value = 0;
+    let shift = 0;
+    let byte;
+    do {
+      if (this.offset >= this.dataView.byteLength) {
+        throw new Error("Buffer not fully read");
+      }
+      byte = this.dataView.getUint8(this.offset);
+      this.offset += 1;
+      value |= (byte & 127) << shift;
+      shift += 7;
+    } while ((byte & 128) !== 0);
+    return value;
+  }
+  readFloat16() {
+    const value = readFloat16(this.dataView, this.offset);
+    this.offset += 2;
+    return value;
+  }
+  readFloat32() {
+    const value = this.dataView.getFloat32(this.offset);
+    this.offset += 4;
+    return value;
+  }
+  readFloat64() {
+    const value = this.dataView.getFloat64(this.offset);
+    this.offset += 8;
+    return value;
+  }
+  readUint8Array() {
+    const length = this.readULEB128();
+    return this.read(length);
+  }
+  readString() {
+    const byteArray = this.readUint8Array();
+    return textDecoder.decode(byteArray);
+  }
+  readJSON() {
+    return JSON.parse(this.readString());
+  }
+  readFlags(length) {
+    return Flags.read(this, length);
+  }
+  finish() {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    this.finished = true;
+    if (this.offset !== this.dataView.byteLength) {
+      throw new Error("Buffer not fully read");
+    }
+  }
+}
+// src/serialize/serializer.ts
+class Serializer {
+  serialize;
+  deserialize;
+  constructor(serialize, deserialize) {
+    this.serialize = serialize;
+    this.deserialize = deserialize;
+  }
+  static of(serializer) {
+    return new Serializer(serializer.serialize, serializer.deserialize);
+  }
+  static pipe(ser1, ser2) {
+    return new Serializer((data) => ser2.serialize(ser1.serialize(data)), (data) => ser1.deserialize(ser2.deserialize(data)));
+  }
+  static transform(func) {
+    return new Serializer(func, func);
+  }
+  static noop() {
+    return new Serializer((data) => data, (data) => data);
+  }
+  field(key, serializer) {
+    return new Serializer((data) => {
+      const serialized = this.serialize(data);
+      return {
+        ...serialized,
+        [key]: serializer.serialize(serialized[key])
+      };
+    }, (data) => {
+      return this.deserialize({
+        ...data,
+        [key]: serializer.deserialize(data[key])
+      });
+    });
+  }
+  static json() {
+    return new Serializer((data) => textEncoder.encode(JSON.stringify(data)), (data) => {
+      const text = textDecoder.decode(data);
+      return JSON.parse(text);
+    });
+  }
+  toJson() {
+    return new Serializer((data) => textEncoder.encode(JSON.stringify(this.serialize(data))), (data) => {
+      const text = textDecoder.decode(data);
+      return this.deserialize(JSON.parse(text));
+    });
+  }
+  toArray() {
+    return new Serializer((data) => data.map((item) => this.serialize(item)), (data) => data.map((item) => this.deserialize(item)));
+  }
+  toMap() {
+    return new Serializer((data) => {
+      const result = new Map;
+      data.forEach((value, key) => {
+        result.set(key, this.serialize(value));
+      });
+      return result;
+    }, (data) => {
+      const result = new Map;
+      data.forEach((value, key) => {
+        result.set(key, this.deserialize(value));
+      });
+      return result;
+    });
+  }
+  fallback(fallback) {
+    return new Serializer((data) => this.serialize(data), (data) => {
+      try {
+        return this.deserialize(data);
+      } catch {
+        return fallback;
+      }
+    });
+  }
+  fallbackMap(fallback) {
+    return new Serializer((data) => this.serialize(data), (data) => {
+      try {
+        return this.deserialize(data);
+      } catch (error) {
+        return fallback(data, error);
+      }
+    });
+  }
+  pipe(serializer) {
+    return new Serializer((data) => serializer.serialize(this.serialize(data)), (data) => this.deserialize(serializer.deserialize(data)));
+  }
+}
+// src/network/frame-transport.ts
+var FRAME_TYPE_KEY = "omuapps-frame";
+
+class FrameTransport {
+  connect() {
+    return FrameConnection.create();
+  }
+}
+
+class FrameConnection {
+  connectedWaiter;
+  connected;
+  origin = null;
+  packetQueue = [];
+  sendQueue = [];
+  receiveWaiter = null;
+  constructor(connectedWaiter) {
+    this.connectedWaiter = connectedWaiter;
+    this.connected = false;
+    window.addEventListener("message", (event) => {
+      if (event.data === null || typeof event.data !== "object") {
+        return;
+      }
+      if (!("type_key" in event.data) || event.data.type_key !== FRAME_TYPE_KEY) {
+        return;
+      }
+      const command = event.data;
+      if (command.type === "syn") {
+        this.origin = event.origin;
+      }
+      if (event.origin !== this.origin) {
+        return;
+      }
+      this.handleCommand(command);
+    });
+  }
+  static create() {
+    return new Promise((resolve) => {
+      const connection = new FrameConnection(() => resolve(connection));
+      connection.postCommand({
+        type: "connect",
+        payload: {}
+      });
+    });
+  }
+  handleCommand(command) {
+    const { type, payload } = command;
+    switch (type) {
+      case "syn":
+        this.origin = payload.origin;
+        this.postCommand({
+          type: "syn",
+          payload: {
+            origin: window.origin
+          }
+        });
+        break;
+      case "connect":
+        this.connected = true;
+        if (this.connectedWaiter) {
+          this.connectedWaiter();
+          this.connectedWaiter = null;
+        }
+        break;
+      case "disconnect":
+        this.connected = false;
+        break;
+      case "receive": {
+        const reader = ByteReader.fromUint8Array(payload);
+        this.packetQueue.push({
+          type: reader.readString(),
+          data: reader.readUint8Array()
+        });
+        reader.finish();
+        if (this.receiveWaiter) {
+          this.receiveWaiter();
+        }
+        break;
+      }
+      case "error":
+        throw new Error(payload);
+      case "send":
+        break;
+      default:
+        throw new Error(`Unknown command type: ${type}`);
+    }
+  }
+  postCommand(command) {
+    command.type_key = FRAME_TYPE_KEY;
+    if (!this.origin) {
+      this.sendQueue.push(command);
+      return;
+    }
+    for (const queuedCommand of this.sendQueue) {
+      window.parent.postMessage(queuedCommand, this.origin);
+    }
+    this.sendQueue.length = 0;
+    window.parent.postMessage(command, this.origin);
+  }
+  async receive(serializer) {
+    if (this.receiveWaiter) {
+      throw new Error("Already receiving");
+    }
+    if (!this.connected) {
+      return null;
+    }
+    while (this.packetQueue.length === 0 && this.connected) {
+      await new Promise((resolve) => {
+        this.receiveWaiter = () => resolve();
+      });
+    }
+    if (!this.connected) {
+      return null;
+    }
+    const packet = serializer.deserialize(this.packetQueue.shift());
+    this.receiveWaiter = null;
+    return packet;
+  }
+  get closed() {
+    return !this.connected;
+  }
+  close() {
+    if (this.connected) {
+      this.postCommand({
+        type: "disconnect",
+        payload: {}
+      });
+    }
+    this.connected = false;
+    if (this.receiveWaiter) {
+      this.receiveWaiter();
+      this.receiveWaiter = null;
+    }
+  }
+  send(packet, serializer) {
+    if (!this.connected) {
+      throw new Error("Not connected");
+    }
+    const packetData = serializer.serialize(packet);
+    const writer = new ByteWriter;
+    writer.writeString(packetData.type);
+    writer.writeUint8Array(packetData.data);
+    this.postCommand({
+      type: "send",
+      payload: writer.finish()
+    });
+  }
+}
+// src/identifier.ts
+var NAMESPACE_REGEX = /^(\.[^/:.]|[\w-])+$/;
+var NAME_REGEX = /^[^/:]+$/;
+
+class Identifier {
+  namespace;
+  path;
+  constructor(namespace, ...path) {
+    Identifier.validate(namespace, path);
+    this.namespace = namespace;
+    this.path = path;
+  }
+  static serialize(identifier) {
+    return identifier.key();
+  }
+  static deserialize(json) {
+    return Identifier.fromJson(json);
+  }
+  static from(id) {
+    if (id instanceof Identifier) {
+      return id;
+    } else if (id instanceof App) {
+      return id.id;
+    } else if (typeof id === "string") {
+      return Identifier.fromKey(id);
+    } else {
+      const idCasted = id;
+      if (typeof idCasted.namespace === "string" && Array.isArray(idCasted.path) && idCasted.path.every((p) => typeof p === "string")) {
+        return new Identifier(idCasted.namespace, ...idCasted.path);
+      }
+      const idWithId = id;
+      if (typeof idWithId.id !== "undefined") {
+        return Identifier.from(idWithId.id);
+      }
+      throw new Error(`Cannot convert to Identifier: ${id}`);
+    }
+  }
+  static fromOptional(id) {
+    if (id === undefined || id === null) {
+      return;
+    }
+    return Identifier.from(id);
+  }
+  static validate(namespace, path) {
+    if (!namespace) {
+      throw new Error("Invalid namespace: Namespace cannot be empty");
+    }
+    if (path.length === 0) {
+      throw new Error("Invalid path: Path must have at least one name");
+    }
+    if (!NAMESPACE_REGEX.test(namespace)) {
+      throw new Error(`Invalid namespace: Namespace must match ${NAMESPACE_REGEX}`);
+    }
+    for (const name of path) {
+      if (!NAME_REGEX.test(name)) {
+        throw new Error(`Invalid path: Name must match ${NAME_REGEX} but got ${name}`);
+      }
+    }
+  }
+  static format(namespace, ...path) {
+    Identifier.validate(namespace, path);
+    return `${namespace}:${path.join("/")}`;
+  }
+  static fromKey(key) {
+    const separator = key.indexOf(":");
+    if (separator === -1) {
+      throw new Error(`Invalid key: No separator found in ${key}`);
+    }
+    if (key.indexOf(":", separator + 1) !== -1) {
+      throw new Error(`Invalid key: Multiple separators found in ${key}`);
+    }
+    const namespace = key.slice(0, separator);
+    const path = key.slice(separator + 1);
+    if (!namespace || !path) {
+      throw new Error("Invalid key: Namespace and path cannot be empty");
+    }
+    return new Identifier(namespace, ...path.split("/"));
+  }
+  static fromUrl(url) {
+    const parsedUrl = new URL(url);
+    const namespace = Identifier.namespaceFromUrl(parsedUrl.href);
+    const path = parsedUrl.pathname.slice(1).split("/");
+    return new Identifier(namespace, ...path);
+  }
+  static namespaceFromUrl(url) {
+    const parsed = new URL(url);
+    return parsed.hostname.split(".").reverse().join(".");
+  }
+  get base() {
+    return new Identifier(this.namespace, this.path[0]);
+  }
+  toJson() {
+    return this.key();
+  }
+  static fromJson(json) {
+    return Identifier.fromKey(json);
+  }
+  key() {
+    return Identifier.format(this.namespace, ...this.path);
+  }
+  isEqual(other) {
+    return this.key() === other.key();
+  }
+  isNamespaceEqual(other) {
+    return this.namespace === other.namespace;
+  }
+  isSubpathOf(other) {
+    if (this.namespace !== other.namespace) {
+      return false;
+    }
+    if (this.path.length < other.path.length) {
+      return false;
+    }
+    for (let i = 0;i < other.path.length; i++) {
+      if (this.path[i] !== other.path[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  join(...path) {
+    return new Identifier(this.namespace, ...this.path, ...path);
+  }
+}
+
+class IdentifierMap {
+  map = new Map;
+  constructor(entries) {
+    if (!entries)
+      return;
+    for (const [id, value] of entries) {
+      this.map.set(id.key(), value);
+    }
+  }
+  get size() {
+    return this.map.size;
+  }
+  set(identifier, value) {
+    this.map.set(identifier.key(), value);
+  }
+  get(identifier) {
+    return this.map.get(identifier.key());
+  }
+  has(identifier) {
+    return this.map.has(identifier.key());
+  }
+  delete(identifier) {
+    this.map.delete(identifier.key());
+  }
+  clear() {
+    this.map.clear();
+  }
+  *keys() {
+    for (const key of this.map.keys()) {
+      yield Identifier.fromKey(key);
+    }
+  }
+  values() {
+    return this.map.values();
+  }
+  *entries() {
+    for (const [key, value] of this.map.entries()) {
+      yield [Identifier.fromKey(key), value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+
+class IdentifierSet {
+  set = new Set;
+  get size() {
+    return this.set.size;
+  }
+  add(identifier) {
+    this.set.add(identifier.key());
+  }
+  has(identifier) {
+    return this.set.has(identifier.key());
+  }
+  delete(identifier) {
+    this.set.delete(identifier.key());
+  }
+  clear() {
+    this.set.clear();
+  }
+  *keys() {
+    for (const key of this.set.keys()) {
+      yield Identifier.fromKey(key);
+    }
+  }
+  values() {
+    return this.keys();
+  }
+  *entries() {
+    for (const key of this.set.keys()) {
+      const identifier = Identifier.fromKey(key);
+      yield [identifier, identifier];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+
+// src/app.ts
+class App {
+  id;
+  type;
+  parentId;
+  version;
+  url;
+  metadata;
+  dependencies;
+  constructor(id, options) {
+    this.id = Identifier.from(id);
+    this.parentId = Identifier.fromOptional(options.parentId);
+    this.version = options.version;
+    this.url = options.url;
+    this.metadata = options.metadata;
+    this.type = options.type ?? "app";
+    this.dependencies = options.dependencies ?? {};
+  }
+  static deserialize(info) {
+    const id = Identifier.fromKey(info.id);
+    return new App(id, {
+      parentId: Identifier.fromOptional(info.parent_id),
+      version: info.version,
+      url: info.url,
+      type: info.type,
+      metadata: info.metadata,
+      dependencies: info.dependencies ?? {}
+    });
+  }
+  static serialize(data) {
+    return {
+      id: data.id.key(),
+      type: data.type,
+      parent_id: data.parentId?.key(),
+      version: data.version,
+      url: data.url,
+      metadata: data.metadata,
+      dependencies: data.dependencies
+    };
+  }
+  join(...paths) {
+    return new App(this.id.join(...paths), {
+      parentId: this.parentId,
+      version: this.version,
+      url: this.url,
+      type: this.type,
+      metadata: this.metadata,
+      dependencies: this.dependencies
+    });
+  }
+}
+
+// src/network/packet/packet.ts
+class PacketType {
+  id;
+  serializer;
+  constructor(id, serializer) {
+    this.id = id;
+    this.serializer = serializer;
+  }
+  new(data) {
+    return {
+      type: this,
+      data
+    };
+  }
+  match(packet) {
+    return packet.type === this;
+  }
+  static createJson(identifier, {
+    name,
+    serializer
+  }) {
+    return new PacketType(identifier.join(name), Serializer.pipe(serializer ?? Serializer.noop(), Serializer.json()));
+  }
+  static createSerialized(identifier, {
+    name,
+    serializer
+  }) {
+    return new PacketType(identifier.join(name), serializer);
+  }
+}
+
+// src/network/packet/packet-types.ts
+var IDENTIFIER = new Identifier("core", "packet");
+
+class ConnectPacket {
+  protocol;
+  app;
+  token;
+  encryption;
+  constructor(options) {
+    this.protocol = options.protocol;
+    this.app = options.app;
+    this.token = options.token;
+    this.encryption = options.encryption ?? null;
+  }
+  static deserialize(data) {
+    return new ConnectPacket({
+      protocol: data.protocol,
+      app: App.deserialize(data.app),
+      encryption: data.encryption,
+      token: data.token
+    });
+  }
+  static serialize(data) {
+    return {
+      protocol: data.protocol,
+      app: App.serialize(data.app),
+      encryption: data.encryption,
+      token: data.token
+    };
+  }
+}
+class DisconnectPacket {
+  type;
+  message;
+  constructor(options) {
+    this.type = options.type;
+    this.message = options.message ?? null;
+  }
+  static serialize(data) {
+    return data.toJson();
+  }
+  static deserialize(data) {
+    return DisconnectPacket.fromJson(data);
+  }
+  static fromJson(data) {
+    return new DisconnectPacket({
+      type: data.type,
+      message: data.message
+    });
+  }
+  toJson() {
+    return {
+      type: this.type,
+      message: this.message
+    };
+  }
+}
+var PACKET_TYPES = {
+  SERVER_META: PacketType.createJson(IDENTIFIER, {
+    name: "server_meta"
+  }),
+  CONNECT: PacketType.createJson(IDENTIFIER, {
+    name: "connect",
+    serializer: ConnectPacket
+  }),
+  DISCONNECT: PacketType.createJson(IDENTIFIER, {
+    name: "disconnect",
+    serializer: DisconnectPacket
+  }),
+  TOKEN: PacketType.createJson(IDENTIFIER, {
+    name: "token"
+  }),
+  READY: PacketType.createJson(IDENTIFIER, {
+    name: "ready"
+  }),
+  ENCRYPTED_PACKET: PacketType.createSerialized(IDENTIFIER, {
+    name: "e",
+    serializer: Serializer.noop()
+  })
+};
+
+// src/errors.ts
+class OmuError extends Error {
+  constructor(message) {
+    super(message ?? undefined);
+    this.name = this.constructor.name;
+  }
+}
+
+class DisconnectReason extends OmuError {
+  type;
+  message;
+  constructor(type, message = "") {
+    super(message);
+    this.type = type;
+    this.message = message;
+  }
+}
+
+class ServerRestart extends DisconnectReason {
+  constructor(message) {
+    super("server_restart" /* SERVER_RESTART */, message);
+  }
+}
+
+class AnotherConnection extends DisconnectReason {
+  constructor(message) {
+    super("another_connection" /* ANOTHER_CONNECTION */, message);
+  }
+}
+
+class PermissionDenied extends DisconnectReason {
+  constructor(message) {
+    super("permission_denied" /* PERMISSION_DENIED */, message);
+  }
+}
+
+class AppRemoved extends DisconnectReason {
+  constructor(message) {
+    super("app_removed" /* APP_REMOVED */, message);
+  }
+}
+
+class InvalidToken extends DisconnectReason {
+  constructor(message) {
+    super("invalid_token" /* INVALID_TOKEN */, message);
+  }
+}
+
+class InvalidOrigin extends DisconnectReason {
+  constructor(message) {
+    super("invalid_origin" /* INVALID_ORIGIN */, message);
+  }
+}
+
+class InvalidVersion extends DisconnectReason {
+  constructor(message) {
+    super("invalid_version" /* INVALID_VERSION */, message);
+  }
+}
+
+class InvalidPacket extends DisconnectReason {
+  constructor(message) {
+    super("invalid_packet" /* INVALID_PACKET */, message);
+  }
+}
+
+class InternalError extends DisconnectReason {
+  constructor(message) {
+    super("internal_error" /* INTERNAL_ERROR */, message);
+  }
+}
+
+// src/event/index.ts
+class EventEmitter {
+  listeners = [];
+  listen(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners.splice(this.listeners.indexOf(listener), 1);
+    };
+  }
+  async emit(...args) {
+    for (const listener of [...this.listeners]) {
+      await listener(...args);
+    }
+  }
+}
+
+// src/version.ts
+var VERSION = "0.9.49";
+
+// src/network/connection.ts
+class PacketMapper {
+  packetMap = new IdentifierMap;
+  register(...packetTypes) {
+    for (const type of packetTypes) {
+      if (this.packetMap.has(type.id)) {
+        throw new Error(`Packet id ${type.id.key()} already registered`);
+      }
+      this.packetMap.set(type.id, type);
+    }
+  }
+  serialize(packet) {
+    return {
+      type: packet.type.id.key(),
+      data: packet.type.serializer.serialize(packet.data)
+    };
+  }
+  deserialize(data) {
+    const identifier = Identifier.fromKey(data.type);
+    const type = this.packetMap.get(identifier);
+    if (!type)
+      throw new Error(`Packet type ${data.type} not registered`);
+    return {
+      type,
+      data: type.serializer.deserialize(data.data)
+    };
+  }
+}
+
+// src/network/encryption.ts
+function base64UrlEncode(buffer) {
+  return buffer.toBase64().replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode(data) {
+  data = data.replace(/-/g, "+").replace(/_/g, "/");
+  while (data.length % 4) {
+    data += "=";
+  }
+  return Uint8Array.fromBase64(data);
+}
+function convertUint8ArrayToArrayBuffer(u8) {
+  const buf = new ArrayBuffer(u8.length);
+  const view = new Uint8Array(buf);
+  view.set(u8);
+  return buf;
+}
+var ENCRYPTION_AVAILABLE = typeof crypto !== "undefined" && !!crypto.subtle;
+
+class Decryptor {
+  privateKey;
+  publicKey;
+  constructor(privateKey, publicKey) {
+    this.privateKey = privateKey;
+    this.publicKey = publicKey;
+  }
+  static async new() {
+    const { privateKey, publicKey } = await crypto.subtle.generateKey({
+      name: "RSA-OAEP",
+      modulusLength: 4096,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: "SHA-256"
+    }, true, ["encrypt", "decrypt"]);
+    return new Decryptor(privateKey, publicKey);
+  }
+  async toRequest() {
+    const key = await crypto.subtle.exportKey("jwk", this.publicKey);
+    if (!key.e)
+      throw new Error("Key export failed: missing exponent");
+    if (!key.n)
+      throw new Error("Key export failed: missing modulus");
+    return {
+      e: key.e,
+      n: key.n
+    };
+  }
+  async decrypt(data) {
+    const decrypted = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, this.privateKey, data);
+    return decrypted;
+  }
+  async decryptString(data) {
+    const decrypted = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, this.privateKey, convertUint8ArrayToArrayBuffer(base64UrlDecode(data)));
+    return textDecoder.decode(decrypted);
+  }
+}
+
+class Encryptor {
+  publicKey;
+  constructor(publicKey) {
+    this.publicKey = publicKey;
+  }
+  static async new(request) {
+    const publicKey = await crypto.subtle.importKey("jwk", {
+      alg: "RSA-OAEP-256",
+      ext: true,
+      key_ops: ["encrypt"],
+      kty: "RSA",
+      e: request.e.replace(/=+$/, ""),
+      n: request.n.replace(/=+$/, "")
+    }, {
+      name: "RSA-OAEP",
+      hash: "SHA-256"
+    }, true, ["encrypt"]);
+    return new Encryptor(publicKey);
+  }
+  async encrypt(data) {
+    return await crypto.subtle.encrypt({
+      name: "RSA-OAEP"
+    }, this.publicKey, data);
+  }
+  async encryptString(data) {
+    const encrypted = await crypto.subtle.encrypt({
+      name: "RSA-OAEP"
+    }, this.publicKey, textEncoder.encode(data));
+    return base64UrlEncode(new Uint8Array(encrypted));
+  }
+}
+
+class AES {
+  key;
+  iv;
+  constructor(key, iv) {
+    this.key = key;
+    this.iv = iv;
+  }
+  static async new() {
+    const key = await crypto.subtle.generateKey({
+      name: "AES-CBC",
+      length: 128
+    }, true, ["encrypt", "decrypt"]);
+    const iv = crypto.getRandomValues(new Uint8Array(16));
+    return new AES(key, iv.buffer);
+  }
+  static async deserialize(aes, decryptor) {
+    const decrypted = await decryptor.decrypt(convertUint8ArrayToArrayBuffer(base64UrlDecode(aes)));
+    const reader = ByteReader.fromArrayBuffer(decrypted);
+    const key = reader.readUint8Array();
+    const iv = reader.readUint8Array();
+    const key_encoded = await crypto.subtle.importKey("raw", convertUint8ArrayToArrayBuffer(key), "AES-CBC", false, ["encrypt", "decrypt"]);
+    return new AES(key_encoded, convertUint8ArrayToArrayBuffer(iv));
+  }
+  async serialize(encryptor) {
+    const writer = new ByteWriter;
+    const rawKey = await crypto.subtle.exportKey("raw", this.key);
+    writer.writeUint8Array(new Uint8Array(rawKey));
+    writer.writeUint8Array(new Uint8Array(this.iv));
+    const encrypted = await encryptor.encrypt(convertUint8ArrayToArrayBuffer(writer.finish()));
+    return base64UrlEncode(new Uint8Array(encrypted));
+  }
+  async encrypt(data) {
+    const writer = new ByteWriter;
+    writer.writeString(data.type);
+    writer.writeUint8Array(data.data);
+    const encrypted = await crypto.subtle.encrypt({
+      name: "AES-CBC",
+      iv: this.iv,
+      length: 16
+    }, this.key, convertUint8ArrayToArrayBuffer(writer.finish()));
+    return PACKET_TYPES.ENCRYPTED_PACKET.new(new Uint8Array(encrypted));
+  }
+  async decrypt(packet) {
+    const decrypted = await crypto.subtle.decrypt({
+      name: "AES-CBC",
+      iv: this.iv,
+      length: 16
+    }, this.key, convertUint8ArrayToArrayBuffer(packet.data));
+    const reader = ByteReader.fromArrayBuffer(decrypted);
+    const type = reader.readString();
+    const data = reader.readUint8Array();
+    return {
+      type,
+      data
+    };
+  }
+}
+
+// src/network/network.ts
+class Network {
+  omu;
+  address;
+  tokenProvider;
+  transport;
+  connection;
+  aes;
+  status = { type: "disconnected" };
+  event = {
+    connected: new EventEmitter,
+    disconnected: new EventEmitter,
+    packet: new EventEmitter,
+    status: new EventEmitter
+  };
+  tasks = [];
+  packetMapper = new PacketMapper;
+  packetHandlers = new IdentifierMap;
+  listenTask = undefined;
+  reason = undefined;
+  attempt = 0;
+  constructor(omu, address, tokenProvider, transport, connection, aes) {
+    this.omu = omu;
+    this.address = address;
+    this.tokenProvider = tokenProvider;
+    this.transport = transport;
+    this.connection = connection;
+    this.aes = aes;
+    this.registerPacket(PACKET_TYPES.SERVER_META, PACKET_TYPES.CONNECT, PACKET_TYPES.DISCONNECT, PACKET_TYPES.TOKEN, PACKET_TYPES.READY, PACKET_TYPES.ENCRYPTED_PACKET);
+    this.addPacketHandler(PACKET_TYPES.DISCONNECT, async (reason) => {
+      if (reason.type === "shutdown" /* SHUTDOWN */ || reason.type === "close" /* CLOSE */) {
+        this.setStatus({ type: "disconnected" });
+        return;
+      }
+      const ERROR_MAP = {
+        ["another_connection" /* ANOTHER_CONNECTION */]: AnotherConnection,
+        ["permission_denied" /* PERMISSION_DENIED */]: PermissionDenied,
+        ["app_removed" /* APP_REMOVED */]: AppRemoved,
+        ["invalid_token" /* INVALID_TOKEN */]: InvalidToken,
+        ["invalid_origin" /* INVALID_ORIGIN */]: InvalidOrigin,
+        ["invalid_version" /* INVALID_VERSION */]: InvalidVersion,
+        ["internal_error" /* INTERNAL_ERROR */]: InternalError,
+        ["invalid_packet" /* INVALID_PACKET */]: InvalidPacket,
+        ["invalid_packet_type" /* INVALID_PACKET_TYPE */]: InvalidPacket,
+        ["invalid_packet_data" /* INVALID_PACKET_DATA */]: InvalidPacket,
+        ["server_restart" /* SERVER_RESTART */]: ServerRestart,
+        ["close" /* CLOSE */]: undefined,
+        ["shutdown" /* SHUTDOWN */]: undefined
+      };
+      const error = ERROR_MAP[reason.type];
+      if (error) {
+        this.reason = new error(reason.message ?? "");
+      }
+    });
+    this.addPacketHandler(PACKET_TYPES.READY, () => {
+      if (this.status.type === "ready") {
+        throw new Error("Received READY packet when already ready");
+      }
+      this.setStatus({ type: "ready" });
+      this.attempt = 0;
+    });
+  }
+  setConnection(connection) {
+    if (this.status.type !== "disconnected") {
+      throw new Error("Cannot change connection while connected");
+    }
+    this.connection = connection;
+  }
+  registerPacket(...packetTypes) {
+    this.packetMapper.register(...packetTypes);
+    for (const type of packetTypes) {
+      this.packetHandlers.set(type.id, {
+        type,
+        event: new EventEmitter
+      });
+    }
+  }
+  addPacketHandler(type, handler) {
+    const listeners = this.packetHandlers.get(type.id);
+    if (!listeners) {
+      throw new Error(`Packet type ${type.id.key()} not registered`);
+    }
+    listeners.event.listen(handler);
+  }
+  async scheduleReconnect(attempt) {
+    const timeout = Math.min(30000, 2000 * (Math.pow(1.5, attempt) - 1) + 2000);
+    const date = new Date;
+    let cancelled = false;
+    const status = {
+      type: "reconnecting",
+      attempt,
+      timeout,
+      date,
+      cancel: () => {
+        cancelled = true;
+      }
+    };
+    await this.setStatus(status);
+    if (cancelled) {
+      return false;
+    }
+    const remaining = status.timeout - (new Date().getTime() - date.getTime());
+    await new Promise((resolve) => setTimeout(resolve, remaining));
+    return true;
+  }
+  async connect(reconnect = true) {
+    if (!this.isState("disconnected")) {
+      throw new Error(`Cannot connect while ${this.status.type}`);
+    }
+    if (this.listenTask) {
+      throw new Error("Cannot connect while already connecting");
+    }
+    this.attempt = 0;
+    while (this.omu.running) {
+      this.attempt++;
+      try {
+        this.aes = undefined;
+        this.connection = await this.transport.connect();
+        await this.setStatus({ type: "connecting" });
+        const metaReceived = await this.connection.receive(this.packetMapper);
+        if (!metaReceived) {
+          throw new Error("Connection closed before receiving server meta");
+        }
+        if (!PACKET_TYPES.SERVER_META.match(metaReceived)) {
+          throw new Error("First packet received was not server meta");
+        }
+        const { data: meta } = metaReceived;
+        this.address.hash = meta.hash;
+        let token = await this.tokenProvider.get(this.address, this.omu.app);
+        if (!token) {
+          throw new InvalidToken(`No token available for app ${this.omu.app.id.key()} at ${this.address.host}:${this.address.port}:${this.address.hash}`);
+        }
+        let encryptionResp = undefined;
+        if (this.omu.app.type === "remote" && ENCRYPTION_AVAILABLE && meta.encryption) {
+          const decryptor = await Decryptor.new();
+          const encryptor = await Encryptor.new(meta.encryption.rsa);
+          if (token) {
+            token = await encryptor.encryptString(token);
+          }
+          this.aes = await AES.new();
+          encryptionResp = {
+            kind: "v1",
+            rsa: await decryptor.toRequest(),
+            aes: await this.aes.serialize(encryptor)
+          };
+        }
+        this.connection.send({
+          type: PACKET_TYPES.CONNECT,
+          data: new ConnectPacket({
+            app: this.omu.app,
+            protocol: { version: VERSION },
+            encryption: encryptionResp,
+            token
+          })
+        }, this.packetMapper);
+        this.listenTask = this.listen();
+        await this.setStatus({ type: "connected" });
+        await this.event.connected.emit();
+        this.dispatchTasks().then(() => {
+          this.send({
+            type: PACKET_TYPES.READY,
+            data: null
+          });
+        });
+        await this.listenTask;
+      } catch (error) {
+        if (error instanceof DisconnectReason) {
+          this.reason = error;
+        }
+        if (!reconnect) {
+          throw error;
+        }
+      } finally {
+        this.event.disconnected.emit(this.reason);
+        if (this.status.type !== "disconnected" && this.status.type !== "reconnecting") {
+          this.setStatus({ type: "disconnected", attempt: this.attempt, reason: this.reason });
+        }
+        this.connection?.close();
+        this.connection = undefined;
+        this.listenTask = undefined;
+      }
+      if (this.reason && ![
+        "shutdown" /* SHUTDOWN */,
+        "server_restart" /* SERVER_RESTART */
+      ].includes(this.reason.type)) {
+        break;
+      }
+      this.reason = undefined;
+      if (!reconnect) {
+        break;
+      }
+      const shouldReconnect = await this.scheduleReconnect(this.attempt);
+      if (!shouldReconnect) {
+        break;
+      }
+    }
+    await this.setStatus({ type: "disconnected", reason: this.reason });
+    this.connection?.close();
+    this.connection = undefined;
+  }
+  isState(state) {
+    return this.status.type === state;
+  }
+  async send(packet) {
+    if (!this.connection) {
+      throw new Error("No connection established");
+    }
+    if (this.aes) {
+      const serialized = this.packetMapper.serialize(packet);
+      packet = await this.aes.encrypt(serialized);
+    }
+    this.connection.send(packet, this.packetMapper);
+  }
+  async listen() {
+    while (this.connection) {
+      const packet = await this.connection.receive(this.packetMapper);
+      if (!packet) {
+        break;
+      }
+      await this.dispatchPacket(packet);
+    }
+  }
+  async dispatchPacket(packet) {
+    if (PACKET_TYPES.ENCRYPTED_PACKET.match(packet)) {
+      if (!this.aes) {
+        throw new Error("Received encrypted packet before encryption was established");
+      }
+      const decrypted = await this.aes.decrypt(packet);
+      packet = this.packetMapper.deserialize(decrypted);
+    }
+    await this.event.packet.emit(packet);
+    const packetHandler = this.packetHandlers.get(packet.type.id);
+    if (!packetHandler) {
+      return;
+    }
+    await packetHandler.event.emit(packet.data);
+  }
+  addTask(task) {
+    if (this.omu.running) {
+      throw new Error("Cannot add task after client is ready");
+    }
+    this.tasks.push(task);
+  }
+  removeTask(task) {
+    this.tasks.splice(this.tasks.indexOf(task), 1);
+  }
+  async dispatchTasks() {
+    for (const task of this.tasks) {
+      await task();
+    }
+  }
+  async setStatus(status) {
+    if (this.status === status) {
+      throw new Error(`Cannot set status to ${status} when already ${status}`);
+    }
+    this.status = status;
+    await this.event.status.emit(status);
+  }
+  close() {
+    this.setStatus({ type: "disconnected" });
+    this.attempt = 0;
+  }
+}
+// src/network/websocket-transport.ts
+class WebsocketTransport {
+  address;
+  constructor(address) {
+    this.address = address;
+  }
+  get wsEndpoint() {
+    const protocol = this.address.secure ? "wss" : "ws";
+    const { host, port } = this.address;
+    return `${protocol}://${host}:${port}/ws`;
+  }
+  connect() {
+    const socket = new WebSocket(this.wsEndpoint);
+    return WebsocketConnection.fromSocket(socket);
+  }
+}
+
+class WebsocketConnection {
+  socket;
+  packetQueue = [];
+  receiveWaiter = null;
+  readingPromise = null;
+  beingClosed = false;
+  constructor(socket) {
+    this.socket = socket;
+  }
+  static fromSocket(socket) {
+    const connection = new WebsocketConnection(socket);
+    return new Promise((resolve, reject) => {
+      socket.onerror = reject;
+      socket.onclose = () => {
+        connection.beingClosed = true;
+        if (connection.receiveWaiter) {
+          connection.receiveWaiter();
+          connection.receiveWaiter = null;
+        }
+      };
+      socket.onmessage = (event) => {
+        connection.readingPromise = connection.onMessage(event).finally(() => {
+          connection.readingPromise = null;
+        });
+      };
+      socket.onopen = () => {
+        resolve(connection);
+      };
+    });
+  }
+  async onMessage(event) {
+    if (typeof event.data === "string") {
+      throw new Error("Received string data");
+    }
+    const reader = await ByteReader.fromBlob(event.data);
+    const data = {
+      type: reader.readString(),
+      data: reader.readUint8Array()
+    };
+    this.packetQueue.push(data);
+    reader.finish();
+    if (this.receiveWaiter) {
+      this.receiveWaiter();
+    }
+  }
+  async receive(serializer) {
+    if (this.receiveWaiter) {
+      throw new Error("Already receiving");
+    }
+    while (this.packetQueue.length === 0 && !this.beingClosed) {
+      await new Promise((resolve) => {
+        this.receiveWaiter = resolve;
+      });
+      this.receiveWaiter = null;
+    }
+    if (this.packetQueue.length === 0 && this.beingClosed) {
+      return null;
+    }
+    const packetData = this.packetQueue.shift();
+    return serializer.deserialize(packetData);
+  }
+  get closed() {
+    if (this.readingPromise) {
+      return false;
+    }
+    if (this.packetQueue.length > 0) {
+      return false;
+    }
+    if (this.receiveWaiter) {
+      return false;
+    }
+    if (this.socket.readyState !== WebSocket.CLOSED && this.socket.readyState !== WebSocket.CLOSING) {
+      return false;
+    }
+    return true;
+  }
+  close() {
+    if (this.socket) {
+      this.socket.close();
+    }
+    if (this.receiveWaiter) {
+      this.receiveWaiter();
+      this.receiveWaiter = null;
+    }
+  }
+  send(packet, serializer) {
+    const packetData = serializer.serialize(packet);
+    const writer = new ByteWriter;
+    writer.writeString(packetData.type);
+    writer.writeUint8Array(packetData.data);
+    this.socket.send(writer.finish());
+  }
+}
+export {
+  WebsocketTransport,
+  Network,
+  FrameTransport
+};
+
+//# debugId=B6141139050B2B3264756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/const.ts", "../../src/serialize/bytebuffer.ts", "../../src/serialize/serializer.ts", "../../src/network/frame-transport.ts", "../../src/identifier.ts", "../../src/app.ts", "../../src/network/packet/packet.ts", "../../src/network/packet/packet-types.ts", "../../src/errors.ts", "../../src/event/index.ts", "../../src/version.ts", "../../src/network/connection.ts", "../../src/network/encryption.ts", "../../src/network/network.ts", "../../src/network/websocket-transport.ts"],
  "sourcesContent": [
    "export const textEncoder: TextEncoder = new TextEncoder();\nexport const textDecoder: TextDecoder = new TextDecoder();\n",
    "import { textDecoder, textEncoder } from '../const.js';\nimport { JsonType } from './serializer.js';\n\nexport class Flags {\n    private value: number;\n    private length: number;\n\n    constructor(options: { value?: number; length?: number }) {\n        this.value = options.value ?? 0;\n        this.length = options.length ?? 32;\n    }\n\n    public has(position: number): boolean {\n        return (this.value & (1 << position)) !== 0;\n    }\n\n    public get(position: number): boolean {\n        return (this.value & (1 << position)) !== 0;\n    }\n\n    public ifSet<T>(position: number, callback: () => T): T | undefined {\n        if (this.has(position)) {\n            return callback();\n        }\n        return undefined;\n    }\n\n    public set(position: number, value: boolean): void {\n        if (value) {\n            this.value |= 1 << position;\n        } else {\n            this.value &= ~(1 << position);\n        }\n    }\n\n    public write(writer: ByteWriter): void {\n        const bits = new Uint8Array((this.length + 7) / 8);\n        for (let i = 0; i < bits.length; i++) {\n            bits[i] = (this.value >> (i * 8)) & 0xff;\n        }\n        writer.write(bits);\n    }\n\n    public static read(reader: ByteReader, length: number): Flags {\n        let value = 0;\n        for (let i = 0; i < (length + 7) / 8; i++) {\n            value |= reader.readUint8() << (i * 8);\n        }\n        return new Flags({ value, length });\n    }\n}\n\nfunction readFloat16(dataView: DataView, offset: number): number {\n    const sign = (dataView.getUint16(offset) & 0x8000) ? -1 : 1;\n    const exponent = (dataView.getUint16(offset) & 0x7c00) >> 10;\n    const mantissa = (dataView.getUint16(offset) & 0x03ff);\n    if (exponent === 0 && mantissa === 0) {\n        return 0;\n    } else if (exponent === 0x1f) {\n        return mantissa === 0 ? Infinity * sign : NaN;\n    } else {\n        const normalizedExponent = exponent - 15;\n        const normalizedMantissa = mantissa / 1024;\n        return sign * Math.pow(2, normalizedExponent) * (1 + normalizedMantissa);\n    }\n}\n\nfunction writeFloat16(dataView: DataView, offset: number, value: number): void {\n    if (value === 0) {\n        dataView.setUint16(offset, 0);\n        return;\n    }\n    const sign = value < 0 ? 1 : 0;\n    value = Math.abs(value);\n    if (!isFinite(value)) {\n        dataView.setUint16(offset, 0x7c00 | (sign << 15));\n        return;\n    }\n    const exponent = Math.floor(Math.log2(value));\n    const mantissa = value / Math.pow(2, exponent) - 1;\n    const normalizedExponent = exponent + 15;\n    const normalizedMantissa = Math.round(mantissa * 1024);\n    if (normalizedExponent <= 0) {\n        dataView.setUint16(offset, sign << 15);\n    } else if (normalizedExponent >= 0x1f) {\n        dataView.setUint16(offset, 0x7c00 | (sign << 15));\n    } else {\n        dataView.setUint16(offset, (sign << 15) | (normalizedExponent << 10) | normalizedMantissa);\n    }\n}\n\nexport class ByteWriter {\n    private dataView: DataView;\n    private buffer: ArrayBuffer;\n    private offset = 0;\n    private finished = false;\n\n    constructor(init?: ArrayBuffer, offset?: number) {\n        this.offset = offset ?? 0;\n        this.buffer = init ?? new ArrayBuffer(1024);\n        this.dataView = new DataView(this.buffer);\n    }\n\n    public static fromUint8Array(buffer: Uint8Array): ByteWriter {\n        const arrayBuffer = new ArrayBuffer(buffer.byteLength);\n        const uint8Array = new Uint8Array(arrayBuffer);\n        uint8Array.set(new Uint8Array(buffer));\n        return new ByteWriter(arrayBuffer, buffer.byteLength);\n    }\n\n    private allocate(length: number): void {\n        if (this.offset + length > this.buffer.byteLength) {\n            const newByteLength = Math.max(this.buffer.byteLength * 2, this.offset + length);\n            const newBuffer = new ArrayBuffer(newByteLength);\n            new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));\n            this.buffer = newBuffer;\n            this.dataView = new DataView(this.buffer);\n        }\n    }\n\n    public write(data: Uint8Array): ByteWriter {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        this.allocate(data.length);\n        new Uint8Array(this.buffer).set(data, this.offset);\n        this.offset += data.length;\n        return this;\n    }\n\n    public writeBoolean(value: boolean): ByteWriter {\n        this.allocate(1);\n        this.dataView.setInt8(this.offset, value ? 1 : 0);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeInt8(value: number): ByteWriter {\n        this.allocate(1);\n        this.dataView.setInt8(this.offset, value);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeUint8(value: number): ByteWriter {\n        this.allocate(1);\n        this.dataView.setUint8(this.offset, value);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeInt16(value: number): ByteWriter {\n        this.allocate(2);\n        this.dataView.setInt16(this.offset, value);\n        this.offset += 2;\n        return this;\n    }\n\n    public writeUint16(value: number): ByteWriter {\n        this.allocate(2);\n        this.dataView.setUint16(this.offset, value);\n        this.offset += 2;\n        return this;\n    }\n\n    public writeInt32(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setInt32(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeUint32(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setUint32(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeInt64(value: bigint): ByteWriter {\n        this.allocate(8);\n        this.dataView.setBigInt64(this.offset, value);\n        this.offset += 8;\n        return this;\n    }\n\n    public writeUint64(value: bigint): ByteWriter {\n        this.allocate(8);\n        this.dataView.setBigUint64(this.offset, value);\n        this.offset += 8;\n        return this;\n    }\n\n    public writeULEB128(value: number): ByteWriter {\n        // Unsigned LEB128\n        if (value < 0) {\n            throw new Error('Value must be non-negative');\n        }\n        while (value > 0x7f) {\n            this.allocate(1);\n            this.dataView.setUint8(this.offset, (value & 0x7f) | 0x80);\n            this.offset += 1;\n            value >>= 7;\n        }\n        this.allocate(1);\n        this.dataView.setUint8(this.offset, value & 0x7f);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeFloat16(value: number): ByteWriter {\n        this.allocate(2);\n        writeFloat16(this.dataView, this.offset, value);\n        this.offset += 2;\n        return this;\n    }\n\n    public writeFloat32(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setFloat32(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeFloat64(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setFloat64(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeUint8Array(value: Uint8Array): ByteWriter {\n        this.writeULEB128(value.byteLength);\n        this.write(value);\n        return this;\n    }\n\n    public writeString(value: string): ByteWriter {\n        this.writeUint8Array(textEncoder.encode(value));\n        return this;\n    }\n\n    public writeJSON(value: JsonType): ByteWriter {\n        this.writeString(JSON.stringify(value));\n        return this;\n    }\n\n    public writeFlags(flags: Flags): ByteWriter {\n        flags.write(this);\n        return this;\n    }\n\n    public finish(): Uint8Array {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        this.finished = true;\n        return new Uint8Array(this.buffer, 0, this.offset);\n    }\n\n    public toUint8Array(): Uint8Array {\n        return new Uint8Array(this.buffer, 0, this.offset);\n    }\n\n    public toArrayBuffer(): ArrayBuffer {\n        return this.buffer.slice(0, this.offset);\n    }\n}\n\nexport class ByteReader {\n    private dataView: DataView;\n    private offset: number;\n    private finished: boolean;\n\n    private constructor(data: DataView) {\n        this.dataView = data;\n        this.offset = 0;\n        this.finished = false;\n    }\n\n    public static fromUint8Array(buffer: Uint8Array): ByteReader {\n        const arrayBuffer = new ArrayBuffer(buffer.byteLength);\n        const uint8Array = new Uint8Array(arrayBuffer);\n        uint8Array.set(new Uint8Array(buffer));\n        const dataView = new DataView(arrayBuffer);\n        return new ByteReader(dataView);\n    }\n\n    public static fromArrayBuffer(buffer: ArrayBuffer): ByteReader {\n        const dataView = new DataView(buffer);\n        return new ByteReader(dataView);\n    }\n\n    public static async fromBlob(blob: Blob): Promise<ByteReader> {\n        const arrayBuffer = await blob.arrayBuffer();\n        const dataView = new DataView(arrayBuffer);\n        return new ByteReader(dataView);\n    }\n\n    public read(size: number): Uint8Array {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        if (size < 0) {\n            throw new Error('Size must be positive');\n        }\n        if (this.offset + size > this.dataView.byteLength) {\n            throw new Error('Buffer not fully read');\n        }\n        const value = new Uint8Array(this.dataView.buffer, this.offset, size);\n        this.offset += size;\n        return value;\n    }\n\n    public readBoolean(): boolean {\n        const value = this.dataView.getInt8(this.offset);\n        this.offset += 1;\n        return value !== 0;\n    }\n\n    public readInt8(): number {\n        const value = this.dataView.getInt8(this.offset);\n        this.offset += 1;\n        return value;\n    }\n\n    public readUint8(): number {\n        const value = this.dataView.getUint8(this.offset);\n        this.offset += 1;\n        return value;\n    }\n\n    public readInt16(): number {\n        const value = this.dataView.getInt16(this.offset);\n        this.offset += 2;\n        return value;\n    }\n\n    public readUint16(): number {\n        const value = this.dataView.getUint16(this.offset);\n        this.offset += 2;\n        return value;\n    }\n\n    public readInt32(): number {\n        const value = this.dataView.getInt32(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    public readUint32(): number {\n        const value = this.dataView.getUint32(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    public readInt64(): bigint {\n        const value = this.dataView.getBigInt64(this.offset);\n        this.offset += 8;\n        return value;\n    }\n\n    public readUint64(): bigint {\n        const value = this.dataView.getBigUint64(this.offset);\n        this.offset += 8;\n        return value;\n    }\n\n    public readULEB128(): number {\n        // Unsigned LEB128\n        let value = 0;\n        let shift = 0;\n        let byte: number;\n        do {\n            if (this.offset >= this.dataView.byteLength) {\n                throw new Error('Buffer not fully read');\n            }\n            byte = this.dataView.getUint8(this.offset);\n            this.offset += 1;\n            value |= (byte & 0b01111111) << shift;\n            shift += 7;\n        }\n        while ((byte & 0b10000000) !== 0);\n        return value;\n    }\n\n    public readFloat16(): number {\n        const value = readFloat16(this.dataView, this.offset);\n        this.offset += 2;\n        return value;\n    }\n\n    public readFloat32(): number {\n        const value = this.dataView.getFloat32(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    public readFloat64(): number {\n        const value = this.dataView.getFloat64(this.offset);\n        this.offset += 8;\n        return value;\n    }\n\n    public readUint8Array(): Uint8Array {\n        const length = this.readULEB128();\n        return this.read(length);\n    }\n\n    public readString(): string {\n        const byteArray = this.readUint8Array();\n        return textDecoder.decode(byteArray);\n    }\n\n    public readJSON<T extends JsonType>(): T {\n        return JSON.parse(this.readString());\n    }\n\n    public readFlags(length: number): Flags {\n        return Flags.read(this, length);\n    }\n\n    public finish(): void {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        this.finished = true;\n        if (this.offset !== this.dataView.byteLength) {\n            throw new Error('Buffer not fully read');\n        }\n    }\n}\n",
    "import { textDecoder, textEncoder } from '../const.js';\n\nexport type JsonType = string | number | boolean | null | undefined | { [key in never]?: JsonType } | JsonType[];\n\nexport interface Serializable<T, D> {\n    serialize(data: T): D;\n    deserialize(data: D): T;\n}\n\nexport class Serializer<T, D> {\n    constructor(\n        public serialize: (data: T) => D,\n        public deserialize: (data: D) => T,\n    ) { }\n\n    public static of<T, D>(serializer: Serializable<T, D>): Serializer<T, D> {\n        return new Serializer<T, D>(serializer.serialize, serializer.deserialize);\n    }\n\n    public static pipe<T, R, D>(ser1: Serializable<T, R>, ser2: Serializable<R, D>): Serializable<T, D> {\n        return new Serializer<T, D>(\n            (data) => ser2.serialize(ser1.serialize(data)),\n            (data) => ser1.deserialize(ser2.deserialize(data)),\n        );\n    }\n\n    public static transform<T>(func: (value: T) => T): Serializer<T, T> {\n        return new Serializer<T, T>(\n            func,\n            func,\n        );\n    }\n\n    public static noop<T>(): Serializer<T, T> {\n        return new Serializer<T, T>(\n            (data) => data,\n            (data) => data,\n        );\n    }\n\n    public field<\n        K extends keyof D,\n        R,\n    >(\n        key: K,\n        serializer: Serializable<D[K], R>,\n    ): Serializer<\n        T,\n        { [P in keyof D]: P extends K ? R : D[P] }\n    > {\n        return new Serializer<\n            T,\n            { [P in keyof D]: P extends K ? R : D[P] }\n        >(\n            (data) => {\n                const serialized = this.serialize(data);\n                return {\n                    ...serialized,\n                    [key]: serializer.serialize(serialized[key]),\n                } as { [P in keyof D]: P extends K ? R : D[P] };\n            },\n            (data) => {\n                return this.deserialize({\n                    ...data,\n                    [key]: serializer.deserialize(data[key] as R),\n                } as D);\n            },\n        );\n    }\n\n    static json<T extends JsonType>(): Serializer<T, Uint8Array> {\n        return new Serializer<T, Uint8Array>(\n            (data) => textEncoder.encode(JSON.stringify(data)),\n            (data) => {\n                const text = textDecoder.decode(data);\n                return JSON.parse(text);\n            },\n        );\n    }\n\n    public toJson(): Serializer<T, Uint8Array> {\n        return new Serializer<T, Uint8Array>(\n            (data) => textEncoder.encode(JSON.stringify(this.serialize(data))),\n            (data) => {\n                const text = textDecoder.decode(data);\n                return this.deserialize(JSON.parse(text));\n            },\n        );\n    }\n\n    public toArray(): Serializer<T[], D[]> {\n        return new Serializer<T[], D[]>(\n            (data) => data.map((item) => this.serialize(item)),\n            (data) => data.map((item) => this.deserialize(item)),\n        );\n    }\n\n    public toMap(): Serializer<Map<string, T>, Map<string, D>> {\n        return new Serializer<Map<string, T>, Map<string, D>>(\n            (data) => {\n                const result = new Map<string, D>();\n                data.forEach((value, key) => {\n                    result.set(key, this.serialize(value));\n                });\n                return result;\n            },\n            (data) => {\n                const result = new Map<string, T>();\n                data.forEach((value, key) => {\n                    result.set(key, this.deserialize(value));\n                });\n                return result;\n            },\n        );\n    }\n\n    public fallback(fallback: T): Serializer<T, D> {\n        return new Serializer<T, D>(\n            (data) => this.serialize(data),\n            (data) => {\n                try {\n                    return this.deserialize(data);\n                } catch {\n                    return fallback;\n                }\n            },\n        );\n    }\n\n    public fallbackMap(fallback: (data: D, error: unknown) => T): Serializer<T, D> {\n        return new Serializer<T, D>(\n            (data) => this.serialize(data),\n            (data) => {\n                try {\n                    return this.deserialize(data);\n                } catch (error) {\n                    return fallback(data, error);\n                }\n            },\n        );\n    }\n\n    public pipe<E>(serializer: Serializable<D, E>): Serializer<T, E> {\n        return new Serializer<T, E>(\n            (data) => serializer.serialize(this.serialize(data)),\n            (data) => this.deserialize(serializer.deserialize(data)),\n        );\n    }\n}\n",
    "\nimport type { Serializable } from '../serialize';\nimport { ByteReader, ByteWriter } from '../serialize';\n\nimport type { Connection, Transport } from './connection.js';\nimport type { Packet, PacketData } from './packet/packet.js';\n\nconst FRAME_TYPE_KEY = 'omuapps-frame';\n\ntype Command = ({\n    type: 'syn';\n    payload: {\n        origin: string;\n    };\n} | {\n    type: 'connect';\n    payload: object;\n} | {\n    type: 'disconnect';\n    payload: object;\n} | {\n    type: 'send';\n    payload: Uint8Array;\n} | {\n    type: 'receive';\n    payload: Uint8Array;\n} | {\n    type: 'error';\n    payload: string;\n}) & {\n    type_key?: string;\n};\n\nexport class FrameTransport implements Transport {\n    public connect(): Promise<FrameConnection> {\n        return FrameConnection.create();\n    }\n}\n\nexport class FrameConnection implements Connection {\n    public connected: boolean;\n    private origin: string | null = null;\n    private readonly packetQueue: Array<PacketData> = [];\n    private readonly sendQueue: Array<Command> = [];\n    private receiveWaiter: (() => void) | null = null;\n\n    constructor(\n        private connectedWaiter: (() => void) | null,\n    ) {\n        this.connected = false;\n        window.addEventListener('message', (event) => {\n            if (event.data === null || typeof event.data !== 'object') {\n                return;\n            }\n            if (!('type_key' in event.data) || event.data.type_key !== FRAME_TYPE_KEY) {\n                return;\n            }\n            const command = event.data as Command;\n            if (command.type === 'syn') {\n                this.origin = event.origin;\n            }\n            if (event.origin !== this.origin) {\n                return;\n            }\n            this.handleCommand(command);\n        });\n    }\n\n    public static create(): Promise<FrameConnection> {\n        return new Promise<FrameConnection>((resolve) => {\n            const connection = new FrameConnection((): void => resolve(connection));\n            connection.postCommand({\n                type: 'connect',\n                payload: {},\n            });\n        });\n    }\n\n    private handleCommand(command: Command): void {\n        const { type, payload } = command;\n        switch (type) {\n            case 'syn':\n                this.origin = payload.origin;\n                this.postCommand({\n                    type: 'syn',\n                    payload: {\n                        origin: window.origin,\n                    },\n                });\n                break;\n            case 'connect':\n                this.connected = true;\n                if (this.connectedWaiter) {\n                    this.connectedWaiter();\n                    this.connectedWaiter = null;\n                }\n                break;\n            case 'disconnect':\n                this.connected = false;\n                break;\n            case 'receive': {\n                const reader = ByteReader.fromUint8Array(payload);\n                this.packetQueue.push({\n                    type: reader.readString(),\n                    data: reader.readUint8Array(),\n                });\n                reader.finish();\n                if (this.receiveWaiter) {\n                    this.receiveWaiter();\n                }\n                break;\n            }\n            case 'error':\n                throw new Error(payload);\n            case 'send':\n                break;\n            default:\n                throw new Error(`Unknown command type: ${type}`);\n        }\n    }\n\n    private postCommand(command: Command): void {\n        command.type_key = FRAME_TYPE_KEY;\n        if (!this.origin) {\n            this.sendQueue.push(command);\n            return;\n        }\n        for (const queuedCommand of this.sendQueue) {\n            window.parent.postMessage(queuedCommand, this.origin);\n        }\n        this.sendQueue.length = 0;\n        window.parent.postMessage(command, this.origin);\n    }\n\n    public async receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null> {\n        if (this.receiveWaiter) {\n            throw new Error('Already receiving');\n        }\n        if (!this.connected) {\n            return null;\n        }\n        while (this.packetQueue.length === 0 && this.connected) {\n            await new Promise<void>((resolve) => {\n                this.receiveWaiter = (): void => resolve();\n            });\n        }\n        if (!this.connected) {\n            return null;\n        }\n        const packet = serializer.deserialize(this.packetQueue.shift()!);\n        this.receiveWaiter = null;\n        return packet;\n    }\n\n    get closed(): boolean {\n        return !this.connected;\n    }\n\n    close(): void {\n        if (this.connected) {\n            this.postCommand({\n                type: 'disconnect',\n                payload: {},\n            });\n        }\n        this.connected = false;\n        if (this.receiveWaiter) {\n            this.receiveWaiter();\n            this.receiveWaiter = null;\n        }\n    }\n\n    send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void {\n        if (!this.connected) {\n            throw new Error('Not connected');\n        }\n        const packetData = serializer.serialize(packet);\n        const writer = new ByteWriter();\n        writer.writeString(packetData.type);\n        writer.writeUint8Array(packetData.data);\n        this.postCommand({\n            type: 'send',\n            payload: writer.finish(),\n        });\n    }\n}\n",
    "import type { ExtensionType } from './api';\nimport { App } from './app';\n\nconst NAMESPACE_REGEX = /^(\\.[^/:.]|[\\w-])+$/;\nconst NAME_REGEX = /^[^/:]+$/;\n\nexport type IntoId = Identifier | string | ExtensionType | App;\n\nexport class Identifier {\n    public readonly namespace: string;\n    public readonly path: string[];\n\n    constructor(\n        namespace: string,\n        ...path: string[]\n    ) {\n        Identifier.validate(namespace, path);\n        this.namespace = namespace;\n        this.path = path;\n    }\n\n    public static serialize(identifier: Identifier): string {\n        return identifier.key();\n    }\n\n    public static deserialize(json: string): Identifier {\n        return Identifier.fromJson(json);\n    }\n\n    public static from(id: IntoId): Identifier {\n        if (id instanceof Identifier) {\n            return id;\n        } else if (id instanceof App) {\n            return id.id;\n        } else if (typeof id === 'string') {\n            return Identifier.fromKey(id);\n        } else {\n            // Try to infer\n            // Vite does not preserve class information when importing from different packages\n            const idCasted = id as { namespace: string; path: string[] };\n            if (\n                typeof idCasted.namespace === 'string' &&\n                Array.isArray(idCasted.path) &&\n                idCasted.path.every((p) => typeof p === 'string')\n            ) {\n                return new Identifier(idCasted.namespace, ...idCasted.path);\n            }\n            const idWithId = id as { id: IntoId | undefined };\n            if (typeof idWithId.id !== 'undefined') {\n                return Identifier.from(idWithId.id);\n            }\n            throw new Error(`Cannot convert to Identifier: ${id}`);\n        }\n    }\n\n    public static fromOptional(id: IntoId | undefined | null): Identifier | undefined {\n        if (id === undefined || id === null) {\n            return undefined;\n        }\n        return Identifier.from(id);\n    }\n\n    static validate(namespace: string, path: string[]): void {\n        if (!namespace) {\n            throw new Error('Invalid namespace: Namespace cannot be empty');\n        }\n        if (path.length === 0) {\n            throw new Error('Invalid path: Path must have at least one name');\n        }\n        if (!NAMESPACE_REGEX.test(namespace)) {\n            throw new Error(`Invalid namespace: Namespace must match ${NAMESPACE_REGEX}`);\n        }\n        for (const name of path) {\n            if (!NAME_REGEX.test(name)) {\n                throw new Error(`Invalid path: Name must match ${NAME_REGEX} but got ${name}`);\n            }\n        }\n    }\n\n    static format(namespace: string, ...path: string[]): string {\n        Identifier.validate(namespace, path);\n        return `${namespace}:${path.join('/')}`;\n    }\n\n    static fromKey(key: string): Identifier {\n        const separator = key.indexOf(':');\n        if (separator === -1) {\n            throw new Error(`Invalid key: No separator found in ${key}`);\n        }\n        if (key.indexOf(':', separator + 1) !== -1) {\n            throw new Error(`Invalid key: Multiple separators found in ${key}`);\n        }\n        const namespace = key.slice(0, separator);\n        const path = key.slice(separator + 1);\n        if (!namespace || !path) {\n            throw new Error('Invalid key: Namespace and path cannot be empty');\n        }\n        return new Identifier(namespace, ...path.split('/'));\n    }\n\n    public static fromUrl(url: string | URL): Identifier {\n        const parsedUrl = new URL(url);\n        const namespace = Identifier.namespaceFromUrl(parsedUrl.href);\n        const path = parsedUrl.pathname.slice(1).split('/');\n        return new Identifier(namespace, ...path);\n    }\n\n    public static namespaceFromUrl(url: string | URL): string {\n        const parsed = new URL(url);\n        return parsed.hostname.split('.').reverse().join('.');\n    }\n\n    public get base(): Identifier {\n        return new Identifier(this.namespace, this.path[0]);\n    }\n\n    public toJson(): string {\n        return this.key();\n    }\n\n    static fromJson(json: string): Identifier {\n        return Identifier.fromKey(json);\n    }\n\n    public key(): string {\n        return Identifier.format(this.namespace, ...this.path);\n    }\n\n    public isEqual(other: Identifier): boolean {\n        return this.key() === other.key();\n    }\n\n    public isNamespaceEqual(other: Identifier): boolean {\n        return this.namespace === other.namespace;\n    }\n\n    public isSubpathOf(other: Identifier): boolean {\n        if (this.namespace !== other.namespace) {\n            return false;\n        }\n        if (this.path.length < other.path.length) {\n            return false;\n        }\n        for (let i = 0; i < other.path.length; i++) {\n            if (this.path[i] !== other.path[i]) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    public join(...path: string[]): Identifier {\n        return new Identifier(this.namespace, ...this.path, ...path);\n    }\n}\n\nexport class IdentifierMap<T> {\n    private readonly map: Map<string, T> = new Map();\n    constructor(\n        entries?: Iterable<[Identifier, T]>,\n    ) {\n        if (!entries) return;\n        for (const [id, value] of entries) {\n            this.map.set(id.key(), value);\n        }\n    }\n\n    public get size(): number {\n        return this.map.size;\n    }\n\n    public set(identifier: Identifier, value: T): void {\n        this.map.set(identifier.key(), value);\n    }\n\n    public get(identifier: Identifier): T | undefined {\n        return this.map.get(identifier.key());\n    }\n\n    public has(identifier: Identifier): boolean {\n        return this.map.has(identifier.key());\n    }\n\n    public delete(identifier: Identifier): void {\n        this.map.delete(identifier.key());\n    }\n\n    public clear(): void {\n        this.map.clear();\n    }\n\n    public *keys(): IterableIterator<Identifier> {\n        for (const key of this.map.keys()) {\n            yield Identifier.fromKey(key);\n        }\n    }\n\n    public values(): IterableIterator<T> {\n        return this.map.values();\n    }\n\n    public *entries(): IterableIterator<[Identifier, T]> {\n        for (const [key, value] of this.map.entries()) {\n            yield [Identifier.fromKey(key), value];\n        }\n    }\n\n    public [Symbol.iterator](): IterableIterator<[Identifier, T]> {\n        return this.entries();\n    }\n}\n\nexport class IdentifierSet {\n    private readonly set: Set<string> = new Set();\n\n    public get size(): number {\n        return this.set.size;\n    }\n\n    public add(identifier: Identifier): void {\n        this.set.add(identifier.key());\n    }\n\n    public has(identifier: Identifier): boolean {\n        return this.set.has(identifier.key());\n    }\n\n    public delete(identifier: Identifier): void {\n        this.set.delete(identifier.key());\n    }\n\n    public clear(): void {\n        this.set.clear();\n    }\n\n    public *keys(): IterableIterator<Identifier> {\n        for (const key of this.set.keys()) {\n            yield Identifier.fromKey(key);\n        }\n    }\n\n    public values(): IterableIterator<Identifier> {\n        return this.keys();\n    }\n\n    public *entries(): IterableIterator<[Identifier, Identifier]> {\n        for (const key of this.set.keys()) {\n            const identifier = Identifier.fromKey(key);\n            yield [identifier, identifier];\n        }\n    }\n\n    public [Symbol.iterator](): IterableIterator<[Identifier, Identifier]> {\n        return this.entries();\n    }\n}\n",
    "import { Identifier, IntoId } from './identifier';\nimport type { Locale } from './localization/locale.js';\nimport type { LocalizedText } from './localization/localization.js';\n\nexport type AppMetadata = {\n    locale: Locale;\n    name?: LocalizedText;\n    icon?: LocalizedText;\n    description?: LocalizedText;\n    image?: LocalizedText;\n    site?: LocalizedText;\n    repository?: LocalizedText;\n    authors?: LocalizedText;\n    license?: LocalizedText;\n    tags?: string[];\n};\n\nexport type AppType = 'app' | 'service' | 'remote' | 'plugin' | 'dashboard';\n\nexport type DependencySpecifier = {\n    version: string;\n    index?: string;\n};\n\nexport type AppJson = {\n    id: string;\n    type: AppType;\n    parent_id?: string;\n    version?: string;\n    url?: string;\n    metadata?: AppMetadata;\n    dependencies?: Record<string, DependencySpecifier | string>;\n};\n\nexport class App {\n    public readonly id: Identifier;\n    public readonly type: AppType;\n    public readonly parentId?: Identifier;\n    public readonly version?: string;\n    public readonly url?: string;\n    public readonly metadata?: AppMetadata;\n    public readonly dependencies: Record<string, DependencySpecifier | string>;\n\n    constructor(id: IntoId, options: {\n        type?: AppType;\n        parentId?: IntoId;\n        version?: string;\n        url?: string;\n        metadata?: AppMetadata;\n        dependencies?: Record<string, DependencySpecifier | string>;\n    }) {\n        this.id = Identifier.from(id);\n        this.parentId = Identifier.fromOptional(options.parentId);\n        this.version = options.version;\n        this.url = options.url;\n        this.metadata = options.metadata;\n        this.type = options.type ?? 'app';\n        this.dependencies = options.dependencies ?? {};\n    }\n\n    public static deserialize(info: AppJson): App {\n        const id = Identifier.fromKey(info.id);\n        return new App(id, {\n            parentId: Identifier.fromOptional(info.parent_id),\n            version: info.version,\n            url: info.url,\n            type: info.type,\n            metadata: info.metadata,\n            dependencies: info.dependencies ?? {},\n        });\n    }\n\n    public static serialize(data: App): AppJson {\n        return {\n            id: data.id.key(),\n            type: data.type,\n            parent_id: data.parentId?.key(),\n            version: data.version,\n            url: data.url,\n            metadata: data.metadata,\n            dependencies: data.dependencies,\n        };\n    }\n\n    public join(...paths: string[]): App {\n        return new App(this.id.join(...paths), {\n            parentId: this.parentId,\n            version: this.version,\n            url: this.url,\n            type: this.type,\n            metadata: this.metadata,\n            dependencies: this.dependencies,\n        });\n    }\n}\n",
    "import type { Identifier } from '../../identifier';\nimport { JsonType, type Serializable, Serializer } from '../../serialize';\n\nexport type PacketData = {\n    readonly type: string;\n    readonly data: Uint8Array;\n};\n\nexport type Packet<T = unknown> = {\n    readonly type: PacketType<T>;\n    readonly data: T;\n};\n\nexport class PacketType<T> {\n    constructor(\n        public readonly id: Identifier,\n        public readonly serializer: Serializable<T, Uint8Array>,\n    ) { }\n\n    public new(data: T): Packet<T> {\n        return {\n            type: this,\n            data,\n        };\n    }\n    public match(packet: Packet): packet is Packet<T> {\n        return packet.type === this;\n    }\n\n    static createJson<T, D extends JsonType = JsonType>(identifier: Identifier, {\n        name,\n        serializer,\n    }: {\n        name: string;\n        serializer?: Serializable<T, D>;\n    }): PacketType<T> {\n        return new PacketType<T>(\n            identifier.join(name),\n            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),\n        );\n    }\n\n    static createSerialized<T>(identifier: Identifier, {\n        name,\n        serializer,\n    }: {\n        name: string;\n        serializer: Serializable<T, Uint8Array>;\n    }): PacketType<T> {\n        return new PacketType(\n            identifier.join(name),\n            serializer,\n        );\n    }\n}\n",
    "import type { AppJson } from '../../app.js';\nimport { App } from '../../app.js';\nimport { Identifier } from '../../identifier';\nimport { Serializer } from '../../serialize/serializer.js';\nimport { PacketType } from './packet.js';\n\nconst IDENTIFIER = new Identifier('core', 'packet');\n\ntype ProtocolInfo = {\n    version: string;\n};\n\ntype RSANumbers = {\n    e: string;\n    n: string;\n};\n\ntype EncryptionRequest = {\n    kind: 'v1';\n    rsa: RSANumbers;\n};\n\ntype EncryptionResponse = {\n    kind: 'v1';\n    rsa: RSANumbers;\n    aes: string;\n};\n\nexport type ServerMeta = {\n    protocol: ProtocolInfo;\n    encryption: EncryptionRequest | null;\n    hash: string | undefined;\n};\n\ntype ConnectPacketJson = {\n    protocol: ProtocolInfo;\n    app: AppJson;\n    token: string;\n    encryption: EncryptionResponse | null;\n};\n\nexport class ConnectPacket {\n    public readonly protocol: ProtocolInfo;\n    public readonly app: App;\n    public readonly token: string;\n    public readonly encryption: EncryptionResponse | null;\n\n    constructor(options: {\n        protocol: ProtocolInfo;\n        app: App;\n        token: string;\n        encryption?: EncryptionResponse | null;\n    }) {\n        this.protocol = options.protocol;\n        this.app = options.app;\n        this.token = options.token;\n        this.encryption = options.encryption ?? null;\n    }\n\n    public static deserialize(data: ConnectPacketJson): ConnectPacket {\n        return new ConnectPacket({\n            protocol: data.protocol,\n            app: App.deserialize(data.app),\n            encryption: data.encryption,\n            token: data.token,\n        });\n    }\n\n    public static serialize(data: ConnectPacket): ConnectPacketJson {\n        return {\n            protocol: data.protocol,\n            app: App.serialize(data.app),\n            encryption: data.encryption,\n            token: data.token,\n        };\n    }\n}\n\nexport enum DisconnectType {\n    INVALID_TOKEN = 'invalid_token',\n    INVALID_ORIGIN = 'invalid_origin',\n    INVALID_VERSION = 'invalid_version',\n    INVALID_PACKET_TYPE = 'invalid_packet_type',\n    INVALID_PACKET_DATA = 'invalid_packet_data',\n    INVALID_PACKET = 'invalid_packet',\n    INTERNAL_ERROR = 'internal_error',\n    ANOTHER_CONNECTION = 'another_connection',\n    PERMISSION_DENIED = 'permission_denied',\n    APP_REMOVED = 'app_removed',\n    SERVER_RESTART = 'server_restart',\n    SHUTDOWN = 'shutdown',\n    CLOSE = 'close',\n}\n\ntype DisconnectPacketJson = {\n    type: DisconnectType;\n    message: string | null;\n};\n\nexport class DisconnectPacket {\n    public readonly type: DisconnectType;\n    public readonly message: string | null;\n\n    constructor(options: {\n        type: DisconnectType;\n        message?: string | null;\n    }) {\n        this.type = options.type;\n        this.message = options.message ?? null;\n    }\n\n    public static serialize(data: DisconnectPacket): DisconnectPacketJson {\n        return data.toJson();\n    }\n\n    public static deserialize(data: DisconnectPacketJson): DisconnectPacket {\n        return DisconnectPacket.fromJson(data);\n    }\n\n    static fromJson(data: DisconnectPacketJson): DisconnectPacket {\n        return new DisconnectPacket({\n            type: data.type,\n            message: data.message,\n        });\n    }\n\n    toJson(): DisconnectPacketJson {\n        return {\n            type: this.type,\n            message: this.message,\n        };\n    }\n}\n\nexport const PACKET_TYPES: {\n    SERVER_META: PacketType<ServerMeta>;\n    CONNECT: PacketType<ConnectPacket>;\n    DISCONNECT: PacketType<DisconnectPacket>;\n    TOKEN: PacketType<string>;\n    READY: PacketType<undefined>;\n    ENCRYPTED_PACKET: PacketType<Uint8Array>;\n} = {\n    SERVER_META: PacketType.createJson<ServerMeta>(IDENTIFIER, {\n        name: 'server_meta',\n    }),\n    CONNECT: PacketType.createJson<ConnectPacket>(IDENTIFIER, {\n        name: 'connect',\n        serializer: ConnectPacket,\n    }),\n    DISCONNECT: PacketType.createJson<DisconnectPacket>(IDENTIFIER, {\n        name: 'disconnect',\n        serializer: DisconnectPacket,\n    }),\n    TOKEN: PacketType.createJson<string>(IDENTIFIER, {\n        name: 'token',\n    }),\n    READY: PacketType.createJson<undefined>(IDENTIFIER, {\n        name: 'ready',\n    }),\n    ENCRYPTED_PACKET: PacketType.createSerialized<Uint8Array>(IDENTIFIER, {\n        name: 'e',\n        serializer: Serializer.noop(),\n    }),\n};\n",
    "import { DisconnectType } from './network/packet/packet-types.js';\nexport class OmuError extends Error {\n    constructor(message: string | null) {\n        super(message ?? undefined);\n        this.name = this.constructor.name;\n    }\n}\n\nexport class DisconnectReason extends OmuError {\n    constructor(\n        public type: DisconnectType,\n        public message = '',\n    ) {\n        super(message);\n    }\n}\n\nexport class ServerRestart extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.SERVER_RESTART, message);\n    }\n}\n\nexport class AnotherConnection extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.ANOTHER_CONNECTION, message);\n    }\n}\n\nexport class PermissionDenied extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.PERMISSION_DENIED, message);\n    }\n}\n\nexport class AppRemoved extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.APP_REMOVED, message);\n    }\n}\n\nexport class InvalidToken extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.INVALID_TOKEN, message);\n    }\n}\n\nexport class InvalidOrigin extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.INVALID_ORIGIN, message);\n    }\n}\n\nexport class InvalidVersion extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.INVALID_VERSION, message);\n    }\n}\n\nexport class InvalidPacket extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.INVALID_PACKET, message);\n    }\n}\n\nexport class InternalError extends DisconnectReason {\n    constructor(message: string) {\n        super(DisconnectType.INTERNAL_ERROR, message);\n    }\n}\n",
    "export type Unlisten = () => void;\n\nexport class EventEmitter<P extends Array<any>> {\n    private readonly listeners: Array<(...args: P) => Promise<void> | void> = [];\n\n    public listen(listener: (...args: P) => any): Unlisten {\n        this.listeners.push(listener);\n        return () => {\n            this.listeners.splice(this.listeners.indexOf(listener), 1);\n        };\n    }\n\n    public async emit(...args: P): Promise<void> {\n        for (const listener of [...this.listeners]) {\n            await listener(...args);\n        }\n    }\n}\n",
    "export const VERSION = '0.9.49';\nexport const VERSION_MINOR = '0.9.0';\n",
    "import { Identifier, IdentifierMap } from '../identifier';\nimport type { Serializable } from '../serialize';\n\nimport type { Packet, PacketData, PacketType } from './packet';\n\nexport class PacketMapper implements Serializable<Packet, PacketData> {\n    private readonly packetMap = new IdentifierMap<PacketType<unknown>>();\n\n    public register(...packetTypes: PacketType<unknown>[]): void {\n        for (const type of packetTypes) {\n            if (this.packetMap.has(type.id)) {\n                throw new Error(`Packet id ${type.id.key()} already registered`);\n            }\n            this.packetMap.set(type.id, type);\n        }\n    }\n\n    serialize(packet: Packet): PacketData {\n        return {\n            type: packet.type.id.key(),\n            data: packet.type.serializer.serialize(packet.data),\n        };\n    }\n\n    deserialize(data: PacketData): Packet {\n        const identifier = Identifier.fromKey(data.type);\n        const type = this.packetMap.get(identifier);\n        if (!type) throw new Error(`Packet type ${data.type} not registered`);\n        return {\n            type,\n            data: type.serializer.deserialize(data.data),\n        };\n    }\n}\n\nexport interface Transport {\n    connect(): Promise<Connection>;\n}\n\nexport interface Connection {\n    send(packet: Packet, serializer: Serializable<Packet, PacketData>): void;\n    receive(serializer: Serializable<Packet, PacketData>): Promise<Packet | null>;\n    close(): void;\n    closed: boolean;\n}\n",
    "import { textDecoder, textEncoder } from '../const';\nimport { ByteReader, ByteWriter } from '../serialize';\nimport { Packet, PacketData } from './packet';\nimport { PACKET_TYPES } from './packet/packet-types';\n\nfunction base64UrlEncode(buffer: Uint8Array): string {\n    return buffer\n        .toBase64()\n        .replace(/\\+/g, '-')\n        .replace(/\\//g, '_')\n        .replace(/=/g, '');\n}\n\nfunction base64UrlDecode(data: string): Uint8Array {\n    data = data.replace(/-/g, '+').replace(/_/g, '/');\n    while (data.length % 4) {\n        data += '=';\n    }\n    return Uint8Array.fromBase64(data);\n}\n\nfunction convertUint8ArrayToArrayBuffer(u8: Uint8Array): ArrayBuffer {\n    const buf = new ArrayBuffer(u8.length);\n    const view = new Uint8Array(buf);\n    view.set(u8);\n    return buf;\n}\n\ntype RSANumbers = {\n    e: string;\n    n: string;\n};\n\nexport type EncryptionResponse = {\n    kind: 'v1';\n    rsa: RSANumbers;\n    aes: string;\n};\n\nexport const ENCRYPTION_AVAILABLE: boolean = typeof crypto !== 'undefined' && !!crypto.subtle;\n\nexport class Decryptor {\n    private constructor(\n        private readonly privateKey: CryptoKey,\n        private readonly publicKey: CryptoKey,\n    ) {}\n\n    public static async new(): Promise<Decryptor> {\n        const { privateKey, publicKey } = await crypto.subtle.generateKey(\n            {\n                name: 'RSA-OAEP',\n                modulusLength: 4096,\n                publicExponent: new Uint8Array([1, 0, 1]),\n                hash: 'SHA-256',\n            },\n            true,\n            ['encrypt', 'decrypt'],\n        );\n\n        return new Decryptor(privateKey, publicKey);\n    }\n\n    public async toRequest(): Promise<RSANumbers> {\n        const key = await crypto.subtle.exportKey('jwk', this.publicKey);\n        if (!key.e) throw new Error('Key export failed: missing exponent');\n        if (!key.n) throw new Error('Key export failed: missing modulus');\n        return {\n            e: key.e,\n            n: key.n,\n        };\n    }\n\n    public async decrypt(data: ArrayBuffer): Promise<ArrayBuffer> {\n        const decrypted = await crypto.subtle.decrypt(\n            { name: 'RSA-OAEP' },\n            this.privateKey,\n            data,\n        );\n        return decrypted;\n    }\n\n    public async decryptString(data: string): Promise<string> {\n        const decrypted = await crypto.subtle.decrypt(\n            { name: 'RSA-OAEP' },\n            this.privateKey,\n            convertUint8ArrayToArrayBuffer(base64UrlDecode(data)),\n        );\n        return textDecoder.decode(decrypted);\n    }\n}\n\nexport class Encryptor {\n    private constructor(\n        private readonly publicKey: CryptoKey,\n    ) {}\n\n    public static async new(request: RSANumbers): Promise<Encryptor> {\n        const publicKey = await crypto.subtle.importKey(\n            'jwk',\n            {\n                alg: 'RSA-OAEP-256',\n                ext: true,\n                key_ops: ['encrypt'],\n                kty: 'RSA',\n                e: request.e.replace(/=+$/, ''),\n                n: request.n.replace(/=+$/, ''),\n            },\n            {\n                name: 'RSA-OAEP',\n                hash: 'SHA-256',\n            },\n            true,\n            ['encrypt'],\n        );\n        return new Encryptor(publicKey);\n    }\n\n    public async encrypt(data: ArrayBuffer): Promise<ArrayBuffer> {\n        return await crypto.subtle.encrypt(\n            {\n                name: 'RSA-OAEP',\n            },\n            this.publicKey,\n            data,\n        );\n    }\n\n    public async encryptString(data: string): Promise<string> {\n        const encrypted = await crypto.subtle.encrypt(\n            {\n                name: 'RSA-OAEP',\n            },\n            this.publicKey,\n            textEncoder.encode(data),\n        );\n        return base64UrlEncode(new Uint8Array(encrypted));\n    }\n}\n\nexport class AES {\n    private constructor(\n        private readonly key: CryptoKey,\n        private readonly iv: ArrayBuffer,\n    ) {}\n\n    public static async new(): Promise<AES> {\n        const key = await crypto.subtle.generateKey(\n            {\n                name: 'AES-CBC',\n                length: 128,\n            },\n            true,\n            ['encrypt', 'decrypt'],\n        );\n        const iv = crypto.getRandomValues(new Uint8Array(16));\n        return new AES(key, iv.buffer);\n    }\n\n    public static async deserialize(aes: string, decryptor: Decryptor): Promise<AES> {\n        const decrypted = await decryptor.decrypt(convertUint8ArrayToArrayBuffer(base64UrlDecode(aes)));\n        const reader = ByteReader.fromArrayBuffer(decrypted);\n        const key = reader.readUint8Array();\n        const iv = reader.readUint8Array();\n\n        const key_encoded = await crypto.subtle.importKey(\n            'raw',\n            convertUint8ArrayToArrayBuffer(key),\n            'AES-CBC',\n            false,\n            ['encrypt', 'decrypt'],\n        );\n        return new AES(\n            key_encoded,\n            convertUint8ArrayToArrayBuffer(iv),\n        );\n    }\n\n    public async serialize(encryptor: Encryptor): Promise<string> {\n        const writer = new ByteWriter();\n        const rawKey = await crypto.subtle.exportKey('raw', this.key);\n        writer.writeUint8Array(new Uint8Array(rawKey));\n        writer.writeUint8Array(new Uint8Array(this.iv));\n        const encrypted = await encryptor.encrypt(convertUint8ArrayToArrayBuffer(writer.finish()));\n        return base64UrlEncode(new Uint8Array(encrypted));\n    }\n\n    public async encrypt(data: PacketData): Promise<Packet> {\n        const writer = new ByteWriter();\n        writer.writeString(data.type);\n        writer.writeUint8Array(data.data);\n        const encrypted = await crypto.subtle.encrypt(\n            {\n                name: 'AES-CBC',\n                iv: this.iv,\n                length: 16,\n            },\n            this.key,\n            convertUint8ArrayToArrayBuffer(writer.finish()),\n        );\n        return PACKET_TYPES.ENCRYPTED_PACKET.new(new Uint8Array(encrypted));\n    }\n\n    public async decrypt(packet: Packet<Uint8Array>): Promise<PacketData> {\n        const decrypted = await crypto.subtle.decrypt(\n            {\n                name: 'AES-CBC',\n                iv: this.iv,\n                length: 16,\n            },\n            this.key,\n            convertUint8ArrayToArrayBuffer(packet.data),\n        );\n        const reader = ByteReader.fromArrayBuffer(decrypted);\n        const type = reader.readString();\n        const data = reader.readUint8Array();\n        return {\n            type,\n            data,\n        };\n    }\n}\n",
    "import type { Address } from '../address.js';\nimport {\n    AnotherConnection, AppRemoved, DisconnectReason, InternalError,\n    InvalidOrigin,\n    InvalidPacket,\n    InvalidToken,\n    InvalidVersion,\n    PermissionDenied,\n    ServerRestart,\n} from '../errors.js';\nimport { EventEmitter } from '../event';\nimport { IdentifierMap } from '../identifier';\nimport { Omu } from '../omu.js';\nimport type { SessioTokenProvider } from '../token.js';\nimport { VERSION } from '../version.js';\n\nimport type { Connection, Transport } from './connection.js';\nimport { PacketMapper } from './connection.js';\nimport { AES, Decryptor, ENCRYPTION_AVAILABLE, EncryptionResponse, Encryptor } from './encryption.js';\nimport { ConnectPacket, DisconnectType, PACKET_TYPES } from './packet/packet-types.js';\nimport type { Packet, PacketType } from './packet/packet.js';\n\ntype PacketHandler<T> = {\n    readonly type: PacketType<T>;\n    event: EventEmitter<[T]>;\n};\n\ntype StatusType<T> = {\n    type: T;\n};\n\nexport type NetworkStatus = StatusType<'connecting'> | StatusType<'connected'> | StatusType<'ready'> | {\n    type: 'disconnected';\n    attempt?: number;\n    reason?: DisconnectReason;\n} | {\n    type: 'reconnecting';\n    attempt: number;\n    timeout: number;\n    date: Date;\n    cancel: () => void;\n};\n\nexport class Network {\n    public status: NetworkStatus = { type: 'disconnected' };\n    public readonly event: { connected: EventEmitter<[]>; disconnected: EventEmitter<[DisconnectReason | undefined]>; packet: EventEmitter<[Packet<unknown>]>; status: EventEmitter<[NetworkStatus]> } = {\n        connected: new EventEmitter(),\n        disconnected: new EventEmitter(),\n        packet: new EventEmitter(),\n        status: new EventEmitter(),\n    };\n    private readonly tasks: Array<() => Promise<void> | void> = [];\n    private readonly packetMapper = new PacketMapper();\n    private readonly packetHandlers = new IdentifierMap<PacketHandler<unknown>>();\n    private listenTask: Promise<void> | undefined = undefined;\n    public reason: DisconnectReason | undefined = undefined;\n    private attempt = 0;\n\n    constructor(\n        private readonly omu: Omu,\n        public address: Address,\n        private readonly tokenProvider: SessioTokenProvider,\n        private transport: Transport,\n        private connection?: Connection | undefined,\n        private aes?: AES | undefined,\n    ) {\n        this.registerPacket(\n            PACKET_TYPES.SERVER_META,\n            PACKET_TYPES.CONNECT,\n            PACKET_TYPES.DISCONNECT,\n            PACKET_TYPES.TOKEN,\n            PACKET_TYPES.READY,\n            PACKET_TYPES.ENCRYPTED_PACKET,\n        );\n        this.addPacketHandler(PACKET_TYPES.DISCONNECT, async (reason) => {\n            if (reason.type === DisconnectType.SHUTDOWN\n                || reason.type === DisconnectType.CLOSE) {\n                this.setStatus({ type: 'disconnected' });\n                return;\n            }\n            const ERROR_MAP = {\n                [DisconnectType.ANOTHER_CONNECTION]: AnotherConnection,\n                [DisconnectType.PERMISSION_DENIED]: PermissionDenied,\n                [DisconnectType.APP_REMOVED]: AppRemoved,\n                [DisconnectType.INVALID_TOKEN]: InvalidToken,\n                [DisconnectType.INVALID_ORIGIN]: InvalidOrigin,\n                [DisconnectType.INVALID_VERSION]: InvalidVersion,\n                [DisconnectType.INTERNAL_ERROR]: InternalError,\n                [DisconnectType.INVALID_PACKET]: InvalidPacket,\n                [DisconnectType.INVALID_PACKET_TYPE]: InvalidPacket,\n                [DisconnectType.INVALID_PACKET_DATA]: InvalidPacket,\n                [DisconnectType.SERVER_RESTART]: ServerRestart,\n                [DisconnectType.CLOSE]: undefined,\n                [DisconnectType.SHUTDOWN]: undefined,\n            };\n            const error = ERROR_MAP[reason.type];\n            if (error) {\n                this.reason = new error(reason.message ?? '');\n            }\n        });\n        this.addPacketHandler(PACKET_TYPES.READY, () => {\n            if (this.status.type === 'ready') {\n                throw new Error('Received READY packet when already ready');\n            }\n            this.setStatus({ type: 'ready' });\n            this.attempt = 0;\n        });\n    }\n\n    public setConnection(connection: Connection): void {\n        if (this.status.type !== 'disconnected') {\n            throw new Error('Cannot change connection while connected');\n        }\n        this.connection = connection;\n    }\n\n    public registerPacket(...packetTypes: PacketType<unknown>[]): void {\n        this.packetMapper.register(...packetTypes);\n        for (const type of packetTypes) {\n            this.packetHandlers.set(type.id, {\n                type,\n                event: new EventEmitter(),\n            });\n        }\n    }\n\n    public addPacketHandler<T>(type: PacketType<T>, handler: (packet: T) => void): void {\n        const listeners = this.packetHandlers.get(type.id) as PacketHandler<unknown> | undefined;\n        if (!listeners) {\n            throw new Error(`Packet type ${type.id.key()} not registered`);\n        }\n        listeners.event.listen(handler as (packet: unknown) => void);\n    }\n\n    private async scheduleReconnect(attempt: number): Promise<boolean> {\n        const timeout = Math.min(30000, 2000 * (Math.pow(1.5, attempt) - 1) + 2000);\n        const date = new Date();\n        let cancelled = false;\n        const status: Extract<NetworkStatus, { type: 'reconnecting' }> = {\n            type: 'reconnecting',\n            attempt,\n            timeout,\n            date,\n            cancel: () => {cancelled = true;},\n        };\n        await this.setStatus(status);\n        if (cancelled) {\n            return false;\n        }\n        const remaining = status.timeout - (new Date().getTime() - date.getTime());\n        await new Promise((resolve) => setTimeout(resolve, remaining));\n        return true;\n    }\n\n    public async connect(reconnect = true): Promise<void> {\n        if (!this.isState('disconnected')) {\n            throw new Error(`Cannot connect while ${this.status.type}`);\n        }\n        if (this.listenTask) {\n            throw new Error('Cannot connect while already connecting');\n        }\n\n        this.attempt = 0;\n        while (this.omu.running) {\n            this.attempt++;\n            try {\n                this.aes = undefined;\n                this.connection = await this.transport.connect();\n                await this.setStatus({ type: 'connecting' });\n                const metaReceived = await this.connection.receive(this.packetMapper);\n                if (!metaReceived) {\n                    throw new Error('Connection closed before receiving server meta');\n                }\n                if (!PACKET_TYPES.SERVER_META.match(metaReceived)) {\n                    throw new Error('First packet received was not server meta');\n                }\n                const { data: meta } = metaReceived;\n                this.address.hash = meta.hash;\n                let token = await this.tokenProvider.get(this.address, this.omu.app);\n                if (!token) {\n                    throw new InvalidToken(`No token available for app ${this.omu.app.id.key()} at ${this.address.host}:${this.address.port}:${this.address.hash}`);\n                }\n                let encryptionResp: EncryptionResponse | undefined = undefined;\n                if (this.omu.app.type === 'remote' && ENCRYPTION_AVAILABLE && meta.encryption) {\n                    const decryptor = await Decryptor.new();\n                    const encryptor = await Encryptor.new(meta.encryption.rsa);\n                    if (token) {\n                        token = await encryptor.encryptString(token);\n                    }\n                    this.aes = await AES.new();\n                    encryptionResp = {\n                        kind: 'v1',\n                        rsa: await decryptor.toRequest(),\n                        aes: await this.aes.serialize(encryptor),\n                    };\n                }\n                this.connection.send({\n                    type: PACKET_TYPES.CONNECT,\n                    data: new ConnectPacket({\n                        app: this.omu.app,\n                        protocol: { version: VERSION },\n                        encryption: encryptionResp,\n                        token,\n                    }),\n                }, this.packetMapper);\n                this.listenTask = this.listen();\n                await this.setStatus({ type: 'connected' });\n                await this.event.connected.emit();\n                this.dispatchTasks().then(() => {\n                    this.send({\n                        type: PACKET_TYPES.READY,\n                        data: null,\n                    });\n                });\n                await this.listenTask;\n            } catch (error) {\n                if (error instanceof DisconnectReason) {\n                    this.reason = error;\n                }\n                if (!reconnect) {\n                    throw error;\n                }\n            } finally {\n                this.event.disconnected.emit(this.reason);\n                if (this.status.type !== 'disconnected' && this.status.type !== 'reconnecting') {\n                    this.setStatus({ type: 'disconnected', attempt: this.attempt, reason: this.reason });\n                }\n                this.connection?.close();\n                this.connection = undefined;\n                this.listenTask = undefined;\n            }\n            if (this.reason && ![\n                DisconnectType.SHUTDOWN,\n                DisconnectType.SERVER_RESTART,\n            ].includes(this.reason.type)) {\n                break;\n            }\n            this.reason = undefined;\n            if (!reconnect) {\n                break;\n            }\n            const shouldReconnect = await this.scheduleReconnect(this.attempt);\n            if (!shouldReconnect) {\n                break;\n            }\n        }\n        await this.setStatus({ type: 'disconnected', reason: this.reason });\n        this.connection?.close();\n        this.connection = undefined;\n    }\n\n    private isState(state: NetworkStatus['type']): boolean {\n        return this.status.type === state;\n    }\n\n    public async send(packet: Packet): Promise<void> {\n        if (!this.connection) {\n            throw new Error('No connection established');\n        }\n        if (this.aes) {\n            const serialized = this.packetMapper.serialize(packet);\n            packet = await this.aes.encrypt(serialized);\n        }\n        this.connection.send(packet, this.packetMapper);\n    }\n\n    private async listen(): Promise<void> {\n        while (this.connection) {\n            const packet = await this.connection.receive(this.packetMapper);\n            if (!packet) {\n                break;\n            }\n            await this.dispatchPacket(packet);\n        }\n    }\n\n    private async dispatchPacket(packet: Packet): Promise<void> {\n        if (PACKET_TYPES.ENCRYPTED_PACKET.match(packet)) {\n            if (!this.aes) {\n                throw new Error('Received encrypted packet before encryption was established');\n            }\n            const decrypted = await this.aes.decrypt(packet);\n            packet = this.packetMapper.deserialize(decrypted);\n        }\n        await this.event.packet.emit(packet);\n        const packetHandler = this.packetHandlers.get(packet.type.id);\n        if (!packetHandler) {\n            return;\n        }\n        await packetHandler.event.emit(packet.data);\n    }\n\n    public addTask(task: () => Promise<void> | void): void {\n        if (this.omu.running) {\n            throw new Error('Cannot add task after client is ready');\n        }\n        this.tasks.push(task);\n    }\n\n    public removeTask(task: () => Promise<void> | void): void {\n        this.tasks.splice(this.tasks.indexOf(task), 1);\n    }\n\n    private async dispatchTasks(): Promise<void> {\n        for (const task of this.tasks) {\n            await task();\n        }\n    }\n\n    private async setStatus(status: NetworkStatus): Promise<void> {\n        if (this.status === status) {\n            throw new Error(`Cannot set status to ${status} when already ${status}`);\n        }\n        this.status = status;\n        await this.event.status.emit(status);\n    }\n\n    public close(): void {\n        this.setStatus({ type: 'disconnected' });\n        this.attempt = 0;\n    }\n}\n",
    "import type { Address } from '../address.js';\nimport type { Serializable } from '../serialize';\nimport { ByteReader, ByteWriter } from '../serialize';\n\nimport type { Connection, Transport } from './connection.js';\nimport type { Packet, PacketData } from './packet/packet.js';\n\nexport class WebsocketTransport implements Transport {\n    constructor(\n        private readonly address: Address,\n    ) { }\n\n    private get wsEndpoint(): string {\n        const protocol = this.address.secure ? 'wss' : 'ws';\n        const { host, port } = this.address;\n        return `${protocol}://${host}:${port}/ws`;\n    }\n\n    public connect(): Promise<Connection> {\n        const socket = new WebSocket(this.wsEndpoint);\n        return WebsocketConnection.fromSocket(socket);\n    }\n}\n\nexport class WebsocketConnection implements Connection {\n    private readonly packetQueue: Array<PacketData> = [];\n    private receiveWaiter: (() => void) | null = null;\n    private readingPromise: Promise<void> | null = null;\n    private beingClosed: boolean = false;\n\n    constructor(\n        private socket: WebSocket,\n    ) { }\n\n    public static fromSocket(socket: WebSocket): Promise<WebsocketConnection> {\n        const connection = new WebsocketConnection(socket);\n        return new Promise((resolve, reject) => {\n            socket.onerror = reject;\n            socket.onclose = () => {\n                connection.beingClosed = true;\n                if (connection.receiveWaiter) {\n                    connection.receiveWaiter();\n                    connection.receiveWaiter = null;\n                }\n            };\n            socket.onmessage = (event): void => {\n                connection.readingPromise = connection.onMessage(event).finally(() => {\n                    connection.readingPromise = null;\n                });\n            };\n            socket.onopen = (): void => {\n                resolve(connection);\n            };\n        });\n    }\n\n    private async onMessage(event: MessageEvent<string | Blob>): Promise<void> {\n        if (typeof event.data === 'string') {\n            throw new Error('Received string data');\n        }\n        const reader = await ByteReader.fromBlob(event.data);\n        const data = {\n            type: reader.readString(),\n            data: reader.readUint8Array(),\n        };\n        this.packetQueue.push(data);\n        reader.finish();\n        if (this.receiveWaiter) {\n            this.receiveWaiter();\n        }\n    }\n\n    public async receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null> {\n        if (this.receiveWaiter) {\n            throw new Error('Already receiving');\n        }\n        while (this.packetQueue.length === 0 && !this.beingClosed) {\n            await new Promise<void>((resolve) => {\n                this.receiveWaiter = resolve;\n            });\n            this.receiveWaiter = null;\n        }\n        if (this.packetQueue.length === 0 && this.beingClosed) {\n            return null;\n        }\n        const packetData = this.packetQueue.shift()!;\n        return serializer.deserialize(packetData);\n    }\n\n    get closed(): boolean {\n        if (this.readingPromise) {\n            return false;\n        }\n        if (this.packetQueue.length > 0) {\n            return false;\n        }\n        if (this.receiveWaiter) {\n            return false;\n        }\n        if (this.socket.readyState !== WebSocket.CLOSED && this.socket.readyState !== WebSocket.CLOSING) {\n            return false;\n        }\n        return true;\n    }\n\n    close(): void {\n        if (this.socket) {\n            this.socket.close();\n        }\n        if (this.receiveWaiter) {\n            this.receiveWaiter();\n            this.receiveWaiter = null;\n        }\n    }\n\n    send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void {\n        const packetData = serializer.serialize(packet);\n        const writer = new ByteWriter();\n        writer.writeString(packetData.type);\n        writer.writeUint8Array(packetData.data);\n        this.socket.send(writer.finish());\n    }\n}\n"
  ],
  "mappings": "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",
  "debugId": "B6141139050B2B3264756E2164756E21",
  "names": []
}