@transia/isomorphic 1.0.1

package/dist/utils/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToHex = exports.hexToString = exports.randomBytes = exports.hexToBytes = exports.bytesToHex = void 0;
+const crypto_1 = require("crypto");
+const shared_1 = require("./shared");
+const OriginalBuffer = Symbol('OriginalBuffer');
+/**
+ * Converts a Node.js Buffer to a Uint8Array for uniform behavior with browser implementations.
+ *
+ * Choices:
+ * 1. Directly returning the Buffer:
+ *    - Operation: Return Buffer as is (a Buffer *IS* an instanceof Uint8Array).
+ *    - Pros: Most memory and performance efficient.
+ *    - Cons: Violates strict Uint8Array typing and may lead to issues where Buffer-specific features are [ab]used.
+ *
+ * 2. Using `new Uint8Array(buffer)` or `Uint8Array.from(buffer)`:
+ *    - Operation: Copies the buffer's data into a new Uint8Array.
+ *    - Pros: Ensures data isolation; memory-safe.
+ *    - Cons: Less performant due to data duplication.
+ *
+ * 3. Using buf.buffer slice:
+ *    - Operation: Shares memory between Buffer and Uint8Array.
+ *    - Pros: Performant.
+ *    - Cons: Risks with shared memory and potential for invalid references.
+ *
+ * 4. Using buf.buffer slice and keeping a Buffer reference for ownership semantics:
+ *    - Operation: Shares memory and associates the original Buffer with the resulting Uint8Array.
+ *    - Pros: Performant while ensuring the original Buffer isn't garbage collected.
+ *    - Cons: Risks with shared memory but mitigates potential for invalid references.
+ *
+ * The chosen method (4) prioritizes performance by sharing memory while ensuring buffer ownership.
+ *
+ * @param {Buffer} buffer - The Node.js Buffer to convert.
+ * @returns {Uint8Array} Resulting Uint8Array sharing the same memory as the Buffer and maintaining a reference to it.
+ */
+function toUint8Array(buffer) {
+    const u8Array = new Uint8Array(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
+    u8Array[OriginalBuffer] = buffer;
+    return u8Array;
+}
+/* eslint-disable func-style -- Typed to ensure uniformity between node and browser implementations and docs */
+const bytesToHex = (bytes) => {
+    const buf = Buffer.from(bytes);
+    return buf.toString('hex').toUpperCase();
+};
+exports.bytesToHex = bytesToHex;
+const hexToBytes = (hex) => {
+    if (!shared_1.HEX_REGEX.test(hex)) {
+        throw new Error('Invalid hex string');
+    }
+    return toUint8Array(Buffer.from(hex, 'hex'));
+};
+exports.hexToBytes = hexToBytes;
+const randomBytes = (size) => {
+    return toUint8Array((0, crypto_1.randomBytes)(size));
+};
+exports.randomBytes = randomBytes;
+const hexToString = (hex, encoding = 'utf8') => {
+    if (!shared_1.HEX_REGEX.test(hex)) {
+        throw new Error('Invalid hex string');
+    }
+    return new TextDecoder(encoding).decode((0, exports.hexToBytes)(hex));
+};
+exports.hexToString = hexToString;
+const stringToHex = (string) => {
+    return (0, exports.bytesToHex)(new TextEncoder().encode(string));
+};
+exports.stringToHex = stringToHex;
+/* eslint-enable func-style */
+__exportStar(require("./shared"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mCAAyD;AAGzD,qCAAoC;AAEpC,MAAM,cAAc,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAA;AAe/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,SAAS,YAAY,CAAC,MAAc;IAClC,MAAM,OAAO,GAAG,IAAI,UAAU,CAC5B,MAAM,CAAC,MAAM,CAAC,KAAK,CACjB,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CACtC,CACyB,CAAA;IAC5B,OAAO,CAAC,cAAc,CAAC,GAAG,MAAM,CAAA;IAChC,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,+GAA+G;AACxG,MAAM,UAAU,GAAwB,CAAC,KAAK,EAAE,EAAE;IACvD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAC9B,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAA;AAC1C,CAAC,CAAA;AAHY,QAAA,UAAU,cAGtB;AAEM,MAAM,UAAU,GAAwB,CAAC,GAAG,EAAE,EAAE;IACrD,IAAI,CAAC,kBAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAA;KACtC;IACD,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;AAC9C,CAAC,CAAA;AALY,QAAA,UAAU,cAKtB;AAEM,MAAM,WAAW,GAAyB,CAAC,IAAI,EAAE,EAAE;IACxD,OAAO,YAAY,CAAC,IAAA,oBAAiB,EAAC,IAAI,CAAC,CAAC,CAAA;AAC9C,CAAC,CAAA;AAFY,QAAA,WAAW,eAEvB;AAEM,MAAM,WAAW,GAAyB,CAC/C,GAAW,EACX,QAAQ,GAAG,MAAM,EACT,EAAE;IACV,IAAI,CAAC,kBAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAA;KACtC;IACD,OAAO,IAAI,WAAW,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAA,kBAAU,EAAC,GAAG,CAAC,CAAC,CAAA;AAC1D,CAAC,CAAA;AARY,QAAA,WAAW,eAQvB;AAEM,MAAM,WAAW,GAAyB,CAAC,MAAc,EAAU,EAAE;IAC1E,OAAO,IAAA,kBAAU,EAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAA;AACrD,CAAC,CAAA;AAFY,QAAA,WAAW,eAEvB;AACD,8BAA8B;AAE9B,2CAAwB"}

package/dist/utils/shared.d.ts

@@ -0,0 +1,4 @@
+export declare const HEX_REGEX: RegExp;
+export declare function concat(views: Uint8Array[]): Uint8Array;
+export declare function equal(buf1: Uint8Array, buf2: Uint8Array): boolean;
+//# sourceMappingURL=shared.d.ts.map

package/dist/utils/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/utils/shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,QAAkB,CAAA;AAExC,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,CAEtD;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAYjE"}

package/dist/utils/shared.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = exports.concat = exports.HEX_REGEX = void 0;
+const utils_1 = require("@noble/hashes/utils");
+exports.HEX_REGEX = /^[A-F0-9]*$/iu;
+function concat(views) {
+    return (0, utils_1.concatBytes)(...views);
+}
+exports.concat = concat;
+function equal(buf1, buf2) {
+    if (buf1.byteLength !== buf2.byteLength) {
+        return false;
+    }
+    const dv1 = new Int8Array(buf1);
+    const dv2 = new Int8Array(buf2);
+    for (let i = 0; i !== buf1.byteLength; i++) {
+        if (dv1[i] !== dv2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equal = equal;
+//# sourceMappingURL=shared.js.map

package/dist/utils/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../src/utils/shared.ts"],"names":[],"mappings":";;;AAAA,+CAAiD;AAEpC,QAAA,SAAS,GAAG,eAAe,CAAA;AAExC,SAAgB,MAAM,CAAC,KAAmB;IACxC,OAAO,IAAA,mBAAW,EAAC,GAAG,KAAK,CAAC,CAAA;AAC9B,CAAC;AAFD,wBAEC;AAED,SAAgB,KAAK,CAAC,IAAgB,EAAE,IAAgB;IACtD,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,EAAE;QACvC,OAAO,KAAK,CAAA;KACb;IACD,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,CAAA;IAC/B,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,CAAA;IAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE;QAC1C,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE;YACrB,OAAO,KAAK,CAAA;SACb;KACF;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAZD,sBAYC"}

package/dist/utils/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Convert a UInt8Array to hex. The returned hex will be in all caps.
+ *
+ * @param bytes - {Uint8Array} to convert to hex
+ */
+export declare function BytesToHexFn(bytes: Uint8Array | number[]): string;
+/**
+ * Convert hex to a Uint8Array.
+ *
+ * @param hex - {string} to convert to a Uint8Array
+ */
+export declare function HexToBytesFn(hex: string): Uint8Array;
+/**
+ * Create a Uint8Array of the supplied size.
+ *
+ * @param size - number of bytes to generate
+ */
+export declare function RandomBytesFn(size: number): Uint8Array;
+/**
+ * Converts hex to its string equivalent. Useful to read the Domain field and some Memos.
+ *
+ * @param hex - The hex to convert to a string.
+ * @param encoding - The encoding to use. Defaults to 'utf8' (UTF-8). 'ascii' is also allowed.
+ * @returns The converted string.
+ */
+export declare function HexToStringFn(hex: string, encoding?: string): string;
+/**
+ * Converts a utf-8 to its hex equivalent. Useful for Memos.
+ *
+ * @param string - The string to convert to Hex.
+ * @returns The Hex equivalent of the string.
+ */
+export declare function StringToHexFn(string: string): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,MAAM,CAAA;AAE1E;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;AAE7D;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAA;AAE/D;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;AAE7E;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA"}

package/dist/utils/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":""}

package/dist/ws/browser.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'eventemitter3';
+interface WSWrapperOptions {
+    perMessageDeflate: boolean;
+    handshakeTimeout: number;
+    protocolVersion: number;
+    origin: string;
+    maxPayload: number;
+    followRedirects: boolean;
+    maxRedirects: number;
+}
+/**
+ * Provides `EventEmitter` interface for native browser `WebSocket`,
+ * same, as `ws` package provides.
+ */
+export default class WSWrapper extends EventEmitter {
+    static CONNECTING: number;
+    static OPEN: number;
+    static CLOSING: number;
+    static CLOSED: number;
+    private readonly ws;
+    /**
+     * Constructs a browser-safe websocket.
+     *
+     * @param url - URL to connect to.
+     * @param _protocols - Not used.
+     * @param _websocketOptions - Not used.
+     */
+    constructor(url: string, _protocols: string | string[] | WSWrapperOptions | undefined, _websocketOptions: WSWrapperOptions);
+    /**
+     * Get the ready state of the websocket.
+     *
+     * @returns The Websocket's ready state.
+     */
+    get readyState(): number;
+    /**
+     * Closes the websocket.
+     *
+     * @param code - Close code.
+     * @param reason - Close reason.
+     */
+    close(code?: number, reason?: Buffer): void;
+    /**
+     * Sends a message over the Websocket connection.
+     *
+     * @param message - Message to send.
+     */
+    send(message: string): void;
+}
+export {};
+//# sourceMappingURL=browser.d.ts.map

package/dist/ws/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/ws/browser.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAc5C,UAAU,gBAAgB;IACxB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,gBAAgB,EAAE,MAAM,CAAA;IACxB,eAAe,EAAE,MAAM,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,YAAY;IACjD,OAAc,UAAU,SAAI;IAC5B,OAAc,IAAI,SAAI;IACtB,OAAc,OAAO,SAAI;IAEzB,OAAc,MAAM,SAAI;IACxB,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;IAE9B;;;;;;OAMG;gBAED,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,EAC5D,iBAAiB,EAAE,gBAAgB;IA4BrC;;;;OAIG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAMlD;;;;OAIG;IACI,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAGnC"}

package/dist/ws/browser.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-classes-per-file -- Needs to be a wrapper for ws */
+const eventemitter3_1 = require("eventemitter3");
+/**
+ * Provides `EventEmitter` interface for native browser `WebSocket`,
+ * same, as `ws` package provides.
+ */
+class WSWrapper extends eventemitter3_1.EventEmitter {
+    /**
+     * Constructs a browser-safe websocket.
+     *
+     * @param url - URL to connect to.
+     * @param _protocols - Not used.
+     * @param _websocketOptions - Not used.
+     */
+    constructor(url, _protocols, _websocketOptions) {
+        super();
+        this.ws = new WebSocket(url);
+        this.ws.onclose = (closeEvent) => {
+            let reason;
+            if (closeEvent.reason) {
+                const enc = new TextEncoder();
+                reason = enc.encode(closeEvent.reason);
+            }
+            this.emit('close', closeEvent.code, reason);
+        };
+        this.ws.onopen = () => {
+            this.emit('open');
+        };
+        this.ws.onerror = (error) => {
+            this.emit('error', error);
+        };
+        this.ws.onmessage = (message) => {
+            this.emit('message', message.data);
+        };
+    }
+    /**
+     * Get the ready state of the websocket.
+     *
+     * @returns The Websocket's ready state.
+     */
+    get readyState() {
+        return this.ws.readyState;
+    }
+    /**
+     * Closes the websocket.
+     *
+     * @param code - Close code.
+     * @param reason - Close reason.
+     */
+    close(code, reason) {
+        if (this.readyState === 1) {
+            this.ws.close(code, reason);
+        }
+    }
+    /**
+     * Sends a message over the Websocket connection.
+     *
+     * @param message - Message to send.
+     */
+    send(message) {
+        this.ws.send(message);
+    }
+}
+WSWrapper.CONNECTING = 0;
+WSWrapper.OPEN = 1;
+WSWrapper.CLOSING = 2;
+WSWrapper.CLOSED = 3;
+exports.default = WSWrapper;
+//# sourceMappingURL=browser.js.map

package/dist/ws/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../src/ws/browser.ts"],"names":[],"mappings":";;AAAA,yEAAyE;AACzE,iDAA4C;AAwB5C;;;GAGG;AACH,MAAqB,SAAU,SAAQ,4BAAY;IAQjD;;;;;;OAMG;IACH,YACE,GAAW,EACX,UAA4D,EAC5D,iBAAmC;QAEnC,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,EAAE,GAAG,IAAI,SAAS,CAAC,GAAG,CAAC,CAAA;QAE5B,IAAI,CAAC,EAAE,CAAC,OAAO,GAAG,CAAC,UAAsB,EAAQ,EAAE;YACjD,IAAI,MAA8B,CAAA;YAClC,IAAI,UAAU,CAAC,MAAM,EAAE;gBACrB,MAAM,GAAG,GAAG,IAAI,WAAW,EAAE,CAAA;gBAC7B,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;aACvC;YACD,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAC7C,CAAC,CAAA;QAED,IAAI,CAAC,EAAE,CAAC,MAAM,GAAG,GAAS,EAAE;YAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACnB,CAAC,CAAA;QAED,IAAI,CAAC,EAAE,CAAC,OAAO,GAAG,CAAC,KAAK,EAAQ,EAAE;YAChC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QAC3B,CAAC,CAAA;QAED,IAAI,CAAC,EAAE,CAAC,SAAS,GAAG,CAAC,OAAqB,EAAQ,EAAE;YAClD,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;QACpC,CAAC,CAAA;IACH,CAAC;IAED;;;;OAIG;IACH,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,EAAE,CAAC,UAAU,CAAA;IAC3B,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAa,EAAE,MAAe;QACzC,IAAI,IAAI,CAAC,UAAU,KAAK,CAAC,EAAE;YACzB,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;SAC5B;IACH,CAAC;IAED;;;;OAIG;IACI,IAAI,CAAC,OAAe;QACzB,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACvB,CAAC;;AAzEa,oBAAU,GAAG,CAAC,CAAA;AACd,cAAI,GAAG,CAAC,CAAA;AACR,iBAAO,GAAG,CAAC,CAAA;AAEX,gBAAM,GAAG,CAAC,CAAA;kBALL,SAAS"}

package/dist/ws/index.d.ts

@@ -0,0 +1,6 @@
+import WebSocket from 'ws';
+export default class Socket extends WebSocket {
+    constructor(...args: any[]);
+}
+export type ClientOptions = WebSocket.ClientOptions;
+//# sourceMappingURL=index.d.ts.map

package/dist/ws/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ws/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,IAAI,CAAA;AAE1B,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,SAAS;gBAC/B,GAAG,IAAI,OAAA;CAIpB;AAED,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC,aAAa,CAAA"}

package/dist/ws/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = __importDefault(require("ws"));
+class Socket extends ws_1.default {
+    constructor(...args) {
+        super(args[0], args[1], args[2]);
+        this.setMaxListeners(Infinity);
+    }
+}
+exports.default = Socket;
+//# sourceMappingURL=index.js.map

package/dist/ws/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ws/index.ts"],"names":[],"mappings":";;;;;AAAA,4CAA0B;AAE1B,MAAqB,MAAO,SAAQ,YAAS;IAC3C,YAAY,GAAG,IAAI;QACjB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QAChC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAA;IAChC,CAAC;CACF;AALD,yBAKC"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@transia/isomorphic",
+  "version": "1.0.1",
+  "description": "A collection of isomorphic and tree-shakeable crypto hashes and utils for xrpl.js",
+  "keywords": [
+    "crypto",
+    "isomorphic",
+    "xrpl"
+  ],
+  "scripts": {
+    "build": "tsc --build ./tsconfig.build.json",
+    "test": "npm run build && jest --verbose false --silent=false ./test/*.test.ts",
+    "test:browser": "npm run build && karma start ./karma.config.js",
+    "clean": "rm -rf ./dist ./coverage ./test/testCompiledForWeb tsconfig.build.tsbuildinfo",
+    "lint": "eslint . --max-warnings 0",
+    "prepublish": "npm run lint && npm test"
+  },
+  "files": [
+    "dist/*",
+    "sha256/*",
+    "sha512/*",
+    "ripemd160/*",
+    "src/*",
+    "utils/*",
+    "ws/*"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.0.0",
+    "eventemitter3": "5.0.1",
+    "ws": "^8.17.1"
+  },
+  "devDependencies": {
+    "@types/node": "^18.18.38",
+    "@types/ws": "^8.5.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:XRPLF/xrpl.js.git"
+  },
+  "license": "ISC",
+  "prettier": "@xrplf/prettier-config",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "gitHead": "cdaeed0dc8ccb726deb35aaaddcc229eb9aabe6c",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/ripemd160/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@transia/isomorphic/ripemd160",
+  "private": true,
+  "main": "../dist/ripemd160",
+  "types": "../dist/ripemd160",
+  "browser": "../dist/ripemd160/browser.js"
+}

package/sha256/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@transia/isomorphic/sha256",
+  "private": true,
+  "main": "../dist/sha256",
+  "types": "../dist/sha256",
+  "browser": "../dist/sha256/browser.js"
+}

package/sha512/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@transia/isomorphic/sha512",
+  "private": true,
+  "main": "../dist/sha512",
+  "types": "../dist/sha512",
+  "browser": "../dist/sha512/browser.js"
+}

package/src/internal/normalizeInput.ts

@@ -0,0 +1,11 @@
+import { Input } from './types'
+
+/**
+ * Normalize a string, number array, or Uint8Array to a string or Uint8Array.
+ * Both node and noble lib functions accept these types.
+ *
+ * @param input - value to normalize
+ */
+export default function normalizeInput(input: Input): string | Uint8Array {
+  return Array.isArray(input) ? new Uint8Array(input) : input
+}

package/src/internal/types.ts

@@ -0,0 +1,33 @@
+export type ByteEncodedString = string
+export type Input = Uint8Array | number[] | ByteEncodedString
+
+/**
+ * A stripped down isomorphic hash inspired by node's `crypto.Hash`
+ */
+export interface Hash {
+  /**
+   * Updates the hash content with the given data,
+   *
+   * @param data - a byte encoded string, an array of numbers or a Uint8Array
+   */
+  update: (data: Input) => this
+  /**
+   * Calculates the digest of all the data passed to be hashed and returns a Uint8Array
+   */
+  digest: () => Uint8Array
+}
+
+export interface HashFn {
+  /**
+   * Produces a Uint8Array for the given hash contents
+   * Shorthand for calling `create`, `update`, and then `digest`
+   *
+   * @param data - a byte encoded string, an array of numbers or a Uint8Array
+   */
+  (data: Input): Uint8Array
+
+  /**
+   * Creates a new empty `Hash`.
+   */
+  create: () => Hash
+}

package/src/internal/wrapCryptoCreateHash.ts

@@ -0,0 +1,32 @@
+import { createHash } from 'crypto'
+import { Hash, HashFn, Input } from './types'
+import normalizeInput from './normalizeInput'
+
+/**
+ * Wrap createHash from node to provide an interface that is isomorphic
+ *
+ * @param type - the hash name
+ * @param fn - {createHash} the hash factory
+ */
+export default function wrapCryptoCreateHash(
+  type: string,
+  fn: typeof createHash,
+): HashFn {
+  function hashFn(input: Input): Uint8Array {
+    return fn(type).update(normalizeInput(input)).digest()
+  }
+
+  hashFn.create = (): Hash => {
+    const hash = fn(type)
+    return {
+      update(input: Input): Hash {
+        hash.update(normalizeInput(input))
+        return this
+      },
+      digest(): Uint8Array {
+        return hash.digest()
+      },
+    }
+  }
+  return hashFn
+}

package/src/internal/wrapNoble.ts

@@ -0,0 +1,28 @@
+import { CHash } from '@noble/hashes/utils'
+import { Hash, HashFn, Input } from './types'
+import normalizeInput from './normalizeInput'
+
+/**
+ * Wrap a CHash object from @noble/hashes to provide a interface that is isomorphic
+ *
+ * @param chash - {CHash} hash function to wrap
+ */
+export default function wrapNoble(chash: CHash): HashFn {
+  function wrapped(input: Input): Uint8Array {
+    return chash(normalizeInput(input))
+  }
+
+  wrapped.create = (): Hash => {
+    const hash = chash.create()
+    return {
+      update(input: Input): Hash {
+        hash.update(normalizeInput(input))
+        return this
+      },
+      digest(): Uint8Array {
+        return hash.digest()
+      },
+    }
+  }
+  return wrapped
+}

package/src/ripemd160/browser.ts

@@ -0,0 +1,8 @@
+import { ripemd160 as nobleImpl } from '@noble/hashes/ripemd160'
+
+import wrapNoble from '../internal/wrapNoble'
+
+/**
+ * Wrap noble-libs's ripemd160 implementation in HashFn
+ */
+export const ripemd160 = wrapNoble(nobleImpl)

package/src/ripemd160/index.ts

@@ -0,0 +1,7 @@
+import { createHash } from 'crypto'
+import wrapCryptoCreateHash from '../internal/wrapCryptoCreateHash'
+
+/**
+ * Wrap node's native ripemd160 implementation in HashFn
+ */
+export const ripemd160 = wrapCryptoCreateHash('ripemd160', createHash)

package/src/sha256/browser.ts

@@ -0,0 +1,8 @@
+import { sha256 as nobleImpl } from '@noble/hashes/sha256'
+
+import wrapNoble from '../internal/wrapNoble'
+
+/**
+ * Wrap noble-libs's sha256 implementation in HashFn
+ */
+export const sha256 = wrapNoble(nobleImpl)

package/src/sha256/index.ts

@@ -0,0 +1,7 @@
+import { createHash } from 'crypto'
+import wrapCryptoCreateHash from '../internal/wrapCryptoCreateHash'
+
+/**
+ * Wrap node's native sha256 implementation in HashFn
+ */
+export const sha256 = wrapCryptoCreateHash('sha256', createHash)

package/src/sha512/browser.ts

@@ -0,0 +1,8 @@
+import { sha512 as nobleImpl } from '@noble/hashes/sha512'
+
+import wrapNoble from '../internal/wrapNoble'
+
+/**
+ * Wrap noble-libs's sha512 implementation in HashFn
+ */
+export const sha512 = wrapNoble(nobleImpl)

package/src/sha512/index.ts

@@ -0,0 +1,7 @@
+import { createHash } from 'crypto'
+import wrapCryptoCreateHash from '../internal/wrapCryptoCreateHash'
+
+/**
+ * Wrap node's native sha512 implementation in HashFn
+ */
+export const sha512 = wrapCryptoCreateHash('sha512', createHash)

package/src/utils/browser.ts

@@ -0,0 +1,54 @@
+import {
+  bytesToHex as nobleBytesToHex,
+  randomBytes as nobleRandomBytes,
+} from '@noble/hashes/utils'
+import type {
+  BytesToHexFn,
+  HexToBytesFn,
+  HexToStringFn,
+  RandomBytesFn,
+  StringToHexFn,
+} from './types'
+import { HEX_REGEX } from './shared'
+
+/* eslint-disable func-style -- Typed to ensure uniformity between node and browser implementations and docs */
+export const bytesToHex: typeof BytesToHexFn = (bytes) => {
+  const hex = nobleBytesToHex(
+    bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes),
+  )
+  return hex.toUpperCase()
+}
+
+// A clone of hexToBytes from @noble/hashes without the length checks. This allows us to do our own checks.
+export const hexToBytes: typeof HexToBytesFn = (hex): Uint8Array => {
+  const len = hex.length
+  const array = new Uint8Array(len / 2)
+  if (!HEX_REGEX.test(hex)) {
+    throw new Error('Invalid hex string')
+  }
+  for (let i = 0; i < array.length; i++) {
+    const j = i * 2
+    const hexByte = hex.slice(j, j + 2)
+    const byte = Number.parseInt(hexByte, 16)
+    if (Number.isNaN(byte) || byte < 0) {
+      throw new Error('Invalid byte sequence')
+    }
+    array[i] = byte
+  }
+  return array
+}
+
+export const hexToString: typeof HexToStringFn = (
+  hex: string,
+  encoding = 'utf8',
+): string => {
+  return new TextDecoder(encoding).decode(hexToBytes(hex))
+}
+
+export const stringToHex: typeof StringToHexFn = (string: string): string => {
+  return bytesToHex(new TextEncoder().encode(string))
+}
+/* eslint-enable func-style */
+
+export const randomBytes: typeof RandomBytesFn = nobleRandomBytes
+export * from './shared'