jmini 0.0.64 → 0.0.65

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "jmini",
-  "version": "0.0.64",
+  "version": "0.0.65",
   "description": "minified JavaScript Framework",
   "main": "cjs/index.js",
   "module": "esm/index.js",
+  "types": "./esm",
   "files": [
     "cjs",
     "esm",
     "declare"
   ],
-  "types": "./declare",
   "scripts": {
     "start": "run-p clean build:*",
     "clean": "rimraf cjs esm declare",
     "build:cjs": "nodemon --config nodemon.cjs.json",
     "build:esm": "nodemon --config nodemon.esm.json",
-    "build:declare": "nodemon --config nodemon.declare.json",
+    "_build:declare": "nodemon --config nodemon.declare.json",
     "demo": "run-p demo:esbuild:*",
     "demo:esbuild:server": "ts-node-dev --files --respawn demo/esbuild/server.ts",
     "demo:esbuild:front": "nodemon --config demo/esbuild/nodemon.json"
@@ -47,8 +47,5 @@
     "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.5.4"
-  },
-  "dependencies": {
-    "jmini": "^0.0.63"
   }
 }

package/declare/core.d.ts

@@ -1,174 +0,0 @@
-import { KeyValueDict, IFEXIST } from '.';
-import './primitiveExtension';
-declare global {
-    interface JminiExtension {
-    }
-}
-declare namespace Jmini {
-    type Args = any;
-    type ElementableValue = any;
-    type ForFunction = {
-        (element: HTMLElement, index: number): void;
-    };
-    namespace Events {
-        type CustomEventListener<K extends keyof WindowEventMap> = {
-            (this: HTMLElement, event: WindowEventMap[K]): void;
-        };
-        type EventType = keyof WindowEventMap;
-        type AddEventInput<K extends keyof WindowEventMap> = {
-            eventType: K;
-            eventID?: string;
-            target?: string | Chains | HTMLElement;
-            callback: CustomEventListener<K>;
-            options?: AddEventListenerOptions;
-        };
-        type RemoveEventInput = string | string[];
-    }
-    type CreateElementInput = {
-        tag?: string;
-        className?: string;
-        id?: string;
-        html?: ElementableValue;
-        attr?: KeyValueDict;
-        parent?: ElementableValue;
-        style?: React.CSSProperties;
-    };
-    type Chains = {
-        [Symbol.iterator](): void;
-        [index: number]: HTMLElement;
-        length: number;
-        queue: Function[];
-        queueProcess: boolean;
-        synchronous: boolean;
-        warn?: string;
-        src?: Args;
-        srcType?: string;
-        get(v?: number): HTMLElement | HTMLElement[];
-        for(v: {
-            (element: HTMLElement, index: number): void;
-        }, n?: number): any[];
-        await(time: number): Chains;
-        abort(): Chains;
-        callback: {
-            (fn: {
-                (jmini: Chains): void;
-            }): Chains;
-        };
-        click(): Chains;
-        focus(): Chains;
-        addEvent<K extends keyof WindowEventMap>(args: Events.AddEventInput<K>): Chains;
-        removeEvent(args: Events.RemoveEventInput): Chains;
-        html(v: ElementableValue): Chains;
-        empty(): Chains;
-        append(v: ElementableValue): Chains;
-        remove(): Chains;
-        before(...v: ElementableValue[]): Chains;
-        after(...v: ElementableValue[]): Chains;
-        find(v: ElementableValue): Chains;
-        parent(v?: string): Chains;
-        children(v?: string | 'first' | 'last' | number): Chains;
-        addClass(v: string | string[]): Chains;
-        removeClass(v: string | string[]): Chains;
-        toggleClass(v: string): Chains;
-        hasClass(v: string): boolean;
-        findClass(v: RegExp): string[];
-        css(v: React.CSSProperties): Chains;
-        getAttribute(key: string): string;
-        setAttribute(key: string, value: string): Chains;
-        getStyleProperty(property: string): string;
-        setStyleProperty(property: string, value: string): Chains;
-        val(): string;
-        position(): DOMRect;
-        jmini: {
-            new (v?: Args): Chains;
-        };
-    };
-    type Methods = {
-        expando: string;
-        prototype: Chains;
-        (v?: Args): Chains;
-        extend<T = KeyValueDict>(v: IFEXIST<T>, t?: any): void;
-        createElement: (v: CreateElementInput) => HTMLElement;
-        setCookie(props: {
-            name: string;
-            value: string;
-            age?: number;
-            path?: string;
-            domain?: string;
-            secure?: boolean;
-        }): void;
-        getCookie(name: string): string;
-        deleteCookie(name: string): void;
-        localStrage: {
-            set(key: string, value: any): any;
-            get<T = any>(key: string): T | null;
-        };
-        queryParams: {
-            get(url?: string): KeyValueDict;
-            set(searchParams: {
-                [key: string]: string | number;
-            }, url?: string): string;
-            delete(keys: string[], url?: string): string;
-        };
-        pending(callback: {
-            (resolve: {
-                (result: boolean): void;
-            }): void;
-        }, ms?: number): Promise<boolean>;
-        getCursor(event: Event): {
-            x: number;
-            y: number;
-        };
-        getScreenSize(): {
-            height: number;
-            width: number;
-            pageHeight: number;
-            scrollY: number;
-            scrollX: number;
-            pageYOffset: number;
-            pageXOffset: number;
-            safeAreaTop: number;
-            safeAreaBottom: number;
-        };
-        is: {
-            equal(a: any, b: any, stringify?: boolean): boolean;
-            what(v: any): string;
-            exist(v: any): boolean;
-            nullish(val: any): boolean;
-            jmini(v: any): v is Methods & Chains;
-            string(v: any): v is string;
-            boolean(v: any): v is boolean;
-            number(v: any): v is number;
-            array(v: any): v is any[];
-            function(v: any): v is Function;
-            keyValueDictionary(v: any): v is KeyValueDict;
-            element(v: any): v is HTMLElement;
-            elements(v: any): v is HTMLElement[];
-            shadowRoot(v: any): v is ShadowRoot;
-            date(v: any): v is Date;
-        };
-        ellipsisText(value: string, length: number): string;
-        flatArray<T = any>(v: any, regression?: '-R'): T[];
-        uniqueArray<T = any>(v: T[], key?: string): T[];
-        getKeyValue<T = any>(object: KeyValueDict, keys: string): T;
-        deepMerge<T = any>(target: T, ...args: T[]): T;
-        deepCopy<T = any>(target: T): T;
-        randomNumber(min?: number, max?: number, notIn?: number[]): number;
-        Stringify(value: any, replacer?: ((this: any, key: string, value: any) => any) | (number | string)[] | null, space?: string | number): string;
-        Objectify<T = any>(value: any, OnError?: any): T;
-        try<T = any>(fn: {
-            (): T;
-        }): [T, boolean];
-        trySync<T = any>(fn: {
-            (): Promise<T>;
-        }): Promise<[T, boolean]>;
-        scope<T = any>(fn: {
-            (): T;
-        }): T;
-        scopeSync<T = any>(fn: {
-            (): Promise<T>;
-        }): Promise<T>;
-    };
-}
-declare const Jmini: Jmini.Methods & JminiExtension;
-export { Jmini, Jmini as default };

