@powfix/core-js 0.20.5 → 0.21.0

package/dist/cjs/shared/utils/ObjectIdUtils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectIdUtils = void 0;
+const UuidUtils_1 = require("./UuidUtils");
+const Uint8ArrayUtils_1 = require("./Uint8ArrayUtils");
+class ObjectIdUtils {
+    static toUuid(objectId, pad = 'start') {
+        const src = Uint8ArrayUtils_1.Uint8ArrayUtils.fromHex(objectId);
+        if (src.length !== 12) {
+            throw new Error(`objectId must be 12 bytes (24 hex), got ${src.length} bytes`);
+        }
+        const result = new Uint8Array(16);
+        const offset = pad === 'start' ? 4 : 0;
+        result.set(src, offset);
+        return UuidUtils_1.UuidUtils.toString(result);
+    }
+    static fromUuid(uuid, pad) {
+        const buffer = UuidUtils_1.UuidUtils.toBuffer(uuid);
+        const isPadEnd = buffer.subarray(buffer.length - 4).every(byte => byte === 0);
+        if (isPadEnd || pad === 'end') {
+            return buffer.subarray(0, buffer.length - 4).toString('hex');
+        }
+        const isPadStart = buffer.subarray(0, 4).every(byte => byte === 0);
+        if (!isPadStart) {
+            console.warn('buffer is not pad start and pad end');
+        }
+        return buffer.subarray(4).toString('hex');
+    }
+}
+exports.ObjectIdUtils = ObjectIdUtils;

package/dist/cjs/shared/utils/Point3Utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Point3Utils = void 0;
+class Point3Utils {
+    static distance(p1, p2) {
+        const dx = p1.x - p2.x;
+        const dy = p1.y - p2.y;
+        const dz = p1.z - p2.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+}
+exports.Point3Utils = Point3Utils;

package/dist/cjs/shared/utils/RandomUtils.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomUtils = void 0;
+class RandomUtils {
+    static randomNumber(min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    static randomLatinStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            const isLowerCase = RandomUtils.randomNumber(0, 1);
+            if (isLowerCase) {
+                strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+            }
+            else {
+                strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+            }
+        }
+        return strings.join('');
+    }
+    static randomLatinLowercaseStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+        }
+        return strings.join('');
+    }
+    static randomLatinUppercaseStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+        }
+        return strings.join('');
+    }
+    static randomNumberStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            strings.push(String.fromCharCode(RandomUtils.randomNumber(48, 57)));
+        }
+        return strings.join('');
+    }
+    static randomStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            const isNumber = RandomUtils.randomNumber(0, 1);
+            if (isNumber) {
+                strings.push(String.fromCharCode(RandomUtils.randomNumber(48, 57)));
+            }
+            else {
+                const isLowerCase = RandomUtils.randomNumber(0, 1);
+                if (isLowerCase) {
+                    strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+                }
+                else {
+                    strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+                }
+            }
+        }
+        return strings.join('');
+    }
+}
+exports.RandomUtils = RandomUtils;

package/dist/cjs/shared/utils/Sequencer.js

