@powfix/core-js 0.22.2 → 0.23.0

package/dist/shared/utils/Uint8ArrayUtils.js

@@ -0,0 +1,48 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+import '../../chunk-PKBMQBKP.js';
+var Uint8ArrayUtils = /*#__PURE__*/ function() {
+    "use strict";
+    function Uint8ArrayUtils() {
+        _class_call_check(this, Uint8ArrayUtils);
+    }
+    _create_class(Uint8ArrayUtils, null, [
+        {
+            key: "fromHex",
+            value: function fromHex(hex) {
+                var _hex_match;
+                var _hex_match_map;
+                return Uint8Array.from((_hex_match_map = (_hex_match = hex.match(/.{1,2}/g)) === null || _hex_match === void 0 ? void 0 : _hex_match.map(function(byte) {
+                    return parseInt(byte, 16);
+                })) !== null && _hex_match_map !== void 0 ? _hex_match_map : []);
+            }
+        },
+        {
+            key: "toHex",
+            value: function toHex(bytes) {
+                return bytes.reduce(function(str, byte) {
+                    return str + byte.toString(16).padStart(2, "0");
+                }, "");
+            }
+        }
+    ]);
+    return Uint8ArrayUtils;
+}();
+export { Uint8ArrayUtils };

package/dist/shared/utils/UuidUtils.cjs

@@ -0,0 +1,95 @@
+'use strict';
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+require('../../chunk-ETV4XYOV.cjs');
+var uuid = require('uuid');
+var Uint8ArrayUtils = require('./Uint8ArrayUtils');
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function(k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function get() {
+                        return e[k];
+                    }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+var uuid__namespace = /*#__PURE__*/ _interopNamespace(uuid);
+var UuidUtils = /*#__PURE__*/ function() {
+    function UuidUtils() {
+        _class_call_check(this, UuidUtils);
+    }
+    _create_class(UuidUtils, null, [
+        {
+            key: "v4",
+            value: function v4() {
+                return uuid__namespace.v4();
+            }
+        },
+        {
+            key: "format",
+            value: function format(uuid2) {
+                if (uuid2.length === 32) {
+                    return "".concat(uuid2.substring(0, 8), "-").concat(uuid2.substring(8, 12), "-").concat(uuid2.substring(12, 16), "-").concat(uuid2.substring(16, 20), "-").concat(uuid2.substring(20, 32)).toLowerCase();
+                } else if (uuid2.length === 36) {
+                    return uuid2.toLowerCase();
+                } else {
+                    console.warn("Unexpected uuid length", uuid2);
+                    return uuid2;
+                }
+            }
+        },
+        {
+            key: "toString",
+            value: function toString(binary) {
+                if (!binary) return null;
+                return UuidUtils.format(Uint8ArrayUtils.Uint8ArrayUtils.toHex(binary));
+            }
+        },
+        {
+            key: "toBuffer",
+            value: function toBuffer(uuid2) {
+                if (!uuid2) {
+                    return null;
+                }
+                return Buffer.from(uuid2.replace(/-/g, ""), "hex");
+            }
+        },
+        {
+            key: "isValidUUID",
+            value: function isValidUUID(uuid2) {
+                if (!uuid2) return false;
+                if (typeof uuid2 !== "string") return false;
+                return RegExp(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/i).test(uuid2);
+            }
+        }
+    ]);
+    return UuidUtils;
+}();
+exports.UuidUtils = UuidUtils;

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

@@ -0,0 +1,16 @@
+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;
+}
+
+export { UuidUtils };

package/dist/shared/utils/UuidUtils.js

