utils-lib-js 1.4.6 → 1.6.0

package/commonjs.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{common → cjs}/array.d.ts

@@ -2,3 +2,9 @@ import { IArrayRandom, IArrayUniq, IArrayDemote, IDemoteArray } from "./index.js
 export declare const arrayRandom: IArrayRandom<any[]>;
 export declare const arrayUniq: IArrayUniq<any[]>;
 export declare const arrayDemote: IArrayDemote<IDemoteArray<any>>;
+declare const _default: {
+    arrayRandom: IArrayRandom<any[]>;
+    arrayUniq: IArrayUniq<any[]>;
+    arrayDemote: IArrayDemote<IDemoteArray<any>>;
+};
+export default _default;

package/dist/{common → cjs}/array.js

@@ -22,4 +22,9 @@ var arrayDemote = function (arr, result) {
     });
     return result;
 };
-exports.arrayDemote = arrayDemote;
+exports.arrayDemote = arrayDemote;
+exports.default = {
+    arrayRandom: exports.arrayRandom,
+    arrayUniq: exports.arrayUniq,
+    arrayDemote: exports.arrayDemote
+};

package/dist/{common → cjs}/base.d.ts

@@ -4,3 +4,11 @@ export declare const urlSplit: IUrlSplit;
 export declare const urlJoin: IUrlJoin;
 export declare const getType: IGetType<types>;
 export declare const getTypeByList: IGetTypeByList;
+declare const _default: {
+    randomNum: IRandomNum;
+    urlSplit: IUrlSplit;
+    urlJoin: IUrlJoin;
+    getType: IGetType<types>;
+    getTypeByList: IGetTypeByList;
+};
+export default _default;

package/dist/{common → cjs}/base.js

@@ -53,4 +53,11 @@ var getTypeByList = function (data, whiteList) {
     var __type = (0, exports.getType)(data);
     return whiteList.indexOf(__type) > 0;
 };
-exports.getTypeByList = getTypeByList;
+exports.getTypeByList = getTypeByList;
+exports.default = {
+    randomNum: exports.randomNum,
+    urlSplit: exports.urlSplit,
+    urlJoin: exports.urlJoin,
+    getType: exports.getType,
+    getTypeByList: exports.getTypeByList
+};

package/dist/cjs/element.d.ts

@@ -0,0 +1,6 @@
+import { ICreateElement } from "./index.js";
+export declare const createElement: ICreateElement;
+declare const _default: {
+    createElement: ICreateElement<HTMLElement>;
+};
+export default _default;

package/dist/{common → cjs}/element.js

@@ -18,4 +18,7 @@ var createElement = function (_a) {
     parent && parent.appendChild(element);
     return element;
 };
-exports.createElement = createElement;
+exports.createElement = createElement;
+exports.default = {
+    createElement: exports.createElement
+};

package/dist/{common → cjs}/event.d.ts

@@ -4,3 +4,11 @@ export declare const stopBubble: IStopBubble;
 export declare const stopDefault: IStopDefault;
 export declare const removeHandler: IRemoveHandler;
 export declare const dispatchEvent: IDispatchEvent;
+declare const _default: {
+    addHandler: IAddHandler;
+    stopBubble: IStopBubble;
+    stopDefault: IStopDefault;
+    removeHandler: IRemoveHandler;
+    dispatchEvent: IDispatchEvent;
+};
+export default _default;

package/dist/{common → cjs}/event.js

@@ -40,4 +40,11 @@ var dispatchEvent = function (ele, data) {
     var evts = new Event(data);
     ele.dispatchEvent(evts);
 };
-exports.dispatchEvent = dispatchEvent;
+exports.dispatchEvent = dispatchEvent;
+exports.default = {
+    addHandler: exports.addHandler,
+    stopBubble: exports.stopBubble,
+    stopDefault: exports.stopDefault,
+    removeHandler: exports.removeHandler,
+    dispatchEvent: exports.dispatchEvent
+};

package/dist/{common → cjs}/function.d.ts

@@ -3,3 +3,10 @@ export declare const throttle: IThrottle;
 export declare const debounce: IDebounce;
 export declare const defer: IDefer;
 export declare const catchAwait: ICatchAwait<Promise<any>>;
+declare const _default: {
+    throttle: IThrottle;
+    debounce: IDebounce;
+    defer: IDefer;
+    catchAwait: ICatchAwait<Promise<any>>;
+};
+export default _default;

