@psy-protocol/utils 1.0.0

package/dist/EventHub.d.ts

@@ -0,0 +1,52 @@
+interface IBaseEvent<T> {
+    type: T;
+}
+type IndexableType = string | number | symbol;
+type TEventListenerMap<T extends IndexableType, TEvents extends IBaseEvent<T>> = {
+    [K in T]?: ((event: TEvents & {
+        type: K;
+    }) => any)[];
+};
+declare class EventHub<TEventType extends IndexableType, TEvents extends IBaseEvent<TEventType>> {
+    eventListeners: TEventListenerMap<TEventType, TEvents>;
+    addEventListener<T extends TEventType>(type: T, listener: (event: TEvents & {
+        type: T;
+    }) => any): boolean;
+    on<T extends TEventType>(type: T, listener: (event: TEvents & {
+        type: T;
+    }) => any): boolean;
+    onOneOf(types: TEventType[], listener: (event: TEvents) => any): boolean;
+    removeOneOf(types: TEventType[], listener: (event: TEvents) => any): boolean;
+    remove<T extends TEventType>(type: T, listener: (event: TEvents & {
+        type: T;
+    }) => any): boolean;
+    once<T extends TEventType>(type: T, listener: (event: TEvents & {
+        type: T;
+    }) => any): () => boolean;
+    onceFilter<T extends TEventType>(type: T, filter: (event: TEvents & {
+        type: T;
+    }) => boolean, listener: (event: TEvents & {
+        type: T;
+    }) => any): () => boolean;
+    removeEventListener<T extends TEventType>(type: T, listener: (event: TEvents & {
+        type: T;
+    }) => any): boolean;
+    removeAllEventListeners<T extends TEventType>(type: T): void;
+    private notifyWithErrorsInternal;
+    notifyWithErrors<T extends TEventType>(type: T, event: Omit<TEvents & {
+        type: T;
+    }, "type">): any[];
+    notifyWithErrors<T extends TEventType>(event: TEvents & {
+        type: T;
+    }): any[];
+    notify<T extends TEventType>(type: T, event: Omit<TEvents & {
+        type: T;
+    }, "type">): void;
+    notify<T extends TEventType>(event: TEvents & {
+        type: T;
+    }): void;
+    private notifyInternal;
+}
+export type { IBaseEvent, IndexableType, TEventListenerMap };
+export { EventHub };
+//# sourceMappingURL=EventHub.d.ts.map

package/dist/EventHub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventHub.d.ts","sourceRoot":"","sources":["../src/EventHub.ts"],"names":[],"mappings":"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"}

package/dist/EventHub.js

