@omujs/omu 0.9.48 → 0.9.50

package/dist/api/endpoint/extension.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/endpoint/extension.ts"],
+  "sourcesContent": ["import type { Identifier } from '../../identifier';\nimport { IdentifierMap } from '../../identifier';\nimport { PacketType } from '../../network/packet';\nimport { Omu } from '../../omu';\nimport { ExtensionType } from '../extension.js';\n\nimport { EndpointType } from './endpoint.js';\nimport { EndpointInvokedPacket, EndpointInvokePacket, EndpointRegisterPacket, EndpointResponsePacket, InvokedParams, InvokeParams, ResponseParams } from './packets.js';\n\nexport const ENDPOINT_EXTENSION_TYPE: ExtensionType<EndpointExtension> = new ExtensionType(\n    'endpoint',\n    (omu: Omu) => new EndpointExtension(omu),\n);\n\ntype CallPromise = {\n    resolve: (data: Uint8Array) => void;\n    reject: (error: Error) => void;\n};\n\ntype EndpointHandler = {\n    type: EndpointType;\n    handler: (packet: EndpointInvokedPacket) => Promise<Uint8Array>;\n};\n\nexport class EndpointExtension {\n    public readonly type: ExtensionType<EndpointExtension> = ENDPOINT_EXTENSION_TYPE;\n    private readonly boundEndpoints = new IdentifierMap<EndpointHandler>();\n    private readonly responsePromises: Map<number, CallPromise> = new Map();\n    private callId: number;\n\n    constructor(private readonly omu: Omu) {\n        this.callId = Math.floor((performance.timeOrigin + performance.now()) * 1000);\n        omu.network.registerPacket(\n            ENDPOINT_REGISTER_PACKET,\n            ENDPOINT_INVOKE_PACKET,\n            ENDPOINT_INVOKED_PACKET,\n            ENDPOINT_RESPONSE_PACKET,\n        );\n        omu.network.addPacketHandler(ENDPOINT_INVOKED_PACKET, (packet) => {\n            this.handleInvoked(packet);\n        });\n        omu.network.addPacketHandler(ENDPOINT_RESPONSE_PACKET, (packet) => {\n            const promise = this.responsePromises.get(packet.params.key);\n            if (!promise) {\n                throw new Error(\n                    `Received response for unknown key ${packet.params.key} (${packet.params.id.key()})`,\n                );\n            }\n            this.responsePromises.delete(packet.params.key);\n            if (packet.params.error) {\n                promise.reject(new Error(packet.params.error));\n                return;\n            }\n            promise.resolve(packet.buffer);\n        });\n        omu.network.addTask(() => this.onTask());\n    }\n\n    private async handleInvoked(packet: EndpointInvokedPacket) {\n        const endpoint = this.boundEndpoints.get(packet.params.id);\n        if (!endpoint) {\n            throw new Error(`Received invocation for unknown endpoint ${packet.params.id.key()} (${packet.params.key})`);\n        }\n        try {\n            const result = await endpoint.handler(packet);\n            this.omu.send(ENDPOINT_RESPONSE_PACKET, new EndpointResponsePacket(\n                new ResponseParams(packet.params.id, packet.params.key, null),\n                result,\n            ));\n        } catch (error) {\n            this.omu.send(ENDPOINT_RESPONSE_PACKET, new EndpointResponsePacket(\n                new ResponseParams(packet.params.id, packet.params.key, JSON.stringify(error)),\n                new Uint8Array(),\n            ));\n        }\n    }\n\n    private onTask(): void {\n        const endpoints = new IdentifierMap<Identifier | undefined>();\n        for (const [key, endpoint] of this.boundEndpoints) {\n            endpoints.set(key, endpoint.type.permissionId);\n        }\n        const packet = new EndpointRegisterPacket(endpoints);\n        this.omu.send(ENDPOINT_REGISTER_PACKET, packet);\n    }\n\n    public bind<Req, Res>(\n        type: EndpointType<Req, Res>,\n        handler: (data: Req, params: InvokedParams) => Promise<Res>,\n    ): void {\n        if (this.omu.running) {\n            throw new Error('Cannot register endpoints after the client has started');\n        }\n        if (this.boundEndpoints.has(type.id)) {\n            throw new Error(`Endpoint with id ${type.id.key()} is already registered`);\n        }\n        this.boundEndpoints.set(type.id, { type, handler: async ({ buffer, params }) => {\n            const req = type.requestSerializer.deserialize(buffer);\n            const result = await handler(req, params);\n            return type.responseSerializer.serialize(result);\n        } });\n    }\n\n    public async call<Req, Res>(endpoint: EndpointType<Req, Res>, data: Req): Promise<Res> {\n        const key = this.callId++;\n        const promise = new Promise<Uint8Array>((resolve, reject) => {\n            this.responsePromises.set(key, { resolve, reject });\n        });\n        this.omu.send(ENDPOINT_INVOKE_PACKET, new EndpointInvokePacket(\n            new InvokeParams(endpoint.id, key),\n            endpoint.requestSerializer.serialize(data),\n        ));\n        const response = await promise;\n        return endpoint.responseSerializer.deserialize(response);\n    }\n}\n\nconst ENDPOINT_REGISTER_PACKET = PacketType.createSerialized<EndpointRegisterPacket>(ENDPOINT_EXTENSION_TYPE, {\n    name: 'register',\n    serializer: EndpointRegisterPacket,\n});\nconst ENDPOINT_INVOKE_PACKET = PacketType.createSerialized<EndpointInvokePacket>(ENDPOINT_EXTENSION_TYPE, {\n    name: 'invoke',\n    serializer: EndpointInvokePacket,\n});\nconst ENDPOINT_INVOKED_PACKET = PacketType.createSerialized<EndpointInvokedPacket>(ENDPOINT_EXTENSION_TYPE, {\n    name: 'invoked',\n    serializer: EndpointInvokedPacket,\n});\nconst ENDPOINT_RESPONSE_PACKET = PacketType.createSerialized<EndpointResponsePacket>(ENDPOINT_EXTENSION_TYPE, {\n    name: 'response',\n    serializer: EndpointResponsePacket,\n});\n"],
+  "mappings": "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",
+  "names": ["IdentifierMap", "PacketType", "ExtensionType", "EndpointInvokedPacket", "EndpointInvokePacket", "EndpointRegisterPacket", "EndpointResponsePacket", "InvokeParams", "ResponseParams", "ENDPOINT_EXTENSION_TYPE", "omu", "EndpointExtension", "ENDPOINT_REGISTER_PACKET", "ENDPOINT_INVOKE_PACKET", "ENDPOINT_INVOKED_PACKET", "ENDPOINT_RESPONSE_PACKET", "packet", "promise", "endpoint", "result", "error", "endpoints", "key", "type", "handler", "buffer", "params", "req", "data", "resolve", "reject", "response"]
+}

package/{src/api/endpoint/index.ts → dist/api/endpoint/index.d.ts}

@@ -1,3 +1,2 @@
 export { EndpointType } from './endpoint.js';
 export type { InvokedParams, InvokeParams } from './packets.js';
-

package/dist/api/endpoint/index.js

@@ -0,0 +1,2 @@
+import{EndpointType as p}from"./endpoint.js";export{p as EndpointType};
+//# sourceMappingURL=index.js.map

package/dist/api/endpoint/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/endpoint/index.ts"],
+  "sourcesContent": ["export { EndpointType } from './endpoint.js';\nexport type { InvokedParams, InvokeParams } from './packets.js';\n\n"],
+  "mappings": "AAAA,OAAS,gBAAAA,MAAoB",
+  "names": ["EndpointType"]
+}

package/dist/api/endpoint/packets.d.ts

@@ -0,0 +1,51 @@
+import { Identifier, IdentifierMap } from '../../identifier';
+export declare class EndpointRegisterPacket {
+    endpoints: IdentifierMap<Identifier | undefined>;
+    constructor(endpoints: IdentifierMap<Identifier | undefined>);
+    static serialize(item: EndpointRegisterPacket): Uint8Array;
+    static deserialize(item: Uint8Array): EndpointRegisterPacket;
+}
+export declare class InvokedParams {
+    readonly id: Identifier;
+    readonly caller: Identifier;
+    readonly key: number;
+    constructor(id: Identifier, caller: Identifier, key: number);
+    static serialize(item: InvokedParams): string;
+    static deserialize(item: string): InvokedParams;
+}
+export declare class EndpointInvokedPacket {
+    params: InvokedParams;
+    buffer: Uint8Array;
+    constructor(params: InvokedParams, buffer: Uint8Array);
+    static serialize(item: EndpointInvokedPacket): Uint8Array;
+    static deserialize(item: Uint8Array): EndpointInvokedPacket;
+}
+export declare class InvokeParams {
+    readonly id: Identifier;
+    readonly key: number;
+    constructor(id: Identifier, key: number);
+    static serialize(item: InvokeParams): string;
+    static deserialize(item: string): InvokeParams;
+}
+export declare class EndpointInvokePacket {
+    params: InvokeParams;
+    buffer: Uint8Array;
+    constructor(params: InvokeParams, buffer: Uint8Array);
+    static serialize(item: EndpointInvokePacket): Uint8Array;
+    static deserialize(item: Uint8Array): EndpointInvokePacket;
+}
+export declare class ResponseParams {
+    readonly id: Identifier;
+    readonly key: number;
+    readonly error: string | null;
+    constructor(id: Identifier, key: number, error: string | null);
+    static serialize(item: ResponseParams): string;
+    static deserialize(item: string): ResponseParams;
+}
+export declare class EndpointResponsePacket {
+    params: ResponseParams;
+    buffer: Uint8Array;
+    constructor(params: ResponseParams, buffer: Uint8Array);
+    static serialize(item: EndpointResponsePacket): Uint8Array;
+    static deserialize(item: Uint8Array): EndpointResponsePacket;
+}

package/dist/api/endpoint/packets.js

