j-kompact 1.0.0

package/dist/Comparison.js

@@ -0,0 +1,64 @@
+import { And } from './Type.js';
+import { isObject } from './Object.js';
+import { flat, getOptions, lazyWrap, MLArray } from './Array.js';
+import { isString } from "./String.js";
+import { log } from './Dynamic.js';
+export function isSame(...arr) {
+    return new Set(flat(arr)).size === 1;
+}
+export function sameWith(value, ...arr) {
+    const { withLog = true, logic = And } = getOptions(arr), flattenArr = arr.lazyFlat();
+    if (withLog) {
+        log(`Value: ${JSON.stringify(value)}`);
+        log(`Compare With: ${JSON.stringify(flattenArr)}`);
+    }
+    const compare = (val) => isObject(value) && isObject(val)
+        ? Object.keys(val).every(key => val[key] === value[key])
+        : val === value;
+    return logic === And
+        ? flattenArr.every(compare)
+        : flattenArr.some(compare);
+}
+export function notSameWith(value, ...arr) {
+    return !flat(arr).includes(value);
+}
+/**
+ * Mengecek apakah 'value' ada di antara 'start' sampai 'until'
+ * Mendukung komparasi: '<', '<=', '<=<', '<<='
+ */
+export function between(start, value, until, compare = '<') {
+    [start, until] = [start ?? 0, until ?? 0];
+    let values = lazyWrap(value).map((value) => value ?? 0);
+    const compares = lazyWrap(compare);
+    if (values.length !== compare.length && values.length === 1)
+        values = MLArray.repeat(values[0], compare.length);
+    return compares.every((compare, no) => {
+        const number = values[no];
+        switch (compare) {
+            case '<':
+                return (start < number) && (number < until);
+            case '<=':
+                return (start <= number) && (number <= until);
+            case '<=<':
+                return (start <= number) && (number < until);
+            case '<<=':
+                return (start < number) && (number <= until);
+        }
+    });
+}
+export function lowerThan(value, ...comparations) {
+    const { logic = And } = getOptions(comparations), isLowerThan = (comparation) => value < comparation;
+    return logic === And
+        ? flat(comparations).every(isLowerThan)
+        : flat(comparations).some(isLowerThan);
+}
+/**
+ * Mengecek tipe data menggunakan "typeof" bawaan JavaScript untuk banyak variabel sekaligus
+ */
+export function isTypeOf(type, ...array) {
+    const { logic = And } = getOptions(array);
+    array = array.lazyFlat();
+    return logic === And
+        ? array.every((val) => type === 'string' ? isString(val) : typeof val === type)
+        : array.some((val) => type === 'string' ? isString(val) : typeof val === type);
+}

package/dist/Date.d.ts

@@ -0,0 +1,32 @@
+declare const shortMonths: import("./Array.ts").MLArray<"AGS" | "APR" | "DES" | "FEB" | "JAN" | "JUL" | "JUN" | "MAR" | "MEI" | "NOV" | "OKT" | "SEP">, longMonths: import("./Array.ts").MLArray<"AGUSTUS" | "APRIL" | "DESEMBER" | "FEBRUARI" | "JANUARI" | "JULI" | "JUNI" | "MARET" | "MEI" | "NOVEMBER" | "OKTOBER" | "SEPTEMBER">;
+export declare class MLDate extends Date {
+    constructor(...values: number[] | [string | Date | MLDate | DateObject]);
+    /** Getter & Setter */
+    get date(): number;
+    get lastDate(): number;
+    get month(): number;
+    get shortMonth(): import("./String.ts").MLString<string>;
+    get longMonth(): import("./String.ts").MLString<string>;
+    get year(): number;
+    set date(date: number);
+    set month(month: number | string);
+    set year(year: number);
+    setDate(date: number): MLDate;
+    setDate(date: number): number;
+    setMonth(month: number | string): MLDate;
+    setMonth(month: number, date?: number): number;
+    lastMonth(): MLDate;
+    nextMonth(): MLDate;
+    format(format: string, timezone?: string): any;
+}
+export type DateObject = {
+    year?: number;
+    month?: number | typeof longMonths[number] | typeof shortMonths[number];
+    date?: number;
+};
+export declare function initDate(...value: number[] | [string | Date | MLDate | DateObject]): MLDate;
+/**
+ * Cek apakah string / objek Date adalah tanggal yang valid
+ */
+export declare function isDate(value: any): boolean;
+export {};