package/declare/extension.d.ts

@@ -1,34 +0,0 @@
-declare global {
-    interface JminiExtension {
-        formatCharacter: {
-            postal: {
-                JP(params: string): string;
-            };
-            tel: {
-                _(params: string): string;
-                mobile(params: string): string;
-                fixed(params: string): string;
-            };
-        };
-        transformer: {
-            weekday: {
-                ENG(params: number): string;
-                JP(params: number): string;
-                shortJP(params: number): string;
-            };
-            wareki(value: number): {
-                era: string[];
-                value: string[];
-                gap: boolean;
-            };
-        };
-        ImageLoader: {
-            (dataUrl: string, img?: HTMLImageElement): Promise<HTMLImageElement>;
-        };
-        copyToClipboard(data: any): Promise<{
-            ok: boolean;
-            body: any;
-        }>;
-    }
-}
-export type FileReadAsType = 'dataURL' | 'arrayBuffer' | 'binaryString' | 'text';

package/declare/fetcher.d.ts

@@ -1,105 +0,0 @@
-import { KeyValueDict } from 'src';
-declare namespace Fetcher {
-    type urlInput = string | URL | globalThis.Request;
-    type Input = Omit<RequestInit, 'body'> & {
-        key?: string;
-        body?: any;
-        bodyStringify?: boolean;
-        queries?: Record<string, string | number>;
-        response_format?: 'text' | 'json' | 'formData' | 'blob' | 'arrayBuffer' | 'stream' | 'none';
-        preventMultiRequest?: boolean;
-        timeout?: number;
-        trafficControl?: number;
-    };
-    type Output<R = any, E = any, A = any> = {
-        isCancelled: boolean;
-        isAborted: boolean;
-        statusText: string;
-        requestTime: number;
-        rawData: Response;
-        additionalBody?: KeyValueDict<A>;
-        [key: string]: any;
-    } & ({
-        status: 200;
-        ok: true;
-        body: R;
-    } | {
-        status: number;
-        ok: false;
-        body: E;
-    });
-    namespace onStream {
-        type ProcessArgs = {
-            response: Output<any>;
-            errorCB: (...params: any) => void;
-            streamCB: (...params: any) => void;
-            reader: ReadableStreamDefaultReader<Uint8Array>;
-            decoder: TextDecoder;
-        };
-    }
-    type SystemMethods = {
-        onStreamProcess(params: onStream.ProcessArgs): void;
-        onStartCB?(params: Input, abort: Function): Promise<void>;
-        onKeyDuplicateCB?(retry: Function): Promise<void>;
-        onStreamCB?(data: any, done: boolean): void;
-        onResultCB?(result: Output<any>, params: Input): void;
-        onCompleteCB?(result: any): void;
-        onRetryCB?(result: any, current_params: Input, _this: Chains): Promise<Input | null>;
-        extraBody?: KeyValueDict;
-        isRetry: boolean;
-        onErrorCB(error: any): void;
-        Fetcher: {
-            new <R = any, E = any, A = any>(url: urlInput, v?: Input): Chains<R, E, A>;
-        };
-    };
-    type Chains<R = any, E = any, A = any> = {
-        params: Input;
-        url: urlInput;
-        method: string;
-        abortController: AbortController | null;
-        streamStatus: 'open' | 'abort' | 'closed';
-        get<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E, _A>>;
-        head<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E, _A>>;
-        post<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E, _A>>;
-        put<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E, _A>>;
-        delete<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E, _A>>;
-        patch<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E, _A>>;
-        options<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E, _A>>;
-        setExtraBody(body: KeyValueDict): Chains<R, E, A>;
-        send<_R = R, _E = E, _A = A>(): Promise<Output<_R, _E>>;
-        abortStream(): void;
-        onKeyDuplicate(cb: (retry: Function) => Promise<void>): Chains<R, E, A>;
-        onStart(cb: (params: Input, abort: Function) => Promise<void>): Chains<R, E, A>;
-        onStream<T = any>(callback: (data: T, done: boolean) => void, options?: {
-            decoder?: TextDecoder;
-        }): Chains<R, E, A>;
-        onResult<_R = R, _E = E, _A = A>(cb: (result: Output<_R, _E, _A>, params: Input) => void): Chains<_R, _E, _A>;
-        onComplete<_R = R, _E = E, _A = A>(cb: (result: _R) => void): Chains<_R, _E, _A>;
-        onRetry<_R = R, _E = E, _A = A>(cb: (result: _E, current_params: Input, _this: Chains<_R, _E, _A>) => Promise<Input | null>): Chains<_R, _E, _A>;
-        onError<_R = R, _E = E, _A = A>(cb: (error: _E) => void): Chains<_R, _E, _A>;
-    };
-    type Property = SystemMethods & Chains;
-    type Methods = {
-        prototype: Property;
-        <R = any, E = any, A = any>(url: urlInput, v?: Input): Chains<R, E, A>;
-        waitList: string[];
-        abort(key: string): void;
-        setDefaultTrafficControl: number;
-        setDefaultTimeout: number;
-        setDefaultHeaders?: () => HeadersInit;
-        setDefaultOnStart?: (params: Input, abort: Function) => void;
-        setDefaultOnEnd?: (result: Output<any>, params: Input) => void;
-        isReadableStream(v: any): boolean;
-        isReadableStreamReader(v: any): boolean;
-        streamToContext(streamData: ReadableStream<Uint8Array>, options?: {
-            reader?: ReadableStreamDefaultReader<Uint8Array>;
-            decoder?: TextDecoder;
-        }): Promise<{
-            ok: boolean;
-            done: boolean;
-            data: any;
-        }>;
-    };
-}
-declare const Fetcher: Fetcher.Methods;
-export { Fetcher, Fetcher as default };