@@ -0,0 +1,2 @@
+import{Identifier as n,IdentifierMap as m}from"../../identifier";import{ByteReader as a,ByteWriter as s}from"../../serialize";class u{constructor(e){this.endpoints=e}static serialize(e){const r=new s;r.writeULEB128(e.endpoints.size);for(const[i,t]of e.endpoints)r.writeString(i.key()),r.writeString(t?.key()??"");return r.finish()}static deserialize(e){const r=a.fromUint8Array(e),i=r.readULEB128(),t=new m;for(let d=0;d<i;d++){const b=n.fromKey(r.readString()),k=n.fromKey(r.readString());t.set(b,k)}return new u(t)}}class o{constructor(e,r,i){this.id=e;this.caller=r;this.key=i}static serialize(e){return JSON.stringify({id:e.id.key(),caller:e.caller.key(),key:e.key})}static deserialize(e){const r=JSON.parse(e);return new o(n.fromKey(r.id),n.fromKey(r.caller),r.key)}}class p{constructor(e,r){this.params=e;this.buffer=r}static serialize(e){const r=new s;return r.writeString(o.serialize(e.params)),r.writeUint8Array(e.buffer),r.finish()}static deserialize(e){const r=a.fromUint8Array(e),i=o.deserialize(r.readString()),t=r.readUint8Array();return new p(i,t)}}class c{constructor(e,r){this.id=e;this.key=r}static serialize(e){return JSON.stringify({id:e.id.key(),key:e.key})}static deserialize(e){const r=JSON.parse(e);return new c(n.fromKey(r.id),r.key)}}class y{constructor(e,r){this.params=e;this.buffer=r}static serialize(e){const r=new s;return r.writeString(c.serialize(e.params)),r.writeUint8Array(e.buffer),r.finish()}static deserialize(e){const r=a.fromUint8Array(e),i=c.deserialize(r.readString()),t=r.readUint8Array();return new y(i,t)}}class l{constructor(e,r,i){this.id=e;this.key=r;this.error=i}static serialize(e){return JSON.stringify({id:e.id.key(),key:e.key,error:e.error})}static deserialize(e){const r=JSON.parse(e);return new l(n.fromKey(r.id),r.key,r.error)}}class f{constructor(e,r){this.params=e;this.buffer=r}static serialize(e){const r=new s;return r.writeString(l.serialize(e.params)),r.writeUint8Array(e.buffer),r.finish()}static deserialize(e){const r=a.fromUint8Array(e),i=l.deserialize(r.readString()),t=r.readUint8Array();return new f(i,t)}}export{y as EndpointInvokePacket,p as EndpointInvokedPacket,u as EndpointRegisterPacket,f as EndpointResponsePacket,c as InvokeParams,o as InvokedParams,l as ResponseParams};
+//# sourceMappingURL=packets.js.map

package/dist/api/endpoint/packets.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/endpoint/packets.ts"],
+  "sourcesContent": ["import { Identifier, IdentifierMap } from '../../identifier';\nimport { ByteReader, ByteWriter } from '../../serialize';\n\nexport class EndpointRegisterPacket {\n    constructor(\n        public endpoints: IdentifierMap<Identifier | undefined>,\n    ) { }\n\n    public static serialize(item: EndpointRegisterPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeULEB128(item.endpoints.size);\n        for (const [key, value] of item.endpoints) {\n            writer.writeString(key.key());\n            writer.writeString(value?.key() ?? '');\n        }\n        return writer.finish();\n    }\n\n    public static deserialize(item: Uint8Array): EndpointRegisterPacket {\n        const reader = ByteReader.fromUint8Array(item);\n        const count = reader.readULEB128();\n        const endpoints = new IdentifierMap<Identifier | undefined>();\n        for (let i = 0; i < count; i++) {\n            const key = Identifier.fromKey(reader.readString());\n            const value = Identifier.fromKey(reader.readString());\n            endpoints.set(key, value);\n        }\n        return new EndpointRegisterPacket(endpoints);\n    }\n}\n\nexport class InvokedParams {\n    constructor(\n        public readonly id: Identifier,\n        public readonly caller: Identifier,\n        public readonly key: number,\n    ) { }\n\n    public static serialize(item: InvokedParams): string {\n        return JSON.stringify({\n            id: item.id.key(),\n            caller: item.caller.key(),\n            key: item.key,\n        });\n    }\n\n    public static deserialize(item: string): InvokedParams {\n        const data: {\n            id: string;\n            caller: string;\n            key: number;\n        } = JSON.parse(item);\n        return new InvokedParams(\n            Identifier.fromKey(data.id),\n            Identifier.fromKey(data.caller),\n            data.key,\n        );\n    }\n};\n\nexport class EndpointInvokedPacket {\n    constructor(\n        public params: InvokedParams,\n        public buffer: Uint8Array,\n    ) { }\n\n    public static serialize(item: EndpointInvokedPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(InvokedParams.serialize(item.params));\n        writer.writeUint8Array(item.buffer);\n        return writer.finish();\n    }\n\n    public static deserialize(item: Uint8Array): EndpointInvokedPacket {\n        const reader = ByteReader.fromUint8Array(item);\n        const params = InvokedParams.deserialize(reader.readString());\n        const buffer = reader.readUint8Array();\n        return new EndpointInvokedPacket(params, buffer);\n    }\n}\n\nexport class InvokeParams {\n    constructor(\n        public readonly id: Identifier,\n        public readonly key: number,\n    ) { }\n\n    public static serialize(item: InvokeParams): string {\n        return JSON.stringify({\n            id: item.id.key(),\n            key: item.key,\n        });\n    }\n\n    public static deserialize(item: string): InvokeParams {\n        const data: {\n            id: string;\n            key: number;\n        } = JSON.parse(item);\n        return new InvokeParams(\n            Identifier.fromKey(data.id),\n            data.key,\n        );\n    }\n};\n\nexport class EndpointInvokePacket {\n    constructor(\n        public params: InvokeParams,\n        public buffer: Uint8Array,\n    ) { }\n\n    public static serialize(item: EndpointInvokePacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(InvokeParams.serialize(item.params));\n        writer.writeUint8Array(item.buffer);\n        return writer.finish();\n    }\n\n    public static deserialize(item: Uint8Array): EndpointInvokePacket {\n        const reader = ByteReader.fromUint8Array(item);\n        const params = InvokeParams.deserialize(reader.readString());\n        const buffer = reader.readUint8Array();\n        return new EndpointInvokePacket(params, buffer);\n    }\n}\n\nexport class ResponseParams {\n    constructor(\n        public readonly id: Identifier,\n        public readonly key: number,\n        public readonly error: string | null,\n    ) { }\n\n    public static serialize(item: ResponseParams): string {\n        return JSON.stringify({\n            id: item.id.key(),\n            key: item.key,\n            error: item.error,\n        });\n    }\n\n    public static deserialize(item: string): ResponseParams {\n        const data: {\n            id: string;\n            key: number;\n            error: string | null;\n        } = JSON.parse(item);\n        return new ResponseParams(\n            Identifier.fromKey(data.id),\n            data.key,\n            data.error,\n        );\n    }\n};\n\nexport class EndpointResponsePacket {\n    constructor(\n        public params: ResponseParams,\n        public buffer: Uint8Array,\n    ) { }\n\n    public static serialize(item: EndpointResponsePacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(ResponseParams.serialize(item.params));\n        writer.writeUint8Array(item.buffer);\n        return writer.finish();\n    }\n\n    public static deserialize(item: Uint8Array): EndpointResponsePacket {\n        const reader = ByteReader.fromUint8Array(item);\n        const params = ResponseParams.deserialize(reader.readString());\n        const buffer = reader.readUint8Array();\n        return new EndpointResponsePacket(params, buffer);\n    }\n}\n"],
+  "mappings": "AAAA,OAAS,cAAAA,EAAY,iBAAAC,MAAqB,mBAC1C,OAAS,cAAAC,EAAY,cAAAC,MAAkB,kBAEhC,MAAMC,CAAuB,CAChC,YACWC,EACT,CADS,eAAAA,CACP,CAEJ,OAAc,UAAUC,EAA0C,CAC9D,MAAMC,EAAS,IAAIJ,EACnBI,EAAO,aAAaD,EAAK,UAAU,IAAI,EACvC,SAAW,CAACE,EAAKC,CAAK,IAAKH,EAAK,UAC5BC,EAAO,YAAYC,EAAI,IAAI,CAAC,EAC5BD,EAAO,YAAYE,GAAO,IAAI,GAAK,EAAE,EAEzC,OAAOF,EAAO,OAAO,CACzB,CAEA,OAAc,YAAYD,EAA0C,CAChE,MAAMI,EAASR,EAAW,eAAeI,CAAI,EACvCK,EAAQD,EAAO,YAAY,EAC3BL,EAAY,IAAIJ,EACtB,QAASW,EAAI,EAAGA,EAAID,EAAOC,IAAK,CAC5B,MAAMJ,EAAMR,EAAW,QAAQU,EAAO,WAAW,CAAC,EAC5CD,EAAQT,EAAW,QAAQU,EAAO,WAAW,CAAC,EACpDL,EAAU,IAAIG,EAAKC,CAAK,CAC5B,CACA,OAAO,IAAIL,EAAuBC,CAAS,CAC/C,CACJ,CAEO,MAAMQ,CAAc,CACvB,YACoBC,EACAC,EACAP,EAClB,CAHkB,QAAAM,EACA,YAAAC,EACA,SAAAP,CAChB,CAEJ,OAAc,UAAUF,EAA6B,CACjD,OAAO,KAAK,UAAU,CAClB,GAAIA,EAAK,GAAG,IAAI,EAChB,OAAQA,EAAK,OAAO,IAAI,EACxB,IAAKA,EAAK,GACd,CAAC,CACL,CAEA,OAAc,YAAYA,EAA6B,CACnD,MAAMU,EAIF,KAAK,MAAMV,CAAI,EACnB,OAAO,IAAIO,EACPb,EAAW,QAAQgB,EAAK,EAAE,EAC1BhB,EAAW,QAAQgB,EAAK,MAAM,EAC9BA,EAAK,GACT,CACJ,CACJ,CAEO,MAAMC,CAAsB,CAC/B,YACWC,EACAC,EACT,CAFS,YAAAD,EACA,YAAAC,CACP,CAEJ,OAAc,UAAUb,EAAyC,CAC7D,MAAMC,EAAS,IAAIJ,EACnB,OAAAI,EAAO,YAAYM,EAAc,UAAUP,EAAK,MAAM,CAAC,EACvDC,EAAO,gBAAgBD,EAAK,MAAM,EAC3BC,EAAO,OAAO,CACzB,CAEA,OAAc,YAAYD,EAAyC,CAC/D,MAAMI,EAASR,EAAW,eAAeI,CAAI,EACvCY,EAASL,EAAc,YAAYH,EAAO,WAAW,CAAC,EACtDS,EAAST,EAAO,eAAe,EACrC,OAAO,IAAIO,EAAsBC,EAAQC,CAAM,CACnD,CACJ,CAEO,MAAMC,CAAa,CACtB,YACoBN,EACAN,EAClB,CAFkB,QAAAM,EACA,SAAAN,CAChB,CAEJ,OAAc,UAAUF,EAA4B,CAChD,OAAO,KAAK,UAAU,CAClB,GAAIA,EAAK,GAAG,IAAI,EAChB,IAAKA,EAAK,GACd,CAAC,CACL,CAEA,OAAc,YAAYA,EAA4B,CAClD,MAAMU,EAGF,KAAK,MAAMV,CAAI,EACnB,OAAO,IAAIc,EACPpB,EAAW,QAAQgB,EAAK,EAAE,EAC1BA,EAAK,GACT,CACJ,CACJ,CAEO,MAAMK,CAAqB,CAC9B,YACWH,EACAC,EACT,CAFS,YAAAD,EACA,YAAAC,CACP,CAEJ,OAAc,UAAUb,EAAwC,CAC5D,MAAMC,EAAS,IAAIJ,EACnB,OAAAI,EAAO,YAAYa,EAAa,UAAUd,EAAK,MAAM,CAAC,EACtDC,EAAO,gBAAgBD,EAAK,MAAM,EAC3BC,EAAO,OAAO,CACzB,CAEA,OAAc,YAAYD,EAAwC,CAC9D,MAAMI,EAASR,EAAW,eAAeI,CAAI,EACvCY,EAASE,EAAa,YAAYV,EAAO,WAAW,CAAC,EACrDS,EAAST,EAAO,eAAe,EACrC,OAAO,IAAIW,EAAqBH,EAAQC,CAAM,CAClD,CACJ,CAEO,MAAMG,CAAe,CACxB,YACoBR,EACAN,EACAe,EAClB,CAHkB,QAAAT,EACA,SAAAN,EACA,WAAAe,CAChB,CAEJ,OAAc,UAAUjB,EAA8B,CAClD,OAAO,KAAK,UAAU,CAClB,GAAIA,EAAK,GAAG,IAAI,EAChB,IAAKA,EAAK,IACV,MAAOA,EAAK,KAChB,CAAC,CACL,CAEA,OAAc,YAAYA,EAA8B,CACpD,MAAMU,EAIF,KAAK,MAAMV,CAAI,EACnB,OAAO,IAAIgB,EACPtB,EAAW,QAAQgB,EAAK,EAAE,EAC1BA,EAAK,IACLA,EAAK,KACT,CACJ,CACJ,CAEO,MAAMQ,CAAuB,CAChC,YACWN,EACAC,EACT,CAFS,YAAAD,EACA,YAAAC,CACP,CAEJ,OAAc,UAAUb,EAA0C,CAC9D,MAAMC,EAAS,IAAIJ,EACnB,OAAAI,EAAO,YAAYe,EAAe,UAAUhB,EAAK,MAAM,CAAC,EACxDC,EAAO,gBAAgBD,EAAK,MAAM,EAC3BC,EAAO,OAAO,CACzB,CAEA,OAAc,YAAYD,EAA0C,CAChE,MAAMI,EAASR,EAAW,eAAeI,CAAI,EACvCY,EAASI,EAAe,YAAYZ,EAAO,WAAW,CAAC,EACvDS,EAAST,EAAO,eAAe,EACrC,OAAO,IAAIc,EAAuBN,EAAQC,CAAM,CACpD,CACJ",
+  "names": ["Identifier", "IdentifierMap", "ByteReader", "ByteWriter", "EndpointRegisterPacket", "endpoints", "item", "writer", "key", "value", "reader", "count", "i", "InvokedParams", "id", "caller", "data", "EndpointInvokedPacket", "params", "buffer", "InvokeParams", "EndpointInvokePacket", "ResponseParams", "error", "EndpointResponsePacket"]
+}

