@nktkas/hyperliquid 0.13.1 → 0.14.0

package/script/src/transports/websocket/_reconnecting_websocket.js

@@ -0,0 +1,400 @@
+// deno-lint-ignore-file no-explicit-any
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../base.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ReconnectingWebSocket = exports.ReconnectingWebSocketError = void 0;
+    const base_js_1 = require("../../base.js");
+    /** Simple FIFO (First In, First Out) buffer implementation. */
+    class FIFOMessageBuffer {
+        constructor() {
+            Object.defineProperty(this, "messages", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: []
+            });
+        }
+        push(data) {
+            this.messages.push(data);
+        }
+        shift() {
+            return this.messages.shift();
+        }
+        clear() {
+            this.messages = [];
+        }
+    }
+    /** Error thrown when reconnection problems occur. */
+    class ReconnectingWebSocketError extends base_js_1.TransportError {
+        constructor(code, originalError) {
+            super(`Error when reconnecting WebSocket: ${code}`);
+            Object.defineProperty(this, "code", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: code
+            });
+            Object.defineProperty(this, "originalError", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: originalError
+            });
+            this.name = "ReconnectingWebSocketError";
+        }
+    }
+    exports.ReconnectingWebSocketError = ReconnectingWebSocketError;
+    /**
+     * A WebSocket that automatically reconnects when disconnected.
+     * Fully compatible with standard WebSocket API.
+     */
+    class ReconnectingWebSocket {
+        /**
+         * Creates a new reconnecting WebSocket.
+         * @param url - The WebSocket URL to connect to.
+         * @param protocols - The WebSocket protocols to use.
+         * @param options - The configuration options.
+         */
+        constructor(url, protocols, options) {
+            /** Controller for handling connection termination */
+            Object.defineProperty(this, "_terminationController", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: new AbortController()
+            });
+            /** WebSocket protocols */
+            Object.defineProperty(this, "_protocols", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            /** The underlying WebSocket instance */
+            Object.defineProperty(this, "_socket", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            /** Current number of reconnection attempts */
+            Object.defineProperty(this, "_reconnectCount", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 0
+            });
+            /** Array of registered event listeners */
+            Object.defineProperty(this, "_eventListeners", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: []
+            });
+            /** Configuration options */
+            Object.defineProperty(this, "reconnectOptions", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            /** An AbortSignal that is triggered when the connection is permanently closed */
+            Object.defineProperty(this, "terminationSignal", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: this._terminationController.signal
+            });
+            Object.defineProperty(this, "CLOSED", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.CLOSED
+            });
+            Object.defineProperty(this, "CLOSING", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.CLOSING
+            });
+            Object.defineProperty(this, "CONNECTING", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.CONNECTING
+            });
+            Object.defineProperty(this, "OPEN", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.OPEN
+            });
+            this.reconnectOptions = {
+                maxRetries: options?.maxRetries ?? 3,
+                connectionTimeout: options?.connectionTimeout === undefined ? 10_000 : options.connectionTimeout,
+                connectionDelay: options?.connectionDelay ?? ((attempt) => Math.min(~~(1 << attempt) * 150, 10_000)),
+                shouldReconnect: options?.shouldReconnect ?? (() => true),
+                messageBuffer: options?.messageBuffer ?? new FIFOMessageBuffer(),
+            };
+            this._protocols = protocols;
+            this._socket = this.reconnectOptions.connectionTimeout
+                ? this._connectWithTimeout(url, this._protocols, this.reconnectOptions.connectionTimeout)
+                : new WebSocket(url, this._protocols);
+            this._initEventListeners();
+        }
+        /**
+         * Creates a WebSocket connection with timeout.
+         * @param url - The WebSocket URL to connect to.
+         * @param protocols - The WebSocket protocols to use.
+         * @param timeout - The connection timeout in ms.
+         * @returns A new WebSocket instance.
+         */
+        _connectWithTimeout(url, protocols, timeout) {
+            const socket = new WebSocket(url, protocols);
+            const timeoutId = setTimeout(() => {
+                socket.removeEventListener("open", openHandler);
+                socket.removeEventListener("close", closeHandler);
+                socket.close(3008, "Timeout"); // https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
+            }, timeout);
+            const openHandler = () => {
+                socket.removeEventListener("close", closeHandler);
+                clearTimeout(timeoutId);
+            };
+            const closeHandler = () => {
+                socket.removeEventListener("open", openHandler);
+                clearTimeout(timeoutId);
+            };
+            socket.addEventListener("open", openHandler, { once: true });
+            socket.addEventListener("close", closeHandler, { once: true });
+            return socket;
+        }
+        /** Initializes the internal event listeners for the WebSocket. */
+        _initEventListeners() {
+            this._socket.addEventListener("open", () => {
+                // Reset reconnection count
+                this._reconnectCount = 0;
+                // Send all buffered messages
+                let message;
+                while ((message = this.reconnectOptions.messageBuffer.shift()) !== undefined) {
+                    this._socket.send(message);
+                }
+            }, { once: true });
+            this._socket.addEventListener("close", async (event) => {
+                try {
+                    // If the termination signal is already aborted, do not attempt to reconnect
+                    if (this.terminationSignal.aborted)
+                        return;
+                    // Check if reconnection should be attempted
+                    if (++this._reconnectCount > this.reconnectOptions.maxRetries) {
+                        this._cleanup(new ReconnectingWebSocketError("RECONNECTION_LIMIT_REACHED"));
+                        return;
+                    }
+                    const userDecision = await this.reconnectOptions.shouldReconnect(event);
+                    if (this.terminationSignal.aborted)
+                        return; // Check again after the await
+                    if (!userDecision) {
+                        this._cleanup(new ReconnectingWebSocketError("RECONNECTION_STOPPED_BY_USER"));
+                        return;
+                    }
+                    // Delay before reconnecting
+                    const delay = typeof this.reconnectOptions.connectionDelay === "number"
+                        ? this.reconnectOptions.connectionDelay
+                        : await this.reconnectOptions.connectionDelay(this._reconnectCount);
+                    if (this.terminationSignal.aborted)
+                        return; // Check again after the await
+                    await sleep(delay, this.terminationSignal);
+                    // Reconnect the socket
+                    this._socket = this.reconnectOptions.connectionTimeout
+                        ? this._connectWithTimeout(this.url, this._protocols, this.reconnectOptions.connectionTimeout)
+                        : new WebSocket(this.url, this._protocols);
+                    // Reconnect all listeners
+                    this._initEventListeners();
+                    this._eventListeners.forEach(({ type, listenerProxy, options }) => {
+                        this._socket.addEventListener(type, listenerProxy, options);
+                    });
+                }
+                catch (error) {
+                    this._cleanup(new ReconnectingWebSocketError("UNKNOWN_ERROR", error));
+                }
+            }, { once: true });
+        }
+        /**
+         * Clean up internal resources.
+         * @param reason - The reason for cleanup.
+         */
+        _cleanup(reason) {
+            this._terminationController.abort(reason);
+            this.reconnectOptions.messageBuffer.clear();
+            this._eventListeners = [];
+        }
+        /**
+         * Check if two event listeners are the same (just like EventTarget).
+         * @param a - First event listener configuration.
+         * @param b - Second event listener configuration.
+         * @returns True if the listeners match.
+         */
+        _isListenerMatch(a, b) {
+            const aCapture = Boolean(typeof a.options === "object" ? a.options.capture : a.options);
+            const bCapture = Boolean(typeof b.options === "object" ? b.options.capture : b.options);
+            return a.type === b.type && a.listener === b.listener && aCapture === bCapture;
+        }
+        // WebSocket property implementations
+        get url() {
+            return this._socket.url;
+        }
+        get readyState() {
+            return this._socket.readyState;
+        }
+        get bufferedAmount() {
+            return this._socket.bufferedAmount;
+        }
+        get extensions() {
+            return this._socket.extensions;
+        }
+        get protocol() {
+            return this._socket.protocol;
+        }
+        get binaryType() {
+            return this._socket.binaryType;
+        }
+        set binaryType(value) {
+            this._socket.binaryType = value;
+        }
+        get onclose() {
+            return this._socket.onclose;
+        }
+        set onclose(value) {
+            this._socket.onclose = value;
+        }
+        get onerror() {
+            return this._socket.onerror;
+        }
+        set onerror(value) {
+            this._socket.onerror = value;
+        }
+        get onmessage() {
+            return this._socket.onmessage;
+        }
+        set onmessage(value) {
+            this._socket.onmessage = value;
+        }
+        get onopen() {
+            return this._socket.onopen;
+        }
+        set onopen(value) {
+            this._socket.onopen = value;
+        }
+        /**
+         * @param permanently - If true, the connection will be permanently closed. Default is true.
+         */
+        close(code, reason, permanently = true) {
+            if (permanently)
+                this._cleanup(new ReconnectingWebSocketError("USER_INITIATED_CLOSE"));
+            this._socket.close(code, reason);
+        }
+        /**
+         * @note If the connection is not open, the data will be buffered and sent when the connection is established.
+         */
+        send(data) {
+            if (this._socket.readyState !== WebSocket.OPEN && !this.terminationSignal.aborted) {
+                this.reconnectOptions.messageBuffer.push(data);
+            }
+            else {
+                this._socket.send(data);
+            }
+        }
+        addEventListener(type, listener, options) {
+            // Check if the listener is already added
+            const exists = this._eventListeners.some((e) => this._isListenerMatch(e, { type, listener, options }));
+            if (exists)
+                return;
+            // Wrap the original listener to follow the once option when reconnecting
+            const listenerProxy = (event) => {
+                try {
+                    if (typeof listener === "function") {
+                        listener.call(this, event);
+                    }
+                    else {
+                        listener.handleEvent(event);
+                    }
+                }
+                finally {
+                    if (typeof options === "object" && options.once === true) {
+                        const index = this._eventListeners.findIndex((e) => this._isListenerMatch(e, { type, listener, options }));
+                        if (index !== -1)
+                            this._eventListeners.splice(index, 1);
+                    }
+                }
+            };
+            this._eventListeners.push({ type, listener, options, listenerProxy });
+            this._socket.addEventListener(type, listenerProxy, options);
+        }
+        removeEventListener(type, listener, options) {
+            const index = this._eventListeners.findIndex((e) => this._isListenerMatch(e, { type, listener, options }));
+            if (index !== -1) {
+                const { listenerProxy } = this._eventListeners[index];
+                this._socket.removeEventListener(type, listenerProxy, options);
+                this._eventListeners.splice(index, 1);
+            }
+        }
+        dispatchEvent(event) {
+            return this._socket.dispatchEvent(event);
+        }
+    }
+    exports.ReconnectingWebSocket = ReconnectingWebSocket;
+    Object.defineProperty(ReconnectingWebSocket, "CLOSED", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.CLOSED
+    });
+    Object.defineProperty(ReconnectingWebSocket, "CLOSING", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.CLOSING
+    });
+    Object.defineProperty(ReconnectingWebSocket, "CONNECTING", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.CONNECTING
+    });
+    Object.defineProperty(ReconnectingWebSocket, "OPEN", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.OPEN
+    });
+    /**
+     * Returns a promise that resolves after the specified number of ms,
+     * or rejects as soon as the given signal is aborted.
+     * @param ms - The number of ms to sleep.
+     * @param signal - An optional abort signal.
+     * @returns A promise that resolves after the specified delay.
+     */
+    function sleep(ms, signal) {
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(signal?.reason);
+            };
+            const onTimeout = () => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            };
+            const timer = setTimeout(onTimeout, ms);
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+});