package/dist/{common → cjs}/function.js

@@ -63,4 +63,10 @@ var catchAwait = function (defer) {
         return [err];
     });
 };
-exports.catchAwait = catchAwait;
+exports.catchAwait = catchAwait;
+exports.default = {
+    throttle: exports.throttle,
+    debounce: exports.debounce,
+    defer: exports.defer,
+    catchAwait: exports.catchAwait
+};

package/dist/cjs/index.d.ts

@@ -0,0 +1,49 @@
+export * from "./object.js";
+export * from "./base.js";
+export * from "./array.js";
+export * from "./function.js";
+export * from "./element.js";
+export * from "./static.js";
+export * from "./types.js";
+export * from "./request.js";
+export * from "./event.js";
+export * from "./storage.js";
+declare const _default: {
+    setStorage: (key: string, val: any) => void;
+    getStorage: (key: string) => any;
+    clearStorage: (key: string) => void;
+    addHandler: import("./types.js").IAddHandler;
+    stopBubble: import("./types.js").IStopBubble;
+    stopDefault: import("./types.js").IStopDefault;
+    removeHandler: import("./types.js").IRemoveHandler;
+    dispatchEvent: import("./types.js").IDispatchEvent;
+    Request: typeof import("./request.js").Request;
+    types: typeof import("./static.js").types;
+    createElement: import("./types.js").ICreateElement<HTMLElement>;
+    throttle: import("./types.js").IThrottle;
+    debounce: import("./types.js").IDebounce;
+    defer: import("./types.js").IDefer;
+    catchAwait: import("./types.js").ICatchAwait<Promise<any>>;
+    arrayRandom: import("./types.js").IArrayRandom<any[]>;
+    arrayUniq: import("./types.js").IArrayUniq<any[]>;
+    arrayDemote: import("./types.js").IArrayDemote<import("./types.js").IDemoteArray<any>>;
+    randomNum: import("./types.js").IRandomNum;
+    urlSplit: import("./types.js").IUrlSplit;
+    urlJoin: import("./types.js").IUrlJoin;
+    getType: import("./types.js").IGetType<import("./static.js").types>;
+    getTypeByList: import("./types.js").IGetTypeByList;
+    getValue: import("./types.js").IGetValue;
+    setValue: import("./types.js").ISetValue;
+    mixIn: import("./types.js").IMixIn;
+    enumInversion: import("./types.js").IEnumInversion;
+    isNotObject: (source: any, type: any) => boolean;
+    cloneDeep: import("./types.js").ICloneDeep;
+    createObjectVariable: import("./types.js").ICreateObjectVariable;
+    createObject: import("./types.js").ICreateObject;
+    inherit: import("./types.js").IInherit;
+    getInstance: import("./types.js").IGetInstance;
+    classDecorator: import("./types.js").IClassDecorator;
+    stringToJson: import("./types.js").IStringToJson;
+    jsonToString: import("./types.js").IJsonToString;
+};
+export default _default;

package/dist/cjs/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var __assign = this && this.__assign || function () {
+    __assign = Object.assign || function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () {
+                return m[k];
+            } };
+    }
+    Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+});
+var __exportStar = this && this.__exportStar || function (m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = this && this.__importDefault || function (mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./object.js"), exports);
+__exportStar(require("./base.js"), exports);
+__exportStar(require("./array.js"), exports);
+__exportStar(require("./function.js"), exports);
+__exportStar(require("./element.js"), exports);
+__exportStar(require("./static.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./request.js"), exports);
+__exportStar(require("./event.js"), exports);
+__exportStar(require("./storage.js"), exports);
+var object_js_1 = __importDefault(require("./object.js"));
+var base_js_1 = __importDefault(require("./base.js"));
+var array_js_1 = __importDefault(require("./array.js"));
+var function_js_1 = __importDefault(require("./function.js"));
+var element_js_1 = __importDefault(require("./element.js"));
+var static_js_1 = __importDefault(require("./static.js"));
+var request_js_1 = __importDefault(require("./request.js"));
+var event_js_1 = __importDefault(require("./event.js"));
+var storage_js_1 = __importDefault(require("./storage.js"));
+exports.default = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, object_js_1.default), base_js_1.default), array_js_1.default), function_js_1.default), element_js_1.default), static_js_1.default), request_js_1.default), event_js_1.default), storage_js_1.default);