package/dist/api/extension-registry.d.ts

@@ -0,0 +1,8 @@
+import { Omu } from '../omu.js';
+import type { Extension, ExtensionType } from './extension.js';
+export declare class ExtensionRegistry {
+    private readonly omu;
+    private readonly extensionMap;
+    constructor(omu: Omu);
+    register<T extends Extension>(type: ExtensionType<T>): T;
+}

package/dist/api/extension-registry.js

@@ -0,0 +1,2 @@
+class r{constructor(e){this.omu=e}extensionMap=new Map;register(e){if(this.extensionMap.has(e.name))throw new Error(`Extension type ${e.name} already registered`);const n=e.create(this.omu);return this.extensionMap.set(e.name,n),n}}export{r as ExtensionRegistry};
+//# sourceMappingURL=extension-registry.js.map

package/dist/api/extension-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/api/extension-registry.ts"],
+  "sourcesContent": ["import { Omu } from '../omu.js';\nimport type { Extension, ExtensionType } from './extension.js';\n\nexport class ExtensionRegistry {\n    private readonly extensionMap: Map<string, Extension> = new Map();\n\n    constructor(private readonly omu: Omu) {}\n\n    register<T extends Extension>(type: ExtensionType<T>): T {\n        if (this.extensionMap.has(type.name)) {\n            throw new Error(`Extension type ${type.name} already registered`);\n        }\n        const extension = type.create(this.omu);\n        this.extensionMap.set(type.name, extension);\n        return extension;\n    }\n}\n"],
+  "mappings": "AAGO,MAAMA,CAAkB,CAG3B,YAA6BC,EAAU,CAAV,SAAAA,CAAW,CAFvB,aAAuC,IAAI,IAI5D,SAA8BC,EAA2B,CACrD,GAAI,KAAK,aAAa,IAAIA,EAAK,IAAI,EAC/B,MAAM,IAAI,MAAM,kBAAkBA,EAAK,IAAI,qBAAqB,EAEpE,MAAMC,EAAYD,EAAK,OAAO,KAAK,GAAG,EACtC,YAAK,aAAa,IAAIA,EAAK,KAAMC,CAAS,EACnCA,CACX,CACJ",
+  "names": ["ExtensionRegistry", "omu", "type", "extension"]
+}

package/dist/api/extension.d.ts

@@ -0,0 +1,11 @@
+import { Identifier } from '../identifier';
+import { Omu } from '../omu';
+export interface Extension {
+    readonly type: ExtensionType;
+}
+export declare class ExtensionType<T extends Extension = Extension> extends Identifier {
+    readonly name: string;
+    readonly create: (omu: Omu) => T;
+    constructor(name: string, create: (omu: Omu) => T);
+    key(): string;
+}

package/dist/api/extension.js

@@ -0,0 +1,2 @@
+import{Identifier as e}from"../identifier";class x extends e{constructor(n,o){super("ext",n);this.name=n;this.create=o}key(){return new e("ext",this.name).key()}}export{x as ExtensionType};
+//# sourceMappingURL=extension.js.map

package/dist/api/extension.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/api/extension.ts"],
+  "sourcesContent": ["import { Identifier } from '../identifier';\nimport { Omu } from '../omu';\n\nexport interface Extension {\n    readonly type: ExtensionType;\n}\n\nexport class ExtensionType<T extends Extension = Extension> extends Identifier {\n    constructor(\n        public readonly name: string,\n        public readonly create: (omu: Omu) => T,\n    ) {\n        super('ext', name);\n    }\n\n    public key(): string {\n        return new Identifier('ext', this.name).key();\n    }\n}\n"],
+  "mappings": "AAAA,OAAS,cAAAA,MAAkB,gBAOpB,MAAMC,UAAuDD,CAAW,CAC3E,YACoBE,EACAC,EAClB,CACE,MAAM,MAAOD,CAAI,EAHD,UAAAA,EACA,YAAAC,CAGpB,CAEO,KAAc,CACjB,OAAO,IAAIH,EAAW,MAAO,KAAK,IAAI,EAAE,IAAI,CAChD,CACJ",
+  "names": ["Identifier", "ExtensionType", "name", "create"]
+}

package/dist/api/http/extension.d.ts

