@tachybase/schema 0.23.41 → 0.23.47

package/lib/reactive-react/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/shared/array.d.ts

@@ -0,0 +1,35 @@
+type EachArrayIterator<T> = (currentValue: T, key: number) => void | boolean;
+type EachStringIterator = (currentValue: string, key: number) => void | boolean;
+type EachObjectIterator<T = any> = (currentValue: T, key: string) => void | boolean;
+type MapArrayIterator<TItem, TResult> = (currentValue: TItem, key: number) => TResult;
+type MapStringIterator<TResult> = (currentValue: string, key: number) => TResult;
+type MapObjectIterator<TItem, TResult> = (currentValue: TItem, key: string) => TResult;
+type MemoArrayIterator<T, U> = (previousValue: U, currentValue: T, key: number) => U;
+type MemoStringIterator<T> = (previousValue: T, currentValue: string, key: number) => T;
+type MemoObjectIterator<TValue, TResult> = (previousValue: TResult, currentValue: TValue, key: string) => TResult;
+export declare const toArr: (val: any) => any[];
+export declare function each(val: string, iterator: EachStringIterator, revert?: boolean): void;
+export declare function each<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): void;
+export declare function each<T extends {}, TValue extends T[keyof T]>(val: T, iterator: EachObjectIterator<TValue>, revert?: boolean): void;
+export declare function map<T>(val: string, iterator: MapStringIterator<T>, revert?: boolean): T[];
+export declare function map<TItem, TResult>(val: TItem[], iterator: MapArrayIterator<TItem, TResult>, revert?: boolean): TResult[];
+export declare function map<T extends {}, TResult>(val: T, iterator: MapObjectIterator<T[keyof T], TResult>, revert?: boolean): Record<keyof T, TResult>;
+export declare function reduce<T, U>(val: T[], iterator: MemoArrayIterator<T, U>, accumulator?: U, revert?: boolean): U;
+export declare function reduce<T>(val: string, iterator: MemoStringIterator<T>, accumulator?: T, revert?: boolean): T;
+export declare function reduce<T extends {}, TValue extends T[keyof T], TResult = any>(val: T, iterator: MemoObjectIterator<TValue, TResult>, accumulator?: TResult, revert?: boolean): TResult;
+export declare function every<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): boolean;
+export declare function every<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): boolean;
+export declare function every<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): boolean;
+export declare function some<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): boolean;
+export declare function some<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): boolean;
+export declare function some<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): boolean;
+export declare function findIndex<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): number;
+export declare function findIndex<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): number;
+export declare function findIndex<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): keyof T;
+export declare function find<T extends string>(val: T, iterator: EachStringIterator, revert?: boolean): any;
+export declare function find<T>(val: T[], iterator: EachArrayIterator<T>, revert?: boolean): T;
+export declare function find<T extends {}>(val: T, iterator: EachObjectIterator, revert?: boolean): T[keyof T];
+export declare function includes<T extends string>(val: T, searchElement: string, revert?: boolean): boolean;
+export declare function includes<T>(val: T[], searchElement: T, revert?: boolean): boolean;
+export declare function move<T extends any>(array: T[], fromIndex: number, toIndex: number): T[];
+export {};

package/lib/shared/array.js

