@powfix/core-js 0.18.2 → 0.19.0

package/dist/browser/esm/browser/utils/UUID.mjs

@@ -1,5 +1,39 @@
-import { Uint8ArrayUtils } from "../../shared/utils/Uint8ArrayUtils.mjs";
+import { Uint8ArrayUtils } from "../../shared/index.mjs";
 export class UUID {
+    static isValidHex(hex) {
+        if (typeof hex !== 'string') {
+            return false;
+        }
+        return UUID.REGEX_HEX.test(hex);
+    }
+    static isValidString(str) {
+        if (typeof str !== 'string') {
+            return false;
+        }
+        return UUID.REGEX_RFC4122.test(str);
+    }
+    static isValidBytes(bytes) {
+        return bytes.byteLength === UUID.BYTE_LENGTH;
+    }
+    static isValid(input) {
+        if (typeof input === 'string') {
+            const length = input.length;
+            switch (length) {
+                case UUID.STR_LENGTH:
+                    return UUID.isValidString(input);
+                case UUID.HEX_STR_LENGTH:
+                    return UUID.isValidHex(input);
+                default:
+                    return false;
+            }
+        }
+        else if (ArrayBuffer.isView(input)) {
+            return UUID.isValidBytes(input);
+        }
+        else {
+            return false;
+        }
+    }
     static formatHex(hex) {
         if (hex.length !== UUID.HEX_STR_LENGTH) {
             throw new Error(`hex length should be ${UUID.HEX_STR_LENGTH}`);
@@ -13,34 +47,74 @@ export class UUID {
     static stripHyphens(str) {
         return str.replace(/-/g, "");
     }
+    static parseHex(hex) {
+        if (hex.length !== UUID.HEX_STR_LENGTH) {
+            throw new Error(`Invalid hex string, length should be ${UUID.HEX_STR_LENGTH}`);
+        }
+        return Uint8ArrayUtils.fromHex(hex);
+    }
     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');
+            throw new Error('Invalid UUID string, invalid character length after strip hyphens');
         }
         return Uint8ArrayUtils.fromHex(hex);
     }
+    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);
+    }
+    static fromHex(hex) {
+        return new UUID(UUID.parseHex(hex));
+    }
     static fromString(str) {
-        return new UUID(str);
+        return new UUID(UUID.parseString(str));
     }