package/dist/{common → cjs}/object.d.ts

@@ -12,3 +12,19 @@ export declare const getInstance: IGetInstance;
 export declare const classDecorator: IClassDecorator;
 export declare const stringToJson: IStringToJson;
 export declare const jsonToString: IJsonToString;
+declare const _default: {
+    getValue: IGetValue;
+    setValue: ISetValue;
+    mixIn: IMixIn;
+    enumInversion: IEnumInversion;
+    isNotObject: (source: any, type: any) => boolean;
+    cloneDeep: ICloneDeep;
+    createObjectVariable: ICreateObjectVariable;
+    createObject: ICreateObject;
+    inherit: IInherit;
+    getInstance: IGetInstance;
+    classDecorator: IClassDecorator;
+    stringToJson: IStringToJson;
+    jsonToString: IJsonToString;
+};
+export default _default;

package/dist/{common → cjs}/object.js

@@ -182,4 +182,19 @@ var jsonToString = function (target) {
         return "";
     }
 };
-exports.jsonToString = jsonToString;
+exports.jsonToString = jsonToString;
+exports.default = {
+    getValue: exports.getValue,
+    setValue: exports.setValue,
+    mixIn: exports.mixIn,
+    enumInversion: exports.enumInversion,
+    isNotObject: exports.isNotObject,
+    cloneDeep: exports.cloneDeep,
+    createObjectVariable: exports.createObjectVariable,
+    createObject: exports.createObject,
+    inherit: exports.inherit,
+    getInstance: exports.getInstance,
+    classDecorator: exports.classDecorator,
+    stringToJson: exports.stringToJson,
+    jsonToString: exports.jsonToString
+};

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{common → cjs}/request.d.ts

@@ -54,4 +54,7 @@ export declare class Request extends RequestInit implements IRequest {
     HEAD: (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => any;
     PATCH: (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => any;
 }
-export {};
+declare const _default: {
+    Request: typeof Request;
+};
+export default _default;

package/dist/{common → cjs}/request.js

@@ -300,4 +300,5 @@ var Request = function (_super) {
     }
     return Request;
 }(RequestInit);
-exports.Request = Request;
+exports.Request = Request;
+exports.default = { Request: Request };

package/dist/{common → cjs}/static.d.ts

@@ -10,3 +10,7 @@ export declare enum types {
     "[object RegExp]" = "regExp",
     "[object Math]" = "math"
 }
+declare const _default: {
+    types: typeof types;
+};
+export default _default;

package/dist/{common → cjs}/static.js

@@ -15,4 +15,5 @@ var types;
     types["[object RegExp]"] = "regExp";
     types["[object Math]"] = "math";
 })(types = exports.types || (exports.types = {}));
-;
+;
+exports.default = { types: types };

package/dist/cjs/storage.d.ts

@@ -0,0 +1,9 @@
+export declare const setStorage: (key: string, val: any) => void;
+export declare const getStorage: (key: string) => any;
+export declare const clearStorage: (key: string) => void;
+declare const _default: {
+    setStorage: (key: string, val: any) => void;
+    getStorage: (key: string) => any;
+    clearStorage: (key: string) => void;
+};
+export default _default;

package/dist/{common → cjs}/storage.js

@@ -31,4 +31,9 @@ var clearStorage = function (key) {
         console.error(error);
     }
 };
-exports.clearStorage = clearStorage;
+exports.clearStorage = clearStorage;
+exports.default = {
+    setStorage: exports.setStorage,
+    getStorage: exports.getStorage,
+    clearStorage: exports.clearStorage
+};

package/dist/cjs/types.d.ts