@@ -0,0 +1,41 @@
+import { Identifier } from '../../identifier';
+import { Omu } from '../../omu';
+import { Extension, ExtensionType } from '../extension';
+import { OmuResponse, RequestHandle } from './http';
+import { OmuWS } from './websocket';
+export declare const HTTP_EXTENSION_TYPE: ExtensionType<HttpExtension>;
+export declare const HTTP_REQUEST_PERMISSION_ID: Identifier;
+type HttpResponse = RequestHandle & {
+    header: Record<string, string>;
+    status: number;
+    statusText: string;
+    url: string;
+    history: HttpResponse[];
+    redirected: boolean;
+};
+export declare class HttpExtension implements Extension {
+    private readonly omu;
+    readonly type: ExtensionType<Extension>;
+    private requestCount;
+    private readonly httpHandles;
+    private readonly wsHandles;
+    private readonly wsSendQueue;
+    private wsSendWaitResolve;
+    constructor(omu: Omu);
+    private wsSendLoop;
+    private generateHeaders;
+    private generateId;
+    request(input: string | URL | globalThis.Request, init?: RequestInit): Promise<{
+        response: HttpResponse;
+        stream: ReadableStream;
+    }>;
+    fetch(input: string | URL | globalThis.Request, init?: RequestInit): Promise<OmuResponse>;
+    ws(input: string | URL | globalThis.Request, options?: {
+        method?: string;
+        autoclose?: boolean;
+        autoping?: boolean;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Promise<OmuWS>;
+}
+export {};

package/dist/api/http/extension.js

@@ -0,0 +1,2 @@
+import{textEncoder as _}from"../../const";import{PacketType as d}from"../../network/packet";import{ExtensionType as C}from"../extension";import{DataChunk as p,OmuResponse as O}from"./http";import{OmuWS as W,WSMsgType as m}from"./websocket";const a=new C("http",i=>new P(i)),G=a.join("request"),S=d.createJson(a,{name:"request_create"}),v=d.createSerialized(a,{name:"request_send",serializer:p}),H=d.createJson(a,{name:"request_close"}),E=d.createJson(a,{name:"response_create"}),g=d.createSerialized(a,{name:"response_chunk",serializer:p}),k=d.createJson(a,{name:"response_close"}),T=d.createJson(a,{name:"ws_create"}),q=d.createJson(a,{name:"ws_open"}),w=d.createSerialized(a,{name:"ws_data",serializer:p}),R=d.createJson(a,{name:"ws_close"}),b=d.createJson(a,{name:"ws_error"});function y(){let i,n;const e=new Promise((t,r)=>{i=t,n=r});if(!i||!n)throw new Error("Failed to create future");return{promise:e,resolve:i,reject:n}}class P{constructor(n){this.omu=n;n.network.registerPacket(S,v,H,E,g,k,R,T,w,q,b),n.network.addPacketHandler(E,e=>{const t=this.httpHandles[e.id];if(!t){console.warn("Received response for unknown request",e.id);return}if(t.type!=="created"){console.warn("Received response for already handled request",e.id);return}t.setResponse(e)}),n.network.addPacketHandler(g,e=>{const t=this.httpHandles[e.meta.id];if(!t){console.warn("Received response for unknown request",e.meta.id);return}if(t.type!=="receiving"){console.warn("Received chunk for non-receiving request",e.meta.id);return}t.receive(e.body)}),n.network.addPacketHandler(k,e=>{const t=this.httpHandles[e.id];if(!t){console.warn("Received response for unknown request",e.id);return}if(t.type!=="receiving"){console.warn("Received chunk for non-receiving request",e.id);return}t.close(),delete this.httpHandles[e.id]}),n.network.addPacketHandler(q,e=>{const t=this.wsHandles[e.id];if(!t){console.warn("Received response for unknown socket",e.id);return}if(t.type!=="created"){console.warn("Received response for already handled socket",e.id);return}t.handle.open(e),t.type="receiving"}),n.network.addPacketHandler(w,e=>{const t=this.wsHandles[e.meta.id];if(!t){console.warn("Received response for unknown socket",e.meta.id);return}if(t.type!=="receiving"){console.warn("Received chunk for non-receiving socket",e.meta.id);return}t.handle.dispatch(e)}),n.network.addPacketHandler(R,e=>{const t=this.wsHandles[e.id];if(!t){console.warn("Received response for unknown socket",e.id);return}t.handle.close(e),delete this.httpHandles[e.id]}),n.network.addPacketHandler(b,e=>{const t=this.wsHandles[e.id];if(!t){console.warn("Received response for unknown socket",e.id);return}t.handle.error(e),delete this.httpHandles[e.id]}),n.event.ready.listen(()=>{this.wsSendLoop()})}type=a;requestCount=0;httpHandles={};wsHandles={};wsSendQueue=[];wsSendWaitResolve=()=>{};async wsSendLoop(){for(;this.omu.running;){const n=this.wsSendQueue.shift();if(n){const e=await A(n.data),t=typeof n.data=="string"?m.TEXT:m.BINARY;this.omu.send(w,new p({id:n.id,type:t},e))}else await new Promise(e=>{this.wsSendWaitResolve=e})}}generateHeaders(n,e){const t={},r={},c=(s,o)=>{const h=s.toLowerCase(),f=r[h];f&&delete t[f],t[s]=o,r[h]=s};if(n.headers.forEach((s,o)=>{c(o,s)}),e?.headers)if(e.headers instanceof Headers)e.headers.forEach((s,o)=>{c(o,s)});else if(Array.isArray(e.headers))for(const[s,o]of e.headers)c(s,o);else for(const s in e.headers){const o=e.headers[s];c(s,o)}return t}generateId(){return this.omu.app.id.join(`${performance.timeOrigin}-${this.requestCount++}`)}async request(n,e){const t=new Request(n,e),r=this.generateId().key();if(this.omu.send(S,{id:r,header:this.generateHeaders(t,e),method:t.method,redirect:t.redirect,url:t.url}),t.body){const u=t.body.getReader();for(;;){const l=await u.read();if(l.done)break;this.omu.send(v,{meta:{id:r},body:l.value})}}this.omu.send(H,{id:r});const c=[],s=y();let o=y();const h=u=>{s.resolve(u),this.httpHandles[r]={type:"receiving",receive(l){c.push(l),o.resolve(!0),o=y()},close(){o.resolve(!1)}}};return this.httpHandles[r]={type:"created",setResponse:h},{response:await s.promise,stream:new ReadableStream({async start(u){for(;await o.promise;){const l=c.shift();if(!l)break;u.enqueue(l)}u.close()}})}}async fetch(n,e){const{response:t,stream:r}=await this.request(n,e);return new O(new Headers(t.header),t.status>=200&&t.status<300,t.redirected,t.status,t.statusText,"basic",t.url,r,!1)}async ws(n,e){const t=new Request(n,e),r=this.generateId(),c=W.create({addQueue:s=>{this.wsSendQueue.push({id:r.key(),data:s}),this.wsSendWaitResolve()},dispose:s=>{this.omu.send(R,{id:r.key(),code:s.code,reason:s.reason}),delete this.wsHandles[r.key()]}});return this.wsHandles[r.key()]={type:"created",handle:c},this.omu.send(T,{id:r.key(),header:this.generateHeaders(t,e),method:t.method,redirect:t.redirect,url:t.url}),c.ws}}async function A(i){if(typeof i=="string")return _.encode(i);if(i instanceof Blob){const n=await i.arrayBuffer();return new Uint8Array(n)}else return new Uint8Array(i)}export{a as HTTP_EXTENSION_TYPE,G as HTTP_REQUEST_PERMISSION_ID,P as HttpExtension};
+//# sourceMappingURL=extension.js.map

package/dist/api/http/extension.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/http/extension.ts"],
+  "sourcesContent": ["\nimport { textEncoder } from '../../const';\nimport { Identifier } from '../../identifier';\nimport { PacketType } from '../../network/packet';\nimport { Omu } from '../../omu';\nimport { Extension, ExtensionType } from '../extension';\nimport { DataChunk, HttpRequest, OmuResponse, RequestHandle } from './http';\nimport { OmuWS, WebSocketClose, WebSocketError, WebSocketOpen, WSData, WSDataMeta, WSHandleState, WSMsgType } from './websocket';\n\nexport const HTTP_EXTENSION_TYPE: ExtensionType<HttpExtension> = new ExtensionType(\n    'http',\n    (omu: Omu) => new HttpExtension(omu),\n);\n\nexport const HTTP_REQUEST_PERMISSION_ID: Identifier = HTTP_EXTENSION_TYPE.join('request');\n\nconst REQUEST_CREATE = PacketType.createJson<HttpRequest>(HTTP_EXTENSION_TYPE, {\n    name: 'request_create',\n});\n\nconst REQUEST_SEND = PacketType.createSerialized<DataChunk<RequestHandle>>(HTTP_EXTENSION_TYPE, {\n    name: 'request_send',\n    serializer: DataChunk,\n});\n\ntype HttpRequestClose = RequestHandle;\n\nconst REQUEST_CLOSE = PacketType.createJson<HttpRequestClose>(HTTP_EXTENSION_TYPE, {\n    name: 'request_close',\n});\n\ntype HttpResponse = RequestHandle & {\n    header: Record<string, string>;\n    status: number;\n    statusText: string;\n    url: string;\n    history: HttpResponse[];\n    redirected: boolean;\n};\n\nconst RESPONSE_CREATE = PacketType.createJson<HttpResponse>(HTTP_EXTENSION_TYPE, {\n    name: 'response_create',\n});\n\nconst RESPONSE_CHUNK = PacketType.createSerialized<DataChunk<RequestHandle>>(HTTP_EXTENSION_TYPE, {\n    name: 'response_chunk',\n    serializer: DataChunk,\n});\n\nconst RESPONSE_CLOSE = PacketType.createJson<RequestHandle>(HTTP_EXTENSION_TYPE, {\n    name: 'response_close',\n});\n\ntype HandleStateReceiving = {\n    type: 'receiving';\n    receive(data: Uint8Array): void;\n    close(): void;\n};\n\ntype HandleStateCreated = {\n    type: 'created';\n    setResponse(response: HttpResponse): void;\n};\n\ntype HandleState = HandleStateCreated | HandleStateReceiving;\n\nconst WEBSOCKET_CREATE = PacketType.createJson<HttpRequest>(HTTP_EXTENSION_TYPE, {\n    name: 'ws_create',\n});\n\nconst WEBSOCKET_OPEN = PacketType.createJson<WebSocketOpen>(HTTP_EXTENSION_TYPE, {\n    name: 'ws_open',\n});\n\nconst WEBSOCKET_DATA = PacketType.createSerialized<DataChunk<WSDataMeta>>(HTTP_EXTENSION_TYPE, {\n    name: 'ws_data',\n    serializer: DataChunk,\n});\n\nconst WEBSOCKET_CLOSE = PacketType.createJson<WebSocketClose>(HTTP_EXTENSION_TYPE, {\n    name: 'ws_close',\n});\n\nconst WEBSOCKET_ERROR = PacketType.createJson<WebSocketError>(HTTP_EXTENSION_TYPE, {\n    name: 'ws_error',\n});\n\nfunction createFuture<T>(): {\n    promise: Promise<T>;\n    resolve: (value: T) => void;\n    reject: (reason?: unknown) => void;\n} {\n    let resolve: ((value: T) => void) | undefined = undefined;\n    let reject: ((reason?: unknown) => void) | undefined = undefined;\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    if (!resolve || !reject) throw new Error('Failed to create future');\n    return {\n        promise,\n        resolve,\n        reject,\n    };\n}\n\ntype WSSendTask = {\n    id: string;\n    data: WSData;\n};\n\nexport class HttpExtension implements Extension {\n    public readonly type: ExtensionType<Extension> = HTTP_EXTENSION_TYPE;\n    private requestCount: number = 0;\n\n    private readonly httpHandles: Record<string, HandleState | undefined> = {};\n    private readonly wsHandles: Record<string, WSHandleState> = {};\n    private readonly wsSendQueue: WSSendTask[] = [];\n    private wsSendWaitResolve: () => void = () => {};\n\n    constructor(\n        private readonly omu: Omu,\n    ) {\n        omu.network.registerPacket(\n            REQUEST_CREATE,\n            REQUEST_SEND,\n            REQUEST_CLOSE,\n            RESPONSE_CREATE,\n            RESPONSE_CHUNK,\n            RESPONSE_CLOSE,\n            WEBSOCKET_CLOSE,\n            WEBSOCKET_CREATE,\n            WEBSOCKET_DATA,\n            WEBSOCKET_OPEN,\n            WEBSOCKET_ERROR,\n        );\n        omu.network.addPacketHandler(RESPONSE_CREATE, (packet) => {\n            const handle = this.httpHandles[packet.id];\n            if (!handle) {\n                console.warn('Received response for unknown request', packet.id);\n                return;\n            }\n            if (handle.type !== 'created') {\n                console.warn('Received response for already handled request', packet.id);\n                return;\n            }\n            handle.setResponse(packet);\n        });\n        omu.network.addPacketHandler(RESPONSE_CHUNK, (packet) => {\n            const handle = this.httpHandles[packet.meta.id];\n            if (!handle) {\n                console.warn('Received response for unknown request', packet.meta.id);\n                return;\n            }\n            if (handle.type !== 'receiving') {\n                console.warn('Received chunk for non-receiving request', packet.meta.id);\n                return;\n            }\n            handle.receive(packet.body);\n        });\n        omu.network.addPacketHandler(RESPONSE_CLOSE, (packet) => {\n            const handle = this.httpHandles[packet.id];\n            if (!handle) {\n                console.warn('Received response for unknown request', packet.id);\n                return;\n            }\n            if (handle.type !== 'receiving') {\n                console.warn('Received chunk for non-receiving request', packet.id);\n                return;\n            }\n            handle.close();\n            delete this.httpHandles[packet.id];\n        });\n        omu.network.addPacketHandler(WEBSOCKET_OPEN, (packet) => {\n            const handle = this.wsHandles[packet.id];\n            if (!handle) {\n                console.warn('Received response for unknown socket', packet.id);\n                return;\n            }\n            if (handle.type !== 'created') {\n                console.warn('Received response for already handled socket', packet.id);\n                return;\n            }\n            handle.handle.open(packet);\n            handle.type = 'receiving';\n        });\n        omu.network.addPacketHandler(WEBSOCKET_DATA, (packet) => {\n            const handle = this.wsHandles[packet.meta.id];\n            if (!handle) {\n                console.warn('Received response for unknown socket', packet.meta.id);\n                return;\n            }\n            if (handle.type !== 'receiving') {\n                console.warn('Received chunk for non-receiving socket', packet.meta.id);\n                return;\n            }\n            handle.handle.dispatch(packet);\n        });\n        omu.network.addPacketHandler(WEBSOCKET_CLOSE, (packet) => {\n            const handle = this.wsHandles[packet.id];\n            if (!handle) {\n                console.warn('Received response for unknown socket', packet.id);\n                return;\n            }\n            handle.handle.close(packet);\n            delete this.httpHandles[packet.id];\n        });\n        omu.network.addPacketHandler(WEBSOCKET_ERROR, (packet) => {\n            const handle = this.wsHandles[packet.id];\n            if (!handle) {\n                console.warn('Received response for unknown socket', packet.id);\n                return;\n            }\n            handle.handle.error(packet);\n            delete this.httpHandles[packet.id];\n        });\n        omu.event.ready.listen(() => {\n            this.wsSendLoop();\n        });\n    }\n\n    private async wsSendLoop() {\n        while (this.omu.running) {\n            const send = this.wsSendQueue.shift();\n            if (send) {\n                const array = await toUint8Array(send.data);\n                const type = typeof send.data === 'string' ? WSMsgType.TEXT : WSMsgType.BINARY;\n                this.omu.send(WEBSOCKET_DATA, new DataChunk({ id: send.id, type }, array));\n            } else {\n                await new Promise<void>((resolve) => {\n                    this.wsSendWaitResolve = resolve;\n                });\n            }\n        }\n    }\n\n    private generateHeaders(request: Request, init?: RequestInit): Record<string, string> {\n        const headers: Record<string, string> = {};\n        const keys: Record<string, string> = {};\n        const set = (key: string, value: string) => {\n            const lowerKey = key.toLowerCase();\n            const originalKey = keys[lowerKey];\n            if (originalKey) {\n                delete headers[originalKey];\n            }\n            headers[key] = value;\n            keys[lowerKey] = key;\n        };\n        request.headers.forEach((value, key) => {\n            set(key, value);\n        });\n        if (init?.headers) {\n            if (init.headers instanceof Headers) {\n                init.headers.forEach((value, key) => {\n                    set(key, value);\n                });\n            } else if (Array.isArray(init.headers)) {\n                for (const [key, value] of init.headers) {\n                    set(key, value);\n                }\n            } else {\n                for (const key in init.headers) {\n                    const value = init.headers[key];\n                    set(key, value);\n                }\n            }\n        }\n        return headers;\n    }\n\n    private generateId(): Identifier {\n        return this.omu.app.id.join(`${performance.timeOrigin}-${this.requestCount++}`);\n    }\n\n    public async request(input: string | URL | globalThis.Request, init?: RequestInit): Promise<{ response: HttpResponse; stream: ReadableStream }> {\n        const request = new Request(input, init);\n        const id = this.generateId().key();\n        this.omu.send(REQUEST_CREATE, {\n            id,\n            header: this.generateHeaders(request, init),\n            method: request.method,\n            redirect: request.redirect,\n            url: request.url,\n        });\n        if (request.body) {\n            const reader = request.body.getReader();\n            while (true) {\n                const result = await reader.read();\n                if (result.done) {\n                    break;\n                }\n                this.omu.send(REQUEST_SEND, {\n                    meta: { id },\n                    body: result.value,\n                });\n            }\n        }\n        this.omu.send(REQUEST_CLOSE, { id });\n        const chunks: Uint8Array[] = [];\n        const responseFuture = createFuture<HttpResponse>();\n        let chunkEvent = createFuture<boolean>();\n        const setResponse = (response: HttpResponse) => {\n            responseFuture.resolve(response);\n            this.httpHandles[id] = {\n                type: 'receiving',\n                receive(data: Uint8Array<ArrayBufferLike>) {\n                    chunks.push(data);\n                    chunkEvent.resolve(true);\n                    chunkEvent = createFuture<boolean>();\n                },\n                close() {\n                    chunkEvent.resolve(false);\n                },\n            };\n        };\n        this.httpHandles[id] = {\n            type: 'created',\n            setResponse,\n        };\n        const response = await responseFuture.promise;\n        return {\n            response,\n            stream: new ReadableStream<Uint8Array>({\n                async start(controller) {\n                    while (await chunkEvent.promise) {\n                        const chunk = chunks.shift();\n                        if (!chunk) break;\n                        controller.enqueue(chunk);\n                    }\n                    controller.close();\n                },\n            }),\n        };\n    }\n\n    public async fetch(input: string | URL | globalThis.Request, init?: RequestInit): Promise<OmuResponse> {\n        const { response, stream } = await this.request(input, init);\n        return new OmuResponse(\n            new Headers(response.header),\n            response.status >= 200 && response.status < 300,\n            response.redirected,\n            response.status,\n            response.statusText,\n            'basic',\n            response.url,\n            stream,\n            false,\n        );\n    }\n\n    public async ws(input: string | URL | globalThis.Request, options?: {\n        method?: string;\n        autoclose?: boolean;\n        autoping?: boolean;\n        params?: Record<string, string>;\n        headers?: Record<string, string>;\n    }): Promise<OmuWS> {\n        const request = new Request(input, options);\n        const id = this.generateId();\n        const handle = OmuWS.create({\n            addQueue: (data) => {\n                this.wsSendQueue.push({\n                    id: id.key(),\n                    data,\n                });\n                this.wsSendWaitResolve();\n            },\n            dispose: (options: { code?: number; reason?: string }) => {\n                this.omu.send(WEBSOCKET_CLOSE, {\n                    id: id.key(),\n                    code: options.code,\n                    reason: options.reason,\n                });\n                delete this.wsHandles[id.key()];\n            },\n        });\n        this.wsHandles[id.key()] = {\n            type: 'created',\n            handle,\n        };\n        this.omu.send(WEBSOCKET_CREATE, {\n            id: id.key(),\n            header: this.generateHeaders(request, options),\n            method: request.method,\n            redirect: request.redirect,\n            url: request.url,\n        });\n        return handle.ws;\n    }\n}\n\nasync function toUint8Array(data: string | ArrayBufferLike | Blob | ArrayBufferView): Promise<Uint8Array<ArrayBufferLike>> {\n    if (typeof data === 'string') {\n        return textEncoder.encode(data);\n    } else if (data instanceof Blob) {\n        const arrayBuffer = await data.arrayBuffer();\n        return new Uint8Array(arrayBuffer);\n    } else {\n        return new Uint8Array(data as ArrayBufferLike);\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["textEncoder", "PacketType", "ExtensionType", "DataChunk", "OmuResponse", "OmuWS", "WSMsgType", "HTTP_EXTENSION_TYPE", "omu", "HttpExtension", "HTTP_REQUEST_PERMISSION_ID", "REQUEST_CREATE", "REQUEST_SEND", "REQUEST_CLOSE", "RESPONSE_CREATE", "RESPONSE_CHUNK", "RESPONSE_CLOSE", "WEBSOCKET_CREATE", "WEBSOCKET_OPEN", "WEBSOCKET_DATA", "WEBSOCKET_CLOSE", "WEBSOCKET_ERROR", "createFuture", "resolve", "reject", "promise", "res", "rej", "packet", "handle", "send", "array", "toUint8Array", "type", "request", "init", "headers", "keys", "set", "key", "value", "lowerKey", "originalKey", "input", "id", "reader", "result", "chunks", "responseFuture", "chunkEvent", "setResponse", "response", "data", "controller", "chunk", "stream", "options", "arrayBuffer"]
+}

package/dist/api/http/http.d.ts

@@ -0,0 +1,36 @@
+import { JsonType } from '../../serialize';
+export type RequestHandle = {
+    id: string;
+};
+export type HttpRequest = RequestHandle & {
+    header: Record<string, string>;
+    method: string;
+    redirect: RequestRedirect;
+    url: string;
+};
+export declare class DataChunk<T extends JsonType> {
+    readonly meta: T;
+    readonly body: Uint8Array;
+    constructor(meta: T, body: Uint8Array);
+    static serialize<T extends JsonType>(data: DataChunk<T>): Uint8Array;
+    static deserialize<T extends JsonType>(data: Uint8Array): DataChunk<T>;
+}
+export declare class OmuResponse implements Response {
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly redirected: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly type: ResponseType;
+    readonly url: string;
+    readonly body: ReadableStream<Uint8Array<ArrayBuffer>> | null;
+    readonly bodyUsed: boolean;
+    constructor(headers: Headers, ok: boolean, redirected: boolean, status: number, statusText: string, type: ResponseType, url: string, body: ReadableStream<Uint8Array<ArrayBuffer>> | null, bodyUsed: boolean);
+    clone(): OmuResponse;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
+    formData(): Promise<FormData>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}

package/dist/api/http/http.js

@@ -0,0 +1,2 @@
+import{ByteReader as i,ByteWriter as a}from"../../serialize";class n{constructor(e,r){this.meta=e;this.body=r}static serialize(e){const r=new a;return r.writeJSON(e.meta),r.writeUint8Array(e.body),r.finish()}static deserialize(e){const r=i.fromUint8Array(e),t=r.readJSON(),s=r.readUint8Array();return new n(t,s)}}class o{constructor(e,r,t,s,y,d,u,l,p){this.headers=e;this.ok=r;this.redirected=t;this.status=s;this.statusText=y;this.type=d;this.url=u;this.body=l;this.bodyUsed=p}clone(){return new o(this.headers,this.ok,this.redirected,this.status,this.statusText,this.type,this.url,this.body,this.bodyUsed)}async arrayBuffer(){return await new Response(this.body).arrayBuffer()}blob(){return new Response(this.body).blob()}bytes(){return new Response(this.body).arrayBuffer().then(e=>new Uint8Array(e))}formData(){return new Response(this.body).formData()}json(){return new Response(this.body).json()}text(){return new Response(this.body).text()}}export{n as DataChunk,o as OmuResponse};
+//# sourceMappingURL=http.js.map

package/dist/api/http/http.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/http/http.ts"],
+  "sourcesContent": ["import { ByteReader, ByteWriter, JsonType } from '../../serialize';\n\nexport type RequestHandle = {\n    id: string;\n};\n\nexport type HttpRequest = RequestHandle & {\n    header: Record<string, string>;\n    method: string;\n    redirect: RequestRedirect;\n    url: string;\n};\n\nexport class DataChunk<T extends JsonType> {\n    constructor(\n        public readonly meta: T,\n        public readonly body: Uint8Array,\n    ) { }\n\n    public static serialize<T extends JsonType>(data: DataChunk<T>): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeJSON(data.meta);\n        writer.writeUint8Array(data.body);\n        return writer.finish();\n    }\n\n    public static deserialize<T extends JsonType>(data: Uint8Array): DataChunk<T> {\n        const reader = ByteReader.fromUint8Array(data);\n        const meta = reader.readJSON<T>();\n        const body = reader.readUint8Array();\n        return new DataChunk(meta, body);\n    }\n}\n\nexport class OmuResponse implements Response {\n    constructor(\n        public readonly headers: Headers,\n        public readonly ok: boolean,\n        public readonly redirected: boolean,\n        public readonly status: number,\n        public readonly statusText: string,\n        public readonly type: ResponseType,\n        public readonly url: string,\n        public readonly body: ReadableStream<Uint8Array<ArrayBuffer>> | null,\n        public readonly bodyUsed: boolean,\n    ) {}\n\n    clone(): OmuResponse {\n        return new OmuResponse(\n            this.headers,\n            this.ok,\n            this.redirected,\n            this.status,\n            this.statusText,\n            this.type,\n            this.url,\n            this.body,\n            this.bodyUsed,\n        );\n    }\n    async arrayBuffer(): Promise<ArrayBuffer> {\n        return await new Response(this.body).arrayBuffer();\n    }\n    blob(): Promise<Blob> {\n        return new Response(this.body).blob();\n    }\n    bytes(): Promise<Uint8Array<ArrayBuffer>> {\n        return new Response(this.body).arrayBuffer().then((buf) => new Uint8Array(buf));\n    }\n    formData(): Promise<FormData> {\n        return new Response(this.body).formData();\n    }\n    json(): Promise<any> {\n        return new Response(this.body).json();\n    }\n    text(): Promise<string> {\n        return new Response(this.body).text();\n    }\n}\n"],
+  "mappings": "AAAA,OAAS,cAAAA,EAAY,cAAAC,MAA4B,kBAa1C,MAAMC,CAA8B,CACvC,YACoBC,EACAC,EAClB,CAFkB,UAAAD,EACA,UAAAC,CAChB,CAEJ,OAAc,UAA8BC,EAAgC,CACxE,MAAMC,EAAS,IAAIL,EACnB,OAAAK,EAAO,UAAUD,EAAK,IAAI,EAC1BC,EAAO,gBAAgBD,EAAK,IAAI,EACzBC,EAAO,OAAO,CACzB,CAEA,OAAc,YAAgCD,EAAgC,CAC1E,MAAME,EAASP,EAAW,eAAeK,CAAI,EACvCF,EAAOI,EAAO,SAAY,EAC1BH,EAAOG,EAAO,eAAe,EACnC,OAAO,IAAIL,EAAUC,EAAMC,CAAI,CACnC,CACJ,CAEO,MAAMI,CAAgC,CACzC,YACoBC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAX,EACAY,EAClB,CATkB,aAAAP,EACA,QAAAC,EACA,gBAAAC,EACA,YAAAC,EACA,gBAAAC,EACA,UAAAC,EACA,SAAAC,EACA,UAAAX,EACA,cAAAY,CACjB,CAEH,OAAqB,CACjB,OAAO,IAAIR,EACP,KAAK,QACL,KAAK,GACL,KAAK,WACL,KAAK,OACL,KAAK,WACL,KAAK,KACL,KAAK,IACL,KAAK,KACL,KAAK,QACT,CACJ,CACA,MAAM,aAAoC,CACtC,OAAO,MAAM,IAAI,SAAS,KAAK,IAAI,EAAE,YAAY,CACrD,CACA,MAAsB,CAClB,OAAO,IAAI,SAAS,KAAK,IAAI,EAAE,KAAK,CACxC,CACA,OAA0C,CACtC,OAAO,IAAI,SAAS,KAAK,IAAI,EAAE,YAAY,EAAE,KAAMS,GAAQ,IAAI,WAAWA,CAAG,CAAC,CAClF,CACA,UAA8B,CAC1B,OAAO,IAAI,SAAS,KAAK,IAAI,EAAE,SAAS,CAC5C,CACA,MAAqB,CACjB,OAAO,IAAI,SAAS,KAAK,IAAI,EAAE,KAAK,CACxC,CACA,MAAwB,CACpB,OAAO,IAAI,SAAS,KAAK,IAAI,EAAE,KAAK,CACxC,CACJ",
+  "names": ["ByteReader", "ByteWriter", "DataChunk", "meta", "body", "data", "writer", "reader", "OmuResponse", "headers", "ok", "redirected", "status", "statusText", "type", "url", "bodyUsed", "buf"]
+}

package/{src/api/http/index.ts → dist/api/http/index.d.ts}

@@ -1,3 +1,2 @@
 export { HTTP_REQUEST_PERMISSION_ID } from './extension';
 export { OmuWS, type WSMsg } from './websocket';
-

package/dist/api/http/index.js

@@ -0,0 +1,2 @@
+import{HTTP_REQUEST_PERMISSION_ID as r}from"./extension";import{OmuWS as m}from"./websocket";export{r as HTTP_REQUEST_PERMISSION_ID,m as OmuWS};
+//# sourceMappingURL=index.js.map

package/dist/api/http/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/http/index.ts"],
+  "sourcesContent": ["export { HTTP_REQUEST_PERMISSION_ID } from './extension';\nexport { OmuWS, type WSMsg } from './websocket';\n\n"],
+  "mappings": "AAAA,OAAS,8BAAAA,MAAkC,cAC3C,OAAS,SAAAC,MAAyB",
+  "names": ["HTTP_REQUEST_PERMISSION_ID", "OmuWS"]
+}