-    static parseBytes(bytes) {
-        if (bytes instanceof Uint8Array) {
-            return new Uint8Array(bytes);
+    static fromBytes(bytes) {
+        return new UUID(UUID.parseBytes(bytes));
+    }
+    static parse(input) {
+        if (typeof input === 'string') {
+            const length = input.length;
+            switch (length) {
+                case UUID.STR_LENGTH:
+                    return UUID.parseString(input);
+                case UUID.HEX_STR_LENGTH:
+                    return UUID.parseHex(input);
+                default:
+                    throw new Error(`Invalid input string, length should be ${UUID.STR_LENGTH} or ${UUID.HEX_STR_LENGTH}`);
+            }
+        }
+        else if (ArrayBuffer.isView(input)) {
+            return UUID.parseBytes(input);
         }
         else {
-            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+            throw new Error("Invalid input, Expected string or ArrayBufferView");
         }
     }
-    static fromBytes(bytes) {
-        return new UUID(UUID.parseBytes(bytes));
+    static from(input) {
+        return UUID.fromBytes(UUID.parse(input));
     }
     static nil() {
-        return new UUID(new Uint8Array(UUID.BYTE_LENGTH));
+        return UUID.fromBytes(new Uint8Array(UUID.BYTE_LENGTH));
+    }
+    static max() {
+        return UUID.fromBytes((new Uint8Array(UUID.BYTE_LENGTH)).fill(0xFF));
     }
     static equals(...uuids) {
         const n = uuids.length;
-        if (n <= 1)
-            return true;
+        if (n < 2) {
+            throw new Error('At least two UUIDs required for comparison');
+        }
         const ref = uuids[0].bytes;
         for (let i = 1; i < n; ++i) {
             const b = uuids[i].bytes;
@@ -61,21 +135,7 @@ export class UUID {
         return 0;
     }
     constructor(input) {
-        if (input == null) {
-            throw new Error('Input cannot be null');
-        }
-        if (typeof input === 'string') {
-            this.bytes = UUID.parseString(input);
-        }
-        else if (ArrayBuffer.isView(input)) {
-            this.bytes = UUID.parseBytes(input);
-        }
-        else {
-            throw new Error("Expected string or ArrayBufferView");
-        }
-        if (this.bytes.byteLength !== UUID.BYTE_LENGTH) {
-            throw new Error(`UUID must be ${UUID.BYTE_LENGTH} bytes`);
-        }
+        this.bytes = UUID.parse(input);
     }
     equals(...uuids) {
         return UUID.equals(this, ...uuids);
@@ -88,13 +148,15 @@ export class UUID {
             return this._str;
         }
         const hex = this.toHex();
-        return UUID.formatHex(hex);
+        this._str = UUID.formatHex(hex);
+        return this._str;
     }
     toHex() {
         if (this._hex != null) {
             return this._hex;
         }
-        return Uint8ArrayUtils.toHex(this.bytes);
+        this._hex = Uint8ArrayUtils.toHex(this.bytes);
+        return this._hex;
     }
     toBytes() {
         return new Uint8Array(this.bytes);
@@ -103,5 +165,8 @@ export class UUID {
         return this.toString();
     }
 }
+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}$/;
+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}$/;
 UUID.BYTE_LENGTH = 16;
+UUID.STR_LENGTH = 36;
 UUID.HEX_STR_LENGTH = 32;

package/dist/browser/esm/shared/managers/SessionManager.mjs

@@ -13,10 +13,8 @@ import EventEmitter from 'eventemitter3';
 export class SessionManager extends EventEmitter {
     constructor(options) {
         super();
-        // Init service parameters
         this.api = options.api;
         this.storageProvider = options.storageProvider;
-        // Logging
         console.log('SessionManager initialized', Date.now(), options.api);
     }
     get key() {
@@ -57,7 +55,6 @@ export class SessionManager extends EventEmitter {
                 return null;
             }
             try {
-                // Replace Bearer prefix
                 nextAuthorization = nextAuthorization.replace(/^Bearer\s+/, '');
                 const decoded = jwtDecode(nextAuthorization);
                 if (!decoded) {
@@ -98,13 +95,9 @@ export class SessionManager extends EventEmitter {
                         return [decoded.exp, exp.format(), exp.diff(Date.now(), 'days'), 'days left'];
                     })());
                 })();
-                // AsyncStorage 에 토큰 저장
                 yield this.storageProvider.set(this.key, nextAuthorization);
-                // API Instance header 설정
                 this.api.defaults.headers.common.Authorization = `Bearer ${nextAuthorization}`;
-                // Emit
                 this.emit('AUTHORIZATION_CHANGED', nextAuthorization);
-                // Return
                 return nextAuthorization;
             }
             catch (e) {
@@ -115,11 +108,8 @@ export class SessionManager extends EventEmitter {
     }
     removeAuthorization() {
         return __awaiter(this, void 0, void 0, function* () {
-            // API Instance header 에서 토큰 제거
             delete this.api.defaults.headers.common.Authorization;
-            // 스토리지에서 authorization 제거
             yield this.storageProvider.remove(this.key);
-            // Emit
             this.emit('AUTHORIZATION_CHANGED', null);
         });
     }

package/dist/browser/esm/shared/services/time/TimeService.mjs

@@ -16,11 +16,9 @@ export class TimeService extends EventEmitter {
     }
     constructor(options) {
         super();
-        // Options
         this.syncInterval = options === null || options === void 0 ? void 0 : options.syncInterval;
         this.clientTimeProvider = options === null || options === void 0 ? void 0 : options.clientTimeProvider;
         this.serverTimeProvider = options === null || options === void 0 ? void 0 : options.serverTimeProvider;
-        // Bind
         this.sync = this.sync.bind(this);
         this.fetchServerNTPResult = this.fetchServerNTPResult.bind(this);
     }
@@ -47,7 +45,6 @@ export class TimeService extends EventEmitter {
     }
     setSyncInterval(interval) {
         this.syncInterval = interval;
-        // Emit
         this.emit('SYNC_INTERVAL_CHANGED', interval);
         if (this.syncHandler !== undefined) {
             this.stopSync();
@@ -102,32 +99,22 @@ export class TimeService extends EventEmitter {
     sync() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                // T1 (Client Request Time)
                 const requestedAt = Date.now();
-                // Fetch server time from server
                 const serverNtpResult = yield this.fetchServerNTPResult(requestedAt);
-                // Check is null
                 if (serverNtpResult === null) {
                     console.warn(LOG_TAG, 'Failed to get server time');
                     return null;
                 }
-                // T2 (Server Receive Time)
                 const { t2 } = serverNtpResult;
-                // Check is not a number
                 if (isNaN(Number(t2))) {
-                    // Not a Number
                     console.error(LOG_TAG, 'invalid server time(t2), not a number', t2);
                     return null;
                 }
-                // T3 (Server Transmit Time)
                 const { t3 } = serverNtpResult;
-                // Check is not a number
                 if (isNaN(Number(t3))) {
-                    // Not a Number
                     console.error(LOG_TAG, 'invalid server time(t2), not a number', t2);
                     return null;
                 }
-                // T4 (Client Receive Time)
                 const receivedAt = Date.now();
                 const ntpResult = {
                     t1: requestedAt,
@@ -135,11 +122,8 @@ export class TimeService extends EventEmitter {
                     t3: t3,
                     t4: receivedAt,
                 };
-                // Calculate offset
                 const offset = TimeService.calculateNTPResultOffset(ntpResult);
-                // Save calculated offset
                 this.setOffset(offset);
-                // Mark synced timestamp
                 const syncedAt = Date.now();
                 this.setSyncedAt(syncedAt);
                 this.emit('SYNCED', offset, syncedAt);

package/dist/browser/esm/shared/utils/ArrayUtils.mjs

@@ -3,11 +3,6 @@ export class ArrayUtils {
     static castArray(value) {
         return castArray(value);
     }
-    /**
-     * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
-     * @param e 객체 배열
-     * @param key 값을 비교할 Property 키
-     */
     static getGreatestObject(e, key) {
         return e.reduce((prev, current) => ((prev[key] > current[key] ? prev : current)));
     }

package/dist/browser/esm/shared/utils/AxiosUtils.mjs

@@ -13,7 +13,6 @@ export class AxiosUtils {
                         return e;
                     }
                 }
-                // There is no any values having string type
                 return null;
             }
             else {
@@ -36,7 +35,6 @@ export class AxiosUtils {
                         return e;
                     }
                 }
-                // There is no any values having string type
                 return null;
             }
             else {

package/dist/browser/esm/shared/utils/Calc.mjs

@@ -14,7 +14,7 @@ export class Calc {
         const len = values.length;
         if (len === 0)
             return NaN;
-        const sorted = values.slice().sort((a, b) => a - b); // O(n log n)
+        const sorted = values.slice().sort((a, b) => a - b);
         const mid = len >> 1;
         return len % 2 === 0
             ? (sorted[mid - 1] + sorted[mid]) / 2

package/dist/browser/esm/shared/utils/DateUtils.mjs

@@ -100,7 +100,6 @@ export class DateUtils {
     }
 }
 DateUtils.relativeDate = (input, base = Date.now()) => {
-    // Create new moment instance to apply new locale
     const datetime = moment.isMoment(input) ? moment(input.toDate()) : moment(input);
     if (!datetime.isValid()) {
         console.error('core-js:DateUtils.relativeDate() datetime is invalid', datetime);

package/dist/browser/esm/shared/utils/Enum.mjs

@@ -0,0 +1,32 @@
+export class Enum {
+    static entries(e) {
+        return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
+    }
+    static keys(e) {
+        return Enum.entries(e).map(([key,]) => key);
+    }
+    static values(e) {
+        return Enum.entries(e).map(([, value]) => value);
+    }
+    static from(e) {
+        return new Enum(e);
+    }
+    constructor(e) {
+        this._e = e;
+        this._entries = Enum.entries(e);
+        this._keys = Enum.keys(e);
+        this._values = Enum.values(e);
+    }
+    value() {
+        return this._e;
+    }
+    entries() {
+        return this._entries;
+    }
+    keys() {
+        return this._keys;
+    }
+    values() {
+        return this._values;
+    }
+}

package/dist/browser/esm/shared/utils/Enum.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/browser/esm/shared/utils/JuminNumberUtils.mjs

@@ -16,10 +16,9 @@ export class JuminNumberUtils {
         if (replacedJuminNumber.length !== 13) {
             return false;
         }
-        // 연도에 해당하는 숫자와 성별에 해당하는 숫자 비교
         const TODAY_YEAR = parseInt(new Date().getFullYear().toString().slice(-2), 10);
         const yearNum = parseInt(replacedJuminNumber.slice(0, 2), 10);
-        const sexNum = replacedJuminNumber.slice(6, 7); // 대시 있는경우 7로 변경
+        const sexNum = replacedJuminNumber.slice(6, 7);
         if (sexNum === '1' || sexNum === '2') {
             if (yearNum < TODAY_YEAR)
                 return false;
@@ -30,11 +29,9 @@ export class JuminNumberUtils {
         }
         else
             return false;
-        // 월과 일에 해당하는 숫자 조건 검사 (정규식으로)
         const regex = /^\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\d{7}$/;
         if (!regex.test(replacedJuminNumber))
             return false;
-        // Validation X
         const currentX = parseInt(replacedJuminNumber.slice(-1), 10);
         const calculatedX = JuminNumberUtils.calculateX(replacedJuminNumber);
         if (currentX !== calculatedX) {

package/dist/browser/esm/shared/utils/Sequencer.mjs

@@ -28,11 +28,9 @@ export class Sequencer {
         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();
         this.pushSequence = (sequence) => {
             this.sequences.push(sequence);
@@ -51,7 +49,6 @@ export class Sequencer {
                 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* () {
@@ -95,7 +92,6 @@ export class Sequencer {
                         }
                     }));
                     console.log('Out of Promise');
-                    // Emitter
                     this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
                 }
                 catch (e) {
@@ -104,14 +100,12 @@ export class Sequencer {
                         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);
                 }
             }

package/dist/browser/esm/shared/utils/StringUtils.mjs

@@ -24,9 +24,7 @@ StringUtils.levenshteinDistance = (str1 = '', str2 = '') => {
     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);
+            track[j][i] = Math.min(track[j][i - 1] + 1, track[j - 1][i] + 1, track[j - 1][i - 1] + indicator);
         }
     }
     return track[str2.length][str1.length];

package/dist/browser/esm/shared/utils/UuidUtils.mjs

@@ -6,15 +6,12 @@ export class UuidUtils {
     }
     static format(uuid) {
         if (uuid.length === 32) {
-            // Without dash: ca23c587d7f84c76be59f53bbc9f91f8
             return `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20, 32)}`.toLowerCase();
         }
         else if (uuid.length === 36) {
-            // With dash: ca23c587-d7f8-4c76-be59-f53bbc9f91f8
             return uuid.toLowerCase();
         }
         else {
-            // Unexpected uuid
             console.warn('Unexpected uuid length', uuid);
             return uuid;
         }

package/dist/browser/esm/shared/utils/Validator.mjs

@@ -13,14 +13,12 @@ export class Validator {
         const startsWithNumber = /^\d/.test(value);
         const startsWithAlphabet = /^[A-Za-z]/.test(value);
         const startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
-        // 최소 길이
         if (options.minLength !== undefined && options.minLength > -1) {
             validations.push(Validator.VALIDATION.MIN_LENGTH);
             if (length < options.minLength) {
                 errors.push(Validator.VALIDATION.MIN_LENGTH);
             }
         }
-        // 최대 길이
         if (options.maxLength !== undefined && options.maxLength > -1) {
             validations.push(Validator.VALIDATION.MAX_LENGTH);
             if (length > options.maxLength) {
@@ -43,39 +41,30 @@ export class Validator {
                 }
             }
         };
-        // 공백 개수
         validateMin(options.spaceMinCount, spaceCount, Validator.VALIDATION.SPACE_MIN_COUNT);
         validateMax(options.spaceMaxCount, spaceCount, Validator.VALIDATION.SPACE_MAX_COUNT);
-        // 숫자 개수
         validateMin(options.numberMinCount, numberCount, Validator.VALIDATION.NUMBER_MIN_COUNT);
         validateMax(options.numberMaxCount, numberCount, Validator.VALIDATION.NUMBER_MAX_COUNT);
-        // 알파벳 개수
         validateMin(options.alphabetMinCount, alphabetCount, Validator.VALIDATION.ALPHABET_MIN_COUNT);
         validateMax(options.alphabetMaxCount, alphabetCount, Validator.VALIDATION.ALPHABET_MAX_COUNT);
-        // 알파벳(소문자) 개수
         validateMin(options.alphabetLowerCaseMinCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MIN_COUNT);
         validateMax(options.alphabetLowerCaseMaxCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MAX_COUNT);
-        // 알파벳(대문자) 개수
         validateMin(options.alphabetUpperCaseMinCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MIN_COUNT);
         validateMax(options.alphabetUpperCaseMaxCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MAX_COUNT);
-        // 특수문자 개수
         validateMin(options.specialCharacterMinCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MIN_COUNT);
         validateMax(options.specialCharacterMaxCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MAX_COUNT);
-        // 숫자로 시작
         if (options.startsWithNumber) {
             validations.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
             if (!startsWithNumber) {
                 errors.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
             }
         }
-        // 영문으로 시작
         if (options.startsWithAlphabet) {
             validations.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
             if (!startsWithAlphabet) {
                 errors.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
             }
         }
-        // 특수문자로 시작
         if (options.startsWithSpecialCharacter) {
             validations.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
             if (!startsWithSpecialCharacter) {

package/dist/browser/esm/shared/utils/global/firstNonNullish.mjs

@@ -3,7 +3,6 @@ export function firstNonNullish(...args) {
         return undefined;
     }
     if (args[0] != null) {
-        // Not Nullish
         return args[0];
     }
     return firstNonNullish(...args.slice(1));

package/dist/browser/esm/shared/utils/global/flat.mjs

@@ -1,4 +1,3 @@
-// flat.ts
 function isBuffer(obj) {
     return !!(obj &&
         obj.constructor &&

package/dist/browser/esm/shared/utils/index.mjs

@@ -8,6 +8,8 @@ export * from './BooleanUtils.mjs';
 export * from './Calc.mjs';
 export * from './CoordinateUtils.mjs';
 export * from './DateUtils.mjs';
+export * from './Enum.mjs';
+export * from './Enum.types.mjs';
 export * from './I18nUtils.mjs';
 export * from './NumberUtils.mjs';
 export * from './ObjectIdUtils.mjs';

package/dist/browser/esm/shared/utils/try-catch/TryCatch.mjs

@@ -7,19 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-/**
- * Provides a utility class for handling synchronous and asynchronous operations with a consistent try-catch pattern.
- * It returns a tuple where the first element is the error (or null on success) and the second element is the result (or undefined on error).
- */
 export class TryCatch {
-    /**
-     * Executes a synchronous function within a try-catch block.
-     * @template T The return type of the function.
-     * @template E The type of the error that might be thrown (defaults to Error).
-     * @param fn The synchronous function to execute.
-     *@param disableLogging console.error is default way of logging on error. You can disable it by setting it true
-     * @returns A tuple containing the result of the function and an error (null if successful).
-     */
     static function(fn, disableLogging) {
         try {
             return [
@@ -40,14 +28,6 @@ export class TryCatch {
             ];
         }
     }
-    /**
-     * Executes an asynchronous function (Promise) within a try-catch block.
-     * @template T The resolved value type of the Promise.
-     * @template E The type of the error that might be rejected (defaults to Error).
-     * @param fn The Promise to await.
-     * @param disableLogging console.error is default way of logging on error. You can disable it by setting it true
-     * @returns A tuple containing the resolved value of the Promise and an error (null if successful).
-     */
     static asyncFunction(fn, disableLogging) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/dist/browser/types/browser/utils/UUID.d.ts

@@ -1,16 +1,28 @@
 export declare class UUID {
+    private static REGEX_HEX;
+    private static REGEX_RFC4122;
     private static BYTE_LENGTH;
+    private static STR_LENGTH;
     private static HEX_STR_LENGTH;
+    static isValidHex(hex: string): boolean;
+    static isValidString(str: string): boolean;
+    static isValidBytes(bytes: ArrayBufferView): boolean;
+    static isValid(input: string | ArrayBufferView): boolean;
     private static formatHex;
     private static stripHyphens;
+    private static parseHex;
     private static parseString;
-    static fromString(str: string): UUID;
     private static parseBytes;
+    static fromHex(hex: string): UUID;
+    static fromString(str: string): UUID;
     static fromBytes(bytes: ArrayBufferView): UUID;
+    private static parse;
+    static from(input: string | ArrayBufferView): UUID;
     static nil(): UUID;
+    static max(): UUID;
     static equals(...uuids: UUID[]): boolean;
     static compare(uuid1: UUID, uuid2: UUID): number;
-    private readonly bytes;
+    protected readonly bytes: Uint8Array;
     private _str?;
     private _hex?;
     constructor(input: string | ArrayBufferView);

package/dist/browser/types/shared/utils/ArrayUtils.d.ts

@@ -1,10 +1,5 @@
 export declare class ArrayUtils {
     static castArray<T>(value: T | T[]): T[];
-    /**
-     * 객체를 요소로 가지는 배열에서 가장 큰 값(Property)를 가지는 객체를 반환한다
-     * @param e 객체 배열
-     * @param key 값을 비교할 Property 키
-     */
     static getGreatestObject(e: any[], key: string): any;
     static removeDuplicate<T>(arr: T[]): T[];
     static removeObjectDuplicate(arr: any[], key: string): any[];

package/dist/browser/types/shared/utils/Enum.d.ts

@@ -0,0 +1,16 @@
+import type { EnumEntries } from "./Enum.types";
+export declare class Enum<E extends object> {
+    static entries<E extends object>(e: E): EnumEntries<E>;
+    static keys<E extends object>(e: E): ({ [K in keyof E]: E[K] extends Function ? never : K; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+    static values<E extends object>(e: E): ({ [K in keyof E]: E[K] extends Function ? never : E[K]; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+    static from<E extends object>(e: E): Enum<E>;
+    private readonly _e;
+    private readonly _entries;
+    private readonly _keys;
+    private readonly _values;
+    constructor(e: E);
+    value(): E;
+    entries(): EnumEntries<E>;
+    keys(): ({ [K in keyof E]: E[K] extends Function ? never : K; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+    values(): ({ [K in keyof E]: E[K] extends Function ? never : E[K]; }[keyof E] extends infer R ? R extends never ? never : R : never)[];
+}

package/dist/browser/types/shared/utils/Enum.types.d.ts

@@ -0,0 +1,6 @@
+type NonFunction<T, Type extends "keys" | "values"> = {
+    [K in keyof T]: T[K] extends Function ? never : Type extends "keys" ? K : T[K];
+}[keyof T] extends infer R ? (R extends never ? never : R) : never;
+export type EnumEntry<E extends object> = [NonFunction<E, "keys">, NonFunction<E, "values">];
+export type EnumEntries<E extends object> = EnumEntry<E>[];
+export {};

package/dist/browser/types/shared/utils/UuidUtils.d.ts

@@ -1,13 +1,7 @@
 export declare class UuidUtils {
     static v4(): string;
     static format(uuid: string): string;
-    /**
-     * (UUID: Buffer) to (UUID: string)
-     * @param binary UUID
-     * @returns {string|null} When binary not exists return null
-     */
     static toString(binary: Uint8Array): string;
-    /** (UUID: string) to (UUID: Buffer) */
     static toBuffer(uuid: string): Buffer;
     static toBuffer(uuid: string | null | undefined): Buffer | null;
     static isValidUUID(uuid: string): boolean;