package/declare/filer.d.ts

@@ -1,40 +0,0 @@
-declare namespace Filer {
-    type FileType = 'dataURL' | 'blob' | 'arrayBuffer' | 'objectURL';
-    type Options = {
-        fileName?: string;
-        extension?: string;
-        mimeType?: string;
-    };
-    type SystemMethods = {
-        Filer: {
-            new (v: any): any;
-        };
-    };
-    type Chains = {
-        ok: boolean;
-        extension: string;
-        type: string;
-        file: File;
-        fileName: string;
-        toBlob(): Promise<Blob>;
-        toDataURL(): Promise<string>;
-        toAarrayBuffer(): Promise<ArrayBuffer>;
-        toObjectURL(): Promise<string>;
-        isValid(): boolean;
-        updateFileName(fileName: string): void;
-        updateMimeType(mimeType: string): void;
-        updateExtension(extension: string): void;
-    };
-    type Property = SystemMethods & Chains;
-    type Methods = {
-        prototype: Property;
-        (v: any): Chains;
-        fromFile(file: File): Promise<Chains>;
-        fromBlob(file: Blob, options?: Options): Promise<Chains>;
-        fromDataURL(dataURL: string, options?: Options): Promise<Chains>;
-        fromArrayBuffer(arrayBuffer: ArrayBuffer, options?: Options): Promise<Chains>;
-        fromObjectURL(objectURL: string, options?: Options): Promise<Chains>;
-    };
-}
-declare const Filer: Filer.Methods;
-export { Filer, Filer as default };