@@ -0,0 +1,189 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var array_exports = {};
+__export(array_exports, {
+  each: () => each,
+  every: () => every,
+  find: () => find,
+  findIndex: () => findIndex,
+  includes: () => includes,
+  map: () => map,
+  move: () => move,
+  reduce: () => reduce,
+  some: () => some,
+  toArr: () => toArr
+});
+module.exports = __toCommonJS(array_exports);
+var import_checkers = require("./checkers");
+const toArr = /* @__PURE__ */ __name((val) => (0, import_checkers.isArr)(val) ? val : val ? [val] : [], "toArr");
+function each(val, iterator, revert) {
+  if ((0, import_checkers.isArr)(val) || (0, import_checkers.isStr)(val)) {
+    if (revert) {
+      for (let i = val.length - 1; i >= 0; i--) {
+        if (iterator(val[i], i) === false) {
+          return;
+        }
+      }
+    } else {
+      for (let i = 0; i < val.length; i++) {
+        if (iterator(val[i], i) === false) {
+          return;
+        }
+      }
+    }
+  } else if ((0, import_checkers.isObj)(val)) {
+    let key;
+    for (key in val) {
+      if (Object.hasOwnProperty.call(val, key)) {
+        if (iterator(val[key], key) === false) {
+          return;
+        }
+      }
+    }
+  }
+}
+__name(each, "each");
+function map(val, iterator, revert) {
+  const res = (0, import_checkers.isArr)(val) || (0, import_checkers.isStr)(val) ? [] : {};
+  each(
+    val,
+    (item, key) => {
+      const value = iterator(item, key);
+      if ((0, import_checkers.isArr)(res)) {
+        res.push(value);
+      } else {
+        res[key] = value;
+      }
+    },
+    revert
+  );
+  return res;
+}
+__name(map, "map");
+function reduce(val, iterator, accumulator, revert) {
+  let result = accumulator;
+  each(
+    val,
+    (item, key) => {
+      result = iterator(result, item, key);
+    },
+    revert
+  );
+  return result;
+}
+__name(reduce, "reduce");
+function every(val, iterator, revert) {
+  let res = true;
+  each(
+    val,
+    (item, key) => {
+      if (!iterator(item, key)) {
+        res = false;
+        return false;
+      }
+    },
+    revert
+  );
+  return res;
+}
+__name(every, "every");
+function some(val, iterator, revert) {
+  let res = false;
+  each(
+    val,
+    (item, key) => {
+      if (iterator(item, key)) {
+        res = true;
+        return false;
+      }
+    },
+    revert
+  );
+  return res;
+}
+__name(some, "some");
+function findIndex(val, iterator, revert) {
+  let res = -1;
+  each(
+    val,
+    (item, key) => {
+      if (iterator(item, key)) {
+        res = key;
+        return false;
+      }
+    },
+    revert
+  );
+  return res;
+}
+__name(findIndex, "findIndex");
+function find(val, iterator, revert) {
+  let res;
+  each(
+    val,
+    (item, key) => {
+      if (iterator(item, key)) {
+        res = item;
+        return false;
+      }
+    },
+    revert
+  );
+  return res;
+}
+__name(find, "find");
+function includes(val, searchElement, revert) {
+  if ((0, import_checkers.isStr)(val)) return val.includes(searchElement);
+  return some(val, (item) => item === searchElement, revert);
+}
+__name(includes, "includes");
+function move(array, fromIndex, toIndex) {
+  if (fromIndex === toIndex) return array;
+  if (toIndex < 0 || fromIndex < 0 || toIndex > array.length - 1 || fromIndex > array.length - 1) {
+    return array;
+  }
+  if (fromIndex < toIndex) {
+    const fromItem = array[fromIndex];
+    for (let index = fromIndex; index < toIndex; index++) {
+      array[index] = array[index + 1];
+    }
+    array[toIndex] = fromItem;
+  } else {
+    const fromItem = array[fromIndex];
+    for (let index = fromIndex; index > toIndex; index--) {
+      array[index] = array[index - 1];
+    }
+    array[toIndex] = fromItem;
+  }
+  return array;
+}
+__name(move, "move");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  each,
+  every,
+  find,
+  findIndex,
+  includes,
+  map,
+  move,
+  reduce,
+  some,
+  toArr
+});

package/lib/shared/case.d.ts

@@ -0,0 +1,6 @@
+import { camelCase } from 'camel-case';
+import { lowerCase } from 'lower-case';
+import { paramCase } from 'param-case';
+import { pascalCase } from 'pascal-case';
+import { upperCase } from 'upper-case';
+export { lowerCase, upperCase, camelCase, pascalCase, paramCase };

package/lib/shared/case.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var case_exports = {};
+__export(case_exports, {
+  camelCase: () => import_camel_case.camelCase,
+  lowerCase: () => import_lower_case.lowerCase,
+  paramCase: () => import_param_case.paramCase,
+  pascalCase: () => import_pascal_case.pascalCase,
+  upperCase: () => import_upper_case.upperCase
+});
+module.exports = __toCommonJS(case_exports);
+var import_camel_case = require("camel-case");
+var import_lower_case = require("lower-case");
+var import_param_case = require("param-case");
+var import_pascal_case = require("pascal-case");
+var import_upper_case = require("upper-case");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  camelCase,
+  lowerCase,
+  paramCase,
+  pascalCase,
+  upperCase
+});

package/lib/shared/checkers.d.ts