@@ -0,0 +1,148 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sequencer = exports.SequencerEvent = exports.SequencerStatus = void 0;
+const moment_1 = __importDefault(require("moment"));
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+var SequencerStatus;
+(function (SequencerStatus) {
+    SequencerStatus[SequencerStatus["IDLE"] = 0] = "IDLE";
+    SequencerStatus[SequencerStatus["RUNNING"] = 1] = "RUNNING";
+    SequencerStatus[SequencerStatus["ERROR"] = 2] = "ERROR";
+    SequencerStatus[SequencerStatus["DONE"] = 3] = "DONE";
+})(SequencerStatus || (exports.SequencerStatus = SequencerStatus = {}));
+var SequencerEvent;
+(function (SequencerEvent) {
+    SequencerEvent["START"] = "START";
+    SequencerEvent["END"] = "END";
+    SequencerEvent["SEQUENCE_START"] = "SEQUENCE_START";
+    SequencerEvent["SEQUENCE_END"] = "SEQUENCE_END";
+})(SequencerEvent || (exports.SequencerEvent = SequencerEvent = {}));
+class Sequencer {
+    constructor(option) {
+        this.sequences = [];
+        this.status = SequencerStatus.IDLE;
+        this.minimumExecutionTime = 0;
+        // Reset variables task is done
+        this.currentSequence = null;
+        this.startTimestamp = null;
+        this.endTimestamp = null;
+        // Emitter
+        this.eventEmitter = new eventemitter3_1.default();
+        this.pushSequence = (sequence) => {
+            this.sequences.push(sequence);
+        };
+        this.start = () => __awaiter(this, void 0, void 0, function* () {
+            if (this.status === SequencerStatus.RUNNING) {
+                console.warn('Sequencer status is', this.status);
+                return;
+            }
+            this.status = SequencerStatus.RUNNING;
+            this.currentSequence = null;
+            this.startTimestamp = this.getCurrentTimeStamp;
+            this.endTimestamp = null;
+            console.log(`Sequence started, started at ${this.startTimestamp}, MINIMUM_EXECUTION_TIME is ${this.minimumExecutionTime}`);
+            for (let sequence of this.sequences) {
+                console.log('Currently total execution time', this.executionTime);
+                const sequenceStartTimeStamp = this.getCurrentTimeStamp;
+                this.currentSequence = sequence;
+                // Emitter
+                this.eventEmitter.emit(SequencerEvent.SEQUENCE_START, sequence);
+                try {
+                    yield new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        try {
+                            console.log(`Sequence ${sequence.key} start`);
+                            yield ((_a = sequence.task) === null || _a === void 0 ? void 0 : _a.call(sequence));
+                            const sequenceEndTimeStamp = this.getCurrentTimeStamp;
+                            const sequenceExecutionTime = sequenceEndTimeStamp - sequenceStartTimeStamp;
+                            console.log(`✅ Sequence ${sequence.key} done at`, sequenceEndTimeStamp);
+                            console.log('Sequence execution time', sequenceExecutionTime, 'ms');
+                            if (sequence.minimumExecutionTime) {
+                                console.log(`Sequence has minimumExecutionTime`, sequence.minimumExecutionTime, 'ms');
+                                if (sequenceExecutionTime < sequence.minimumExecutionTime) {
+                                    const delay = sequence.minimumExecutionTime - sequenceExecutionTime;
+                                    console.log(`Sequence will delay`, delay, 'ms');
+                                    let dotInterpreterBlocked = false;
+                                    const dotInterpreter = setInterval(() => {
+                                        if (dotInterpreterBlocked) {
+                                            console.log('!');
+                                            return;
+                                        }
+                                        console.log('.');
+                                    }, 100);
+                                    setTimeout(() => {
+                                        dotInterpreterBlocked = true;
+                                        clearInterval(dotInterpreter);
+                                        console.log('done');
+                                        resolve();
+                                    }, delay);
+                                    return;
+                                }
+                                console.log('Sequence execution time is greater than minimum execution time');
+                                resolve();
+                                return;
+                            }
+                            resolve();
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }));
+                    console.log('Out of Promise');
+                    // Emitter
+                    this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
+                }
+                catch (e) {
+                    if (sequence.required) {
+                        console.error(`🚫 Sequence ${sequence.key} failed`, e);
+                        this.status = SequencerStatus.ERROR;
+                        this.currentSequence = null;
+                        this.endTimestamp = this.currentSequence;
+                        // IMPORTANT
+                        return Promise.reject({
+                            sequence,
+                            reason: e,
+                        });
+                    }
+                    console.log(`Sequence ${sequence.key} failed`, e);
+                    // Emitter
+                    this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
+                }
+            }
+            this.status = SequencerStatus.DONE;
+            this.currentSequence = null;
+            this.endTimestamp = this.currentSequence;
+        });
+        if (option === null || option === void 0 ? void 0 : option.sequences) {
+            this.sequences.push(...option.sequences);
+        }
+    }
+    get getCurrentTimeStamp() {
+        return parseInt((0, moment_1.default)().format('x'), 10);
+    }
+    get executionTime() {
+        if (this.status === SequencerStatus.IDLE) {
+            return null;
+        }
+        if (!this.startTimestamp) {
+            return null;
+        }
+        if (this.startTimestamp && this.endTimestamp) {
+            return this.endTimestamp - this.startTimestamp;
+        }
+        return this.getCurrentTimeStamp - this.startTimestamp;
+    }
+}
+exports.Sequencer = Sequencer;