package/declare/index.d.ts

@@ -1,21 +0,0 @@
-export type IFEXIST<T = any> = T extends infer V ? V : any;
-export interface KeyValueDict<T = any> {
-    [key: string]: T | void;
-}
-import './primitiveExtension';
-import Jmini from './core';
-import { UUID } from './uuid';
-import { Time } from './time';
-import { Interval } from './interval';
-import { Fetcher } from './fetcher';
-import { Filer } from './filer';
-import { Server } from './server';
-import { useStore } from './useStore';
-export * from './extension';
-declare global {
-    interface JminiExtension {
-        interval: Interval.Methods;
-    }
-}
-export { Time, Fetcher, Filer, Server, useStore, UUID };
-export default Jmini;

package/declare/interval.d.ts

@@ -1,39 +0,0 @@
-declare namespace Interval {
-    type InputArray = [Function, number, string | void];
-    type Input = {
-        fn: Function;
-        ms: number;
-        key?: string;
-    };
-    type SystemMethods = {
-        Interval: {
-            new (...args: InputArray): Chains;
-        };
-        store(): void;
-        setState(p: Partial<Columns>): void;
-    };
-    type Columns = {
-        key: string;
-        ms: number;
-        isFinished: boolean;
-        timeoutIndex: number;
-        fn: Function | null;
-    };
-    type Chains = Columns & {
-        once(): Chains;
-        start(): Chains;
-        abort(): Chains;
-    };
-    type Property = SystemMethods & Chains;
-    type Methods = {
-        prototype: Property;
-        (...args: InputArray): Chains;
-        once(...args: InputArray): Chains;
-        start(...args: InputArray): Chains;
-        series(key: string, ms?: number): Promise<Function | null>;
-        abort(key: number | string): void;
-        get(key: string): Chains | undefined;
-    };
-}
-declare const Interval: Interval.Methods;
-export { Interval, Interval as default };

package/declare/primitiveExtension.d.ts