@@ -0,0 +1,75 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+import '../../chunk-PKBMQBKP.js';
+import * as uuid from 'uuid';
+import { Uint8ArrayUtils } from './Uint8ArrayUtils';
+var UuidUtils = /*#__PURE__*/ function() {
+    "use strict";
+    function UuidUtils() {
+        _class_call_check(this, UuidUtils);
+    }
+    _create_class(UuidUtils, null, [
+        {
+            key: "v4",
+            value: function v4() {
+                return uuid.v4();
+            }
+        },
+        {
+            key: "format",
+            value: function format(uuid2) {
+                if (uuid2.length === 32) {
+                    return "".concat(uuid2.substring(0, 8), "-").concat(uuid2.substring(8, 12), "-").concat(uuid2.substring(12, 16), "-").concat(uuid2.substring(16, 20), "-").concat(uuid2.substring(20, 32)).toLowerCase();
+                } else if (uuid2.length === 36) {
+                    return uuid2.toLowerCase();
+                } else {
+                    console.warn("Unexpected uuid length", uuid2);
+                    return uuid2;
+                }
+            }
+        },
+        {
+            key: "toString",
+            value: function toString(binary) {
+                if (!binary) return null;
+                return UuidUtils.format(Uint8ArrayUtils.toHex(binary));
+            }
+        },
+        {
+            key: "toBuffer",
+            value: function toBuffer(uuid2) {
+                if (!uuid2) {
+                    return null;
+                }
+                return Buffer.from(uuid2.replace(/-/g, ""), "hex");
+            }
+        },
+        {
+            key: "isValidUUID",
+            value: function isValidUUID(uuid2) {
+                if (!uuid2) return false;
+                if (typeof uuid2 !== "string") return false;
+                return RegExp(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/i).test(uuid2);
+            }
+        }
+    ]);
+    return UuidUtils;
+}();
+export { UuidUtils };

package/dist/shared/utils/Validator.cjs

@@ -0,0 +1,135 @@
+'use strict';
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+require('../../chunk-ETV4XYOV.cjs');
+var Validator = /*#__PURE__*/ function() {
+    function Validator() {
+        _class_call_check(this, Validator);
+    }
+    _create_class(Validator, null, [
+        {
+            key: "validate",
+            value: function validate(value, options) {
+                value = value || "";
+                var validations = [];
+                var errors = [];
+                var length = value.length;
+                var spaceCount = (value.match(/\s/g) || []).length;
+                var numberCount = (value.match(/\d/g) || []).length;
+                var alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+                var alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+                var alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+                var specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+                var startsWithNumber = /^\d/.test(value);
+                var startsWithAlphabet = /^[A-Za-z]/.test(value);
+                var startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
+                if (options.minLength !== void 0 && options.minLength > -1) {
+                    validations.push(Validator.VALIDATION.MIN_LENGTH);
+                    if (length < options.minLength) {
+                        errors.push(Validator.VALIDATION.MIN_LENGTH);
+                    }
+                }
+                if (options.maxLength !== void 0 && options.maxLength > -1) {
+                    validations.push(Validator.VALIDATION.MAX_LENGTH);
+                    if (length > options.maxLength) {
+                        errors.push(Validator.VALIDATION.MAX_LENGTH);
+                    }
+                }
+                var validateMin = function(option, value2, validation) {
+                    if (option !== void 0 && option > -1) {
+                        validations.push(validation);
+                        if (value2 < option) {
+                            errors.push(validation);
+                        }
+                    }
+                };
+                var validateMax = function(option, value2, validation) {
+                    if (option !== void 0 && option > -1) {
+                        validations.push(validation);
+                        if (value2 > option) {
+                            errors.push(validation);
+                        }
+                    }
+                };
+                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) {
+                        errors.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+                    }
+                }
+                return {
+                    result: errors.length === 0,
+                    validations: validations,
+                    passes: validations.filter(function(e) {
+                        return !errors.includes(e);
+                    }),
+                    errors: errors
+                };
+            }
+        }
+    ]);
+    return Validator;
+}();
+(function(Validator2) {
+    (function(VALIDATION2) {
+        VALIDATION2["MIN_LENGTH"] = "MIN_LENGTH";
+        VALIDATION2["MAX_LENGTH"] = "MAX_LENGTH";
+        VALIDATION2["SPACE_MIN_COUNT"] = "SPACE_MIN_COUNT";
+        VALIDATION2["SPACE_MAX_COUNT"] = "SPACE_MAX_COUNT";
+        VALIDATION2["NUMBER_MIN_COUNT"] = "NUMBER_MIN_COUNT";
+        VALIDATION2["NUMBER_MAX_COUNT"] = "NUMBER_MAX_COUNT";
+        VALIDATION2["ALPHABET_MIN_COUNT"] = "ALPHABET_MIN_COUNT";
+        VALIDATION2["ALPHABET_MAX_COUNT"] = "ALPHABET_MAX_COUNT";
+        VALIDATION2["ALPHABET_LOWER_CASE_MIN_COUNT"] = "ALPHABET_LOWER_CASE_MIN_COUNT";
+        VALIDATION2["ALPHABET_LOWER_CASE_MAX_COUNT"] = "ALPHABET_LOWER_CASE_MAX_COUNT";
+        VALIDATION2["ALPHABET_UPPER_CASE_MIN_COUNT"] = "ALPHABET_UPPER_CASE_MIN_COUNT";
+        VALIDATION2["ALPHABET_UPPER_CASE_MAX_COUNT"] = "ALPHABET_UPPER_CASE_MAX_COUNT";
+        VALIDATION2["SPECIAL_CHARACTER_MIN_COUNT"] = "SPECIAL_CHARACTER_MIN_COUNT";
+        VALIDATION2["SPECIAL_CHARACTER_MAX_COUNT"] = "SPECIAL_CHARACTER_MAX_COUNT";
+        VALIDATION2["STARTS_WITH_ALPHABET"] = "STARTS_WITH_ALPHABET";
+        VALIDATION2["STARTS_WITH_NUMBER"] = "STARTS_WITH_NUMBER";
+        VALIDATION2["STARTS_WITH_SPECIAL_CHARACTER"] = "STARTS_WITH_SPECIAL_CHARACTER";
+    })(Validator2.VALIDATION || (Validator2.VALIDATION = {}));
+})(Validator || (Validator = {}));
+exports.Validator = Validator;

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