package/dist/Date.js

@@ -0,0 +1,106 @@
+import { initString } from './String.js';
+import { initArray } from './Array.js';
+import { isObject } from './Object.js';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import tz from 'dayjs/plugin/timezone.js';
+const shortMonths = initArray([
+    'JAN', 'FEB', 'MAR', 'APR', 'MEI', 'JUN',
+    'JUL', 'AGS', 'SEP', 'OKT', 'NOV', 'DES'
+]), longMonths = initArray([
+    'JANUARI', 'FEBRUARI', 'MARET', 'APRIL', 'MEI', 'JUNI',
+    'JULI', 'AGUSTUS', 'SEPTEMBER', 'OKTOBER', 'NOVEMBER', 'DESEMBER'
+]);
+export class MLDate extends Date {
+    constructor(...values) {
+        super(...values);
+    }
+    /** Getter & Setter */
+    get date() {
+        return super.getDate();
+    }
+    get lastDate() {
+        return new Date(this.year, this.month, 0).getDate();
+    }
+    get month() {
+        return this.getMonth() + 1;
+    }
+    get shortMonth() {
+        return initString(shortMonths.get(this.month));
+    }
+    get longMonth() {
+        return initString(longMonths.get(this.month));
+    }
+    get year() {
+        return this.getFullYear();
+    }
+    set date(date) {
+        super.setDate(date);
+    }
+    set month(month) {
+        let param;
+        if (typeof month === 'string')
+            param = month.length === 3
+                ? shortMonths.locationOf(month)
+                : longMonths.locationOf(month);
+        else
+            param = month;
+        super.setMonth(param - 1);
+    }
+    set year(year) {
+        super.setFullYear(year);
+    }
+    setDate(date) {
+        this.date = date;
+        return this;
+    }
+    setMonth(month) {
+        this.month = month;
+        return this;
+    }
+    lastMonth() {
+        return new MLDate(this.getTime()).setDate(1).setMonth(this.month - 1);
+    }
+    nextMonth() {
+        return new MLDate(this.getTime()).setDate(1).setMonth(this.month + 1);
+    }
+    format(format, timezone = 'Asia/Jakarta') {
+        if (typeof Utilities !== 'undefined' && typeof Utilities.formatDate === 'function')
+            return Utilities.formatDate(this, timezone, format);
+        dayjs.extend(utc);
+        dayjs.extend(tz);
+        return dayjs(this)
+            .tz(timezone)
+            .format(format.replaceAll('y', 'Y').replaceAll('d', 'D'));
+    }
+}
+export function initDate(...value) {
+    switch (true) {
+        case isObject(value[0]):
+            const today = new MLDate(), { date = today.date, month = today.month, year = today.year } = value[0];
+            return new MLDate(year, +(typeof month === 'string'
+                ? month.length === 3
+                    ? shortMonths.indexOf(month)
+                    : longMonths.indexOf(month)
+                : (month - 1)), date);
+        case !!value.length:
+            return new MLDate(...value);
+        case value[0] instanceof MLDate:
+            return value[0];
+        case value[0] instanceof Date:
+            return new MLDate(value[0]);
+        default:
+            return new MLDate();
+    }
+}
+/**
+ * Cek apakah string / objek Date adalah tanggal yang valid
+ */
+export function isDate(value) {
+    if (value instanceof Date)
+        return !isNaN(value.getTime());
+    if (typeof value !== 'string' || /^[a-zA-Z]+[-_]\d+/.test(value))
+        return false;
+    const date = new Date(value);
+    return !isNaN(date.getTime());
+}

package/dist/Dynamic.d.ts

@@ -0,0 +1,9 @@
+/**
+ * File ini berisikan fungsi2 yang akan dijalankan dinamis sesuai environtment-nya
+ * Mendukung environtment Node.js dan Google Apps Script
+ */
+export declare function log(...args: any[]): void;
+/**
+ * @param delay - In second
+ */
+export declare function wait(delay: number): void;

package/dist/Dynamic.js