package/dist/cjs/shared/utils/StringUtils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringUtils = void 0;
+class StringUtils {
+    static numberWithCommas(x) {
+        return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    }
+    static getByte(s) {
+        const getByteLength = (decimal) => {
+            const LINE_FEED = 10;
+            return (decimal >> 7) || (LINE_FEED === decimal) ? 2 : 1;
+        };
+        return s
+            .split('')
+            .map((s) => s.charCodeAt(0))
+            .reduce((prev, unicodeDecimalValue) => prev + getByteLength(unicodeDecimalValue), 0);
+    }
+}
+exports.StringUtils = StringUtils;
+StringUtils.levenshteinDistance = (str1 = '', str2 = '') => {
+    const track = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+    for (let i = 0; i <= str1.length; i += 1) {
+        track[0][i] = i;
+    }
+    for (let j = 0; j <= str2.length; j += 1) {
+        track[j][0] = j;
+    }
+    for (let j = 1; j <= str2.length; j += 1) {
+        for (let i = 1; i <= str1.length; i += 1) {
+            const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
+            track[j][i] = Math.min(track[j][i - 1] + 1, // deletion
+            track[j - 1][i] + 1, // insertion
+            track[j - 1][i - 1] + indicator);
+        }
+    }
+    return track[str2.length][str1.length];
+};