@@ -0,0 +1,50 @@
+declare class Validator {
+    static validate(value: string | null | undefined, options: Validator.Options): {
+        result: boolean;
+        validations: Validator.VALIDATION[];
+        passes: Validator.VALIDATION[];
+        errors: Validator.VALIDATION[];
+    };
+}
+declare namespace Validator {
+    enum VALIDATION {
+        MIN_LENGTH = "MIN_LENGTH",
+        MAX_LENGTH = "MAX_LENGTH",
+        SPACE_MIN_COUNT = "SPACE_MIN_COUNT",
+        SPACE_MAX_COUNT = "SPACE_MAX_COUNT",
+        NUMBER_MIN_COUNT = "NUMBER_MIN_COUNT",
+        NUMBER_MAX_COUNT = "NUMBER_MAX_COUNT",
+        ALPHABET_MIN_COUNT = "ALPHABET_MIN_COUNT",
+        ALPHABET_MAX_COUNT = "ALPHABET_MAX_COUNT",
+        ALPHABET_LOWER_CASE_MIN_COUNT = "ALPHABET_LOWER_CASE_MIN_COUNT",
+        ALPHABET_LOWER_CASE_MAX_COUNT = "ALPHABET_LOWER_CASE_MAX_COUNT",
+        ALPHABET_UPPER_CASE_MIN_COUNT = "ALPHABET_UPPER_CASE_MIN_COUNT",
+        ALPHABET_UPPER_CASE_MAX_COUNT = "ALPHABET_UPPER_CASE_MAX_COUNT",
+        SPECIAL_CHARACTER_MIN_COUNT = "SPECIAL_CHARACTER_MIN_COUNT",
+        SPECIAL_CHARACTER_MAX_COUNT = "SPECIAL_CHARACTER_MAX_COUNT",
+        STARTS_WITH_ALPHABET = "STARTS_WITH_ALPHABET",
+        STARTS_WITH_NUMBER = "STARTS_WITH_NUMBER",
+        STARTS_WITH_SPECIAL_CHARACTER = "STARTS_WITH_SPECIAL_CHARACTER"
+    }
+    interface Options {
+        minLength?: number;
+        maxLength?: number;
+        spaceMinCount?: number;
+        spaceMaxCount?: number;
+        numberMinCount?: number;
+        numberMaxCount?: number;
+        alphabetMinCount?: number;
+        alphabetMaxCount?: number;
+        alphabetLowerCaseMinCount?: number;
+        alphabetLowerCaseMaxCount?: number;
+        alphabetUpperCaseMinCount?: number;
+        alphabetUpperCaseMaxCount?: number;
+        specialCharacterMinCount?: number;
+        specialCharacterMaxCount?: number;
+        startsWithNumber?: boolean;
+        startsWithAlphabet?: boolean;
+        startsWithSpecialCharacter?: boolean;
+    }
+}
+
+export { Validator };