@@ -0,0 +1,28 @@
+/**
+ * File ini berisikan fungsi2 yang akan dijalankan dinamis sesuai environtment-nya
+ * Mendukung environtment Node.js dan Google Apps Script
+ */
+import { isObject, MLObject } from './Object.js';
+import { toString } from './String.js';
+export function log(...args) {
+    if (typeof Logger !== 'undefined' && typeof Logger.log === 'function')
+        Logger.log(args.map(arg => {
+            if (arg instanceof MLObject)
+                arg = arg.object;
+            if (isObject(arg))
+                return toString(arg);
+            return String(arg);
+        }).join(' '));
+    else
+        console.log(...args);
+}
+/**
+ * @param delay - In second
+ */
+export function wait(delay) {
+    delay *= 1000;
+    if (typeof Utilities !== 'undefined' && typeof Utilities.sleep === 'function')
+        Utilities.sleep(delay);
+    else
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
+}

package/dist/Error.d.ts

@@ -0,0 +1,4 @@
+export declare function templateLogError(e: Error, functionName?: string, options?: {
+    withThrow?: boolean;
+    prefixMessage?: string;
+}): void;

package/dist/Error.js

@@ -0,0 +1,7 @@
+import { log } from './Dynamic.js';
+export function templateLogError(e, functionName = '', options = {}) {
+    const { withThrow = true, prefixMessage = '' } = options;
+    log(`${prefixMessage ? `${prefixMessage}\n` : ''}${functionName ? `Function: ${functionName}\n` : ''}Error: ${e.message}\n${e.stack}`);
+    if (withThrow)
+        throw e;
+}

package/dist/Iteration.d.ts

@@ -0,0 +1,21 @@
+export declare const Break = "BREAK";
+/**
+ * Deklarasi perulangan for dengan formatDate seperti forEach
+ */
+export declare function iterate<T>(func: (no: number) => void | T, options?: {
+    from?: number;
+    until?: number;
+    untilBefore?: boolean;
+    addition?: number;
+    withReturnValue?: boolean;
+}): (void | boolean | T)[] | undefined;
+/**
+ * Fungsi pemanggilan API dengan skema perulangan saat gagal.
+ * Dapat disesuaikan jumlah percobaan dan durasi antar percobaannya.
+ */
+export declare function retry<T>(func: () => void | T, options?: {
+    attempts?: number;
+    waitingInSec?: number;
+    withReturnValue?: boolean;
+    fallback?: any;
+}): void | T[] | any;

package/dist/Iteration.js

@@ -0,0 +1,51 @@
+import { log, wait } from './Dynamic.js';
+export const Break = 'BREAK';
+/**
+ * Deklarasi perulangan for dengan formatDate seperti forEach
+ */
+export function iterate(func, options = {}) {
+    let { from = 1, until = 1 } = options;
+    if (from > until && until === 1)
+        until = from;
+    const { untilBefore = false, addition = 1, withReturnValue = func((from += addition) - addition) } = options, result = [withReturnValue];
+    if (withReturnValue === Break)
+        return;
+    for (let i = from; i <= (until - +untilBefore); i += addition) {
+        const returned = func(i);
+        if (withReturnValue)
+            result.push(returned);
+        if (returned === Break)
+            break;
+    }
+    if (withReturnValue)
+        return result;
+}
+/**
+ * Fungsi pemanggilan API dengan skema perulangan saat gagal.
+ * Dapat disesuaikan jumlah percobaan dan durasi antar percobaannya.
+ */
+export function retry(func, options = {}) {
+    const { attempts = 3, waitingInSec = 2, withReturnValue = false, fallback = null } = options;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            if (withReturnValue)
+                return func();
+            else
+                func();
+        }
+        catch (e) {
+            if (attempt === attempts) {
+                if (typeof fallback === 'function')
+                    if (withReturnValue)
+                        return fallback();
+                    else
+                        fallback();
+                else if (withReturnValue)
+                    return fallback;
+                throw e;
+            }
+            log(`Retry ${attempt}/${attempts}: ${e.message}`);
+            wait(attempt * waitingInSec);
+        }
+    }
+}

package/dist/Manipulation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Melakukan trim string secara menyeluruh, baik untuk string bisa, Array of String, maupun Object dengan value berupa string.
+ * Data Array / Object campuran didukung dan akan melakukan trim pada string saja.
+ */
+export declare function trim<T>(value: T, options?: {
+    useJsObject?: boolean;
+}): T;

package/dist/Manipulation.js