@@ -0,0 +1,21 @@
+export declare const getType: (obj: any) => any;
+export declare const isFn: (val: any) => val is Function;
+export declare const isArr: (arg: any) => arg is any[];
+export declare const isPlainObj: (obj: unknown) => obj is object;
+export declare const isStr: (obj: unknown) => obj is string;
+export declare const isBool: (obj: unknown) => obj is boolean;
+export declare const isNum: (obj: unknown) => obj is number;
+export declare const isMap: (val: any) => val is Map<any, any>;
+export declare const isSet: (val: any) => val is Set<any>;
+export declare const isWeakMap: (val: any) => val is WeakMap<any, any>;
+export declare const isWeakSet: (val: any) => val is WeakSet<any>;
+export declare const isNumberLike: (index: any) => index is number;
+export declare const isObj: (val: unknown) => val is object;
+export declare const isRegExp: (obj: unknown) => obj is RegExp;
+export declare const isReactElement: (obj: any) => boolean;
+export declare const isHTMLElement: (target: any) => target is EventTarget;
+export type Subscriber<S> = (payload: S) => void;
+export interface Subscription<S> {
+    notify?: (payload: S) => void | boolean;
+    filter?: (payload: S) => any;
+}

package/lib/shared/checkers.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var checkers_exports = {};
+__export(checkers_exports, {
+  getType: () => getType,
+  isArr: () => isArr,
+  isBool: () => isBool,
+  isFn: () => isFn,
+  isHTMLElement: () => isHTMLElement,
+  isMap: () => isMap,
+  isNum: () => isNum,
+  isNumberLike: () => isNumberLike,
+  isObj: () => isObj,
+  isPlainObj: () => isPlainObj,
+  isReactElement: () => isReactElement,
+  isRegExp: () => isRegExp,
+  isSet: () => isSet,
+  isStr: () => isStr,
+  isWeakMap: () => isWeakMap,
+  isWeakSet: () => isWeakSet
+});
+module.exports = __toCommonJS(checkers_exports);
+const toString = Object.prototype.toString;
+const isType = /* @__PURE__ */ __name((type) => (obj) => getType(obj) === `[object ${type}]`, "isType");
+const getType = /* @__PURE__ */ __name((obj) => toString.call(obj), "getType");
+const isFn = /* @__PURE__ */ __name((val) => typeof val === "function", "isFn");
+const isArr = Array.isArray;
+const isPlainObj = isType("Object");
+const isStr = isType("String");
+const isBool = isType("Boolean");
+const isNum = isType("Number");
+const isMap = /* @__PURE__ */ __name((val) => val && val instanceof Map, "isMap");
+const isSet = /* @__PURE__ */ __name((val) => val && val instanceof Set, "isSet");
+const isWeakMap = /* @__PURE__ */ __name((val) => val && val instanceof WeakMap, "isWeakMap");
+const isWeakSet = /* @__PURE__ */ __name((val) => val && val instanceof WeakSet, "isWeakSet");
+const isNumberLike = /* @__PURE__ */ __name((index) => isNum(index) || /^\d+$/.test(index), "isNumberLike");
+const isObj = /* @__PURE__ */ __name((val) => typeof val === "object", "isObj");
+const isRegExp = isType("RegExp");
+const isReactElement = /* @__PURE__ */ __name((obj) => obj && obj["$$typeof"] && obj["_owner"], "isReactElement");
+const isHTMLElement = /* @__PURE__ */ __name((target) => {
+  return Object.prototype.toString.call(target).indexOf("HTML") > -1;
+}, "isHTMLElement");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getType,
+  isArr,
+  isBool,
+  isFn,
+  isHTMLElement,
+  isMap,
+  isNum,
+  isNumberLike,
+  isObj,
+  isPlainObj,
+  isReactElement,
+  isRegExp,
+  isSet,
+  isStr,
+  isWeakMap,
+  isWeakSet
+});

package/lib/shared/clone.d.ts

@@ -0,0 +1,2 @@
+export declare const shallowClone: (values: any) => any;
+export declare const clone: (values: any) => any;

package/lib/shared/clone.js

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clone_exports = {};
+__export(clone_exports, {
+  clone: () => clone,
+  shallowClone: () => shallowClone
+});
+module.exports = __toCommonJS(clone_exports);
+var import_checkers = require("./checkers");
+const shallowClone = /* @__PURE__ */ __name((values) => {
+  if (Array.isArray(values)) {
+    return values.slice(0);
+  } else if ((0, import_checkers.isPlainObj)(values)) {
+    if ("$$typeof" in values && "_owner" in values) {
+      return values;
+    }
+    if (values["_isBigNumber"]) {
+      return values;
+    }
+    if (values["_isAMomentObject"]) {
+      return values;
+    }
+    if (values["_isJSONSchemaObject"]) {
+      return values;
+    }
+    if ((0, import_checkers.isFn)(values["toJS"])) {
+      return values;
+    }
+    if ((0, import_checkers.isFn)(values["toJSON"])) {
+      return values;
+    }
+    return {
+      ...values
+    };
+  } else if (typeof values === "object") {
+    return new values.constructor(values);
+  }
+  return values;
+}, "shallowClone");
+const clone = /* @__PURE__ */ __name((values) => {
+  if (Array.isArray(values)) {
+    const res = [];
+    values.forEach((item) => {
+      res.push(clone(item));
+    });
+    return res;
+  } else if ((0, import_checkers.isPlainObj)(values)) {
+    if ("$$typeof" in values && "_owner" in values) {
+      return values;
+    }
+    if (values["_isBigNumber"]) {
+      return values;
+    }
+    if (values["_isAMomentObject"]) {
+      return values;
+    }
+    if (values["_isJSONSchemaObject"]) {
+      return values;
+    }
+    if ((0, import_checkers.isFn)(values["toJS"])) {
+      return values["toJS"]();
+    }
+    if ((0, import_checkers.isFn)(values["toJSON"])) {
+      return values["toJSON"]();
+    }
+    const res = {};
+    for (const key in values) {
+      if (Object.hasOwnProperty.call(values, key)) {
+        res[key] = clone(values[key]);
+      }
+    }
+    return res;
+  } else {
+    return values;
+  }
+}, "clone");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clone,
+  shallowClone
+});