package/{esm/src/transports/websocket/websocket_request_dispatcher.d.ts → script/src/transports/websocket/_websocket_request_dispatcher.d.ts}

@@ -1,15 +1,11 @@
-import { TransportError } from "../base.js";
-import type { HyperliquidEventTarget } from "./hyperliquid_event_target.js";
+import { TransportError } from "../../base.js";
+import type { HyperliquidEventTarget } from "./_hyperliquid_event_target.js";
 /**
  * Error thrown when a WebSocket request fails:
  * - When the WebSocket connection is closed
  * - When the server responds with an error message
  */
 export declare class WebSocketRequestError extends TransportError {
-    /**
-     * Creates a new WebSocket request error.
-     * @param message - The error message.
-     */
     constructor(message: string);
 }
 /**
@@ -60,4 +56,4 @@ export declare class WebSocketRequestDispatcher {
      */
     static requestToId(value: unknown): string;
 }
-//# sourceMappingURL=websocket_request_dispatcher.d.ts.map
+//# sourceMappingURL=_websocket_request_dispatcher.d.ts.map

package/script/src/transports/websocket/_websocket_request_dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_websocket_request_dispatcher.d.ts","sourceRoot":"","sources":["../../../../src/src/transports/websocket/_websocket_request_dispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,cAAc;gBACzC,OAAO,EAAE,MAAM;CAI9B;AAED;;;GAGG;AACH,qBAAa,0BAA0B;IAevB,SAAS,CAAC,MAAM,EAAE,SAAS;IAdvC,2BAA2B;IAC3B,SAAS,CAAC,MAAM,EAAE,MAAM,CAAK;IAE7B,oDAAoD;IACpD,SAAS,CAAC,OAAO,EAAE,GAAG,CAClB,MAAM,GAAG,MAAM,EACf;QAAE,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;QAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;KAAE,CAC3E,CAAa;IAEd;;;;OAIG;gBACmB,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,sBAAsB;IA2DzE,+BAA+B;IAC/B,SAAS,KAAK,MAAM,IAAI,MAAM,CAE7B;IAED;;;;;;OAMG;IACG,OAAO,CACT,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,EAC5C,OAAO,EAAE,OAAO,EAChB,MAAM,CAAC,EAAE,WAAW,GACrB,OAAO,CAAC,OAAO,CAAC;IAkCnB;;;;OAIG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAK5D;;;;OAIG;IACH,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAK5D;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;CAK7C"}