@@ -0,0 +1,103 @@
+export type IKey = string | symbol | number;
+export interface IObject<T> {
+    [key: IKey]: T | IObject<any>;
+}
+export interface IPromise extends IObject<any> {
+    promise: Promise<void>;
+    resolve: (res: any) => unknown;
+    reject: (err: any) => unknown;
+}
+export type IInstance<T> = {
+    _instance: Function;
+} & T;
+export type IDemoteArray<T> = Array<IDemoteArray<T> | T>;
+export type IRandomNum = (min: number, max: number, bool?: boolean) => number;
+export type IUrlSplit = (url: string) => IObject<any>;
+export type IUrlJoin = (url: string, query: object) => string;
+export type IGetType<T> = (data: any) => typeof data | T[keyof T] | "null";
+export type IGetTypeByList = (data: any, whiteList: string[]) => boolean;
+export type IGetValue = <T, U = IObject<T> | IObject<T>[IKey]>(object: U, key: string, defaultValue?: any) => U;
+export type ISetValue = <T>(object: IObject<T>, key: string, value?: any) => IObject<T>;
+export type IMixIn = <U extends IObject<any>>(target?: U, source?: IObject<any>, overwrite?: boolean) => U;
+export type IEnumInversion = (target: IObject<string>) => IObject<string>;
+export type ICloneDeep = (target?: any) => any;
+export type ICreateObjectVariable = (type: string, source?: any) => any;
+export type ICreateObject = <T, U extends T>(source: T) => U;
+export type IInherit = <T extends Function>(source: T, target?: Function) => Function;
+export type IGetInstance = (classProto: IInstance<FunctionConstructor>, overwrite?: boolean, ...params: any[]) => Function;
+export type IClassDecorator = (params: IObject<any>) => <TFunction extends Function>(target: TFunction) => void;
+export type IStringToJson = (target: string) => IObject<any> | null;
+export type IJsonToString = (target: IObject<any>) => string;
+export type IThrottle = (fn: Function, time: number) => (...args: any[]) => void;
+export type IDebounce = (fn: Function, time: number) => (...args: any[]) => void;
+export type IDefer = () => IPromise;
+export type ICatchAwait<T extends Promise<any>> = (defer: T) => T;
+export type IArrayRandom<T extends any[]> = (arr: T) => T;
+export type IArrayUniq<T extends any[]> = (arr: T) => T;
+export type IArrayDemote<T extends IDemoteArray<any>> = (arr: T, result?: T) => T;
+interface IElementParams<T> {
+    ele: T | string;
+    style: CSSStyleDeclaration;
+    attr: Attr;
+    parent: T;
+}
+export type ICreateElement<T = HTMLElement> = (params: IElementParams<T>) => T;
+export type IAddHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export type IStopBubble = (e: Event) => void;
+export type IStopDefault = (e: Event) => void;
+export type IRemoveHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export type IDispatchEvent = <T extends Document>(ele: T, data: any) => void;
+export type IRequestParams<T> = T | IObject<any> | null;
+export type IUrl = string;
+export type IEnv = 'Window' | 'Node';
+export type IDataType = "text" | "json" | "blob" | "formData" | "arrayBuffer";
+export type IRequestMethods = "GET" | "POST" | "DELETE" | "PUT" | "OPTION" | "HEAD" | "PATCH";
+export type IRequestBody = IRequestParams<BodyInit>;
+export type IRequestHeaders = IRequestParams<HeadersInit>;
+export type IRequestBaseFn = (url: IUrl, opts: IRequestOptions) => Promise<any>;
+export type IRequestFn = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => Promise<any>;
+export type IRequestOptions = {
+    method?: IRequestMethods;
+    query?: IRequestParams<IObject<any>>;
+    body?: IRequestBody;
+    headers?: IRequestHeaders;
+    controller?: AbortController;
+    timeout?: number;
+    timer?: number | unknown | null;
+    [key: string]: any;
+};
+export type IInterceptors = {
+    use(type: "request" | "response" | "error", fn: Function): IInterceptors;
+    get reqFn(): Function;
+    get resFn(): Function;
+    get errFn(): Function;
+};
+export type IRequestBase = {
+    readonly origin: string;
+    chackUrl: (url: IUrl) => boolean;
+    envDesc: () => IEnv;
+    errorFn: <Err = any, R = Function>(reject: R) => (err: Err) => R;
+    clearTimer: (opts: IRequestOptions) => void;
+    initAbort: (opts: IRequestOptions) => IRequestOptions;
+    requestType: () => IRequestBaseFn;
+    fixOrigin: (fixStr: string) => string;
+    fetch: IRequestBaseFn;
+    http: IRequestBaseFn;
+    getDataByType: (type: IDataType, response: Response) => Promise<any>;
+    formatBodyString: (bodyString: string) => IObject<Function>;
+};
+export type IRequestInit = {
+    initDefaultParams: (url: IUrl, opts: IRequestOptions) => any;
+    initFetchParams: (url: IUrl, opts: IRequestOptions) => any;
+    initHttpParams: (url: IUrl, opts: IRequestOptions) => any;
+};
+export type IRequest = {
+    GET: IRequestFn;
+    POST: IRequestFn;
+    DELETE: IRequestFn;
+    PUT: IRequestFn;
+    OPTIONS: IRequestFn;
+    HEAD: IRequestFn;
+    PATCH: IRequestFn;
+} & IRequestBase;
+export {};