@@ -0,0 +1,150 @@
+class EventHub {
+    constructor() {
+        this.eventListeners = {};
+    }
+    addEventListener(type, listener) {
+        if (typeof listener !== "function") {
+            throw new Error("you cannot add an event listener that is not a function");
+        }
+        const eventListenerList = this.eventListeners[type];
+        if (Object.hasOwnProperty.call(this.eventListeners, type) &&
+            eventListenerList &&
+            Array.isArray(eventListenerList)) {
+            if (eventListenerList.indexOf(listener) === -1) {
+                eventListenerList.push(listener);
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            this.eventListeners[type] = [listener];
+            return true;
+        }
+    }
+    on(type, listener) {
+        return this.addEventListener(type, listener);
+    }
+    onOneOf(types, listener) {
+        for (const type of types) {
+            this.addEventListener(type, listener);
+        }
+        return true;
+    }
+    removeOneOf(types, listener) {
+        for (const type of types) {
+            this.removeEventListener(type, listener);
+        }
+        return true;
+    }
+    remove(type, listener) {
+        return this.removeEventListener(type, listener);
+    }
+    once(type, listener) {
+        let called = false;
+        const realListener = (event) => {
+            if (called) {
+                return;
+            }
+            called = true;
+            this.removeEventListener(type, realListener);
+            listener(event);
+        };
+        this.addEventListener(type, realListener);
+        return () => this.removeEventListener(type, realListener);
+    }
+    onceFilter(type, filter, listener) {
+        let called = false;
+        const realListener = (event) => {
+            if (called) {
+                return;
+            }
+            if (filter(event)) {
+                called = true;
+                this.removeEventListener(type, realListener);
+                listener(event);
+            }
+        };
+        this.addEventListener(type, realListener);
+        return () => this.removeEventListener(type, realListener);
+    }
+    removeEventListener(type, listener) {
+        if (Object.hasOwnProperty.call(this.eventListeners, type) && Array.isArray(this.eventListeners[type])) {
+            const listeners = this.eventListeners[type];
+            if (!listeners) {
+                return false;
+            }
+            const index = listeners.indexOf(listener);
+            if (index !== -1) {
+                if (listeners.length === 0) {
+                    this.eventListeners[type] = [];
+                    delete this.eventListeners[type];
+                }
+                else {
+                    this.eventListeners[type] = listeners.slice(0, index).concat(listeners.slice(index + 1));
+                }
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    removeAllEventListeners(type) {
+        this.eventListeners[type] = [];
+        delete this.eventListeners[type];
+    }
+    notifyWithErrorsInternal(event) {
+        const errors = [];
+        if (Object.hasOwnProperty.call(this.eventListeners, event.type) &&
+            Array.isArray(this.eventListeners[event.type]) &&
+            this.eventListeners[event.type].length) {
+            const listeners = this.eventListeners[event.type];
+            for (const listener of listeners) {
+                try {
+                    listener(event);
+                }
+                catch (err) {
+                    errors.push(err);
+                }
+            }
+        }
+        return errors;
+    }
+    notifyWithErrors(eventOrType, event) {
+        if (typeof event === "object" && typeof eventOrType !== "object") {
+            return this.notifyWithErrorsInternal({ type: eventOrType, ...event });
+        }
+        else {
+            return this.notifyWithErrorsInternal(eventOrType);
+        }
+    }
+    notify(eventOrType, event) {
+        if (typeof event === "object" && typeof eventOrType !== "object") {
+            this.notifyInternal({ type: eventOrType, ...event });
+        }
+        else {
+            this.notifyInternal(eventOrType);
+        }
+    }
+    notifyInternal(event) {
+        if (Object.hasOwnProperty.call(this.eventListeners, event.type) &&
+            Array.isArray(this.eventListeners[event.type]) &&
+            this.eventListeners[event.type].length) {
+            const listeners = this.eventListeners[event.type];
+            for (const listener of listeners) {
+                try {
+                    listener(event);
+                }
+                catch (err) {
+                    // do nothing
+                }
+            }
+        }
+    }
+}
+export { EventHub };

package/dist/data/array.d.ts

@@ -0,0 +1,18 @@
+declare function u8ArrayToHex(x: Uint8Array | number[]): string;
+declare function hexToU8Array(hex: string): Uint8Array;
+declare function swapEndianU32(x: number): number;
+declare function swapEndianU16(x: number): number;
+declare function u32ArrayToHex(x: Uint32Array | (number | bigint | string)[]): string;
+declare function hexToU32Array(hex: string, bigEndian?: boolean): Uint32Array;
+declare function u16ArrayToHex(x: Uint16Array | (number | bigint | string)[]): string;
+declare function hexToU16Array(hex: string, bigEndian?: boolean): Uint16Array;
+declare function swapEndianU32Array(x: Uint32Array): Uint32Array;
+declare function swapEndianU32Array(x: number[]): number[];
+declare function swapEndianU16Array(x: Uint16Array): Uint16Array;
+declare function swapEndianU16Array(x: number[]): number[];
+declare function isZeroedArray(x: Uint8Array | number[]): boolean;
+declare function isDataValidASCII(array: Uint8Array | number[]): boolean;
+declare function seq(count: number, startIndex?: number, reversed?: number | boolean): number[];
+declare function rseq(count: number, largestIndex?: number): number[];
+export { u8ArrayToHex, hexToU8Array, u32ArrayToHex, hexToU32Array, u16ArrayToHex, hexToU16Array, isZeroedArray, swapEndianU32Array, swapEndianU32, swapEndianU16Array, swapEndianU16, isDataValidASCII, seq, rseq, };
+//# sourceMappingURL=array.d.ts.map

package/dist/data/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/data/array.ts"],"names":[],"mappings":"AAAA,iBAAS,YAAY,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,MAAM,CAMtD;AAED,iBAAS,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAW7C;AAED,iBAAS,aAAa,CAAC,CAAC,EAAE,MAAM,UAE/B;AAED,iBAAS,aAAa,CAAC,CAAC,EAAE,MAAM,UAE/B;AAED,iBAAS,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM,CAU5E;AACD,iBAAS,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW,CAOlE;AAED,iBAAS,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM,CAQ5E;AAED,iBAAS,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW,CAOlE;AAED,iBAAS,kBAAkB,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;AACzD,iBAAS,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AAQnD,iBAAS,kBAAkB,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;AACzD,iBAAS,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AAQnD,iBAAS,aAAa,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,WAO9C;AAED,iBAAS,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,OAAO,CAO/D;AAED,iBAAS,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,SAAI,EAAE,QAAQ,GAAE,MAAM,GAAG,OAAe,GAAG,MAAM,EAAE,CAYxF;AAED,iBAAS,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAM5D;AAED,OAAO,EACH,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,GAAG,EACH,IAAI,GACP,CAAC"}

package/dist/data/array.js

@@ -0,0 +1,109 @@
+function u8ArrayToHex(x) {
+    const output = [];
+    for (let i = 0, l = x.length; i < l; i++) {
+        output[i] = x[i] < 0x10 ? "0" + x[i].toString(16) : x[i].toString(16);
+    }
+    return output.join("");
+}
+function hexToU8Array(hex) {
+    const hexString = hex.charAt(1) === "x" ? hex.substring(2) : hex;
+    if (hexString.length % 2 === 1) {
+        throw new Error("hex strings must have an even number of characters");
+    }
+    const output = new Uint8Array(hexString.length / 2);
+    for (let i = 0, l = hexString.length / 2; i < l; i++) {
+        output[i] = parseInt(hexString.substring(i * 2, i * 2 + 2), 16);
+    }
+    return output;
+}
+function swapEndianU32(x) {
+    return (((x & 0xff) << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >>> 8) | (x >>> 24)) >>> 0;
+}
+function swapEndianU16(x) {
+    return ((x >>> 8) | ((x & 0xff) << 8)) >>> 0;
+}
+function u32ArrayToHex(x) {
+    if (x instanceof Uint32Array) {
+        return u8ArrayToHex(new Uint8Array(x.buffer));
+    }
+    else {
+        return u8ArrayToHex(new Uint8Array(new Uint32Array(x.map((x) => Number(x)).map((x) => (x < 0 ? x >>> 0 : x) & 0xffffffff)).buffer));
+    }
+}
+function hexToU32Array(hex, bigEndian = false) {
+    const r = new Uint32Array(hexToU8Array(hex).buffer);
+    if (bigEndian) {
+        return swapEndianU32Array(r);
+    }
+    else {
+        return r;
+    }
+}
+function u16ArrayToHex(x) {
+    if (x instanceof Uint16Array) {
+        return u8ArrayToHex(new Uint8Array(x.buffer));
+    }
+    else {
+        return u8ArrayToHex(new Uint8Array(new Uint16Array(x.map((x) => Number(x)).map((x) => (x < 0 ? x >>> 0 : x) & 0xffff)).buffer));
+    }
+}
+function hexToU16Array(hex, bigEndian = false) {
+    const r = new Uint16Array(hexToU8Array(hex).buffer);
+    if (bigEndian) {
+        return swapEndianU16Array(r);
+    }
+    else {
+        return r;
+    }
+}
+function swapEndianU32Array(x) {
+    for (let i = 0; i < x.length; i++) {
+        x[i] = swapEndianU32(x[i]);
+    }
+    return x;
+}
+function swapEndianU16Array(x) {
+    for (let i = 0; i < x.length; i++) {
+        x[i] = swapEndianU16(x[i]);
+    }
+    return x;
+}
+function isZeroedArray(x) {
+    for (let i = 0; i < x.length; i++) {
+        if (x[i] !== 0) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDataValidASCII(array) {
+    for (let i = 0; i < array.length; i++) {
+        if (array[i] < 0 || array[i] > 0x7f) {
+            return false;
+        }
+    }
+    return true;
+}
+function seq(count, startIndex = 0, reversed = false) {
+    const arr = [];
+    if (reversed) {
+        for (let i = 0; i < count; i++) {
+            arr[i] = startIndex + count - 1 - i;
+        }
+    }
+    else {
+        for (let i = 0; i < count; i++) {
+            arr[i] = startIndex + i;
+        }
+    }
+    return arr;
+}
+function rseq(count, largestIndex) {
+    if (typeof largestIndex !== "number") {
+        return seq(count, 0, true);
+    }
+    else {
+        return seq(count, largestIndex - count + 1, true);
+    }
+}
+export { u8ArrayToHex, hexToU8Array, u32ArrayToHex, hexToU32Array, u16ArrayToHex, hexToU16Array, isZeroedArray, swapEndianU32Array, swapEndianU32, swapEndianU16Array, swapEndianU16, isDataValidASCII, seq, rseq, };

package/dist/debounce.d.ts

@@ -0,0 +1,8 @@
+declare function debounce(function_: any, wait?: number, options?: any): {
+    (...arguments_: any): any;
+    clear(): void;
+    flush(): void;
+};
+declare function debouncePromise<T, U extends unknown[]>(generator: (...args: U) => Promise<T>, wait?: number, options?: any): (...args: U) => any;
+export { debounce, debouncePromise };
+//# sourceMappingURL=debounce.d.ts.map

package/dist/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../src/debounce.ts"],"names":[],"mappings":"AAAA,iBAAS,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,SAAM,EAAE,OAAO,GAAE,GAAQ;oBAoChB,GAAG;;;EAqDjD;AAED,iBAAS,eAAe,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE,EAC3C,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EACrC,IAAI,CAAC,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,GAAG,GACd,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,GAAG,CAKrB;AACD,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC"}

package/dist/debounce.js

@@ -0,0 +1,80 @@
+function debounce(function_, wait = 100, options = {}) {
+    if (typeof function_ !== "function") {
+        throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
+    }
+    if (wait < 0) {
+        throw new RangeError("`wait` must not be negative.");
+    }
+    // TODO: Deprecate the boolean parameter at some point.
+    const { immediate } = typeof options === "boolean" ? { immediate: options } : options;
+    let storedContext;
+    let storedArguments;
+    let timeoutId;
+    let timestamp;
+    let result;
+    function later() {
+        const last = Date.now() - timestamp;
+        if (last < wait && last >= 0) {
+            timeoutId = setTimeout(later, wait - last);
+        }
+        else {
+            timeoutId = undefined;
+            if (!immediate) {
+                const callContext = storedContext;
+                const callArguments = storedArguments;
+                storedContext = undefined;
+                storedArguments = undefined;
+                result = function_.apply(callContext, callArguments);
+            }
+        }
+    }
+    const debounced = function (...arguments_) {
+        //@ts-ignore
+        if (storedContext && this !== storedContext) {
+            throw new Error("Debounced method called with different contexts.");
+        }
+        //@ts-ignore
+        storedContext = this; // eslint-disable-line unicorn/no-this-assignment
+        storedArguments = arguments_;
+        timestamp = Date.now();
+        const callNow = immediate && !timeoutId;
+        if (!timeoutId) {
+            timeoutId = setTimeout(later, wait);
+        }
+        if (callNow) {
+            const callContext = storedContext;
+            const callArguments = storedArguments;
+            storedContext = undefined;
+            storedArguments = undefined;
+            result = function_.apply(callContext, callArguments);
+        }
+        return result;
+    };
+    debounced.clear = () => {
+        if (!timeoutId) {
+            return;
+        }
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+    };
+    debounced.flush = () => {
+        if (!timeoutId) {
+            return;
+        }
+        const callContext = storedContext;
+        const callArguments = storedArguments;
+        storedContext = undefined;
+        storedArguments = undefined;
+        result = function_.apply(callContext, callArguments);
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+    };
+    return debounced;
+}
+function debouncePromise(generator, wait, options) {
+    const fnc = (...args) => {
+        generator(...args).catch(console.error);
+    };
+    return debounce(fnc, wait, options);
+}
+export { debounce, debouncePromise };

package/dist/hash/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sha256";
+export * from "./ripemd160";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hash/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}

package/dist/hash/index.js

@@ -0,0 +1,2 @@
+export * from "./sha256";
+export * from "./ripemd160";

package/dist/hash/ripemd160.d.ts

@@ -0,0 +1,24 @@
+/*! noble-ripemd160 - MIT License (c) Paul Miller (paulmillr.com) */
+export declare class RIPEMD160 {
+    private h0;
+    private h1;
+    private h2;
+    private h3;
+    private h4;
+    private block;
+    private blockSize;
+    private offset;
+    private length;
+    private finalized;
+    private view;
+    constructor();
+    update(data: Uint8Array): this;
+    private compress;
+    digest(): Uint8Array;
+}
+declare function ripemd160(message: Uint8Array): Uint8Array;
+declare function ripemd160(message: string): string;
+export declare function ripemd160Buffer(data: Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | ArrayBuffer, encoding?: string): Uint8Array | string;
+export declare function ripemd160Hex(hexString: string, encoding?: string): string | Uint8Array;
+export { ripemd160 };
+//# sourceMappingURL=ripemd160.d.ts.map

package/dist/hash/ripemd160.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripemd160.d.ts","sourceRoot":"","sources":["../../src/hash/ripemd160.ts"],"names":[],"mappings":"AAAA,oEAAoE;AA2DpE,qBAAa,SAAS;IAClB,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAW;;IAMvB,MAAM,CAAC,IAAI,EAAE,UAAU;IAyBvB,OAAO,CAAC,QAAQ;IAyChB,MAAM,IAAI,UAAU;CAkCvB;AAYD,iBAAS,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC;AACpD,iBAAS,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;AAQ5C,wBAAgB,eAAe,CAC3B,IAAI,EACE,UAAU,GACV,SAAS,GACT,WAAW,GACX,UAAU,GACV,WAAW,GACX,UAAU,GACV,cAAc,GACd,aAAa,GACb,WAAW,EACjB,QAAQ,CAAC,EAAE,MAAM,GAClB,UAAU,GAAG,MAAM,CAUrB;AACD,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,uBAEhE;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/hash/ripemd160.js

@@ -0,0 +1,186 @@
+/*! noble-ripemd160 - MIT License (c) Paul Miller (paulmillr.com) */
+import { hexToU8Array } from "../data/array";
+// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+// https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+// prettier-ignore
+const rl = Uint8Array.from([
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+    3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+    1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+    4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+]);
+// prettier-ignore
+const rr = Uint8Array.from([
+    5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+    6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+    15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+    8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+    12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+]);
+// prettier-ignore
+const sl = Uint8Array.from([
+    11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+    7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+    11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+    11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+    9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+]);
+// prettier-ignore
+const sr = Uint8Array.from([
+    8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+    9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+    9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+    15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+    8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+]);
+const Kl = Uint32Array.from([0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]);
+const Kr = Uint32Array.from([0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]);
+function rotl(x, n) {
+    return (x << n) | (x >>> (32 - n));
+}
+// It's called f() in spec.
+function f(group, x, y, z) {
+    if (group === 0)
+        return x ^ y ^ z;
+    else if (group === 1)
+        return (x & y) | (~x & z);
+    else if (group === 2)
+        return (x | ~y) ^ z;
+    else if (group === 3)
+        return (x & z) | (y & ~z);
+    else
+        return x ^ (y | ~z);
+}
+export class RIPEMD160 {
+    constructor() {
+        this.h0 = 0x67452301 | 0;
+        this.h1 = 0xefcdab89 | 0;
+        this.h2 = 0x98badcfe | 0;
+        this.h3 = 0x10325476 | 0;
+        this.h4 = 0xc3d2e1f0 | 0;
+        this.block = new Uint8Array(64);
+        this.blockSize = 64;
+        this.offset = 0;
+        this.length = new Uint32Array(4);
+        this.finalized = false;
+        this.view = new DataView(this.block.buffer);
+    }
+    update(data) {
+        if (this.finalized)
+            throw new Error("Digest already called");
+        // consume data
+        const block = this.block;
+        let offset = 0;
+        while (this.offset + data.length - offset >= this.blockSize) {
+            for (let i = this.offset; i < this.blockSize;)
+                block[i++] = data[offset++];
+            this.compress();
+            this.offset = 0;
+        }
+        while (offset < data.length)
+            block[this.offset++] = data[offset++];
+        // update length
+        for (let j = 0, carry = data.length * 8; carry > 0; j++) {
+            let len = this.length[j];
+            len += carry;
+            carry = (len / 0x0100000000) | 0;
+            if (carry > 0)
+                len -= 0x0100000000 * carry;
+            this.length[j] = len;
+        }
+        return this;
+    }
+    compress() {
+        const wordBlocks = new Uint32Array(16);
+        for (let i = 0; i < 16; i++) {
+            wordBlocks[i] = this.view.getInt32(i * 4, true);
+        }
+        // prettier-ignore
+        let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
+        // Instead of iterating 0 to 80, we split it into 5 groups
+        // And use the groups in constants, functions, etc. Much simpler
+        for (let group = 0; group < 5; group++) {
+            const rGroup = 4 - group;
+            const hbl = Kl[group];
+            const hbr = Kr[group];
+            for (let i = 0; i < 16; i++) {
+                const j = 16 * group + i;
+                const tl = (rotl(al + f(group, bl, cl, dl) + wordBlocks[rl[j]] + hbl, sl[j]) + el) | 0;
+                al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
+            }
+            // 2 loops are 10% faster
+            for (let i = 0; i < 16; i++) {
+                const j = 16 * group + i;
+                const tr = (rotl(ar + f(rGroup, br, cr, dr) + wordBlocks[rr[j]] + hbr, sr[j]) + er) | 0;
+                ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore
+            }
+        }
+        // update state
+        const t = (this.h1 + cl + dr) | 0;
+        this.h1 = (this.h2 + dl + er) | 0;
+        this.h2 = (this.h3 + el + ar) | 0;
+        this.h3 = (this.h4 + al + br) | 0;
+        this.h4 = (this.h0 + bl + cr) | 0;
+        this.h0 = t;
+    }
+    digest() {
+        if (this.finalized)
+            throw new Error("Digest already called");
+        this.finalized = true;
+        // create padding and handle blocks
+        this.block[this.offset++] = 0x80;
+        if (this.offset > 56) {
+            this.block.fill(0, this.offset, 64);
+            this.compress();
+            this.offset = 0;
+        }
+        this.block.fill(0, this.offset, 56);
+        this.view.setUint32(56, this.length[0], true);
+        this.view.setUint32(60, this.length[1], true);
+        this.compress();
+        // produce result
+        const res = new DataView(new ArrayBuffer(20));
+        res.setInt32(0, this.h0, true);
+        res.setInt32(4, this.h1, true);
+        res.setInt32(8, this.h2, true);
+        res.setInt32(12, this.h3, true);
+        res.setInt32(16, this.h4, true);
+        // reset state
+        this.block.fill(0);
+        this.offset = 0;
+        for (let i = 0; i < 4; i++) {
+            this.length[i] = 0;
+        }
+        return new Uint8Array(res.buffer);
+    }
+}
+function toHex(uint8a) {
+    return Array.from(uint8a)
+        .map((c) => c.toString(16).padStart(2, "0"))
+        .join("");
+}
+function utf8ToBytes(str) {
+    return new TextEncoder().encode(str);
+}
+function ripemd160(message) {
+    const hasher = new RIPEMD160();
+    hasher.update(message instanceof Uint8Array ? message : utf8ToBytes(message));
+    const hash = hasher.digest();
+    return typeof message === "string" ? toHex(hash) : hash;
+}
+export function ripemd160Buffer(data, encoding) {
+    const inputDataBuffer = data instanceof ArrayBuffer ? data : data.buffer;
+    const hash = new RIPEMD160();
+    hash.update(new Uint8Array(inputDataBuffer));
+    if (encoding === "hex") {
+        return toHex(hash.digest());
+    }
+    else {
+        return hash.digest();
+    }
+}
+export function ripemd160Hex(hexString, encoding) {
+    return ripemd160Buffer(hexToU8Array(hexString), encoding);
+}
+export { ripemd160 };

package/dist/hash/sha256.d.ts

@@ -0,0 +1,30 @@
+export declare function createHash(algorithm?: string): Hash;
+export declare class Hash {
+    private A;
+    private B;
+    private C;
+    private D;
+    private E;
+    private F;
+    private G;
+    private H;
+    private _byte;
+    private _word;
+    private _size;
+    private _sp;
+    constructor();
+    update(data: string, encoding?: string): this;
+    update(data: Uint8Array): this;
+    update(data: ArrayBufferView): this;
+    private _uint8;
+    private _utf8;
+    private _int32;
+    digest(): Uint8Array;
+    digest(encoding: string): string;
+    private _hex;
+    private _bin;
+}
+declare function sha256Buffer(data: Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | ArrayBuffer, encoding?: string): Uint8Array | string;
+declare function sha256Hex(hexString: string, encoding?: string): string | Uint8Array;
+export { sha256Buffer, sha256Hex };
+//# sourceMappingURL=sha256.d.ts.map

package/dist/hash/sha256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.d.ts","sourceRoot":"","sources":["../../src/hash/sha256.ts"],"names":[],"mappings":"AA+GA,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,QAM5C;AAED,qBAAa,IAAI;IAEb,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAE3B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,GAAG,CAAK;;IAahB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAC7C,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAC9B,MAAM,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IA0CnC,OAAO,CAAC,MAAM;IAuBd,OAAO,CAAC,KAAK;IAgDb,OAAO,CAAC,MAAM;IAoCd,MAAM,IAAI,UAAU;IACpB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAqChC,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,IAAI;CAcf;AA6BD,iBAAS,YAAY,CACjB,IAAI,EACE,UAAU,GACV,SAAS,GACT,WAAW,GACX,UAAU,GACV,WAAW,GACX,UAAU,GACV,cAAc,GACd,aAAa,GACb,WAAW,EACjB,QAAQ,CAAC,EAAE,MAAM,GAClB,UAAU,GAAG,MAAM,CAUrB;AACD,iBAAS,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,uBAEtD;AAED,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC"}

package/dist/hash/sha256.js

@@ -0,0 +1,331 @@
+/*
+
+MIT License
+
+Copyright (c) 2020-2023 Yusuke Kawasaki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+import { hexToU8Array } from "../data/array";
+// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311
+const K = [
+    0x428a2f98 | 0,
+    0x71374491 | 0,
+    0xb5c0fbcf | 0,
+    0xe9b5dba5 | 0,
+    0x3956c25b | 0,
+    0x59f111f1 | 0,
+    0x923f82a4 | 0,
+    0xab1c5ed5 | 0,
+    0xd807aa98 | 0,
+    0x12835b01 | 0,
+    0x243185be | 0,
+    0x550c7dc3 | 0,
+    0x72be5d74 | 0,
+    0x80deb1fe | 0,
+    0x9bdc06a7 | 0,
+    0xc19bf174 | 0,
+    0xe49b69c1 | 0,
+    0xefbe4786 | 0,
+    0x0fc19dc6 | 0,
+    0x240ca1cc | 0,
+    0x2de92c6f | 0,
+    0x4a7484aa | 0,
+    0x5cb0a9dc | 0,
+    0x76f988da | 0,
+    0x983e5152 | 0,
+    0xa831c66d | 0,
+    0xb00327c8 | 0,
+    0xbf597fc7 | 0,
+    0xc6e00bf3 | 0,
+    0xd5a79147 | 0,
+    0x06ca6351 | 0,
+    0x14292967 | 0,
+    0x27b70a85 | 0,
+    0x2e1b2138 | 0,
+    0x4d2c6dfc | 0,
+    0x53380d13 | 0,
+    0x650a7354 | 0,
+    0x766a0abb | 0,
+    0x81c2c92e | 0,
+    0x92722c85 | 0,
+    0xa2bfe8a1 | 0,
+    0xa81a664b | 0,
+    0xc24b8b70 | 0,
+    0xc76c51a3 | 0,
+    0xd192e819 | 0,
+    0xd6990624 | 0,
+    0xf40e3585 | 0,
+    0x106aa070 | 0,
+    0x19a4c116 | 0,
+    0x1e376c08 | 0,
+    0x2748774c | 0,
+    0x34b0bcb5 | 0,
+    0x391c0cb3 | 0,
+    0x4ed8aa4a | 0,
+    0x5b9cca4f | 0,
+    0x682e6ff3 | 0,
+    0x748f82ee | 0,
+    0x78a5636f | 0,
+    0x84c87814 | 0,
+    0x8cc70208 | 0,
+    0x90befffa | 0,
+    0xa4506ceb | 0,
+    0xbef9a3f7 | 0,
+    0xc67178f2 | 0,
+];
+const algorithms = {
+    sha256: 1,
+};
+export function createHash(algorithm) {
+    if (algorithm && !algorithms[algorithm] && !algorithms[algorithm.toLowerCase()]) {
+        throw new Error("Digest method not supported");
+    }
+    return new Hash();
+}
+export class Hash {
+    constructor() {
+        // first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19
+        this.A = 0x6a09e667 | 0;
+        this.B = 0xbb67ae85 | 0;
+        this.C = 0x3c6ef372 | 0;
+        this.D = 0xa54ff53a | 0;
+        this.E = 0x510e527f | 0;
+        this.F = 0x9b05688c | 0;
+        this.G = 0x1f83d9ab | 0;
+        this.H = 0x5be0cd19 | 0;
+        this._size = 0;
+        this._sp = 0; // surrogate pair
+        if (!sharedBuffer || sharedOffset >= 8000 /* N.allocTotal */) {
+            sharedBuffer = new ArrayBuffer(8000 /* N.allocTotal */);
+            sharedOffset = 0;
+        }
+        this._byte = new Uint8Array(sharedBuffer, sharedOffset, 80 /* N.allocBytes */);
+        this._word = new Int32Array(sharedBuffer, sharedOffset, 20 /* N.allocWords */);
+        sharedOffset += 80 /* N.allocBytes */;
+    }
+    update(data) {
+        // data: string
+        if ("string" === typeof data) {
+            return this._utf8(data);
+        }
+        // data: undefined
+        if (data == null) {
+            throw new TypeError("Invalid type: " + typeof data);
+        }
+        const byteOffset = data.byteOffset;
+        const length = data.byteLength;
+        let blocks = (length / 64 /* N.inputBytes */) | 0;
+        let offset = 0;
+        // longer than 1 block
+        if (blocks && !(byteOffset & 3) && !(this._size % 64 /* N.inputBytes */)) {
+            const block = new Int32Array(data.buffer, byteOffset, blocks * 16 /* N.inputWords */);
+            while (blocks--) {
+                this._int32(block, offset >> 2);
+                offset += 64 /* N.inputBytes */;
+            }
+            this._size += offset;
+        }
+        // data: TypedArray | DataView
+        const BYTES_PER_ELEMENT = data.BYTES_PER_ELEMENT;
+        if (BYTES_PER_ELEMENT !== 1 && data.buffer) {
+            const rest = new Uint8Array(data.buffer, byteOffset + offset, length - offset);
+            return this._uint8(rest);
+        }
+        // no more bytes
+        if (offset === length)
+            return this;
+        // data: Uint8Array | Int8Array
+        return this._uint8(data, offset);
+    }
+    _uint8(data, offset) {
+        const { _byte, _word } = this;
+        const length = data.length;
+        offset = offset | 0;
+        while (offset < length) {
+            const start = this._size % 64 /* N.inputBytes */;
+            let index = start;
+            while (offset < length && index < 64 /* N.inputBytes */) {
+                _byte[index++] = data[offset++];
+            }
+            if (index >= 64 /* N.inputBytes */) {
+                this._int32(_word);
+            }
+            this._size += index - start;
+        }
+        return this;
+    }
+    _utf8(text) {
+        const { _byte, _word } = this;
+        const length = text.length;
+        let surrogate = this._sp;
+        for (let offset = 0; offset < length;) {
+            const start = this._size % 64 /* N.inputBytes */;
+            let index = start;
+            while (offset < length && index < 64 /* N.inputBytes */) {
+                let code = text.charCodeAt(offset++) | 0;
+                if (code < 0x80) {
+                    // ASCII characters
+                    _byte[index++] = code;
+                }
+                else if (code < 0x800) {
+                    // 2 bytes
+                    _byte[index++] = 0xc0 | (code >>> 6);
+                    _byte[index++] = 0x80 | (code & 0x3f);
+                }
+                else if (code < 0xd800 || code > 0xdfff) {
+                    // 3 bytes
+                    _byte[index++] = 0xe0 | (code >>> 12);
+                    _byte[index++] = 0x80 | ((code >>> 6) & 0x3f);
+                    _byte[index++] = 0x80 | (code & 0x3f);
+                }
+                else if (surrogate) {
+                    // 4 bytes - surrogate pair
+                    code = ((surrogate & 0x3ff) << 10) + (code & 0x3ff) + 0x10000;
+                    _byte[index++] = 0xf0 | (code >>> 18);
+                    _byte[index++] = 0x80 | ((code >>> 12) & 0x3f);
+                    _byte[index++] = 0x80 | ((code >>> 6) & 0x3f);
+                    _byte[index++] = 0x80 | (code & 0x3f);
+                    surrogate = 0;
+                }
+                else {
+                    surrogate = code;
+                }
+            }
+            if (index >= 64 /* N.inputBytes */) {
+                this._int32(_word);
+                _word[0] = _word[16 /* N.inputWords */];
+            }
+            this._size += index - start;
+        }
+        this._sp = surrogate;
+        return this;
+    }
+    _int32(data, offset) {
+        let { A, B, C, D, E, F, G, H } = this;
+        let i = 0;
+        offset = offset | 0;
+        while (i < 16 /* N.inputWords */) {
+            W[i++] = swap32(data[offset++]);
+        }
+        for (i = 16 /* N.inputWords */; i < 64 /* N.workWords */; i++) {
+            W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0;
+        }
+        for (i = 0; i < 64 /* N.workWords */; i++) {
+            const T1 = (H + sigma1(E) + ch(E, F, G) + K[i] + W[i]) | 0;
+            const T2 = (sigma0(A) + maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        this.A = (A + this.A) | 0;
+        this.B = (B + this.B) | 0;
+        this.C = (C + this.C) | 0;
+        this.D = (D + this.D) | 0;
+        this.E = (E + this.E) | 0;
+        this.F = (F + this.F) | 0;
+        this.G = (G + this.G) | 0;
+        this.H = (H + this.H) | 0;
+    }
+    digest(encoding) {
+        const { _byte, _word } = this;
+        let i = this._size % 64 /* N.inputBytes */ | 0;
+        _byte[i++] = 0x80;
+        // pad 0 for current word
+        while (i & 3) {
+            _byte[i++] = 0;
+        }
+        i >>= 2;
+        if (i > 14 /* N.highIndex */) {
+            while (i < 16 /* N.inputWords */) {
+                _word[i++] = 0;
+            }
+            i = 0;
+            this._int32(_word);
+        }
+        // pad 0 for rest words
+        while (i < 16 /* N.inputWords */) {
+            _word[i++] = 0;
+        }
+        // input size
+        const bits64 = this._size * 8;
+        const low32 = (bits64 & 0xffffffff) >>> 0;
+        const high32 = (bits64 - low32) / 0x100000000;
+        if (high32)
+            _word[14 /* N.highIndex */] = swap32(high32);
+        if (low32)
+            _word[15 /* N.lowIndex */] = swap32(low32);
+        this._int32(_word);
+        return encoding === "hex" ? this._hex() : this._bin();
+    }
+    _hex() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return hex32(A) + hex32(B) + hex32(C) + hex32(D) + hex32(E) + hex32(F) + hex32(G) + hex32(H);
+    }
+    _bin() {
+        const { A, B, C, D, E, F, G, H, _byte, _word } = this;
+        _word[0] = swap32(A);
+        _word[1] = swap32(B);
+        _word[2] = swap32(C);
+        _word[3] = swap32(D);
+        _word[4] = swap32(E);
+        _word[5] = swap32(F);
+        _word[6] = swap32(G);
+        _word[7] = swap32(H);
+        return _byte.slice(0, 32);
+    }
+}
+const W = new Int32Array(64 /* N.workWords */);
+let sharedBuffer;
+let sharedOffset = 0;
+const hex32 = (num) => (num + 0x100000000).toString(16).substr(-8);
+const swapLE = (c) => ((c << 24) & 0xff000000) | ((c << 8) & 0xff0000) | ((c >> 8) & 0xff00) | ((c >> 24) & 0xff);
+const swapBE = (c) => c;
+const swap32 = isBE() ? swapBE : swapLE;
+const ch = (x, y, z) => z ^ (x & (y ^ z));
+const maj = (x, y, z) => (x & y) | (z & (x | y));
+const sigma0 = (x) => ((x >>> 2) | (x << 30)) ^ ((x >>> 13) | (x << 19)) ^ ((x >>> 22) | (x << 10));
+const sigma1 = (x) => ((x >>> 6) | (x << 26)) ^ ((x >>> 11) | (x << 21)) ^ ((x >>> 25) | (x << 7));
+const gamma0 = (x) => ((x >>> 7) | (x << 25)) ^ ((x >>> 18) | (x << 14)) ^ (x >>> 3);
+const gamma1 = (x) => ((x >>> 17) | (x << 15)) ^ ((x >>> 19) | (x << 13)) ^ (x >>> 10);
+function isBE() {
+    const buf = new Uint8Array(new Uint16Array([0xfeff]).buffer); // BOM
+    return buf[0] === 0xfe;
+}
+function sha256Buffer(data, encoding) {
+    const inputDataBuffer = data instanceof ArrayBuffer ? data : data.buffer;
+    const hash = new Hash();
+    hash.update(new Uint8Array(inputDataBuffer));
+    if (encoding) {
+        return hash.digest(encoding);
+    }
+    else {
+        return hash.digest();
+    }
+}
+function sha256Hex(hexString, encoding) {
+    return sha256Buffer(hexToU8Array(hexString), encoding);
+}
+export { sha256Buffer, sha256Hex };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { IBaseEvent, IndexableType, TEventListenerMap } from "./EventHub";
+export { EventHub } from "./EventHub";
+export * from "./data/array";
+export * from "./hash";
+export * from "./uuid";
+export * from "./debounce";
+export * from "./seedrandom";
+//# 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,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/E,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,cAAc,cAAc,CAAC;AAE7B,cAAc,QAAQ,CAAC;AAEvB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { EventHub } from "./EventHub";
+export * from "./data/array";
+export * from "./hash";
+export * from "./uuid";
+export * from "./debounce";
+export * from "./seedrandom";

package/dist/object.d.ts

@@ -0,0 +1,4 @@
+declare function setInObject(obj: any, path: string[], value: any): void;
+declare function getInObject(obj: any, path: string[]): any;
+export { setInObject, getInObject };
+//# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":"AAAA,iBAAS,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,QAQxD;AAED,iBAAS,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,OAS5C;AAED,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC"}

package/dist/object.js

@@ -0,0 +1,20 @@
+function setInObject(obj, path, value) {
+    const cur = obj;
+    for (let i = 0, l = path.length - 1; i < l; i++) {
+        if (!Object.hasOwnProperty.call(cur, path[i])) {
+            cur[path[i]] = {};
+        }
+    }
+    cur[path[path.length - 1]] = value;
+}
+function getInObject(obj, path) {
+    let cur = obj;
+    for (let i = 0, l = path.length; i < l; i++) {
+        if (!Object.hasOwnProperty.call(cur, path[i])) {
+            return undefined;
+        }
+        cur = cur[path[i]];
+    }
+    return cur;
+}
+export { setInObject, getInObject };

package/dist/seedrandom.d.ts

@@ -0,0 +1,9 @@
+declare class SeedRandom {
+    seed: string;
+    seedrandom: any;
+    constructor(seed: string);
+    random(): number;
+    randHex(len: number): string;
+}
+export { SeedRandom };
+//# sourceMappingURL=seedrandom.d.ts.map

package/dist/seedrandom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seedrandom.d.ts","sourceRoot":"","sources":["../src/seedrandom.ts"],"names":[],"mappings":"AAmMA,cAAM,UAAU;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,GAAG,CAAC;gBACJ,IAAI,EAAE,MAAM;IAIxB,MAAM,IAAI,MAAM;IAGhB,OAAO,CAAC,GAAG,EAAE,MAAM;CAQtB;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/seedrandom.js

@@ -0,0 +1,175 @@
+const pool = [];
+let width = 256, // each RC4 output is 0 <= x < 256
+chunks = 6, // at least six RC4 outputs for each double
+digits = 52, // there are 52 significant digits in a double
+rngname = "random", // rngname: name for Math.random and Math.seedrandom
+startdenom = Math.pow(width, chunks), significance = Math.pow(2, digits), overflow = significance * 2, mask = width - 1, nodecrypto; // node.js crypto module, initialized at the bottom.
+//
+// seedrandom()
+// This is the seedrandom function described above.
+//
+function seedrandom(seed, options, callback) {
+    const key = [];
+    options = options == true ? { entropy: true } : options || {};
+    // Flatten the seed string or build one from local entropy if needed.
+    const shortseed = mixkey(flatten(options.entropy ? [seed, tostring(pool)] : seed, 3), key);
+    // Use the seed to initialize an ARC4 generator.
+    const arc4 = new ARC4(key);
+    // This function returns a random double in [0, 1) that contains
+    // randomness in every bit of the mantissa of the IEEE 754 value.
+    const prng = function () {
+        let n = arc4.g(chunks), // Start with a numerator n < 2 ^ 48
+        d = startdenom, //   and denominator d = 2 ^ 48.
+        x = 0; //   and no 'extra last byte'.
+        while (n < significance) {
+            // Fill up all significant digits by
+            n = (n + x) * width; //   shifting numerator and
+            d *= width; //   denominator and generating a
+            x = arc4.g(1); //   new least-significant-byte.
+        }
+        while (n >= overflow) {
+            // To avoid rounding up, before adding
+            n /= 2; //   last byte, shift everything
+            d /= 2; //   right using integer math until
+            x >>>= 1; //   we have exactly the desired bits.
+        }
+        return (n + x) / d; // Form the number within [0, 1).
+    };
+    prng.int32 = function () {
+        return arc4.g(4) | 0;
+    };
+    prng.quick = function () {
+        return arc4.g(4) / 0x100000000;
+    };
+    prng.double = prng;
+    // Mix the randomness into accumulated entropy.
+    mixkey(tostring(arc4.S), pool);
+    // Calling convention: what to return as a function of prng, seed, is_math.
+    return (options.pass ||
+        callback ||
+        function (prng, seed, is_math_call, state) {
+            if (state) {
+                // Load the arc4 state from the given state if it has an S array.
+                if (state.S) {
+                    copy(state, arc4);
+                }
+                // Only provide the .state method if requested via options.state.
+                prng.state = function () {
+                    return copy(arc4, {});
+                };
+            }
+            // If called as a method of Math (Math.seedrandom()), mutate
+            // Math.random because that is how seedrandom.js has worked since v1.0.
+            // Otherwise, it is a newer calling convention, so return the
+            // prng directly.
+            else
+                return prng;
+        })(prng, shortseed, 
+    //@ts-ignore
+    "global" in options ? options.global : this == Math, options.state);
+}
+//
+// ARC4
+//
+// An ARC4 implementation.  The constructor takes a key in the form of
+// an array of at most (width) integers that should be 0 <= x < (width).
+//
+// The g(count) method returns a pseudorandom integer that concatenates
+// the next (count) outputs from ARC4.  Its return value is a number x
+// that is in the range 0 <= x < (width ^ count).
+//
+function ARC4(key) {
+    let t, keylen = key.length;
+    //@ts-ignore
+    let me = this, i = 0, j = (me.i = me.j = 0), s = (me.S = []);
+    // The empty key [] is treated as [0].
+    if (!keylen) {
+        key = [keylen++];
+    }
+    // Set up S using the standard key scheduling algorithm.
+    while (i < width) {
+        s[i] = i++;
+    }
+    for (i = 0; i < width; i++) {
+        s[i] = s[(j = mask & (j + key[i % keylen] + (t = s[i])))];
+        s[j] = t;
+    }
+    // The "g" method returns the next (count) outputs as one number.
+    (me.g = function (count) {
+        // Using instance members instead of closure state nearly doubles speed.
+        let t, r = 0, i = me.i, j = me.j, s = me.S;
+        while (count--) {
+            t = s[(i = mask & (i + 1))];
+            r = r * width + s[mask & ((s[i] = s[(j = mask & (j + t))]) + (s[j] = t))];
+        }
+        me.i = i;
+        me.j = j;
+        return r;
+        // For robust unpredictability, the function call below automatically
+        // discards an initial batch of values.  This is called RC4-drop[256].
+        // See http://google.com/search?q=rsa+fluhrer+response&btnI
+    })(width);
+}
+//
+// copy()
+// Copies internal state of ARC4 to or from a plain object.
+//
+function copy(f, t) {
+    t.i = f.i;
+    t.j = f.j;
+    t.S = f.S.slice();
+    return t;
+}
+//
+// flatten()
+// Converts an object tree to nested arrays of strings.
+//
+function flatten(obj, depth) {
+    let result = [], typ = typeof obj, prop;
+    if (depth && typ == "object") {
+        for (prop in obj) {
+            try {
+                result.push(flatten(obj[prop], depth - 1));
+            }
+            catch (e) { }
+        }
+    }
+    return result.length ? result : typ == "string" ? obj : obj + "\0";
+}
+//
+// mixkey()
+// Mixes a string seed into a key that is an array of integers, and
+// returns a shortened string seed that is equivalent to the result key.
+//
+function mixkey(seed, key) {
+    let stringseed = seed + "", smear, j = 0;
+    while (j < stringseed.length) {
+        key[mask & j] = mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));
+    }
+    return tostring(key);
+}
+//
+// tostring()
+// Converts an array of charcodes to a string
+//
+function tostring(a) {
+    return String.fromCharCode.apply(0, a);
+}
+class SeedRandom {
+    constructor(seed) {
+        this.seed = seed;
+        this.seedrandom = seedrandom(seed);
+    }
+    random() {
+        return this.seedrandom();
+    }
+    randHex(len) {
+        const hex = [];
+        for (let i = 0; i < len; i++) {
+            const value = Math.floor(this.random() * 0x100);
+            hex.push(value.toString(16).padStart(2, "0"));
+        }
+        return hex.join("");
+    }
+}
+export { SeedRandom };

package/dist/uuid.d.ts

@@ -0,0 +1,3 @@
+import { v4 as uuidv4 } from "uuid";
+export { uuidv4 };
+//# sourceMappingURL=uuid.d.ts.map

package/dist/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/uuid.js

@@ -0,0 +1,2 @@
+import { v4 as uuidv4 } from "uuid";
+export { uuidv4 };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@psy-protocol/utils",
+  "version": "1.0.0",
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/uuid": "^9.0.8",
+    "rimraf": "~5.0.10",
+    "typescript": "~5.3.3"
+  },
+  "scripts": {
+    "build": "pnpm run clean && pnpm run compile",
+    "clean": "rimraf ./dist",
+    "compile": "tsc -p tsconfig.build.json"
+  }
+}