@omujs/omu 0.9.48 → 0.9.49

package/dist/esm/errors.js

@@ -0,0 +1,548 @@
+// @bun
+// 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/const.ts
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+
+// 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/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);
+  }
+}
+export {
+  ServerRestart,
+  PermissionDenied,
+  OmuError,
+  InvalidVersion,
+  InvalidToken,
+  InvalidPacket,
+  InvalidOrigin,
+  InternalError,
+  DisconnectReason,
+  AppRemoved,
+  AnotherConnection
+};
+
+//# debugId=FF5708A877F2E7D164756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/identifier.ts", "../../src/app.ts", "../../src/const.ts", "../../src/serialize/serializer.ts", "../../src/network/packet/packet.ts", "../../src/network/packet/packet-types.ts", "../../src/errors.ts"],
  "sourcesContent": [
    "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",
    "export const textEncoder: TextEncoder = new TextEncoder();\nexport const textDecoder: TextDecoder = new TextDecoder();\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",
    "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"
  ],
  "mappings": "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",
  "debugId": "FF5708A877F2E7D164756E2164756E21",
  "names": []
}

package/dist/esm/event/index.js

@@ -0,0 +1,22 @@
+// @bun
+// 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);
+    }
+  }
+}
+export {
+  EventEmitter
+};
+
+//# debugId=7F555088E4509AF464756E2164756E21
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2V2ZW50L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWwogICAgImV4cG9ydCB0eXBlIFVubGlzdGVuID0gKCkgPT4gdm9pZDtcblxuZXhwb3J0IGNsYXNzIEV2ZW50RW1pdHRlcjxQIGV4dGVuZHMgQXJyYXk8YW55Pj4ge1xuICAgIHByaXZhdGUgcmVhZG9ubHkgbGlzdGVuZXJzOiBBcnJheTwoLi4uYXJnczogUCkgPT4gUHJvbWlzZTx2b2lkPiB8IHZvaWQ+ID0gW107XG5cbiAgICBwdWJsaWMgbGlzdGVuKGxpc3RlbmVyOiAoLi4uYXJnczogUCkgPT4gYW55KTogVW5saXN0ZW4ge1xuICAgICAgICB0aGlzLmxpc3RlbmVycy5wdXNoKGxpc3RlbmVyKTtcbiAgICAgICAgcmV0dXJuICgpID0+IHtcbiAgICAgICAgICAgIHRoaXMubGlzdGVuZXJzLnNwbGljZSh0aGlzLmxpc3RlbmVycy5pbmRleE9mKGxpc3RlbmVyKSwgMSk7XG4gICAgICAgIH07XG4gICAgfVxuXG4gICAgcHVibGljIGFzeW5jIGVtaXQoLi4uYXJnczogUCk6IFByb21pc2U8dm9pZD4ge1xuICAgICAgICBmb3IgKGNvbnN0IGxpc3RlbmVyIG9mIFsuLi50aGlzLmxpc3RlbmVyc10pIHtcbiAgICAgICAgICAgIGF3YWl0IGxpc3RlbmVyKC4uLmFyZ3MpO1xuICAgICAgICB9XG4gICAgfVxufVxuIgogIF0sCiAgIm1hcHBpbmdzIjogIjs7QUFFTyxNQUFNLGFBQW1DO0FBQUEsRUFDM0IsWUFBeUQsQ0FBQztBQUFBLEVBRXBFLE1BQU0sQ0FBQyxVQUF5QztBQUFBLElBQ25ELEtBQUssVUFBVSxLQUFLLFFBQVE7QUFBQSxJQUM1QixPQUFPLE1BQU07QUFBQSxNQUNULEtBQUssVUFBVSxPQUFPLEtBQUssVUFBVSxRQUFRLFFBQVEsR0FBRyxDQUFDO0FBQUE7QUFBQTtBQUFBLE9BSXBELEtBQUksSUFBSSxNQUF3QjtBQUFBLElBQ3pDLFdBQVcsWUFBWSxDQUFDLEdBQUcsS0FBSyxTQUFTLEdBQUc7QUFBQSxNQUN4QyxNQUFNLFNBQVMsR0FBRyxJQUFJO0FBQUEsSUFDMUI7QUFBQTtBQUVSOyIsCiAgImRlYnVnSWQiOiAiN0Y1NTUwODhFNDUwOUFGNDY0NzU2RTIxNjQ3NTZFMjEiLAogICJuYW1lcyI6IFtdCn0=

package/dist/esm/helper.js

@@ -0,0 +1,15 @@
+// @bun
+// src/helper.ts
+function tryCatch(func) {
+  try {
+    return { ok: true, data: func() };
+  } catch (e) {
+    return { ok: false, data: e };
+  }
+}
+export {
+  tryCatch
+};
+
+//# debugId=C76615AB7855F31464756E2164756E21
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2hlbHBlci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsKICAgICJ0eXBlIE9rPFQ+ID0ge1xuICAgIG9rOiB0cnVlO1xuICAgIGRhdGE6IFQ7XG59O1xudHlwZSBFcnI8RT4gPSB7XG4gICAgb2s6IGZhbHNlO1xuICAgIGRhdGE6IEU7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gdHJ5Q2F0Y2g8VCwgRSA9IEVycm9yPihmdW5jOiAoKSA9PiBUKTogT2s8VD4gfCBFcnI8RT4ge1xuICAgIHRyeSB7XG4gICAgICAgIHJldHVybiB7IG9rOiB0cnVlLCBkYXRhOiBmdW5jKCkgfTtcbiAgICB9IGNhdGNoIChlKSB7XG4gICAgICAgIHJldHVybiB7IG9rOiBmYWxzZSwgZGF0YTogZSBhcyBFIH07XG4gICAgfVxufVxuIgogIF0sCiAgIm1hcHBpbmdzIjogIjs7QUFTTyxTQUFTLFFBQXNCLENBQUMsTUFBK0I7QUFBQSxFQUNsRSxJQUFJO0FBQUEsSUFDQSxPQUFPLEVBQUUsSUFBSSxNQUFNLE1BQU0sS0FBSyxFQUFFO0FBQUEsSUFDbEMsT0FBTyxHQUFHO0FBQUEsSUFDUixPQUFPLEVBQUUsSUFBSSxPQUFPLE1BQU0sRUFBTztBQUFBO0FBQUE7IiwKICAiZGVidWdJZCI6ICJDNzY2MTVBQjc4NTVGMzE0NjQ3NTZFMjE2NDc1NkUyMSIsCiAgIm5hbWVzIjogW10KfQ==