package/script/src/transports/websocket/_websocket_request_dispatcher.js

@@ -0,0 +1,212 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../base.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WebSocketRequestDispatcher = exports.WebSocketRequestError = void 0;
+    const base_js_1 = require("../../base.js");
+    /**
+     * Error thrown when a WebSocket request fails:
+     * - When the WebSocket connection is closed
+     * - When the server responds with an error message
+     */
+    class WebSocketRequestError extends base_js_1.TransportError {
+        constructor(message) {
+            super(message);
+            this.name = "WebSocketRequestError";
+        }
+    }
+    exports.WebSocketRequestError = WebSocketRequestError;
+    /**
+     * Manages WebSocket requests to the Hyperliquid API.
+     * Handles request creation, sending, and mapping responses to their corresponding requests.
+     */
+    class WebSocketRequestDispatcher {
+        /**
+         * Creates a new WebSocket request dispatcher.
+         * @param socket - WebSocket connection instance for sending requests to the Hyperliquid WebSocket API
+         * @param hlEvents - Used to recognize Hyperliquid responses and match them with sent requests
+         */
+        constructor(socket, hlEvents) {
+            Object.defineProperty(this, "socket", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: socket
+            });
+            /** Last used request ID */
+            Object.defineProperty(this, "lastId", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 0
+            });
+            /** Map of pending requests waiting for responses */
+            Object.defineProperty(this, "pending", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: new Map()
+            });
+            // Monitor responses and match the pending request
+            hlEvents.addEventListener("subscriptionResponse", (event) => {
+                // Use a stringified request as an id
+                const id = WebSocketRequestDispatcher.requestToId(event.detail.subscription);
+                this.resolve(id, event.detail);
+            });
+            hlEvents.addEventListener("post", (event) => {
+                const data = event.detail.response.type === "info"
+                    ? event.detail.response.payload.data
+                    : event.detail.response.payload;
+                this.resolve(event.detail.id, data);
+            });
+            hlEvents.addEventListener("error", (event) => {
+                try {
+                    // Error event doesn't have an id, use original request to match
+                    const request = event.detail.match(/{.*}/)?.[0];
+                    if (request) {
+                        const parsedRequest = JSON.parse(request);
+                        if ("id" in parsedRequest && typeof parsedRequest.id === "number") {
+                            // If a post request was sent, it is possible to get the id from the request
+                            this.reject(parsedRequest.id, new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+                        }
+                        else if ("subscription" in parsedRequest &&
+                            typeof parsedRequest.subscription === "object" &&
+                            parsedRequest.subscription !== null) {
+                            // If a subscription/unsubscribe request was sent, use the request as an id
+                            const id = WebSocketRequestDispatcher.requestToId(parsedRequest.subscription);
+                            this.reject(id, new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+                        }
+                        else {
+                            // If the request is not recognized, use the parsed request as an id
+                            const id = WebSocketRequestDispatcher.requestToId(parsedRequest);
+                            this.reject(id, new WebSocketRequestError(`Cannot complete WebSocket request: ${event.detail}`));
+                        }
+                    }
+                }
+                catch {
+                    // Ignore JSON parsing errors
+                }
+            });
+            // Throws all pending requests if the connection is dropped
+            socket.addEventListener("close", () => {
+                this.pending.forEach(({ reject }) => {
+                    reject(new WebSocketRequestError("Cannot complete WebSocket request: connection is closed"));
+                });
+                this.pending.clear();
+            });
+        }
+        /** Gets the next request ID */
+        get nextId() {
+            return ++this.lastId;
+        }
+        /**
+         * Sends a request to the Hyperliquid API.
+         * @param method - The method of websocket request.
+         * @param payload - The payload to send with the request.
+         * @param signal - An optional abort signal.
+         * @returns A promise that resolves with the parsed JSON response body.
+         */
+        async request(method, payload, signal) {
+            signal?.throwIfAborted();
+            // Create a request object
+            let id;
+            let request;
+            if (method === "post") {
+                id = this.nextId;
+                request = { method, id, request: payload };
+            }
+            else {
+                id = WebSocketRequestDispatcher.requestToId(payload);
+                request = { method, subscription: payload };
+            }
+            // Send the request
+            this.socket.send(JSON.stringify(request));
+            // Wait for a response
+            let onAbort;
+            return await new Promise((resolve, reject) => {
+                // Add an abort listener
+                onAbort = () => reject(signal?.reason);
+                signal?.addEventListener("abort", onAbort, { once: true });
+                // Add the promise to the pending list
+                this.pending.set(id, { resolve, reject });
+            }).finally(() => {
+                // Remove the abort listener when the promise is settled
+                signal?.removeEventListener("abort", onAbort);
+            });
+        }
+        /**
+         * Resolves a pending request.
+         * @param id - A request ID or a stringified request.
+         * @param value - A resolution value.
+         */
+        resolve(id, value) {
+            this.pending.get(id)?.resolve(value);
+            this.pending.delete(id);
+        }
+        /**
+         * Rejects a pending request.
+         * @param id - A request ID or a stringified request.
+         * @param reason - A rejection reason.
+         */
+        reject(id, reason) {
+            this.pending.get(id)?.reject(reason);
+            this.pending.delete(id);
+        }
+        /**
+         * Normalizes a request object to an ID.
+         * @param value - A request object.
+         * @returns A stringified request.
+         */
+        static requestToId(value) {
+            const lowerHex = deepLowerHex(value);
+            const sorted = deepSortKeys(lowerHex);
+            return JSON.stringify(sorted);
+        }
+    }
+    exports.WebSocketRequestDispatcher = WebSocketRequestDispatcher;
+    /**
+     * Convert all hexadecimal strings to lowercase in an object/array.
+     * @param obj - The object/array to convert hexadecimal strings to lowercase.
+     * @returns A new object/array with hexadecimal strings converted to lowercase.
+     */
+    function deepLowerHex(obj) {
+        if (Array.isArray(obj)) {
+            return obj.map(deepLowerHex);
+        }
+        else if (obj && typeof obj === "object") {
+            return Object.entries(obj).reduce((acc, [key, val]) => ({
+                ...acc,
+                [key]: deepLowerHex(val),
+            }), {});
+        }
+        else if (typeof obj === "string" && /^0x[0-9A-Fa-f]+$/.test(obj)) {
+            return obj.toLowerCase();
+        }
+        else {
+            return obj;
+        }
+    }
+    /**
+     * Deeply sort the keys of an object.
+     * @param obj - An object to sort the keys of.
+     * @returns A new object with sorted keys.
+     */
+    function deepSortKeys(obj) {
+        if (obj === null || typeof obj !== "object") {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(deepSortKeys);
+        }
+        return Object.fromEntries(Object.entries(obj)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => [k, deepSortKeys(v)]));
+    }
+});