@jsprismarine/client 0.1.0-rc.53 → 0.1.0

package/dist/index.cjs.js

@@ -0,0 +1,275 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const raknet = require('@jsprismarine/raknet');
+const Dgram = require('node:dgram');
+const prismarine = require('@jsprismarine/prismarine');
+const Crypto = require('node:crypto');
+const node_events = require('node:events');
+
+const _interopDefault = e => e && e.__esModule ? e : { default: e };
+
+const Dgram__default = /*#__PURE__*/_interopDefault(Dgram);
+const Crypto__default = /*#__PURE__*/_interopDefault(Crypto);
+
+var clearIntervalAsync$1 = {};
+
+var setIntervalAsyncTimer = {};
+
+Object.defineProperty(setIntervalAsyncTimer, "__esModule", { value: true });
+setIntervalAsyncTimer.SetIntervalAsyncTimer = void 0;
+const MIN_INTERVAL_MS = 10;
+const MAX_INTERVAL_MS = 2147483647;
+class SetIntervalAsyncTimer {
+    #timeout = undefined;
+    #promise = undefined;
+    #stopped = false;
+    static startTimer(strategy, handler, intervalMs, ...handlerArgs) {
+        intervalMs = Math.min(Math.max(Math.trunc(intervalMs), MIN_INTERVAL_MS), MAX_INTERVAL_MS);
+        const timer = new SetIntervalAsyncTimer();
+        timer.#scheduleTimeout(strategy, handler, intervalMs, intervalMs, ...handlerArgs);
+        return timer;
+    }
+    static async stopTimer(timer) {
+        timer.#stopped = true;
+        if (timer.#timeout) {
+            clearTimeout(timer.#timeout);
+        }
+        if (timer.#promise) {
+            await timer.#promise;
+        }
+    }
+    #scheduleTimeout(strategy, handler, intervalMs, delayMs, ...handlerArgs) {
+        this.#timeout = setTimeout(async () => {
+            this.#timeout = undefined;
+            this.#promise = this.#runHandlerAndScheduleTimeout(strategy, handler, intervalMs, ...handlerArgs);
+            await this.#promise;
+            this.#promise = undefined;
+        }, delayMs);
+    }
+    async #runHandlerAndScheduleTimeout(strategy, handler, intervalMs, ...handlerArgs) {
+        const startTimeMs = new Date().getTime();
+        try {
+            await handler(...handlerArgs);
+        }
+        finally {
+            if (!this.#stopped) {
+                const executionTimeMs = new Date().getTime() - startTimeMs;
+                const delayMs = strategy === "dynamic"
+                    ? intervalMs > executionTimeMs
+                        ? intervalMs - executionTimeMs
+                        : 0
+                    : intervalMs;
+                this.#scheduleTimeout(strategy, handler, intervalMs, delayMs, ...handlerArgs);
+            }
+        }
+    }
+}
+setIntervalAsyncTimer.SetIntervalAsyncTimer = SetIntervalAsyncTimer;
+
+Object.defineProperty(clearIntervalAsync$1, "__esModule", { value: true });
+var clearIntervalAsync_2 = clearIntervalAsync$1.clearIntervalAsync = void 0;
+const set_interval_async_timer_cjs_1 = setIntervalAsyncTimer;
+/**
+ * Stops an execution cycle started by setIntervalAsync.
+ * Any ongoing function executions will run until completion,
+ * but all future ones will be cancelled.
+ */
+async function clearIntervalAsync(timer) {
+    if (!(timer instanceof set_interval_async_timer_cjs_1.SetIntervalAsyncTimer)) {
+        throw new TypeError("First argument is not an instance of SetIntervalAsyncTimer");
+    }
+    await set_interval_async_timer_cjs_1.SetIntervalAsyncTimer.stopTimer(timer);
+}
+clearIntervalAsync_2 = clearIntervalAsync$1.clearIntervalAsync = clearIntervalAsync;
+
+var setIntervalAsync = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.setIntervalAsync = exports.clearIntervalAsync = void 0;
+	const clear_interval_async_cjs_1 = clearIntervalAsync$1;
+	Object.defineProperty(exports, "clearIntervalAsync", { enumerable: true, get: function () { return clear_interval_async_cjs_1.clearIntervalAsync; } });
+	const set_interval_async_timer_cjs_1 = setIntervalAsyncTimer;
+	/**
+	 * Executes the given handler at fixed intervals, while preventing
+	 * multiple concurrent executions. The handler will never be executed
+	 * concurrently more than once in any given moment, providing a fixed
+	 * time interval between the end of a given execution and the start of
+	 * the following one.
+	 */
+	function setIntervalAsync(handler, intervalMs, ...handlerArgs) {
+	    if (!(typeof handler === "function")) {
+	        throw new TypeError("First argument is not a function");
+	    }
+	    if (!(typeof intervalMs === "number")) {
+	        throw new TypeError("Second argument is not a number");
+	    }
+	    return set_interval_async_timer_cjs_1.SetIntervalAsyncTimer.startTimer("dynamic", handler, intervalMs, ...handlerArgs);
+	}
+	exports.setIntervalAsync = setIntervalAsync; 
+} (setIntervalAsync));
+
+const getRandomInt = (min, max) => {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+const PROTOCOL = 10;
+const DEF_MTU_SIZE = 1455;
+const RAKNET_TPS = 100;
+const RAKNET_TICK_LENGTH = 1 / RAKNET_TPS;
+class Client extends node_events.EventEmitter {
+  clientGUID = Crypto__default.default.randomBytes(8).readBigInt64BE();
+  logger = new prismarine.Logger();
+  address;
+  targetAddress;
+  connection = null;
+  socket = Dgram__default.default.createSocket({ type: "udp4" });
+  get closed() {
+    return false;
+  }
+  connecting = false;
+  connected = false;
+  offlineHandled = false;
+  loginHandled = false;
+  constructor() {
+    super();
+    this.address = new raknet.InetAddress("0.0.0.0", getRandomInt(46e3, 49999));
+    this.socket.bind(this.address.getPort(), this.address.getAddress());
+  }
+  /**
+   * Creates a packet listener on given address and port.
+   */
+  async connect(address = "0.0.0.0", port = 19132) {
+    this.targetAddress = new raknet.InetAddress(address, port);
+    this.socket.on("message", (buffer) => {
+      void this.handle(buffer);
+    });
+    if (this.connection)
+      throw new Error("Already connected/connecting to server.");
+    this.logger.info("JSPrismarine client is now attempting to connect...");
+    const timer = setIntervalAsync.setIntervalAsync(async () => {
+      if (this.closed) {
+        await clearIntervalAsync_2(timer);
+        return;
+      }
+      if (!this.connecting) {
+        const pk = new raknet.Protocol.UnconnectedPing();
+        pk.timestamp = BigInt(Date.now());
+        pk.encode();
+        await this.sendBuffer(pk.getBuffer());
+      }
+      if (this.connected && !this.loginHandled) {
+        const pk = new prismarine.Protocol.Packets.LoginPacket();
+        pk.encode();
+        const sendPk = new raknet.Protocol.Frame();
+        sendPk.reliability = 0;
+        sendPk.content = pk.getBuffer();
+        this.connection.sendFrame(sendPk, raknet.ConnectionPriority.NORMAL);
+        this.loginHandled = true;
+      }
+      this.connection?.update(Date.now());
+    }, RAKNET_TICK_LENGTH * 1e3);
+    return this;
+  }
+  async handle(buffer) {
+    const header = buffer.readUInt8();
+    if (this.connection && this.offlineHandled) {
+      return this.connection.handle(buffer);
+    }
+    let buf;
+    switch (header) {
+      case raknet.MessageIdentifiers.UNCONNECTED_PONG:
+        buf = this.handleUnconnectedPong(buffer);
+        await this.sendBuffer(buf);
+        break;
+      case raknet.MessageIdentifiers.OPEN_CONNECTION_REPLY_1:
+        buf = this.handleOpenConnectionReply1(buffer);
+        await this.sendBuffer(buf);
+        break;
+      case raknet.MessageIdentifiers.OPEN_CONNECTION_REPLY_2:
+        this.handleOpenConnectionReply2(buffer);
+        break;
+      default:
+        this.logger.warn(`Unhandled offline packet ID: ${header}`, "Client/handle");
+    }
+  }
+  handleUnconnectedPong(buffer) {
+    const decodedPacket = new raknet.Protocol.UnconnectedPong(buffer);
+    decodedPacket.decode();
+    if (!decodedPacket.isValid()) {
+      throw new Error("Received an invalid offline message");
+    }
+    const packet = new raknet.Protocol.OpenConnectionRequest1();
+    packet.protocol = PROTOCOL;
+    packet.mtuSize = DEF_MTU_SIZE;
+    packet.encode();
+    return packet.getBuffer();
+  }
+  handleOpenConnectionReply1(buffer) {
+    const decodedPacket = new raknet.Protocol.OpenConnectionReply1(buffer);
+    decodedPacket.decode();
+    if (!decodedPacket.isValid()) {
+      throw new Error("Received an invalid offline message");
+    }
+    const packet = new raknet.Protocol.OpenConnectionRequest2();
+    packet.serverAddress = this.targetAddress;
+    packet.mtuSize = DEF_MTU_SIZE;
+    packet.clientGUID = this.clientGUID;
+    packet.encode();
+    this.connecting = true;
+    this.connection = new raknet.RakNetSession(
+      this,
+      DEF_MTU_SIZE,
+      {
+        address: this.address.getAddress(),
+        port: this.address.getPort(),
+        family: "IPv4",
+        size: 0
+      },
+      Crypto.randomBytes(8).readBigInt64BE()
+    );
+    return packet.getBuffer();
+  }
+  handleOpenConnectionReply2(buffer) {
+    const decodedPacket = new raknet.Protocol.OpenConnectionReply2(buffer);
+    decodedPacket.decode();
+    if (!decodedPacket.isValid()) {
+      throw new Error("Received an invalid offline message");
+    }
+    const packet = new raknet.Protocol.ConnectionRequest();
+    packet.clientGUID = this.clientGUID;
+    packet.requestTimestamp = BigInt(Date.now());
+    packet.encode();
+    const sendPacket = new raknet.Protocol.Frame();
+    sendPacket.reliability = 0;
+    sendPacket.content = packet.getBuffer();
+    this.connection?.sendFrame(sendPacket, raknet.ConnectionPriority.NORMAL);
+    this.offlineHandled = true;
+    this.connected = true;
+  }
+  /**
+   * Sends the buffer to the server
+   *
+   * @param buffer
+   * @param address
+   * @param port
+   */
+  async sendBuffer(buffer) {
+    this.socket.send(buffer, 0, buffer.byteLength, this.targetAddress.getPort(), this.targetAddress.getAddress());
+  }
+  getSocket() {
+    return this.socket;
+  }
+  getAddress() {
+    return this.address;
+  }
+  async removeConnection(_connection, _reason) {
+    throw new Error("Method not implemented.");
+  }
+}
+
+exports.default = Client;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs.js","sources":["../../../node_modules/.pnpm/set-interval-async@3.0.3/node_modules/set-interval-async/dist/set-interval-async-timer.cjs","../../../node_modules/.pnpm/set-interval-async@3.0.3/node_modules/set-interval-async/dist/clear-interval-async.cjs","../../../node_modules/.pnpm/set-interval-async@3.0.3/node_modules/set-interval-async/dist/dynamic/set-interval-async.cjs","../src/index.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SetIntervalAsyncTimer = void 0;\nconst MIN_INTERVAL_MS = 10;\nconst MAX_INTERVAL_MS = 2147483647;\nclass SetIntervalAsyncTimer {\n    #timeout = undefined;\n    #promise = undefined;\n    #stopped = false;\n    static startTimer(strategy, handler, intervalMs, ...handlerArgs) {\n        intervalMs = Math.min(Math.max(Math.trunc(intervalMs), MIN_INTERVAL_MS), MAX_INTERVAL_MS);\n        const timer = new SetIntervalAsyncTimer();\n        timer.#scheduleTimeout(strategy, handler, intervalMs, intervalMs, ...handlerArgs);\n        return timer;\n    }\n    static async stopTimer(timer) {\n        timer.#stopped = true;\n        if (timer.#timeout) {\n            clearTimeout(timer.#timeout);\n        }\n        if (timer.#promise) {\n            await timer.#promise;\n        }\n    }\n    #scheduleTimeout(strategy, handler, intervalMs, delayMs, ...handlerArgs) {\n        this.#timeout = setTimeout(async () => {\n            this.#timeout = undefined;\n            this.#promise = this.#runHandlerAndScheduleTimeout(strategy, handler, intervalMs, ...handlerArgs);\n            await this.#promise;\n            this.#promise = undefined;\n        }, delayMs);\n    }\n    async #runHandlerAndScheduleTimeout(strategy, handler, intervalMs, ...handlerArgs) {\n        const startTimeMs = new Date().getTime();\n        try {\n            await handler(...handlerArgs);\n        }\n        finally {\n            if (!this.#stopped) {\n                const executionTimeMs = new Date().getTime() - startTimeMs;\n                const delayMs = strategy === \"dynamic\"\n                    ? intervalMs > executionTimeMs\n                        ? intervalMs - executionTimeMs\n                        : 0\n                    : intervalMs;\n                this.#scheduleTimeout(strategy, handler, intervalMs, delayMs, ...handlerArgs);\n            }\n        }\n    }\n}\nexports.SetIntervalAsyncTimer = SetIntervalAsyncTimer;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.clearIntervalAsync = void 0;\nconst set_interval_async_timer_cjs_1 = require(\"./set-interval-async-timer.cjs\");\n/**\n * Stops an execution cycle started by setIntervalAsync.\n * Any ongoing function executions will run until completion,\n * but all future ones will be cancelled.\n */\nasync function clearIntervalAsync(timer) {\n    if (!(timer instanceof set_interval_async_timer_cjs_1.SetIntervalAsyncTimer)) {\n        throw new TypeError(\"First argument is not an instance of SetIntervalAsyncTimer\");\n    }\n    await set_interval_async_timer_cjs_1.SetIntervalAsyncTimer.stopTimer(timer);\n}\nexports.clearIntervalAsync = clearIntervalAsync;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setIntervalAsync = exports.clearIntervalAsync = void 0;\nconst clear_interval_async_cjs_1 = require(\"../clear-interval-async.cjs\");\nObject.defineProperty(exports, \"clearIntervalAsync\", { enumerable: true, get: function () { return clear_interval_async_cjs_1.clearIntervalAsync; } });\nconst set_interval_async_timer_cjs_1 = require(\"../set-interval-async-timer.cjs\");\n/**\n * Executes the given handler at fixed intervals, while preventing\n * multiple concurrent executions. The handler will never be executed\n * concurrently more than once in any given moment, providing a fixed\n * time interval between the end of a given execution and the start of\n * the following one.\n */\nfunction setIntervalAsync(handler, intervalMs, ...handlerArgs) {\n    if (!(typeof handler === \"function\")) {\n        throw new TypeError(\"First argument is not a function\");\n    }\n    if (!(typeof intervalMs === \"number\")) {\n        throw new TypeError(\"Second argument is not a number\");\n    }\n    return set_interval_async_timer_cjs_1.SetIntervalAsyncTimer.startTimer(\"dynamic\", handler, intervalMs, ...handlerArgs);\n}\nexports.setIntervalAsync = setIntervalAsync;\n","import { ConnectionPriority, InetAddress, Protocol, RakNetSession, MessageIdentifiers } from '@jsprismarine/raknet';\nimport Dgram, { type Socket } from 'node:dgram';\nimport { Protocol as JSPProtocol, Logger } from '@jsprismarine/prismarine';\nimport { clearIntervalAsync, setIntervalAsync } from 'set-interval-async/dynamic';\nimport Crypto, { randomBytes } from 'node:crypto';\nimport { EventEmitter } from 'node:events';\n\n// https://stackoverflow.com/a/1527820/3142553\nconst getRandomInt = (min: number, max: number) => {\n    min = Math.ceil(min);\n    max = Math.floor(max);\n    return Math.floor(Math.random() * (max - min + 1)) + min;\n};\n\n// Minecraft related protocol\nconst PROTOCOL = 10;\n\n// Max net transfer unit\nconst DEF_MTU_SIZE = 1455;\n\n// Raknet ticks\nconst RAKNET_TPS = 100;\nconst RAKNET_TICK_LENGTH = 1 / RAKNET_TPS;\n\nexport default class Client extends EventEmitter {\n    private clientGUID = Crypto.randomBytes(8).readBigInt64BE();\n    private readonly logger = new Logger();\n    private readonly address: InetAddress;\n    private targetAddress!: InetAddress;\n    private connection: RakNetSession | null = null;\n    private readonly socket = Dgram.createSocket({ type: 'udp4' });\n    private get closed() {\n        return false;\n    }\n\n    private connecting = false;\n    private connected = false;\n    private offlineHandled = false;\n    private loginHandled = false;\n\n    public constructor() {\n        super();\n        this.address = new InetAddress('0.0.0.0', getRandomInt(46000, 49999));\n        this.socket.bind(this.address.getPort(), this.address.getAddress());\n    }\n\n    /**\n     * Creates a packet listener on given address and port.\n     */\n    public async connect(address = '0.0.0.0', port = 19132) {\n        this.targetAddress = new InetAddress(address, port);\n\n        this.socket.on('message', (buffer: Buffer) => {\n            void this.handle(buffer);\n        });\n\n        if (this.connection) throw new Error('Already connected/connecting to server.');\n\n        this.logger.info('JSPrismarine client is now attempting to connect...');\n\n        const timer = setIntervalAsync(async () => {\n            if (this.closed) {\n                await clearIntervalAsync(timer);\n                return;\n            }\n\n            // Send a client packet to the server\n            // so the server goes in target mode\n            // and the login process starts\n            if (!this.connecting) {\n                const pk = new Protocol.UnconnectedPing();\n                pk.timestamp = BigInt(Date.now());\n                // TODO: can be omitted... pk. = this.clientGUID;\n                pk.encode();\n                await this.sendBuffer(pk.getBuffer());\n            }\n\n            if (this.connected && !this.loginHandled) {\n                const pk = new JSPProtocol.Packets.LoginPacket();\n                pk.encode();\n\n                const sendPk = new Protocol.Frame();\n                sendPk.reliability = 0;\n                sendPk.content = pk.getBuffer();\n\n                this.connection!.sendFrame(sendPk, ConnectionPriority.NORMAL); // Packet needs to be splitted\n                this.loginHandled = true;\n            }\n\n            this.connection?.update(Date.now());\n        }, RAKNET_TICK_LENGTH * 1000);\n        return this;\n    }\n\n    private async handle(buffer: Buffer) {\n        const header = buffer.readUInt8(); // Read packet header\n\n        if (this.connection && this.offlineHandled) {\n            return this.connection.handle(buffer);\n        }\n\n        let buf;\n        switch (header) {\n            case MessageIdentifiers.UNCONNECTED_PONG:\n                buf = this.handleUnconnectedPong(buffer);\n                await this.sendBuffer(buf);\n                break;\n            case MessageIdentifiers.OPEN_CONNECTION_REPLY_1:\n                buf = this.handleOpenConnectionReply1(buffer);\n                await this.sendBuffer(buf);\n                break;\n            case MessageIdentifiers.OPEN_CONNECTION_REPLY_2:\n                this.handleOpenConnectionReply2(buffer);\n                break;\n            default:\n                this.logger.warn(`Unhandled offline packet ID: ${header}`, 'Client/handle');\n        }\n    }\n\n    public handleUnconnectedPong(buffer: Buffer) {\n        // Decode server packet\n        const decodedPacket = new Protocol.UnconnectedPong(buffer);\n        decodedPacket.decode();\n\n        // Check packet validity\n        // To refactor\n        if (!decodedPacket.isValid()) {\n            throw new Error('Received an invalid offline message');\n        }\n\n        // Encode response\n        const packet = new Protocol.OpenConnectionRequest1();\n        packet.protocol = PROTOCOL;\n        packet.mtuSize = DEF_MTU_SIZE;\n        packet.encode();\n\n        // Update session status\n        // this.status = ConnectionStatus.Targetted;\n\n        return packet.getBuffer();\n    }\n\n    public handleOpenConnectionReply1(buffer: Buffer) {\n        // Decode server packet\n        const decodedPacket = new Protocol.OpenConnectionReply1(buffer);\n        decodedPacket.decode();\n\n        // Check packet validity\n        // To refactor\n        if (!decodedPacket.isValid()) {\n            throw new Error('Received an invalid offline message');\n        }\n\n        // Encode response\n        const packet = new Protocol.OpenConnectionRequest2();\n        packet.serverAddress = this.targetAddress;\n        packet.mtuSize = DEF_MTU_SIZE;\n        packet.clientGUID = this.clientGUID;\n        packet.encode();\n\n        // Update session status\n        this.connecting = true;\n        // This.status = ConnectionStatus.Connected;\n        this.connection = new RakNetSession(\n            this as any,\n            DEF_MTU_SIZE,\n            {\n                address: this.address.getAddress(),\n                port: this.address.getPort(),\n                family: 'IPv4',\n                size: 0\n            },\n            randomBytes(8).readBigInt64BE()\n        );\n\n        return packet.getBuffer();\n    }\n\n    public handleOpenConnectionReply2(buffer: Buffer) {\n        // Decode server packet\n        const decodedPacket = new Protocol.OpenConnectionReply2(buffer);\n        decodedPacket.decode();\n\n        // Check packet validity\n        // To refactor\n        if (!decodedPacket.isValid()) {\n            throw new Error('Received an invalid offline message');\n        }\n\n        // Encode response (encapsulated)\n        const packet = new Protocol.ConnectionRequest();\n        packet.clientGUID = this.clientGUID;\n        packet.requestTimestamp = BigInt(Date.now());\n        packet.encode();\n\n        const sendPacket = new Protocol.Frame();\n        sendPacket.reliability = 0;\n        sendPacket.content = packet.getBuffer();\n\n        this.connection?.sendFrame(sendPacket, ConnectionPriority.NORMAL);\n\n        this.offlineHandled = true;\n        this.connected = true; // Should be... we can't rely on it\n    }\n\n    /**\n     * Sends the buffer to the server\n     *\n     * @param buffer\n     * @param address\n     * @param port\n     */\n    public async sendBuffer(buffer: Buffer): Promise<void> {\n        this.socket.send(buffer, 0, buffer.byteLength, this.targetAddress.getPort(), this.targetAddress.getAddress());\n    }\n\n    public getSocket(): Socket {\n        return this.socket;\n    }\n\n    public getAddress(): InetAddress {\n        return this.address;\n    }\n\n    public async removeConnection(_connection: RakNetSession, _reason?: string): Promise<void> {\n        throw new Error('Method not implemented.');\n    }\n}\n"],"names":["clearIntervalAsync_1","require$$0","require$$1","EventEmitter","Crypto","Logger","Dgram","InetAddress","setIntervalAsync","clearIntervalAsync","Protocol","JSPProtocol","ConnectionPriority","MessageIdentifiers","RakNetSession","randomBytes"],"mappings":"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","x_google_ignoreList":[0,1,2]}

package/dist/{Client.d.ts → index.d.ts}

@@ -1,9 +1,9 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import { InetAddress, RakNetSession } from '@jsprismarine/raknet';
-import { type Socket } from 'dgram';
-import { EventEmitter } from 'events';
+import { type Socket } from 'node:dgram';
+import { EventEmitter } from 'node:events';
 export default class Client extends EventEmitter {
     private clientGUID;
     private readonly logger;
@@ -37,4 +37,4 @@ export default class Client extends EventEmitter {
     getAddress(): InetAddress;
     removeConnection(_connection: RakNetSession, _reason?: string): Promise<void>;
 }
-//# sourceMappingURL=Client.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAsB,WAAW,EAAY,aAAa,EAAsB,MAAM,sBAAsB,CAAC;AACpH,OAAc,EAAE,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAIhD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAmB3C,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,YAAY;IAC5C,OAAO,CAAC,UAAU,CAA0C;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;IAC/D,OAAO,KAAK,MAAM,GAEjB;IAED,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,YAAY,CAAS;;IAQ7B;;OAEG;IACU,OAAO,CAAC,OAAO,SAAY,EAAE,IAAI,SAAQ;YA6CxC,MAAM;IAyBb,qBAAqB,CAAC,MAAM,EAAE,MAAM;IAuBpC,0BAA0B,CAAC,MAAM,EAAE,MAAM;IAoCzC,0BAA0B,CAAC,MAAM,EAAE,MAAM;IA2BhD;;;;;;OAMG;IACU,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C,SAAS,IAAI,MAAM;IAInB,UAAU,IAAI,WAAW;IAInB,gBAAgB,CAAC,WAAW,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG7F"}