@@ -1,57 +0,0 @@
-export {};
-import { KeyValueDict } from '.';
-import { FileReadAsType } from '.';
-declare global {
-    interface HTMLElement {
-        [index: string]: any;
-        style: {
-            [index: string]: string;
-        };
-        position(): DOMRect;
-    }
-}
-declare global {
-    interface String {
-        compress(): string;
-        encode(): string;
-        decode(): string;
-        toLower(): string;
-        toUpper(): string;
-        toCapital(): string;
-        clip(from: number, to?: number): string;
-        partReplace(begin: number, string: string): string;
-        toBlob(mimeType: any): Blob | false;
-        toNumber(): number;
-        removeLetters(): string;
-        removeSpecifics(): string;
-        removeJP(): string;
-        zen2hanNumber(): string;
-        escapeRegExChar(): string;
-    }
-}
-declare global {
-    interface Number {
-        zeroEmbed(digit: number): string;
-        ratio(base: number, floatings?: number): number;
-        rate(base: number, floatings?: number): number;
-        rank(floatings?: number): string;
-        rankJp(): string;
-        toDate(separate?: string): string;
-    }
-}
-declare global {
-    interface Array<T = KeyValueDict> {
-        toASC(...args: (keyof T)[]): Array<T>;
-        toDESC(...args: (keyof T)[]): Array<T>;
-        getSum(...args: (keyof T)[]): number;
-        getAve(...args: (keyof T)[]): number;
-        getMedian(...args: (keyof T)[]): number;
-        getMin(...args: (keyof T)[]): number;
-        getMax(...args: (keyof T)[]): number;
-    }
-}
-declare global {
-    interface File {
-        convert(readAs?: FileReadAsType): Promise<ProgressEvent<FileReader>>;
-    }
-}

package/declare/server.d.ts

@@ -1,49 +0,0 @@
-import express from 'express';
-declare namespace Server {
-    interface Request extends express.Request {
-    }
-    interface Response extends express.Response {
-        return(p?: ReturnInput): Response;
-    }
-    type Path = string | RegExp;
-    type Callback<A = Request, B = Response> = (req: A, res: B, next: express.NextFunction, error: Error) => void;
-    type RestArgs<A = Request, B = Response> = [path: Path, ...fns: Callback<A, B>[]];
-    type SetInput = [string, any];
-    type UseInput<A = Request, B = Response> = [Path] | [Path, any] | RestArgs<A, B> | [Callback<A, B>];
-    type ReturnInput<T = any> = {
-        status?: number;
-        ok?: boolean;
-        body?: T;
-        bodyStringify?: boolean;
-    };
-    type PathRouterOmits = 'onPathRouter' | 'pathRouter' | 'exception';
-    type CustomExpress = Omit<express.Express, keyof RestMethods>;
-    type RestMethods<A = Request, B = Response> = {
-        set(...args: SetInput): InstanceMethods<A, B>;
-        use(...args: UseInput<A, B>): InstanceMethods<A, B>;
-        get(...args: RestArgs<A, B>): InstanceMethods<A, B>;
-        post(...args: RestArgs<A, B>): InstanceMethods<A, B>;
-        put(...args: RestArgs<A, B>): InstanceMethods<A, B>;
-        patch(...args: RestArgs<A, B>): InstanceMethods<A, B>;
-        delete(...args: RestArgs<A, B>): InstanceMethods<A, B>;
-        options(...args: RestArgs<A, B>): InstanceMethods<A, B>;
-        all(...args: RestArgs<A, B>): InstanceMethods<A, B>;
-    };
-    type InstanceMethods<A = Request, B = Response> = CustomExpress & RestMethods<A, B> & {
-        onPathRouter(getRouter: (path: string) => express.Router): InstanceMethods<A, B>;
-        pathRouter(path: string): Omit<RestMethods<A, B>, PathRouterOmits>;
-        exception(fn: (err: any, req: A, res: B, next: express.NextFunction) => void): InstanceMethods<A, B>;
-    };
-    namespace Methods {
-        type FN = {
-            <A = Request, B = Response>(express: express.Express): InstanceMethods<A, B>;
-        };
-        type SubMethods = {
-            getLocalIP(os: any): string;
-            getIP(req: any): string;
-        };
-    }
-    type Methods = Methods.FN & Methods.SubMethods;
-}
-declare const Server: Server.Methods;
-export { Server, Server as default };

package/declare/time.d.ts