package/lib/shared/compare.d.ts

@@ -0,0 +1 @@
+export declare const isEqual: (a: any, b: any) => any;

package/lib/shared/compare.js

@@ -0,0 +1,129 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compare_exports = {};
+__export(compare_exports, {
+  isEqual: () => isEqual
+});
+module.exports = __toCommonJS(compare_exports);
+var import_checkers = require("./checkers");
+var import_instanceof = require("./instanceof");
+const isArray = import_checkers.isArr;
+const keyList = Object.keys;
+const hasProp = Object.prototype.hasOwnProperty;
+function equal(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const arrA = isArray(a);
+    const arrB = isArray(b);
+    let i;
+    let length;
+    let key;
+    if (arrA && arrB) {
+      length = a.length;
+      if (length !== b.length) {
+        return false;
+      }
+      for (i = length; i-- !== 0; ) {
+        if (!equal(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (arrA !== arrB) {
+      return false;
+    }
+    const momentA = a && a._isAMomentObject;
+    const momentB = b && b._isAMomentObject;
+    if (momentA !== momentB) return false;
+    if (momentA && momentB) return a.isSame(b);
+    const immutableA = a && a.toJS;
+    const immutableB = b && b.toJS;
+    if (immutableA !== immutableB) return false;
+    if (immutableA) return a.is ? a.is(b) : a === b;
+    const dateA = (0, import_instanceof.instOf)(a, "Date");
+    const dateB = (0, import_instanceof.instOf)(b, "Date");
+    if (dateA !== dateB) {
+      return false;
+    }
+    if (dateA && dateB) {
+      return a.getTime() === b.getTime();
+    }
+    const regexpA = (0, import_instanceof.instOf)(a, "RegExp");
+    const regexpB = (0, import_instanceof.instOf)(b, "RegExp");
+    if (regexpA !== regexpB) {
+      return false;
+    }
+    if (regexpA && regexpB) {
+      return a.toString() === b.toString();
+    }
+    const urlA = (0, import_instanceof.instOf)(a, "URL");
+    const urlB = (0, import_instanceof.instOf)(b, "URL");
+    if (urlA !== urlB) {
+      return false;
+    }
+    if (urlA && urlB) {
+      return a.href === b.href;
+    }
+    const schemaA = a && a.toJSON;
+    const schemaB = b && b.toJSON;
+    if (schemaA !== schemaB) return false;
+    if (schemaA && schemaB) return equal(a.toJSON(), b.toJSON());
+    const keys = keyList(a);
+    length = keys.length;
+    if (length !== keyList(b).length) {
+      return false;
+    }
+    for (i = length; i-- !== 0; ) {
+      if (!hasProp.call(b, keys[i])) {
+        return false;
+      }
+    }
+    for (i = length; i-- !== 0; ) {
+      key = keys[i];
+      if (key === "_owner" && a.$$typeof) {
+        continue;
+      } else {
+        if (!equal(a[key], b[key])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+__name(equal, "equal");
+const isEqual = /* @__PURE__ */ __name(function exportedEqual(a, b) {
+  try {
+    return equal(a, b);
+  } catch (error) {
+    if (error.message && error.message.match(/stack|recursion/i) || error.number === -2146828260) {
+      console.warn("Warning: react-fast-compare does not handle circular references.", error.name, error.message);
+      return false;
+    }
+    throw error;
+  }
+}, "exportedEqual");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isEqual
+});

package/lib/shared/defaults.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param defaults
+ * @param targets
+ */
+export declare const defaults: (defaults_: any, targets: any) => any;