package/dist/esm/array.d.ts

@@ -2,3 +2,9 @@ import { IArrayRandom, IArrayUniq, IArrayDemote, IDemoteArray } from "./index.js
 export declare const arrayRandom: IArrayRandom<any[]>;
 export declare const arrayUniq: IArrayUniq<any[]>;
 export declare const arrayDemote: IArrayDemote<IDemoteArray<any>>;
+declare const _default: {
+    arrayRandom: IArrayRandom<any[]>;
+    arrayUniq: IArrayUniq<any[]>;
+    arrayDemote: IArrayDemote<IDemoteArray<any>>;
+};
+export default _default;

package/dist/esm/array.js

@@ -15,4 +15,9 @@ export var arrayDemote = function (arr, result) {
         return getType(i) === "array" ? arrayDemote(i, result) : result.push(i);
     });
     return result;
+};
+export default {
+    arrayRandom: arrayRandom,
+    arrayUniq: arrayUniq,
+    arrayDemote: arrayDemote
 };

package/dist/esm/base.d.ts

@@ -4,3 +4,11 @@ export declare const urlSplit: IUrlSplit;
 export declare const urlJoin: IUrlJoin;
 export declare const getType: IGetType<types>;
 export declare const getTypeByList: IGetTypeByList;
+declare const _default: {
+    randomNum: IRandomNum;
+    urlSplit: IUrlSplit;
+    urlJoin: IUrlJoin;
+    getType: IGetType<types>;
+    getTypeByList: IGetTypeByList;
+};
+export default _default;

package/dist/esm/base.js

@@ -44,4 +44,11 @@ export var getTypeByList = function (data, whiteList) {
     }
     var __type = getType(data);
     return whiteList.indexOf(__type) > 0;
+};
+export default {
+    randomNum: randomNum,
+    urlSplit: urlSplit,
+    urlJoin: urlJoin,
+    getType: getType,
+    getTypeByList: getTypeByList
 };

package/dist/esm/element.d.ts

@@ -1,2 +1,6 @@
 import { ICreateElement } from "./index.js";
 export declare const createElement: ICreateElement;
+declare const _default: {
+    createElement: ICreateElement<HTMLElement>;
+};
+export default _default;

package/dist/esm/element.js

@@ -13,4 +13,7 @@ export var createElement = function (_a) {
     }));
     parent && parent.appendChild(element);
     return element;
+};
+export default {
+    createElement: createElement
 };

package/dist/esm/event.d.ts

@@ -4,3 +4,11 @@ export declare const stopBubble: IStopBubble;
 export declare const stopDefault: IStopDefault;
 export declare const removeHandler: IRemoveHandler;
 export declare const dispatchEvent: IDispatchEvent;
+declare const _default: {
+    addHandler: IAddHandler;
+    stopBubble: IStopBubble;
+    stopDefault: IStopDefault;
+    removeHandler: IRemoveHandler;
+    dispatchEvent: IDispatchEvent;
+};
+export default _default;

package/dist/esm/event.js

@@ -31,4 +31,11 @@ export var removeHandler = function (ele, type, handler) {
 export var dispatchEvent = function (ele, data) {
     var evts = new Event(data);
     ele.dispatchEvent(evts);
+};
+export default {
+    addHandler: addHandler,
+    stopBubble: stopBubble,
+    stopDefault: stopDefault,
+    removeHandler: removeHandler,
+    dispatchEvent: dispatchEvent
 };

package/dist/esm/function.d.ts

@@ -3,3 +3,10 @@ export declare const throttle: IThrottle;
 export declare const debounce: IDebounce;
 export declare const defer: IDefer;
 export declare const catchAwait: ICatchAwait<Promise<any>>;
+declare const _default: {
+    throttle: IThrottle;
+    debounce: IDebounce;
+    defer: IDefer;
+    catchAwait: ICatchAwait<Promise<any>>;
+};
+export default _default;

package/dist/esm/function.js

@@ -55,4 +55,10 @@ export var catchAwait = function (defer) {
     }).catch(function (err) {
         return [err];
     });