package/dist/api/http/websocket.d.ts

@@ -0,0 +1,125 @@
+import { DataChunk, RequestHandle } from './http';
+export type WSData = string | ArrayBufferLike | Blob | ArrayBufferView;
+export declare const WSMsgType: {
+    readonly CONTINUATION: 0;
+    readonly TEXT: 1;
+    readonly BINARY: 2;
+    readonly PING: 9;
+    readonly PONG: 10;
+    readonly CLOSE: 8;
+};
+export declare const WSCloseCode: {
+    readonly OK: 1000;
+    readonly GOING_AWAY: 1001;
+    readonly PROTOCOL_ERROR: 1002;
+    readonly UNSUPPORTED_DATA: 1003;
+    readonly ABNORMAL_CLOSURE: 1006;
+    readonly INVALID_TEXT: 1007;
+    readonly POLICY_VIOLATION: 1008;
+    readonly MESSAGE_TOO_BIG: 1009;
+    readonly MANDATORY_EXTENSION: 1010;
+    readonly INTERNAL_ERROR: 1011;
+    readonly SERVICE_RESTART: 1012;
+    readonly TRY_AGAIN_LATER: 1013;
+    readonly BAD_GATEWAY: 1014;
+};
+export type WebSocketOpen = RequestHandle & {
+    url: string;
+    protocol?: string | null;
+};
+export type WebSocketClose = RequestHandle & {
+    code?: number;
+    reason?: string | null;
+};
+export type WebSocketError = RequestHandle & {
+    type: 'ConnectionRefused';
+    reason?: string | null;
+};
+export type EventListenerMap<T> = {
+    [K in keyof T]: ((event: T[K]) => unknown)[];
+};
+export type WSMsg = {
+    type: 'open';
+    data: WebSocketOpen;
+} | {
+    type: 'error';
+    data: WebSocketError;
+} | {
+    type: 'text';
+    data: string;
+} | {
+    type: 'binary';
+    data: Uint8Array;
+} | {
+    type: 'close';
+    data: WebSocketClose;
+};
+export type WebSocketHandle = {
+    ws: OmuWS;
+    open: (response: WebSocketOpen) => void;
+    dispatch: (data: DataChunk<WSDataMeta>) => void;
+    close: (response: WebSocketClose) => void;
+    error: (response: WebSocketError) => void;
+};
+export type WSDataMeta = {
+    id: string;
+    type: typeof WSMsgType.TEXT | typeof WSMsgType.BINARY | typeof WSMsgType.PING | typeof WSMsgType.PONG;
+};
+export type WSHandleState = {
+    type: 'created' | 'receiving';
+    handle: WebSocketHandle;
+};
+type WSOptions = {
+    addQueue: (data: WSData) => void;
+    dispose(options: {
+        code?: number;
+        reason?: string;
+    }): void;
+};
+export declare class OmuWS {
+    protected readonly addQueue: (data: WSData) => void;
+    protected readonly dispose: (options: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    protected readonly receiveQueue: WSMsg[];
+    private receiveResolve;
+    private status;
+    constructor(addQueue: (data: WSData) => void, dispose: (options: {
+        code?: number;
+        reason?: string;
+    }) => void, receiveQueue?: WSMsg[], receiveResolve?: (() => void) | undefined, status?: 'connecting' | 'open' | 'closed');
+    toWebSocket(): OmuWebSocket;
+    static create(options: WSOptions): WebSocketHandle;
+    send(data: WSData): void;
+    close(code?: number, reason?: string): void;
+    receive(): Promise<WSMsg>;
+    protocol: string;
+    url: string;
+}
+export declare class OmuWebSocket implements WebSocket {
+    protected readonly ws: OmuWS;
+    private readonly eventListeners;
+    CONNECTING: 0;
+    OPEN: 1;
+    CLOSING: 2;
+    CLOSED: 3;
+    binaryType: BinaryType;
+    bufferedAmount: number;
+    extensions: string;
+    onclose: ((this: WebSocket, ev: CloseEvent) => unknown) | null;
+    onerror: ((this: WebSocket, ev: Event) => unknown) | null;
+    onmessage: ((this: WebSocket, ev: MessageEvent) => unknown) | null;
+    onopen: ((this: WebSocket, ev: Event) => unknown) | null;
+    protocol: string;
+    readyState: 0 | 2 | 1 | 3;
+    url: string;
+    constructor(ws: OmuWS, eventListeners?: EventListenerMap<WebSocketEventMap>);
+    private receiveLoop;
+    dispatchEvent(event: Event): boolean;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void;
+    removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void;
+}
+export {};

package/dist/api/http/websocket.js

@@ -0,0 +1,2 @@
+import{textDecoder as r}from"../../const";const i={CONTINUATION:0,TEXT:1,BINARY:2,PING:9,PONG:10,CLOSE:8},y={OK:1e3,GOING_AWAY:1001,PROTOCOL_ERROR:1002,UNSUPPORTED_DATA:1003,ABNORMAL_CLOSURE:1006,INVALID_TEXT:1007,POLICY_VIOLATION:1008,MESSAGE_TOO_BIG:1009,MANDATORY_EXTENSION:1010,INTERNAL_ERROR:1011,SERVICE_RESTART:1012,TRY_AGAIN_LATER:1013,BAD_GATEWAY:1014};class n{constructor(e,t,o=[],s=void 0,p="connecting"){this.addQueue=e;this.dispose=t;this.receiveQueue=o;this.receiveResolve=s;this.status=p}toWebSocket(){return new a(this)}static create(e){const t=new n(e.addQueue,e.dispose);return{ws:t,open:o=>{t.receiveQueue.push({type:"open",data:o}),t.receiveResolve?.()},dispatch:o=>{o.meta.type===i.BINARY?t.receiveQueue.push({type:"binary",data:o.body}):t.receiveQueue.push({type:"text",data:r.decode(o.body)}),t.receiveResolve?.()},close:o=>{t.receiveQueue.push({type:"close",data:o}),t.receiveResolve?.()},error:o=>{t.receiveQueue.push({type:"error",data:o}),t.receiveResolve?.()}}}send(e){this.addQueue(e)}close(e,t){this.dispose({code:e,reason:t})}async receive(){if(this.receiveResolve)throw new Error("Already receiving from another async call");for(;this.status!=="closed";){const e=this.receiveQueue.shift();if(!e){await new Promise(t=>this.receiveResolve=t);continue}return e.type==="close"&&(this.status="closed"),e.type==="open"&&(this.status="open"),this.receiveResolve=void 0,e}throw new Error("Receiving on already closed socket")}protocol="";url=""}class a{constructor(e,t={close:[],error:[],message:[],open:[]}){this.ws=e;this.eventListeners=t;this.receiveLoop()}CONNECTING=0;OPEN=1;CLOSING=2;CLOSED=3;binaryType="blob";bufferedAmount=0;extensions="";onclose=null;onerror=null;onmessage=null;onopen=null;protocol="";readyState=0;url="";async receiveLoop(){for(;this.readyState===WebSocket.CLOSED;){const{data:e,type:t}=await this.ws.receive();switch(t){case"close":this.dispatchEvent(new CloseEvent("close",{code:e.code,reason:e.reason??void 0}));break;case"open":this.url=e.url,this.protocol=e.protocol??"",this.dispatchEvent(new Event("open",{}));break;case"error":this.dispatchEvent(new ErrorEvent("error",{error:e.type,message:e.reason??void 0}));break;case"text":case"binary":this.dispatchEvent(new MessageEvent("message",{data:e}));break}}}dispatchEvent(e){const t=this.eventListeners[e.type];for(const o of t)o(e);return e.type==="open"&&this.onopen?.(e),e.type==="error"&&this.onerror?.(e),e.type==="message"&&this.onmessage?.(e),e.type==="close"&&this.onclose?.(e),!0}send(e){this.ws.send(e)}close(e,t){this.ws.close(e,t)}addEventListener(e,t){this.eventListeners[e].push(t)}removeEventListener(e,t){const o=this.eventListeners[e],s=o.indexOf(t);s!==-1&&o.splice(s,1)}}export{n as OmuWS,a as OmuWebSocket,y as WSCloseCode,i as WSMsgType};
+//# sourceMappingURL=websocket.js.map

package/dist/api/http/websocket.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/http/websocket.ts"],
+  "sourcesContent": ["import { textDecoder } from '../../const';\nimport { DataChunk, RequestHandle } from './http';\n\nexport type WSData = string | ArrayBufferLike | Blob | ArrayBufferView;\n\nexport const WSMsgType = {\n    CONTINUATION: 0x0,\n    TEXT: 0x1,\n    BINARY: 0x2,\n    PING: 0x9,\n    PONG: 0xA,\n    CLOSE: 0x8,\n} as const;\n\nexport const WSCloseCode = {\n    OK: 1000,\n    GOING_AWAY: 1001,\n    PROTOCOL_ERROR: 1002,\n    UNSUPPORTED_DATA: 1003,\n    ABNORMAL_CLOSURE: 1006,\n    INVALID_TEXT: 1007,\n    POLICY_VIOLATION: 1008,\n    MESSAGE_TOO_BIG: 1009,\n    MANDATORY_EXTENSION: 1010,\n    INTERNAL_ERROR: 1011,\n    SERVICE_RESTART: 1012,\n    TRY_AGAIN_LATER: 1013,\n    BAD_GATEWAY: 1014,\n} as const;\n\nexport type WebSocketOpen = RequestHandle & {\n    url: string;\n    protocol?: string | null;\n};\nexport type WebSocketClose = RequestHandle & {\n    code?: number;\n    reason?: string | null;\n};\nexport type WebSocketError = RequestHandle & {\n    type: 'ConnectionRefused';\n    reason?: string | null;\n};\n\nexport type EventListenerMap<T> = {\n    [K in keyof T]: ((event: T[K]) => unknown)[]\n};\n\nexport type WSMsg = {\n    type: 'open';\n    data: WebSocketOpen;\n} | {\n    type: 'error';\n    data: WebSocketError;\n} | {\n    type: 'text';\n    data: string;\n} | {\n    type: 'binary';\n    data: Uint8Array;\n} | {\n    type: 'close';\n    data: WebSocketClose;\n};\n\nexport type WebSocketHandle = {\n    ws: OmuWS;\n    open: (response: WebSocketOpen) => void;\n    dispatch: (data: DataChunk<WSDataMeta>) => void;\n    close: (response: WebSocketClose) => void;\n    error: (response: WebSocketError) => void;\n};\n\nexport type WSDataMeta = {\n    id: string;\n    type:\n        | typeof WSMsgType.TEXT\n        | typeof WSMsgType.BINARY\n        | typeof WSMsgType.PING\n        | typeof WSMsgType.PONG;\n};\n\nexport type WSHandleState = {\n    type: 'created' | 'receiving';\n    handle: WebSocketHandle;\n};\n\ntype WSOptions = {\n    addQueue: (data: WSData) => void;\n    dispose(options: {\n        code?: number;\n        reason?: string;\n    }): void;\n};\n\nexport class OmuWS {\n    constructor(\n        protected readonly addQueue: (data: WSData) => void,\n        protected readonly dispose: (options: { code?: number; reason?: string }) => void,\n        protected readonly receiveQueue: WSMsg[] = [],\n        private receiveResolve: (() => void) | undefined = undefined,\n        private status: 'connecting' | 'open' | 'closed' = 'connecting',\n    ) { }\n\n    public toWebSocket(): OmuWebSocket {\n        return new OmuWebSocket(this);\n    }\n\n    public static create(options: WSOptions): WebSocketHandle {\n        const ws = new OmuWS(options.addQueue, options.dispose);\n        return {\n            ws,\n            open: (response) => {\n                ws.receiveQueue.push({\n                    type: 'open',\n                    data: response,\n                });\n                ws.receiveResolve?.();\n            },\n            dispatch: (data: DataChunk<WSDataMeta>): void => {\n                if (data.meta.type === WSMsgType.BINARY) {\n                    ws.receiveQueue.push({\n                        type: 'binary',\n                        data: data.body,\n                    });\n                } else {\n                    ws.receiveQueue.push({\n                        type: 'text',\n                        data: textDecoder.decode(data.body),\n                    });\n                }\n                ws.receiveResolve?.();\n            },\n            close: (response) => {\n                ws.receiveQueue.push({\n                    type: 'close',\n                    data: response,\n                });\n                ws.receiveResolve?.();\n            },\n            error: (response) => {\n                ws.receiveQueue.push({\n                    type: 'error',\n                    data: response,\n                });\n                ws.receiveResolve?.();\n            },\n        };\n    }\n\n    public send(data: WSData): void {\n        this.addQueue(data);\n    }\n\n    public close(code?: number, reason?: string): void {\n        this.dispose({ code, reason });\n    }\n\n    public async receive(): Promise<WSMsg> {\n        if (this.receiveResolve) {\n            throw new Error('Already receiving from another async call');\n        }\n        while (this.status !== 'closed') {\n            const data = this.receiveQueue.shift();\n            if (!data) {\n                await new Promise<void>((resolve) => this.receiveResolve = resolve);\n                continue;\n            }\n            if (data.type === 'close') {\n                this.status = 'closed';\n            }\n            if (data.type === 'open') {\n                this.status = 'open';\n            }\n            this.receiveResolve = undefined;\n            return data;\n        }\n        throw new Error('Receiving on already closed socket');\n    }\n\n    protocol: string = '';\n    url: string = '';\n}\n\nexport class OmuWebSocket implements WebSocket {\n    public CONNECTING = 0 as const;\n    public OPEN = 1 as const;\n    public CLOSING = 2 as const;\n    public CLOSED = 3 as const;\n\n    binaryType: BinaryType = 'blob';\n    bufferedAmount: number = 0;\n    extensions: string = '';\n    onclose: ((this: WebSocket, ev: CloseEvent) => unknown) | null = null;\n    onerror: ((this: WebSocket, ev: Event) => unknown) | null = null;\n    onmessage: ((this: WebSocket, ev: MessageEvent) => unknown) | null = null;\n    onopen: ((this: WebSocket, ev: Event) => unknown) | null = null;\n    protocol: string = '';\n    readyState: 0 | 2 | 1 | 3 = 0;\n    url: string = '';\n\n    constructor(\n        protected readonly ws: OmuWS,\n        private readonly eventListeners: EventListenerMap<WebSocketEventMap> = {\n            close: [],\n            error: [],\n            message: [],\n            open: [],\n        },\n    ) {\n        this.receiveLoop();\n    }\n\n    private async receiveLoop() {\n        while (this.readyState === WebSocket.CLOSED) {\n            const { data, type } = await this.ws.receive();\n            switch (type) {\n                case 'close':\n                    this.dispatchEvent(new CloseEvent('close', {\n                        code: data.code,\n                        reason: data.reason ?? undefined,\n                    }));\n                    break;\n                case 'open':\n                    this.url = data.url;\n                    this.protocol = data.protocol ?? '';\n                    this.dispatchEvent(new Event('open', {}));\n                    break;\n                case 'error':\n                    this.dispatchEvent(new ErrorEvent('error', {\n                        error: data.type,\n                        message: data.reason ?? undefined,\n                    }));\n                    break;\n                case 'text':\n                case 'binary':\n                    this.dispatchEvent(new MessageEvent('message', {\n                        data,\n                    }));\n                    break;\n            }\n        }\n    }\n\n    dispatchEvent(event: Event): boolean {\n        const listeners = this.eventListeners[event.type];\n        for (const listener of listeners) {\n            listener(event);\n        }\n        if (event.type === 'open') {\n            this.onopen?.(event as MessageEvent);\n        }\n        if (event.type === 'error') {\n            this.onerror?.(event);\n        }\n        if (event.type === 'message') {\n            this.onmessage?.(event as MessageEvent);\n        }\n        if (event.type === 'close') {\n            this.onclose?.(event as CloseEvent);\n        }\n        return true;\n    }\n\n    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {\n        this.ws.send(data);\n    }\n\n    close(code?: number, reason?: string): void {\n        this.ws.close(code, reason);\n    }\n\n    addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void {\n        this.eventListeners[type].push(listener);\n    }\n\n    removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void {\n        const listeners = this.eventListeners[type];\n        const index = listeners.indexOf(listener);\n        if (index !== -1) {\n            listeners.splice(index, 1);\n        }\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["textDecoder", "WSMsgType", "WSCloseCode", "OmuWS", "addQueue", "dispose", "receiveQueue", "receiveResolve", "status", "OmuWebSocket", "options", "ws", "response", "data", "code", "reason", "resolve", "eventListeners", "type", "event", "listeners", "listener", "index"]
+}

package/dist/api/i18n/extension.d.ts

@@ -0,0 +1,19 @@
+import { Identifier } from '../../identifier';
+import type { Locale } from '../../localization/locale.js';
+import type { LocalizedText } from '../../localization/localization.js';
+import { Omu } from '../../omu';
+import type { Extension } from '../extension.js';
+import { ExtensionType } from '../extension.js';
+import { type Registry } from '../registry';
+export declare const I18N_EXTENSION_TYPE: ExtensionType<I18nExtension>;
+export declare const I18N_SET_LOCALES_PERMISSION_ID: Identifier;
+export declare const I18N_GET_LOCALES_PERMISSION_ID: Identifier;
+export declare class I18nExtension implements Extension {
+    private readonly omu;
+    readonly type: ExtensionType<I18nExtension>;
+    readonly localesRegistry: Registry<Locale[]>;
+    constructor(omu: Omu);
+    translate(localizedText: LocalizedText): string;
+    selectBestTranslation(locales: readonly Locale[], localizedText: LocalizedText): string | undefined;
+    setLocale(locale: Locale[]): Promise<void>;
+}

package/dist/api/i18n/extension.js

@@ -0,0 +1,2 @@
+import{ExtensionType as p}from"../extension.js";import{RegistryType as u}from"../registry";const i=new p("i18n",l=>new y(l)),_=i.join("locales","set"),x=i.join("locales","get"),f=u.createJson(i,{name:"locales",defaultValue:typeof window>"u"?[]:window.navigator.languages});class y{constructor(e){this.omu=e;this.localesRegistry=e.registries.get(f)}type=i;localesRegistry;translate(e){const t=this.localesRegistry.value;if(typeof e=="string")return e;const n=this.selectBestTranslation(t,e);return n||Object.values(e)[0]}selectBestTranslation(e,t){if(typeof t=="string")return t;const n=t,c=e.reduce((o,s)=>{const a=s.split("-");for(let r=a.length;r>0;r--)o.push(a.slice(0,r).join("-"));return o},[]);for(const o of c){const s=n[o];if(s)return s}}setLocale(e){return this.localesRegistry.set(e)}}export{i as I18N_EXTENSION_TYPE,x as I18N_GET_LOCALES_PERMISSION_ID,_ as I18N_SET_LOCALES_PERMISSION_ID,y as I18nExtension};
+//# sourceMappingURL=extension.js.map

package/dist/api/i18n/extension.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/i18n/extension.ts"],
+  "sourcesContent": ["import { Identifier } from '../../identifier';\nimport type { Locale } from '../../localization/locale.js';\nimport type { LocalizedText } from '../../localization/localization.js';\nimport { Omu } from '../../omu';\nimport type { Extension } from '../extension.js';\nimport { ExtensionType } from '../extension.js';\nimport { RegistryType, type Registry } from '../registry';\n\nexport const I18N_EXTENSION_TYPE: ExtensionType<I18nExtension> = new ExtensionType('i18n', (client) => new I18nExtension(client));\n\nexport const I18N_SET_LOCALES_PERMISSION_ID: Identifier = I18N_EXTENSION_TYPE.join('locales', 'set');\nexport const I18N_GET_LOCALES_PERMISSION_ID: Identifier = I18N_EXTENSION_TYPE.join('locales', 'get');\nconst I18N_LOCALES_REGISTRY_TYPE = RegistryType.createJson<Locale[]>(I18N_EXTENSION_TYPE, {\n    name: 'locales',\n    defaultValue: typeof window === 'undefined' ? [] : window.navigator.languages as Locale[],\n});\n\nexport class I18nExtension implements Extension {\n    public readonly type: ExtensionType<I18nExtension> = I18N_EXTENSION_TYPE;\n    public readonly localesRegistry: Registry<Locale[]>;\n\n    constructor(private readonly omu: Omu) {\n        this.localesRegistry = omu.registries.get(I18N_LOCALES_REGISTRY_TYPE);\n    }\n\n    public translate(localizedText: LocalizedText): string {\n        const locales = this.localesRegistry.value;\n        if (typeof localizedText === 'string') {\n            return localizedText;\n        }\n        const translation = this.selectBestTranslation(locales, localizedText);\n        if (!translation) {\n            return Object.values(localizedText)[0];\n        }\n        return translation;\n    }\n\n    public selectBestTranslation(\n        locales: readonly Locale[],\n        localizedText: LocalizedText,\n    ): string | undefined {\n        if (typeof localizedText === 'string') {\n            return localizedText;\n        }\n        const translations = localizedText;\n        const transformedLocales = locales.reduce((acc, l) => {\n            const parts = l.split('-');\n            for (let i = parts.length; i > 0; i--) {\n                acc.push(parts.slice(0, i).join('-'));\n            }\n            return acc;\n        }, [] as string[]);\n        for (const l of transformedLocales) {\n            const translation = translations[l];\n            if (translation) {\n                return translation;\n            }\n        }\n        return undefined;\n    }\n\n    public setLocale(locale: Locale[]): Promise<void> {\n        return this.localesRegistry.set(locale);\n    }\n}\n"],
+  "mappings": "AAKA,OAAS,iBAAAA,MAAqB,kBAC9B,OAAS,gBAAAC,MAAmC,cAErC,MAAMC,EAAoD,IAAIF,EAAc,OAASG,GAAW,IAAIC,EAAcD,CAAM,CAAC,EAEnHE,EAA6CH,EAAoB,KAAK,UAAW,KAAK,EACtFI,EAA6CJ,EAAoB,KAAK,UAAW,KAAK,EAC7FK,EAA6BN,EAAa,WAAqBC,EAAqB,CACtF,KAAM,UACN,aAAc,OAAO,OAAW,IAAc,CAAC,EAAI,OAAO,UAAU,SACxE,CAAC,EAEM,MAAME,CAAmC,CAI5C,YAA6BI,EAAU,CAAV,SAAAA,EACzB,KAAK,gBAAkBA,EAAI,WAAW,IAAID,CAA0B,CACxE,CALgB,KAAqCL,EACrC,gBAMT,UAAUO,EAAsC,CACnD,MAAMC,EAAU,KAAK,gBAAgB,MACrC,GAAI,OAAOD,GAAkB,SACzB,OAAOA,EAEX,MAAME,EAAc,KAAK,sBAAsBD,EAASD,CAAa,EACrE,OAAKE,GACM,OAAO,OAAOF,CAAa,EAAE,CAAC,CAG7C,CAEO,sBACHC,EACAD,EACkB,CAClB,GAAI,OAAOA,GAAkB,SACzB,OAAOA,EAEX,MAAMG,EAAeH,EACfI,EAAqBH,EAAQ,OAAO,CAACI,EAAKC,IAAM,CAClD,MAAMC,EAAQD,EAAE,MAAM,GAAG,EACzB,QAASE,EAAID,EAAM,OAAQC,EAAI,EAAGA,IAC9BH,EAAI,KAAKE,EAAM,MAAM,EAAGC,CAAC,EAAE,KAAK,GAAG,CAAC,EAExC,OAAOH,CACX,EAAG,CAAC,CAAa,EACjB,UAAWC,KAAKF,EAAoB,CAChC,MAAMF,EAAcC,EAAaG,CAAC,EAClC,GAAIJ,EACA,OAAOA,CAEf,CAEJ,CAEO,UAAUO,EAAiC,CAC9C,OAAO,KAAK,gBAAgB,IAAIA,CAAM,CAC1C,CACJ",
+  "names": ["ExtensionType", "RegistryType", "I18N_EXTENSION_TYPE", "client", "I18nExtension", "I18N_SET_LOCALES_PERMISSION_ID", "I18N_GET_LOCALES_PERMISSION_ID", "I18N_LOCALES_REGISTRY_TYPE", "omu", "localizedText", "locales", "translation", "translations", "transformedLocales", "acc", "l", "parts", "i", "locale"]
+}