package/dist/cjs/shared/utils/UUID.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UUID = void 0;
+const index_1 = require("../index");
+/**
+ * Represents a UUID (Universally Unique Identifier) and provides various utility
+ * methods for validation, conversion, comparison and creation.
+ */
+class UUID {
+    /* --------------------------------------------------------------------
+     * Validation helpers
+     * -------------------------------------------------------------------- */
+    /**
+     * Checks if the supplied value is a valid hex representation of a UUID.
+     * @param hex - The string to validate.
+     * @returns true if the string matches {@link REGEX_HEX}.
+     */
+    static isValidHex(hex) {
+        if (typeof hex !== 'string') {
+            return false;
+        }
+        return UUID.REGEX_HEX.test(hex);
+    }
+    /**
+     * Checks if the supplied value is a valid RFC 4122 UUID string.
+     * @param str - The string to validate.
+     * @returns true if the string matches {@link REGEX_RFC4122}.
+     */
+    static isValidString(str) {
+        if (typeof str !== 'string') {
+            return false;
+        }
+        return UUID.REGEX_RFC4122.test(str);
+    }
+    /**
+     * Checks whether an ArrayBufferView contains exactly {@link BYTE_LENGTH} bytes.
+     * @param bytes - The view to check.
+     * @returns true if the byte length is correct.
+     */
+    static isValidBytes(bytes) {
+        return bytes.byteLength === UUID.BYTE_LENGTH;
+    }
+    /**
+     * Generic validation that accepts either a string (hex or RFC 4122 format)
+     * or an ArrayBufferView containing the raw bytes.
+     * @param input - The value to validate.
+     * @returns true if the input is a valid representation of a UUID.
+     */
+    static isValid(input) {
+        if (typeof input === 'string') {
+            const length = input.length;
+            switch (length) {
+                case UUID.STR_LENGTH:
+                    // RFC 4122 uuid(string)
+                    // 9e472052-a654-4693-9a8b-3ce57ada3d6c
+                    return UUID.isValidString(input);
+                case UUID.HEX_STR_LENGTH:
+                    // RFC 4122 uuid(string) without hyphens
+                    // 9e472052a65446939a8b3ce57ada3d6c
+                    return UUID.isValidHex(input);
+                default:
+                    return false;
+            }
+        }
+        else if (input instanceof UUID) {
+            return UUID.isValidBytes(input.bytes);
+        }
+        else if (ArrayBuffer.isView(input)) {
+            return UUID.isValidBytes(input);
+        }
+        else {
+            return false;
+        }
+    }
+    static version(input) {
+        return (this.parse(input)[6] >> 4) & 0x0F;
+    }
+    /* --------------------------------------------------------------------
+     * Parsing / formatting helpers
+     * -------------------------------------------------------------------- */
+    /**
+     * Inserts hyphens into a 32‑character hex string to produce an RFC 4122 string.
+     * @param hex - The plain hexadecimal UUID.
+     * @returns The formatted RFC 4122 string.
+     */
+    static formatHex(hex) {
+        if (hex.length !== UUID.HEX_STR_LENGTH) {
+            throw new Error(`hex length should be ${UUID.HEX_STR_LENGTH}`);
+        }
+        return hex.slice(0, 8) + '-' +
+            hex.slice(8, 12) + '-' +
+            hex.slice(12, 16) + '-' +
+            hex.slice(16, 20) + '-' +
+            hex.slice(20);
+    }
+    /** Removes all hyphens from a UUID string. */
+    static stripHyphens(str) {
+        return str.replace(/-/g, "");
+    }
+    /**
+     * Converts a plain hexadecimal UUID into a Uint8Array.
+     * @param hex - The hex string to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
+    static parseHex(hex) {
+        if (hex.length !== UUID.HEX_STR_LENGTH) {
+            throw new Error(`Invalid hex string, length should be ${UUID.HEX_STR_LENGTH}`);
+        }
+        return index_1.Uint8ArrayUtils.fromHex(hex);
+    }
+    /**
+     * Parses an RFC 4122 string into a Uint8Array.
+     * @param str - The formatted UUID string.
+     * @returns A Uint8Array containing the raw bytes.
+     */
+    static parseString(str) {
+        if (str.length !== UUID.STR_LENGTH) {
+            throw new Error(`Invalid UUID string, invalid character length should be ${UUID.STR_LENGTH}`);
+        }
+        if (!UUID.isValid(str)) {
+            throw new Error('Invalid UUID string, should be RFC 4122 format');
+        }
+        const hex = UUID.stripHyphens(str);
+        if (hex.length !== UUID.HEX_STR_LENGTH) {
+            throw new Error('Invalid UUID string, invalid character length after strip hyphens');
+        }
+        return index_1.Uint8ArrayUtils.fromHex(hex);
+    }
+    /**
+     * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
+     * @param bytes - The view to parse.
+     * @returns A Uint8Array containing the raw bytes.
+     */
+    static parseBytes(bytes) {
+        const view = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        if (view.length !== UUID.BYTE_LENGTH) {
+            throw new Error(`Expected ${UUID.BYTE_LENGTH} bytes`);
+        }
+        return new Uint8Array(view);
+    }
+    /* --------------------------------------------------------------------
+     * Factory methods
+     * -------------------------------------------------------------------- */
+    /**
+     * Creates a UUID instance from a plain hexadecimal string.
+     * @param hex - The hex representation of the UUID.
+     * @returns A new {@link UUID} object.
+     */
+    static fromHex(hex) {
+        return new this(UUID.parseHex(hex));
+    }
+    /**
+     * Creates a UUID instance from an RFC 4122 formatted string.
+     * @param str - The UUID string with hyphens.
+     * @returns A new {@link UUID} object.
+     */
+    static fromString(str) {
+        return new this(UUID.parseString(str));
+    }
+    /**
+     * Creates a UUID instance from raw bytes.
+     * @param bytes - An ArrayBufferView containing 16 bytes.
+     * @returns A new {@link UUID} object.
+     */
+    static fromBytes(bytes) {
+        return new this(UUID.parseBytes(bytes));
+    }
+    /**
+     * Parses any supported input (string or bytes) and returns the raw byte array.
+     * @param input - The value to parse.
+     * @returns A Uint8Array of length {@link BYTE_LENGTH}.
+     */
+    static parse(input) {
+        if (typeof input === 'string') {
+            const length = input.length;
+            switch (length) {
+                case UUID.STR_LENGTH:
+                    // RFC 4122 uuid(string)
+                    return UUID.parseString(input);
+                case UUID.HEX_STR_LENGTH:
+                    // RFC 4122 uuid(string) without hyphens
+                    return UUID.parseHex(input);
+                default:
+                    throw new Error(`Invalid input string, length should be ${UUID.STR_LENGTH} or ${UUID.HEX_STR_LENGTH}`);
+            }
+        }
+        else if (input instanceof UUID) {
+            return input.toBytes();
+        }
+        else if (ArrayBuffer.isView(input)) {
+            return UUID.parseBytes(input);
+        }
+        else {
+            throw new Error("Invalid input, Expected string or ArrayBufferView");
+        }
+    }
+    /**
+     * Creates a UUID from any supported input type.
+     * @param input - The value to parse.
+     * @returns A new {@link UUID} object.
+     */
+    static from(input) {
+        return this.fromBytes(UUID.parse(input));
+    }
+    /** Returns the nil (all zero) UUID. */
+    static nil() {
+        return this.fromBytes(new Uint8Array(UUID.BYTE_LENGTH));
+    }
+    /** Returns a UUID consisting of all 0xFF bytes. */
+    static max() {
+        return this.fromBytes((new Uint8Array(UUID.BYTE_LENGTH)).fill(0xFF));
+    }
+    /* --------------------------------------------------------------------
+     * Equality / comparison
+     * -------------------------------------------------------------------- */
+    /**
+     * Compares multiple UUIDs for strict equality.
+     * @param inputs - The UUIDs to compare (at least two required).
+     * @returns true if all provided UUIDs are identical.
+     */
+    static equals(...inputs) {
+        const n = inputs.length;
+        if (n < 2) {
+            throw new Error('At least two UUIDs required for comparison');
+        }
+        const ref = this.parse(inputs[0]);
+        for (let i = 1; i < n; ++i) {
+            const b = this.parse(inputs[i]);
+            for (let j = 0; j < UUID.BYTE_LENGTH; ++j) {
+                if (ref[j] !== b[j])
+                    return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Lexicographically compares two UUIDs.
+     * @param uuid1 - The first UUID.
+     * @param uuid2 - The second UUID.
+     * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
+     */
+    static compare(uuid1, uuid2) {
+        const a = this.parse(uuid1);
+        const b = this.parse(uuid2);
+        for (let i = 0; i < UUID.BYTE_LENGTH; i++) {
+            if (a[i] !== b[i])
+                return a[i] < b[i] ? -1 : 1;
+        }
+        return 0;
+    }
+    /**
+     * Constructs a new {@link UUID} instance from any supported input type.
+     * @param input - The value to parse (string or ArrayBufferView).
+     */
+    constructor(input) {
+        this.bytes = UUID.parse(input);
+    }
+    /** Instance wrapper for {@link equals}. */
+    equals(...inputs) {
+        return UUID.equals(this, ...inputs);
+    }
+    /** Instance wrapper for {@link compare}. */
+    compare(other) {
+        return UUID.compare(this, other);
+    }
+    version() {
+        return UUID.version(this);
+    }
+    /**
+     * Returns the RFC 4122 string representation of this UUID.
+     * @returns The formatted UUID string.
+     */
+    toString() {
+        if (this._str != null) {
+            return this._str;
+        }
+        const hex = this.toHex();
+        this._str = UUID.formatHex(hex);
+        return this._str;
+    }
+    /**
+     * Returns the plain hexadecimal representation of this UUID.
+     * @returns A 32‑character hex string.
+     */
+    toHex() {
+        if (this._hex != null) {
+            return this._hex;
+        }
+        this._hex = index_1.Uint8ArrayUtils.toHex(this.bytes);
+        return this._hex;
+    }
+    /**
+     * Returns a copy of the raw byte array.
+     * @returns A new Uint8Array containing the UUID bytes.
+     */
+    toBytes() {
+        return new Uint8Array(this.bytes);
+    }
+    /** JSON serialization helper – returns the RFC 4122 string. */
+    toJSON() {
+        return this.toString();
+    }
+}
+exports.UUID = UUID;
+/* --------------------------------------------------------------------
+ * Regular expressions used to validate UUIDs in different string forms
+ * -------------------------------------------------------------------- */
+/** Matches a 32‑character hexadecimal representation of a UUID without hyphens. */
+UUID.REGEX_HEX = /^[0-9a-fA-F]{8}[0-9a-fA-F]{4}[1-5][0-9a-fA-F]{3}[89abAB][0-9a-fA-F]{3}[0-9a-fA-F]{12}$/;
+/** Matches the RFC 4122 canonical UUID format with hyphens. */
+UUID.REGEX_RFC4122 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+/* --------------------------------------------------------------------
+ * Constant lengths used throughout the class
+ * -------------------------------------------------------------------- */
+/** Number of bytes that represent a UUID. */
+UUID.BYTE_LENGTH = 16;
+/** Total length of an RFC 4122 UUID string (including hyphens). */
+UUID.STR_LENGTH = 36;
+/** Length of a UUID represented as a plain hexadecimal string. */
+UUID.HEX_STR_LENGTH = 32;

package/dist/cjs/shared/utils/UUID.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/utils/Uint8ArrayUtils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uint8ArrayUtils = void 0;
+class Uint8ArrayUtils {
+    static fromHex(hex) {
+        var _a, _b;
+        return Uint8Array.from((_b = (_a = hex.match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map((byte) => parseInt(byte, 16))) !== null && _b !== void 0 ? _b : []);
+    }
+    static toHex(bytes) {
+        return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
+    }
+}
+exports.Uint8ArrayUtils = Uint8ArrayUtils;