@@ -0,0 +1,19 @@
+import { isArray } from "./Array.js";
+import { initObject, isObject, MLObject } from "./Object.js";
+import { isString } from "./String.js";
+/**
+ * Melakukan trim string secara menyeluruh, baik untuk string bisa, Array of String, maupun Object dengan value berupa string.
+ * Data Array / Object campuran didukung dan akan melakukan trim pada string saja.
+ */
+export function trim(value, options = {}) {
+    const { useJsObject = false } = options;
+    if (isArray(value))
+        return value.map(val => trim(val, options));
+    if (isObject(value)) {
+        const result = initObject((value instanceof MLObject ? value.object : value)).reEntries((key, value) => [key, trim(value, options)]);
+        if (useJsObject)
+            return result.object;
+        return result;
+    }
+    return isString(value) ? value.trim() : value;
+}

package/dist/Object.d.ts

@@ -0,0 +1,58 @@
+import { type MLArray } from './Array.ts';
+import { MLString } from './String.ts';
+import { mlArray, mlObject } from './Type.ts';
+type mlObjectCallbackFunction<T, U> = (key: string, value: T) => U;
+type CustomMLClass = typeof mlObject | typeof mlArray;
+/**
+ *  ML: MASTER LIBRARY
+ */
+export declare class MLObject<T> {
+    #private;
+    [key: string]: any;
+    object: Record<string, T>;
+    static fromEntries<T>(entries: Iterable<readonly [PropertyKey, any]>): MLObject<any>;
+    static assign<T>(values: MLArray<Record<string, T>>): MLObject<T>;
+    constructor(object: Record<string, T>);
+    get entries(): MLArray<(string | T)[]>;
+    get keys(): MLArray<string>;
+    get values(): MLArray<T>;
+    /**
+     * Membalikkan { key: value } di Object menjadi { value: key }
+     */
+    reverse(): Record<string, string>;
+    reEntries<U>(callbackFunc: mlObjectCallbackFunction<T, U>): MLObject<U>;
+    forEach<U>(func: mlObjectCallbackFunction<T, U>): void;
+    map<U>(func: mlObjectCallbackFunction<T, U>): MLArray<U>;
+    filter(func: mlObjectCallbackFunction<T, boolean>): MLObject<any>;
+    /**
+     * Mendapatkan nilai berdasarkan key (bisa banyak) dari suatu object
+     */
+    get(...keys: string[] | [...string[], {
+        isDeleteNull: boolean;
+    }] | [string[], {
+        isDeleteNull: boolean;
+    }]): T | MLArray<T>;
+    getKeyByValue(...values: T[]): MLArray<MLString<string> | undefined> | MLString<string> | undefined;
+    delete(...keys: string[]): this;
+    set(keys: string | string[] | MLArray<string> | MLObject<T>, values?: T | T[] | MLArray<T> | null): this;
+    convertValueAs(type: CustomMLClass): MLObject<(string | MLArray<T extends readonly any[] ? T[number] : T>)[]>;
+    add(otherObject: Record<string, T> | MLObject<T>): void;
+}
+export declare function initObject<T>(object?: Record<string, T>): MLObject<T>;
+/**
+ * Cek apakah sebuah nilai merupakan objek plain / MLObject, bukan array dan bukan null
+ */
+export declare function isObject(...values: any[]): boolean;
+/**
+ * Cek apakah sebuah objek kosong atau tidak
+ */
+export declare function isEmpty<T>(object: Record<string, T>): boolean;
+/**
+ * Parsing dari tipe data apapun ke dalam bentuk Object
+ */
+export declare function parse<T>(param: Record<string, T>[] | Iterable<readonly [PropertyKey, any]> | string): Record<string, T>;
+/**
+ * Melakukan konversi MLObject ke Object native JavaScript
+ */
+export declare function toJSObject(value: any): Object;
+export {};

package/dist/Object.js