package/{src/api/i18n/index.ts → dist/api/i18n/index.d.ts}

@@ -1,2 +1 @@
 export { I18N_GET_LOCALES_PERMISSION_ID, I18N_SET_LOCALES_PERMISSION_ID } from './extension.js';
-

package/dist/api/i18n/index.js

@@ -0,0 +1,2 @@
+import{I18N_GET_LOCALES_PERMISSION_ID as S,I18N_SET_LOCALES_PERMISSION_ID as E}from"./extension.js";export{S as I18N_GET_LOCALES_PERMISSION_ID,E as I18N_SET_LOCALES_PERMISSION_ID};
+//# sourceMappingURL=index.js.map

package/dist/api/i18n/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/i18n/index.ts"],
+  "sourcesContent": ["export { I18N_GET_LOCALES_PERMISSION_ID, I18N_SET_LOCALES_PERMISSION_ID } from './extension.js';\n\n"],
+  "mappings": "AAAA,OAAS,kCAAAA,EAAgC,kCAAAC,MAAsC",
+  "names": ["I18N_GET_LOCALES_PERMISSION_ID", "I18N_SET_LOCALES_PERMISSION_ID"]
+}

package/dist/api/index.d.ts

@@ -0,0 +1,2 @@
+export { ExtensionRegistry } from './extension-registry.js';
+export { ExtensionType, type Extension } from './extension.js';

package/dist/api/index.js

@@ -0,0 +1,2 @@
+import{ExtensionRegistry as t}from"./extension-registry.js";import{ExtensionType as r}from"./extension.js";export{t as ExtensionRegistry,r as ExtensionType};
+//# sourceMappingURL=index.js.map