package/dist/shared/utils/Validator.js

@@ -0,0 +1,135 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+import '../../chunk-PKBMQBKP.js';
+var Validator = /*#__PURE__*/ function() {
+    "use strict";
+    function Validator() {
+        _class_call_check(this, Validator);
+    }
+    _create_class(Validator, null, [
+        {
+            key: "validate",
+            value: function validate(value, options) {
+                value = value || "";
+                var validations = [];
+                var errors = [];
+                var length = value.length;
+                var spaceCount = (value.match(/\s/g) || []).length;
+                var numberCount = (value.match(/\d/g) || []).length;
+                var alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+                var alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+                var alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+                var specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+                var startsWithNumber = /^\d/.test(value);
+                var startsWithAlphabet = /^[A-Za-z]/.test(value);
+                var startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
+                if (options.minLength !== void 0 && options.minLength > -1) {
+                    validations.push(Validator.VALIDATION.MIN_LENGTH);
+                    if (length < options.minLength) {
+                        errors.push(Validator.VALIDATION.MIN_LENGTH);
+                    }
+                }
+                if (options.maxLength !== void 0 && options.maxLength > -1) {
+                    validations.push(Validator.VALIDATION.MAX_LENGTH);
+                    if (length > options.maxLength) {
+                        errors.push(Validator.VALIDATION.MAX_LENGTH);
+                    }
+                }
+                var validateMin = function(option, value2, validation) {
+                    if (option !== void 0 && option > -1) {
+                        validations.push(validation);
+                        if (value2 < option) {
+                            errors.push(validation);
+                        }
+                    }
+                };
+                var validateMax = function(option, value2, validation) {
+                    if (option !== void 0 && option > -1) {
+                        validations.push(validation);
+                        if (value2 > option) {
+                            errors.push(validation);
+                        }
+                    }
+                };
+                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) {
+                        errors.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+                    }
+                }
+                return {
+                    result: errors.length === 0,
+                    validations: validations,
+                    passes: validations.filter(function(e) {
+                        return !errors.includes(e);
+                    }),
+                    errors: errors
+                };
+            }
+        }
+    ]);
+    return Validator;
+}();
+(function(Validator2) {
+    (function(VALIDATION2) {
+        VALIDATION2["MIN_LENGTH"] = "MIN_LENGTH";
+        VALIDATION2["MAX_LENGTH"] = "MAX_LENGTH";
+        VALIDATION2["SPACE_MIN_COUNT"] = "SPACE_MIN_COUNT";
+        VALIDATION2["SPACE_MAX_COUNT"] = "SPACE_MAX_COUNT";
+        VALIDATION2["NUMBER_MIN_COUNT"] = "NUMBER_MIN_COUNT";
+        VALIDATION2["NUMBER_MAX_COUNT"] = "NUMBER_MAX_COUNT";
+        VALIDATION2["ALPHABET_MIN_COUNT"] = "ALPHABET_MIN_COUNT";
+        VALIDATION2["ALPHABET_MAX_COUNT"] = "ALPHABET_MAX_COUNT";
+        VALIDATION2["ALPHABET_LOWER_CASE_MIN_COUNT"] = "ALPHABET_LOWER_CASE_MIN_COUNT";
+        VALIDATION2["ALPHABET_LOWER_CASE_MAX_COUNT"] = "ALPHABET_LOWER_CASE_MAX_COUNT";
+        VALIDATION2["ALPHABET_UPPER_CASE_MIN_COUNT"] = "ALPHABET_UPPER_CASE_MIN_COUNT";
+        VALIDATION2["ALPHABET_UPPER_CASE_MAX_COUNT"] = "ALPHABET_UPPER_CASE_MAX_COUNT";
+        VALIDATION2["SPECIAL_CHARACTER_MIN_COUNT"] = "SPECIAL_CHARACTER_MIN_COUNT";
+        VALIDATION2["SPECIAL_CHARACTER_MAX_COUNT"] = "SPECIAL_CHARACTER_MAX_COUNT";
+        VALIDATION2["STARTS_WITH_ALPHABET"] = "STARTS_WITH_ALPHABET";
+        VALIDATION2["STARTS_WITH_NUMBER"] = "STARTS_WITH_NUMBER";
+        VALIDATION2["STARTS_WITH_SPECIAL_CHARACTER"] = "STARTS_WITH_SPECIAL_CHARACTER";
+    })(Validator2.VALIDATION || (Validator2.VALIDATION = {}));
+})(Validator || (Validator = {}));
+export { Validator };