@@ -0,0 +1,161 @@
+import { getOptions, initArray, isAllArray, isArray } from './Array.js';
+import { initString, MLString } from './String.js';
+import { mlArray, mlObject } from './Type.js';
+import { log } from './Dynamic.js';
+/**
+ *  ML: MASTER LIBRARY
+ */
+export class MLObject {
+    object = {};
+    #entriesVersion;
+    #keysVersion = initArray();
+    #valuesVersion = initArray();
+    #reversedObject;
+    static fromEntries(entries) {
+        return new this(Object.fromEntries(entries));
+    }
+    static assign(values) {
+        const result = {};
+        values.iterate((data) => Object.assign(result, data));
+        return new this(result);
+    }
+    constructor(object) {
+        this.add(object);
+    }
+    get entries() {
+        if (!this.#entriesVersion)
+            this.#entriesVersion = initArray(Object.entries(this.object));
+        return this.#entriesVersion;
+    }
+    get keys() {
+        if (!this.#keysVersion?.length)
+            this.#keysVersion = initArray(Object.keys(this.object));
+        return this.#keysVersion;
+    }
+    get values() {
+        if (!this.#valuesVersion.length)
+            this.#valuesVersion = initArray(Object.values(this.object));
+        return this.#valuesVersion;
+    }
+    /**
+     * Membalikkan { key: value } di Object menjadi { value: key }
+     */
+    reverse() {
+        if (!this.#reversedObject)
+            this.#reversedObject = this.reEntries((key, value) => [value, key]);
+        return this.#reversedObject;
+    }
+    reEntries(callbackFunc) {
+        return MLObject.fromEntries(this.map(callbackFunc));
+    }
+    forEach(func) {
+        this.entries.forEach(([key, value]) => func(key, value));
+    }
+    map(func) {
+        return this.entries.map(([key, value]) => func(key, value));
+    }
+    filter(func) {
+        return MLObject.fromEntries(this.entries.immutableFilter(([key, value]) => func(key, value)));
+    }
+    /**
+     * Mendapatkan nilai berdasarkan key (bisa banyak) dari suatu object
+     */
+    get(...keys) {
+        const { isDeleteNull = false } = getOptions(keys), mLArrayKeys = initArray(keys, { flatting: true }), process = (key) => this[key];
+        if (mLArrayKeys.length > 1) {
+            const result = mLArrayKeys.map(process);
+            return isDeleteNull
+                ? result.deleteNull()
+                : result;
+        }
+        return process(mLArrayKeys[0]);
+    }
+    getKeyByValue(...values) {
+        const mlArrayValues = initArray(values, { flatting: true }), result = mlArrayValues.map(value => {
+            let result = this.reverse()[value];
+            if (typeof result === 'string')
+                result = initString(result);
+            return result;
+        });
+        return result.length > 1 ? result : result[0];
+    }
+    delete(...keys) {
+        initArray(keys, { flatting: true })
+            .iterate((key) => {
+            delete this.object[key];
+            delete this[key];
+        });
+        return this.#reset();
+    }
+    #reset() {
+        this.#entriesVersion = undefined;
+        this.#keysVersion = initArray();
+        this.#valuesVersion = initArray();
+        return this;
+    }
+    set(keys, values = null) {
+        if (isObject(keys))
+            initObject(keys).forEach((key, value) => this.object[key] = this[key] = value);
+        else {
+            const [keysWrapped, valuesWrapped] = [initArray(keys), initArray(values)];
+            keysWrapped.iterate((data, no) => this.object[data] = this[data] = valuesWrapped[no]);
+        }
+        return this.#reset();
+    }
+    convertValueAs(type) {
+        switch (type) {
+            case mlArray:
+                return this.reEntries((key, value) => [key, initArray(value)]);
+            case mlObject:
+                return this.reEntries((key, value) => [key, initObject(value)]);
+            default:
+                log(`Tipe ${type} tidak valid`);
+                return this;
+        }
+    }
+    add(otherObject) {
+        if (otherObject instanceof MLObject)
+            otherObject = otherObject.object;
+        this.object = otherObject;
+        this.#reset();
+        this.forEach((key, value) => {
+            if (!(key in this))
+                this[key] = value;
+        });
+    }
+}
+export function initObject(object = {}) {
+    return new MLObject(object);
+}
+/**
+ * Cek apakah sebuah nilai merupakan objek plain / MLObject, bukan array dan bukan null
+ */
+export function isObject(...values) {
+    return values.every(value => value && (value.constructor.toString().startsWith('function Object()') || value instanceof MLObject) && !isArray(value));
+}
+/**
+ * Cek apakah sebuah objek kosong atau tidak
+ */
+export function isEmpty(object) {
+    return !(!!Object.keys(object).length);
+}
+/**
+ * Parsing dari tipe data apapun ke dalam bentuk Object
+ */
+export function parse(param) {
+    if (typeof param === 'string')
+        return JSON.parse(param);
+    if (isAllArray(...param))
+        return Object.fromEntries(param);
+    return Object.assign({}, ...param);
+}
+/**
+ * Melakukan konversi MLObject ke Object native JavaScript
+ */
+export function toJSObject(value) {
+    if (isArray(value))
+        return value.map(toJSObject);
+    if (value instanceof MLObject)
+        return value.object;
+    return value;
+}

package/dist/String.d.ts

@@ -0,0 +1,31 @@
+import { And, Or } from './Type.ts';
+declare const Capitalize = "capitalize", LowerCase = "lowercase", UpperCase = "uppercase";
+type NormalizeMode = typeof Capitalize | typeof LowerCase | typeof UpperCase;
+type Logic = typeof And | typeof Or;
+export declare class MLString<T extends string = string> extends String {
+    readonly _literalType: T;
+    toJSON(): string;
+    toCamelCase(): MLString<string>;
+    normalizeFromCamelCase(mode?: NormalizeMode): "" | MLString<string>;
+    capitalize(): "" | MLString<string>;
+    /**
+     * Mengecek apakah suatu teks ada di dalam teks-teks lain
+     */
+    includes(...searchValues: string[] | {
+        logic?: Logic;
+    }[]): boolean;
+    includes(string: string, position?: number): boolean;
+    endWith(...searchValues: string[] | [{
+        logic?: Logic;
+        caseInsensitive?: boolean;
+    }]): boolean;
+    formatNumber(digitCount?: number): string;
+}
+export declare function initString<const T = string>(value: T): MLString<T extends string ? T : string>;
+export declare const toString: {
+    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+};
+export declare function isString(value: any): value is string | String;
+export declare function formatNumber(number: number, digitCount?: number): string;
+export {};

package/dist/String.js

@@ -0,0 +1,57 @@
+import { And, Or } from './Type.js';
+import { getOptions } from './Array.js';
+const Capitalize = 'capitalize', LowerCase = 'lowercase', UpperCase = 'uppercase';
+export class MLString extends String {
+    _literalType;
+    toJSON() {
+        return this.toString();
+    }
+    toCamelCase() {
+        return initString(this
+            .toLowerCase()
+            .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase())
+            .replace(/^[A-Z]/, (char) => char.toLowerCase())
+            .replace(/\W+/, ''));
+    }
+    normalizeFromCamelCase(mode = Capitalize) {
+        const result = this.replace(/[A-Z]/g, ' $&');
+        switch (mode) {
+            case Capitalize:
+                return initString(result).capitalize();
+            case LowerCase:
+                return initString(result.toLowerCase());
+            case UpperCase:
+                return initString(result.toUpperCase());
+        }
+    }
+    capitalize() {
+        return this.length ? initString(this[0].toUpperCase() + this.slice(1).toLowerCase()) : '';
+    }
+    includes(...searchValues) {
+        const { logic = And } = getOptions(searchValues), process = (searchValue) => super.includes(searchValue);
+        searchValues = searchValues.lazyFlat();
+        return logic === And
+            ? searchValues.every(process)
+            : searchValues.some(process);
+    }
+    endWith(...searchValues) {
+        const { logic = And, caseInsensitive = false } = getOptions(searchValues), process = (searchValue) => caseInsensitive ? this.toLowerCase().endsWith(searchValue.toLowerCase()) : this.endsWith(searchValue);
+        const flattenSearchValues = searchValues.lazyFlat();
+        return logic === And
+            ? flattenSearchValues.every(process)
+            : flattenSearchValues.some(process);
+    }
+    formatNumber(digitCount = 2) {
+        return this.padStart(digitCount, '0');
+    }
+}
+export function initString(value) {
+    return new MLString(value);
+}
+export const toString = JSON.stringify;
+export function isString(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+export function formatNumber(number, digitCount = 2) {
+    return initString(number).formatNumber(digitCount);
+}

package/dist/Type.d.ts

@@ -0,0 +1,3 @@
+export declare const /** Type for Storage Manipulation */ array = "ARRAY", object = "OBJECT", 
+/** Type */
+mlArray = "MLArray", mlObject = "MLObject", Ascending = "ASC", Descending = "DESC", And = "&&", Or = "||";

package/dist/Type.js

@@ -0,0 +1,3 @@
+export const /** Type for Storage Manipulation */ array = 'ARRAY', object = 'OBJECT', 
+/** Type */
+mlArray = 'MLArray', mlObject = 'MLObject', Ascending = 'ASC', Descending = 'DESC', And = '&&', Or = '||';