@@ -1,84 +0,0 @@
-declare namespace Time {
-    type Input = any;
-    type DateTrimTypes = 'Y' | 'M' | 'W' | 'D' | 'H' | 'I' | 'S';
-    type SystemMethods = {
-        Time: {
-            new (v: Input): Chains;
-        };
-    };
-    type Chains = {
-        value: Date;
-        validate: boolean;
-        ms: number;
-        weekday: number;
-        weekInMonth: number;
-        weekInYear: number;
-        isLastWeekInMonth: boolean;
-        year: number;
-        month: number;
-        date: number;
-        hours: number;
-        minutes: number;
-        seconds: number;
-        clone(): Chains;
-        set(date: Date): Chains;
-        isPast(): boolean;
-        isSameYear(v: any): boolean;
-        isSameMonth(v: any): boolean;
-        isSameWeek(v: any): boolean;
-        isSameDate(v: any): boolean;
-        setYear(v: number): Chains;
-        setMonth(v: number): Chains;
-        setDate(v: number): Chains;
-        setHours(v: number): Chains;
-        setMinutes(v: number): Chains;
-        setSeconds(v: number): Chains;
-        setMilliseconds(v: number): Chains;
-        addYear(v: number): Chains;
-        addMonth(v: number): Chains;
-        addWeek(v: number): Chains;
-        addDate(v: number): Chains;
-        addHours(v: number): Chains;
-        addMinutes(v: number): Chains;
-        addSeconds(v: number): Chains;
-        toFormat(format: string): string;
-        toFormatYMD(lang?: 'JP'): string;
-        toFormatYM(lang?: 'JP'): string;
-        toFormatMD(lang?: 'JP'): string;
-        toFormatHM(lang?: 'JP'): string;
-        toFormatYMDHM(lang?: 'JP'): string;
-        toFormatYMDHMS(lang?: 'JP'): string;
-        toLangYMD(lang?: 'JP'): string;
-        setFirstOfTheDay(): Chains;
-        setLastOfTheDay(): Chains;
-        setFromFormatHHMM(v: string | number): Chains;
-        setFromFormatHHMMSS(v: string | number): Chains;
-        getFirstDayOfTheYear(): Chains;
-        getLastDayOfTheYear(): Chains;
-        getFirstDayOfTheMonth(): Chains;
-        getLastDayOfTheMonth(): Chains;
-        getFirstDayOfTheWeek(): Chains;
-        getLastDayOfTheWeek(): Chains;
-        diff(v: Chains): {
-            years: number;
-            months: number;
-            dates: number;
-            hours: number;
-            minutes: number;
-            seconds: number;
-            ms: number;
-        };
-        getAge(date?: Time.Chains): number;
-    };
-    type Property = SystemMethods & Chains;
-    type Methods = {
-        prototype: Property;
-        (v?: Time.Input): Chains;
-        isTimeObject(v: any): boolean;
-        getFromNumberYYYYMMDD(v: number): Time.Chains;
-        getShortYMDs(startAt: Chains, endAt: Chains): [string, string];
-        getPeriodArray(type: 'seconds' | 'minutes' | 'hours' | 'day' | 'week' | 'month' | 'year', from: Time.Chains, to: Time.Chains): Time.Chains[];
-    };
-}
-declare const Time: Time.Methods;
-export { Time, Time as default };

package/declare/useStore.d.ts

@@ -1,11 +0,0 @@
-import { KeyValueDict } from '.';
-declare namespace useStore {
-    type Methods = {
-        set(p: KeyValueDict, privateKey?: string): boolean;
-        update(p: KeyValueDict, privateKey?: string): boolean;
-        get<T = any>(key: string, privateKey?: string): T | undefined;
-        delete(key: string, privateKey?: string): boolean;
-    };
-}
-declare const useStore: useStore.Methods;
-export { useStore, useStore as default };

package/declare/uuid.d.ts

@@ -1,13 +0,0 @@
-declare namespace UUID {
-    namespace Methods {
-        type FN = (length?: number) => string;
-        type Chains = {
-            gen128Binary(): string;
-            gen32Hex(type?: 'Formatted' | 'None', separate?: string): string;
-            to32Format(v: string, separate?: string): string;
-        };
-    }
-    type Methods = Methods.FN & Methods.Chains;
-}
-declare const UUID: UUID.Methods;
-export { UUID, UUID as default };