package/dist/shared/utils/global/atob.cjs

@@ -0,0 +1,12 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+var base64 = require('base-64');
+function _interopDefault(e) {
+    return e && e.__esModule ? e : {
+        default: e
+    };
+}
+var base64__default = /*#__PURE__*/ _interopDefault(base64);
+var decode = base64__default.default.decode;
+var atob = decode;
+exports.atob = atob;

package/dist/shared/utils/global/atob.d.ts

@@ -0,0 +1,5 @@
+import base64 from 'base-64';
+
+declare const atob: typeof base64.decode;
+
+export { atob };

package/dist/shared/utils/global/atob.js

@@ -0,0 +1,5 @@
+import '../../../chunk-PKBMQBKP.js';
+import base64 from 'base-64';
+var decode = base64.decode;
+var atob = decode;
+export { atob };

package/dist/shared/utils/global/base64.cjs

@@ -0,0 +1,42 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+var btoa = require('./btoa');
+var atob = require('./atob');
+function encodeBase64(str) {
+    var encoder = new TextEncoder();
+    var bytes = encoder.encode(str);
+    var binary = "";
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = bytes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var byte = _step.value;
+            binary += String.fromCharCode(byte);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return btoa.btoa(binary);
+}
+function decodeBase64(base64) {
+    var binary = atob.atob(base64);
+    var binaryLength = binary.length;
+    var bytes = new Uint8Array(binaryLength);
+    for(var i = 0; i < binaryLength; ++i){
+        bytes[i] = binary.charCodeAt(i);
+    }
+    var decoder = new TextDecoder("utf-8");
+    return decoder.decode(bytes);
+}
+exports.decodeBase64 = decodeBase64;
+exports.encodeBase64 = encodeBase64;

package/dist/shared/utils/global/base64.d.ts

@@ -0,0 +1,4 @@
+declare function encodeBase64(str: string): string;
+declare function decodeBase64(base64: string): string;
+
+export { decodeBase64, encodeBase64 };

package/dist/shared/utils/global/base64.js

@@ -0,0 +1,40 @@
+import '../../../chunk-PKBMQBKP.js';
+import { btoa } from './btoa';
+import { atob } from './atob';
+function encodeBase64(str) {
+    var encoder = new TextEncoder();
+    var bytes = encoder.encode(str);
+    var binary = "";
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = bytes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var byte = _step.value;
+            binary += String.fromCharCode(byte);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return btoa(binary);
+}
+function decodeBase64(base64) {
+    var binary = atob(base64);
+    var binaryLength = binary.length;
+    var bytes = new Uint8Array(binaryLength);
+    for(var i = 0; i < binaryLength; ++i){
+        bytes[i] = binary.charCodeAt(i);
+    }
+    var decoder = new TextDecoder("utf-8");
+    return decoder.decode(bytes);
+}
+export { decodeBase64, encodeBase64 };