@powfix/core-js 0.20.5 → 0.21.1

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

@@ -0,0 +1,33 @@
+export 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);
+    }
+}
+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/esm/shared/utils/UUID.mjs

@@ -0,0 +1,316 @@
+import { Uint8ArrayUtils } from "../index.mjs";
+/**
+ * Represents a UUID (Universally Unique Identifier) and provides various utility
+ * methods for validation, conversion, comparison and creation.
+ */
+export 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 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 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 = 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();
+    }
+}
+/* --------------------------------------------------------------------
+ * 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/esm/shared/utils/UUID.types.mjs

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

package/dist/esm/shared/utils/Uint8ArrayUtils.mjs

@@ -0,0 +1,9 @@
+export 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'), '');
+    }
+}

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

@@ -0,0 +1,40 @@
+import * as uuid from "uuid";
+import { Uint8ArrayUtils } from "./Uint8ArrayUtils.mjs";
+export class UuidUtils {
+    static v4() {
+        return uuid.v4();
+    }
+    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;
+        }
+    }
+    static toString(binary) {
+        if (!binary)
+            return null;
+        return UuidUtils.format(Uint8ArrayUtils.toHex(binary));
+    }
+    static toBuffer(uuid) {
+        if (!uuid) {
+            return null;
+        }
+        return Buffer.from(uuid.replace(/-/g, ''), 'hex');
+    }
+    static isValidUUID(uuid) {
+        if (!uuid)
+            return false;
+        if (typeof uuid !== '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(uuid);
+    }
+}

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

@@ -0,0 +1,114 @@
+export class Validator {
+    static validate(value, options) {
+        value = value || '';
+        const validations = [];
+        const errors = [];
+        const { length } = value;
+        const spaceCount = (value.match(/\s/g) || []).length;
+        const numberCount = (value.match(/\d/g) || []).length;
+        const alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+        const alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+        const alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+        const specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+        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) {
+                errors.push(Validator.VALIDATION.MAX_LENGTH);
+            }
+        }
+        const validateMin = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value < option) {
+                    errors.push(validation);
+                }
+            }
+        };
+        const validateMax = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value > 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,
+            passes: validations.filter(e => !errors.includes(e)),
+            errors,
+        };
+    }
+}
+(function (Validator) {
+    let VALIDATION;
+    (function (VALIDATION) {
+        VALIDATION["MIN_LENGTH"] = "MIN_LENGTH";
+        VALIDATION["MAX_LENGTH"] = "MAX_LENGTH";
+        VALIDATION["SPACE_MIN_COUNT"] = "SPACE_MIN_COUNT";
+        VALIDATION["SPACE_MAX_COUNT"] = "SPACE_MAX_COUNT";
+        VALIDATION["NUMBER_MIN_COUNT"] = "NUMBER_MIN_COUNT";
+        VALIDATION["NUMBER_MAX_COUNT"] = "NUMBER_MAX_COUNT";
+        VALIDATION["ALPHABET_MIN_COUNT"] = "ALPHABET_MIN_COUNT";
+        VALIDATION["ALPHABET_MAX_COUNT"] = "ALPHABET_MAX_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MIN_COUNT"] = "ALPHABET_LOWER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MAX_COUNT"] = "ALPHABET_LOWER_CASE_MAX_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MIN_COUNT"] = "ALPHABET_UPPER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MAX_COUNT"] = "ALPHABET_UPPER_CASE_MAX_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MIN_COUNT"] = "SPECIAL_CHARACTER_MIN_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MAX_COUNT"] = "SPECIAL_CHARACTER_MAX_COUNT";
+        VALIDATION["STARTS_WITH_ALPHABET"] = "STARTS_WITH_ALPHABET";
+        VALIDATION["STARTS_WITH_NUMBER"] = "STARTS_WITH_NUMBER";
+        VALIDATION["STARTS_WITH_SPECIAL_CHARACTER"] = "STARTS_WITH_SPECIAL_CHARACTER";
+    })(VALIDATION = Validator.VALIDATION || (Validator.VALIDATION = {}));
+})(Validator || (Validator = {}));

package/dist/esm/shared/utils/global/atob.mjs

@@ -0,0 +1,3 @@
+import base64 from "base-64";
+const { decode } = base64;
+export const atob = decode;

package/dist/esm/shared/utils/global/base64.mjs

@@ -0,0 +1,21 @@
+import { btoa } from "./btoa.mjs";
+import { atob } from "./atob.mjs";
+export function encodeBase64(str) {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(str);
+    let binary = '';
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+export function decodeBase64(base64) {
+    const binary = atob(base64);
+    const binaryLength = binary.length;
+    const bytes = new Uint8Array(binaryLength);
+    for (let i = 0; i < binaryLength; ++i) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(bytes);
+}

package/dist/esm/shared/utils/global/between.mjs

@@ -0,0 +1,3 @@
+export const between = (value, from, to) => {
+    return value >= from && value <= to;
+};

package/dist/esm/shared/utils/global/btoa.mjs

@@ -0,0 +1,3 @@
+import base64 from "base-64";
+const { decode, encode } = base64;
+export const btoa = encode;

package/dist/esm/shared/utils/global/castArray.mjs

@@ -0,0 +1,3 @@
+export function castArray(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/dist/esm/shared/utils/global/circularDistance.mjs

@@ -0,0 +1,11 @@
+export function circularDistance(value, target, min, max) {
+    const range = max - min;
+    const from = value - min;
+    const to = target - min;
+    if (to >= from) {
+        return to - from;
+    }
+    else {
+        return range - from + to;
+    }
+}

package/dist/esm/shared/utils/global/fallbackIfMatch.mjs

@@ -0,0 +1,6 @@
+export function fallbackIfMatch(value, condition, fallback) {
+    if (typeof value === typeof condition && value === condition) {
+        return fallback;
+    }
+    return value;
+}

package/dist/esm/shared/utils/global/fallbackIfNull.mjs

@@ -0,0 +1,4 @@
+import { fallbackIfMatch } from "./fallbackIfMatch.mjs";
+export function fallbackIfNull(value, fallback) {
+    return fallbackIfMatch(value, null, fallback);
+}

package/dist/esm/shared/utils/global/fallbackIfNullish.mjs

@@ -0,0 +1,6 @@
+export function fallbackIfNullish(value, fallback) {
+    if (value == null) {
+        return fallback;
+    }
+    return value;
+}

package/dist/esm/shared/utils/global/fallbackIfUndefined.mjs

@@ -0,0 +1,4 @@
+import { fallbackIfMatch } from "./fallbackIfMatch.mjs";
+export function fallbackIfUndefined(value, fallback) {
+    return fallbackIfMatch(value, undefined, fallback);
+}

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

@@ -0,0 +1,10 @@
+export function firstNonNullish(...args) {
+    if (args == null || !Array.isArray(args) || args.length === 0) {
+        return undefined;
+    }
+    if (args[0] != null) {
+        // Not Nullish
+        return args[0];
+    }
+    return firstNonNullish(...args.slice(1));
+}