+};
+export default {
+    throttle: throttle,
+    debounce: debounce,
+    defer: defer,
+    catchAwait: catchAwait
 };

package/dist/esm/index.d.ts

@@ -8,3 +8,42 @@ export * from "./types.js";
 export * from "./request.js";
 export * from "./event.js";
 export * from "./storage.js";
+declare const _default: {
+    setStorage: (key: string, val: any) => void;
+    getStorage: (key: string) => any;
+    clearStorage: (key: string) => void;
+    addHandler: import("./types.js").IAddHandler;
+    stopBubble: import("./types.js").IStopBubble;
+    stopDefault: import("./types.js").IStopDefault;
+    removeHandler: import("./types.js").IRemoveHandler;
+    dispatchEvent: import("./types.js").IDispatchEvent;
+    Request: typeof import("./request.js").Request;
+    types: typeof import("./static.js").types;
+    createElement: import("./types.js").ICreateElement<HTMLElement>;
+    throttle: import("./types.js").IThrottle;
+    debounce: import("./types.js").IDebounce;
+    defer: import("./types.js").IDefer;
+    catchAwait: import("./types.js").ICatchAwait<Promise<any>>;
+    arrayRandom: import("./types.js").IArrayRandom<any[]>;
+    arrayUniq: import("./types.js").IArrayUniq<any[]>;
+    arrayDemote: import("./types.js").IArrayDemote<import("./types.js").IDemoteArray<any>>;
+    randomNum: import("./types.js").IRandomNum;
+    urlSplit: import("./types.js").IUrlSplit;
+    urlJoin: import("./types.js").IUrlJoin;
+    getType: import("./types.js").IGetType<import("./static.js").types>;
+    getTypeByList: import("./types.js").IGetTypeByList;
+    getValue: import("./types.js").IGetValue;
+    setValue: import("./types.js").ISetValue;
+    mixIn: import("./types.js").IMixIn;
+    enumInversion: import("./types.js").IEnumInversion;
+    isNotObject: (source: any, type: any) => boolean;
+    cloneDeep: import("./types.js").ICloneDeep;
+    createObjectVariable: import("./types.js").ICreateObjectVariable;
+    createObject: import("./types.js").ICreateObject;
+    inherit: import("./types.js").IInherit;
+    getInstance: import("./types.js").IGetInstance;
+    classDecorator: import("./types.js").IClassDecorator;
+    stringToJson: import("./types.js").IStringToJson;
+    jsonToString: import("./types.js").IJsonToString;
+};
+export default _default;

package/dist/esm/index.js

@@ -1,3 +1,13 @@
+var __assign = this && this.__assign || function () {
+    __assign = Object.assign || function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 export * from "./object.js";
 export * from "./base.js";
 export * from "./array.js";
@@ -7,4 +17,14 @@ export * from "./static.js";
 export * from "./types.js";
 export * from "./request.js";
 export * from "./event.js";
-export * from "./storage.js";
+export * from "./storage.js";
+import object from "./object.js";
+import base from "./base.js";
+import array from "./array.js";
+import __function from "./function.js";
+import element from "./element.js";
+import __static from "./static.js";
+import request from "./request.js";
+import event from "./event.js";
+import storage from "./storage.js";
+export default __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, object), base), array), __function), element), __static), request), event), storage);

package/dist/esm/object.d.ts

@@ -12,3 +12,19 @@ export declare const getInstance: IGetInstance;
 export declare const classDecorator: IClassDecorator;
 export declare const stringToJson: IStringToJson;
 export declare const jsonToString: IJsonToString;
+declare const _default: {
+    getValue: IGetValue;
+    setValue: ISetValue;
+    mixIn: IMixIn;
+    enumInversion: IEnumInversion;
+    isNotObject: (source: any, type: any) => boolean;
+    cloneDeep: ICloneDeep;
+    createObjectVariable: ICreateObjectVariable;
+    createObject: ICreateObject;
+    inherit: IInherit;
+    getInstance: IGetInstance;
+    classDecorator: IClassDecorator;
+    stringToJson: IStringToJson;
+    jsonToString: IJsonToString;
+};
+export default _default;