ddan-js 2.9.17 → 2.9.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.9.17",
+  "version": "2.9.19",
   "description": "",
   "keywords": [
     "ddan-js",
@@ -33,19 +33,19 @@
       "import": "./bin/ddan-upload.mjs",
       "require": "./bin/ddan-upload.js"
     },
-    "./hook": {
-      "types": "./bin/hook.d.ts",
-      "import": "./bin/tiny/hook.mjs",
+    "./tiny/hook": {
+      "types": "./bin/tiny/hook.d.ts",
+      "import": "./bin/tiny/hook.esm.js",
       "require": "./bin/tiny/hook.js"
     },
-    "./utils": {
-      "types": "./bin/utils.d.ts",
-      "import": "./bin/tiny/utils.mjs",
+    "./tiny/utils": {
+      "types": "./bin/tiny/utils.d.ts",
+      "import": "./bin/tiny/utils.esm.js",
       "require": "./bin/tiny/utils.js"
     },
-    "./web": {
-      "types": "./bin/web.d.ts",
-      "import": "./bin/tiny/web.mjs",
+    "./tiny/web": {
+      "types": "./bin/tiny/web.d.ts",
+      "import": "./bin/tiny/web.esm.js",
       "require": "./bin/tiny/web.js"
     },
     "./*": "./*"

package/bin/hook.d.ts

@@ -1,185 +0,0 @@
-declare const dHook: {
-    qs: {
-        parse: (qs: any, { sep, eq, max, multiple, uri, parseNumber, parseBoolean }?: {
-            sep?: string | undefined;
-            eq?: string | undefined;
-            max?: number | undefined;
-            multiple?: boolean | undefined;
-            uri?: boolean | undefined;
-            parseNumber?: boolean | undefined;
-            parseBoolean?: boolean | undefined;
-        }) => {};
-        stringify: (obj: any, { sep, eq, name, uri, cleanZero, cleanNull, cleanWhitespace }?: {
-            sep?: string | undefined;
-            eq?: string | undefined;
-            name?: null | undefined;
-            uri?: boolean | undefined;
-            cleanZero?: boolean | undefined;
-            cleanNull?: boolean | undefined;
-            cleanWhitespace?: boolean | undefined;
-        }) => string;
-        https: (url: string) => string;
-        parseUrl: (url: string) => {
-            pathname: string;
-            params: {};
-            route: string;
-            page: string;
-            name: string;
-            withoutExtension: string;
-            extname: string;
-            href: string;
-            url: string;
-            origin: string;
-            host: string;
-            protocol: string;
-            port: string;
-            query: string;
-        };
-        parsePath: (url: string) => {
-            route: string;
-            page: string;
-            name: string;
-            withoutExtension: string;
-            extname: string;
-        };
-        parseHost: (url: string) => import("..").Ddan.IHttpHost;
-        join: (...args: string[]) => string;
-        shExpMatch: (text: string, pattern: string) => boolean;
-        isLocalIpAddress: (addr: string) => boolean;
-        parseFileUrl: (url: string) => {
-            href: string;
-            file: string;
-            url: string;
-            protocol: string;
-            host: string;
-            query: string;
-            params: {};
-        };
-    };
-    singleton: <T>() => {
-        new (): {};
-        __instance__: any;
-        readonly Instance: T;
-        readonly I: T;
-    };
-    getset: <T_1 = any>(t?: T_1 | undefined) => import("..").Ddan.IGetset<T_1>;
-    random: (max: number) => number;
-    randomRange: (min: number, max: number) => number;
-    lerp: (start: number, end: number, t: number) => number;
-    randoms: (max: number, count?: number, repeat?: boolean) => number[];
-    strip: (num: string | number, digits?: number) => number;
-    float: (num: string | number, { digits, fixed }?: {
-        digits?: number | undefined;
-        fixed?: boolean | undefined;
-    }) => number;
-    radian2degree: (radians: number) => number;
-    degree2radian: (degrees: number) => number;
-    calcDataSize: (data: number) => {
-        gb: number;
-        mb: number;
-        kb: number;
-        b: number;
-        total: number;
-        desc: string;
-    };
-    toString: (value: any) => any;
-    startCase: (string: any) => any;
-    snakeCase: (string: any) => any;
-    kebabCase: (string: any) => any;
-    camelCase: (string: any) => any;
-    upperCase: (string: any) => any;
-    upperFirst: (string: any) => any;
-    lowerCase: (string: any) => any;
-    lowerFirst: (string: any) => any;
-    splitOnFirst: (string: any, separator: any) => string[];
-    parseValue: (value?: any, { number, boolean }?: {
-        number?: boolean | undefined;
-        boolean?: boolean | undefined;
-    }) => any;
-    replace: (source: string, rules: import("..").Ddan.IRegexRule | import("..").Ddan.IRegexRule[]) => string;
-    jsonFormat: (jsonString: string) => string;
-    toLines: (content: string, separator?: string | RegExp) => string[];
-    sleep: (ms?: number) => Promise<unknown>;
-    run: <T_2 = any>(task?: import("..").Ddan.PFunction<T_2> | undefined, wait?: number) => Promise<[any, undefined] | [null, T_2]>;
-    exec: (func: import("..").Ddan.Function, taskId?: string) => import("..").Ddan.PSafeResult<any>;
-    debounce: typeof import("../modules/hook/modules/debounce").default;
-    throttle: typeof import("../modules/hook/modules/throttle").default;
-    task: (param?: import("..").Ddan.Func1<any, any> | undefined) => import("../class/pipeTask").default;
-    mutex: typeof import("../modules/hook/modules/mutex").default;
-    polling: typeof import("../modules/hook/modules/polling").default;
-    pipe: (func: import("..").Ddan.Function, callback?: ((result: import("..").Ddan.SafeResult<any>) => void) | undefined) => import("../modules/hook/modules/pipeline").default;
-    pipeline: (max?: number) => import("../modules/hook/modules/pipeline").default;
-    safeTask: (func: import("..").Ddan.Function, callback?: ((result: import("..").Ddan.SafeResult<any>) => void) | undefined) => import("../modules/hook/modules/safeTask").default;
-    bezier1: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
-    bezier2: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, p2: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
-    bezier3: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, p2: import("..").Ddan.IPoint, p3: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
-    bezier: (points: import("..").Ddan.IPoint[], t: number) => import("..").Ddan.IPoint;
-    bezierCurve: (points: import("..").Ddan.IPoint[], t: number) => import("..").Ddan.IPoint;
-    lerpAverage: (points: import("..").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
-    proportion: (start: number, end: number, current: number) => number;
-    logString: (data: any) => string;
-    logParse: (logStr: string) => string;
-    logRString: (data: any) => Promise<string>;
-    logRParse: (logStr: string) => Promise<string>;
-    to: <T_3 = any, U extends object = any>(promise: Promise<T_3>, errorExt?: object | undefined, fn?: import("..").Ddan.noop | undefined) => Promise<[null, T_3] | [U, undefined]>;
-    go: <T_4 = any>(task?: import("..").Ddan.PFunction<T_4> | undefined, fn?: import("..").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_4]>;
-    delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_5 = any>(func: any, fn?: import("..").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_5]>;
-    toError: (value: any) => any;
-    timeout: <T_6 = any>(task?: import("..").Ddan.PFunction<T_6> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_6]>;
-    base64: {
-        encode: (input: string) => string;
-        decode: (base64Str: string) => string;
-        encodeByOss: (input: string) => string;
-    };
-    tea: {
-        TEAKey: string;
-        encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
-        decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
-        toTeaKey: (str: string) => Uint32Array;
-        encode: (plaintext: string, key: string) => string;
-        decode: (ciphertext: string, key: string) => string;
-        encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
-        decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
-    };
-    uuid: (len?: number, radix?: number) => string;
-    guid: (len: number, prefix?: boolean, sep?: string) => string;
-    getHexString: (len: number) => string;
-    keyNumber: string;
-    keyLower: string;
-    keyUpper: string;
-    keyChars: string;
-    str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
-    ab2str: (data: ArrayBuffer, base64?: boolean) => string;
-    utf8ToBase64: (str: string) => string;
-    base64ToUtf8: (base64Str: string) => string;
-    getRandomBytes: (length: number) => Uint8Array;
-    textEncode: (text: string) => Uint8Array;
-    textDecode: (buf: ArrayBufferLike) => string;
-    toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
-    md5: (input: string | Uint8Array) => string;
-    md5Base64: (input: string | Uint8Array) => string;
-    toBase64: (input?: string) => string;
-    fromBase64: (input?: string) => string;
-    bytesToBase64: (bytes: Uint8Array) => string;
-    base64ToBytes: (input?: string) => Uint8Array;
-    toUtf8: (content: string) => string;
-    fromUtf8: (utftext: string) => string;
-    toUtf8Bytes: (content: string) => Uint8Array;
-    fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
-    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
-    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
-    bytes2str: (bytes: Uint8Array) => string;
-    str2bytes: (str?: string) => Uint8Array;
-    str2hex: (str: string) => string;
-    hex2str: (hexstr: string) => string;
-    concatBytes: (...args: Uint8Array[]) => Uint8Array;
-    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
-    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
-    hex2bytes: (hex: string) => Uint8Array;
-    bytes2hex: (bytes: Uint8Array) => string;
-    toUint32: (str: string) => Uint32Array;
-    fromUint32: (uint32: Uint32Array) => string;
-    flatten: <T_7>(data: T_7[], recursive?: boolean, list?: T_7[]) => T_7[];
-};
-export { dHook };

package/bin/store.d.ts

@@ -1,9 +0,0 @@
-import Store from '../class/store';
-import Persist from '../class/persist';
-declare const dStore: {
-    Store: typeof Store;
-    storeRef: (source: import("..").Ddan.IDStore, persistConfig?: import("..").Ddan.IDPersistConfig | undefined) => any;
-    Persist: typeof Persist;
-    persistConfig: (key: string, fields: string[], storage: import("..").Ddan.IStorage) => import("..").Ddan.IDPersistConfig;
-};
-export { dStore };

package/bin/utils.d.ts

@@ -1,239 +0,0 @@
-declare const dUtils: {
-    Event: {
-        new (type: string, eventInitDict?: EventInit | undefined): Event;
-        prototype: Event;
-        readonly NONE: 0;
-        readonly CAPTURING_PHASE: 1;
-        readonly AT_TARGET: 2;
-        readonly BUBBLING_PHASE: 3;
-    };
-    includes: typeof import("../util/includes").default;
-    forof: (source: any, cb: (key: any, val: any) => void) => void;
-    singleton: <T>() => {
-        new (): {};
-        __instance__: any;
-        readonly Instance: T;
-        readonly I: T;
-    };
-    getset: <T_1 = any>(t?: T_1 | undefined) => import("..").Ddan.IGetset<T_1>;
-    copy: (source: any, options?: {
-        fields?: string[] | undefined;
-        camel?: boolean | undefined;
-        pure?: boolean | undefined;
-    } & import("..").Ddan.IIgnoreParams) => any;
-    clone: (source: any) => any;
-    merge: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => {};
-    isEmpty: (source: any) => boolean;
-    parseValue: (source: any, { number, boolean }?: {
-        number?: boolean | undefined;
-        boolean?: boolean | undefined;
-    }) => any;
-    cloneClass: <T_2>(source: T_2) => T_2;
-    combine: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => any;
-    combines: (objs: any[], options?: import("..").Ddan.IIgnoreParams) => {};
-    observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
-    find: (obj: any, cb: (k: string, v: any) => boolean) => [string, unknown] | undefined;
-    getTag: (value: any) => string;
-    getType: (value: any) => string;
-    toString: () => string;
-    hasOwnProperty: (v: PropertyKey) => boolean;
-    propertyIsEnumerable: (v: PropertyKey) => boolean;
-    is: (val: any, type: string) => boolean;
-    isNumber: (value: any) => boolean;
-    isString: (value: any) => boolean;
-    isObject: (value: any) => boolean;
-    isObjectLike: (value: any) => boolean;
-    isPlainObject: (value: any) => boolean;
-    isSymbol: (value: any) => boolean;
-    isFunction: (value: any) => boolean;
-    isArray: (arg: any) => arg is any[];
-    isArrayLikeObject: (value: any) => boolean;
-    isIndex: (value: any, length: number) => boolean;
-    isArrayLike: (value: any) => boolean;
-    isPrototype: (value: any) => boolean;
-    isArguments: (value: any) => boolean;
-    isPromise: (value: any) => boolean;
-    isBrowser: boolean;
-    isNode: boolean;
-    isBlobOrBuffer: (data: any) => boolean;
-    isUint8Array: (data: any) => boolean;
-    isArrayBuffer: (data: any) => boolean;
-    base64: {
-        encode: (input: string) => string;
-        decode: (base64Str: string) => string;
-        encodeByOss: (input: string) => string;
-    };
-    tea: {
-        TEAKey: string;
-        encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
-        decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
-        toTeaKey: (str: string) => Uint32Array;
-        encode: (plaintext: string, key: string) => string;
-        decode: (ciphertext: string, key: string) => string;
-        encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
-        decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
-    };
-    uuid: (len?: number, radix?: number) => string;
-    guid: (len: number, prefix?: boolean, sep?: string) => string;
-    getHexString: (len: number) => string;
-    keyNumber: string;
-    keyLower: string;
-    keyUpper: string;
-    keyChars: string;
-    str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
-    ab2str: (data: ArrayBuffer, base64?: boolean) => string;
-    utf8ToBase64: (str: string) => string;
-    base64ToUtf8: (base64Str: string) => string;
-    getRandomBytes: (length: number) => Uint8Array;
-    textEncode: (text: string) => Uint8Array;
-    textDecode: (buf: ArrayBufferLike) => string;
-    toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
-    md5: (input: string | Uint8Array) => string;
-    md5Base64: (input: string | Uint8Array) => string;
-    toBase64: (input?: string) => string;
-    fromBase64: (input?: string) => string;
-    bytesToBase64: (bytes: Uint8Array) => string;
-    base64ToBytes: (input?: string) => Uint8Array;
-    toUtf8: (content: string) => string;
-    fromUtf8: (utftext: string) => string;
-    toUtf8Bytes: (content: string) => Uint8Array;
-    fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
-    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
-    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
-    bytes2str: (bytes: Uint8Array) => string;
-    str2bytes: (str?: string) => Uint8Array;
-    str2hex: (str: string) => string;
-    hex2str: (hexstr: string) => string;
-    concatBytes: (...args: Uint8Array[]) => Uint8Array;
-    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
-    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
-    hex2bytes: (hex: string) => Uint8Array;
-    bytes2hex: (bytes: Uint8Array) => string;
-    toUint32: (str: string) => Uint32Array;
-    fromUint32: (uint32: Uint32Array) => string;
-    flatten: <T_3>(data: T_3[], recursive?: boolean, list?: T_3[]) => T_3[];
-    gbk: {
-        gbkLength: (str: string) => number;
-        gbkCut: (source: string, len: number) => string;
-    };
-    math: {
-        random: (max: number) => number;
-        randomRange: (min: number, max: number) => number;
-        lerp: (start: number, end: number, t: number) => number;
-        randoms: (max: number, count?: number, repeat?: boolean) => number[];
-        strip: (num: string | number, digits?: number) => number;
-        float: (num: string | number, { digits, fixed }?: {
-            digits?: number | undefined;
-            fixed?: boolean | undefined;
-        }) => number;
-        radian2degree: (radians: number) => number;
-        degree2radian: (degrees: number) => number;
-        calcDataSize: (data: number) => {
-            gb: number;
-            mb: number;
-            kb: number;
-            b: number;
-            total: number;
-            desc: string;
-        };
-    };
-    list: {
-        stepAction: <T_4>(list: T_4[], func: import("..").Ddan.Task<T_4, void>, stepCount?: number) => void;
-        skip: <T_5>(list: T_5[], count: number) => T_5[];
-        take: <T_6>(list: T_6[], count: number, skip?: number) => T_6[];
-        distinct: <T_7>(list: T_7[]) => T_7[];
-        randoms: <T_8>(list: T_8[], count?: number, repeat?: boolean) => T_8[];
-        toKV: (list: import("..").Ddan.KV<any>[], key: string, value: string) => import("..").Ddan.KV<any>;
-        groupBy: <T_9>(list: T_9[], key: string) => Record<string, T_9[]>;
-        first: <T_10>(list: T_10[]) => T_10 | undefined;
-        last: <T_11>(list: T_11[]) => T_11 | undefined;
-        toList: <T_12>(val: T_12 | T_12[]) => T_12[];
-    };
-    string: {
-        toString: (value: any) => any;
-        startCase: (string: any) => any;
-        snakeCase: (string: any) => any;
-        kebabCase: (string: any) => any;
-        camelCase: (string: any) => any;
-        upperCase: (string: any) => any;
-        upperFirst: (string: any) => any;
-        lowerCase: (string: any) => any;
-        lowerFirst: (string: any) => any;
-        splitOnFirst: (string: any, separator: any) => string[];
-        parseValue: (value?: any, { number, boolean }?: {
-            number?: boolean | undefined;
-            boolean?: boolean | undefined;
-        }) => any;
-        replace: (source: string, rules: import("..").Ddan.IRegexRule | import("..").Ddan.IRegexRule[]) => string;
-        jsonFormat: (jsonString: string) => string;
-        toLines: (content: string, separator?: string | RegExp) => string[];
-    };
-    time: {
-        now: () => import("../modules/time/dtime").default;
-        isToday: (date: any) => any;
-        parseTimestamp: ({ year, month, date, hour, minute, second }: {
-            year?: number | undefined;
-            month?: number | undefined;
-            date?: number | undefined;
-            hour?: number | undefined;
-            minute?: number | undefined;
-            second?: number | undefined;
-        }) => number;
-        todayZero: () => number;
-        format: (time: string | number | Date, reg?: string) => string;
-        countdown: (endTime: string | number | Date, reg?: string) => "" | import("..").Ddan.ICountdown;
-        dtime: (time: string | number | Date) => import("../modules/time/dtime").default;
-        loopFrame: (interval?: number) => import("../modules/time/frame").default;
-        getTimezoneOffset: () => number;
-        getLocalTime: typeof import("../modules/time/dtime").default.getLocalTime;
-        oneDay: number;
-        oneHour: number;
-        oneMinute: number;
-        oneSecond: number;
-    };
-    obj: {
-        copy: (source: any, options?: {
-            fields?: string[] | undefined;
-            camel?: boolean | undefined;
-            pure?: boolean | undefined;
-        } & import("..").Ddan.IIgnoreParams) => any;
-        clone: (source: any) => any;
-        merge: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => {};
-        isEmpty: (source: any) => boolean;
-        parseValue: (source: any, { number, boolean }?: {
-            number?: boolean | undefined;
-            boolean?: boolean | undefined;
-        }) => any;
-        cloneClass: <T_2>(source: T_2) => T_2;
-        combine: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => any;
-        combines: (objs: any[], options?: import("..").Ddan.IIgnoreParams) => {};
-        observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
-        find: (obj: any, cb: (k: string, v: any) => boolean) => [string, unknown] | undefined;
-    };
-    rule: {
-        validateId: (content: any) => boolean;
-        validatePhone: (content: any) => boolean;
-        validator: (rules: import("../modules/rule/async-validator").Rules) => import("../modules/rule/async-validator").default;
-        validate: (rules: import("../modules/rule/async-validator").Rules, source_: import("../modules/rule/async-validator").Values, o?: any, oc?: any) => Promise<import("../modules/rule/async-validator").Values>;
-        isChinese: (content: string) => boolean;
-        isNumber: (content: string) => boolean;
-        isFloat: (content: string) => boolean;
-        isPhoneNumber: (content: any) => boolean;
-    };
-    regex: {
-        pattern: {
-            num: string;
-            zh: string;
-            en: string;
-        };
-        regex: (patt: string, modifiers?: "i" | "g" | "m" | undefined) => RegExp;
-        entire: {
-            chinese: RegExp;
-            real: RegExp;
-            cssReal: RegExp;
-            id: RegExp;
-            yyyyMMdd: RegExp;
-        };
-    };
-};
-export { dUtils };

package/bin/web.d.ts

@@ -1,114 +0,0 @@
-import Http from '../modules/http';
-declare const dWeb: {
-    fetch: {
-        getDataURL: (url: string, cache?: RequestCache | undefined) => Promise<[any, undefined] | [null, {
-            contentType: string;
-            dataUrl: string;
-        }]>;
-        getArrayBuffer: (url: string, cache?: RequestCache | undefined) => Promise<[any, undefined] | [null, ArrayBuffer]>;
-        getJson: (url: string, cache?: RequestCache | undefined) => Promise<[any, undefined] | [null, any]>;
-        download: (url: string, opts?: {
-            success?: ((buffer: Uint8Array) => void) | undefined;
-            progress?: ((percentage: number, current: number, total: number) => void) | undefined;
-            fail?: ((error: Error) => void) | undefined;
-        }) => Promise<Uint8Array | undefined>;
-        getText: (url: string, cache?: RequestCache | undefined) => Promise<[any, undefined] | [null, string]>;
-        cache: (url: string, cache?: RequestCache) => Promise<[any, undefined] | [null, boolean]>;
-    };
-    Http: typeof Http;
-    css: {
-        stringify: (styleObj: Record<string, string | number>) => string;
-        parse: (styleStr: string, { camel, pure }?: {
-            camel?: boolean | undefined;
-            pure?: boolean | undefined;
-        }) => {} | undefined;
-        fixValue: (value: string | number, unit?: string) => string | number;
-        style: (cssKV: Record<string, any>, unit?: string) => string;
-        commonFields: string[];
-    };
-    qs: {
-        parse: (qs: any, { sep, eq, max, multiple, uri, parseNumber, parseBoolean }?: {
-            sep?: string | undefined;
-            eq?: string | undefined;
-            max?: number | undefined;
-            multiple?: boolean | undefined;
-            uri?: boolean | undefined;
-            parseNumber?: boolean | undefined;
-            parseBoolean?: boolean | undefined;
-        }) => {};
-        stringify: (obj: any, { sep, eq, name, uri, cleanZero, cleanNull, cleanWhitespace }?: {
-            sep?: string | undefined;
-            eq?: string | undefined;
-            name?: null | undefined;
-            uri?: boolean | undefined;
-            cleanZero?: boolean | undefined;
-            cleanNull?: boolean | undefined;
-            cleanWhitespace?: boolean | undefined;
-        }) => string;
-        https: (url: string) => string;
-        parseUrl: (url: string) => {
-            pathname: string;
-            params: {};
-            route: string;
-            page: string;
-            name: string;
-            withoutExtension: string;
-            extname: string;
-            href: string;
-            url: string;
-            origin: string;
-            host: string;
-            protocol: string;
-            port: string;
-            query: string;
-        };
-        parsePath: (url: string) => {
-            route: string;
-            page: string;
-            name: string;
-            withoutExtension: string;
-            extname: string;
-        };
-        parseHost: (url: string) => import("..").Ddan.IHttpHost;
-        join: (...args: string[]) => string;
-        shExpMatch: (text: string, pattern: string) => boolean;
-        isLocalIpAddress: (addr: string) => boolean;
-        parseFileUrl: (url: string) => {
-            href: string;
-            file: string;
-            url: string;
-            protocol: string;
-            host: string;
-            query: string;
-            params: {};
-        };
-    };
-    icon: import("../class/icon").DIcon;
-    html: {
-        dataURLtoFile: (dataurl: any, filename: any) => File;
-        dataURLtoBlob: (dataurl: any) => Blob;
-        blobToFile: (blob: any, fileName: string) => any;
-        readAsDataURL: (file: any, cb: any) => void;
-        downloadUrl: (url: string, filename?: string, checkSomeOrigin?: boolean) => void;
-        download: (urlOrFile: string | Blob | MediaSource, filename?: string) => void;
-        downloadFile: (data: Blob | MediaSource, filename?: string) => void;
-        downloadImage: (url: string) => Promise<void> | undefined;
-        watermark: (text: string, { width, height, angle, fillStyle, font, textAlign, textBaseline, }?: {
-            width?: number | undefined;
-            height?: number | undefined;
-            angle?: number | undefined;
-            fillStyle?: string | undefined;
-            font?: string | undefined;
-            textAlign?: "center" | "end" | "left" | "right" | "start" | undefined;
-            textBaseline?: "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top" | undefined;
-        }) => string;
-        copyText: (text: string, legacy?: boolean) => Promise<boolean>;
-        queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
-        isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
-        legacyCopy: (text: string) => boolean;
-        takeHtmlLinks: (htmlContent: string) => never[];
-        takeHtml: (htmlContent: string, regex: RegExp) => string[];
-        toBlobUrl: (part: BlobPart, mime: "application/javascript") => string;
-    };
-};
-export { dWeb };