ut2 1.8.1 → 1.9.1

package/types/difference.d.ts

@@ -2,7 +2,7 @@ import { IterateeParam } from './internals/types';
 /**
  * 创建一个 `array` 排除 `values` 值的新数组。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入一个参数 `value` 。
  *
  * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
  *
@@ -11,7 +11,7 @@ import { IterateeParam } from './internals/types';
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} values 排除的值。
- * @param {Function | string} [iteratee=identity] 迭代函数，调用每个元素。
+ * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，调用每个元素。
  * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 过滤值后的新数组。
  * @example

package/types/groupBy.d.ts

@@ -1,18 +1,20 @@
-import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
+import { ArrayLikeIterator, CollectionList, CollectionObject, PropertyName, ObjectIterator } from './internals/types';
 interface GroupBy {
-    <T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): Record<string, T[]>;
-    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): Record<string, V[]>;
+    <T extends object>(collection: CollectionList<T>, iteratee?: ArrayLikeIterator<T, PropertyName> | keyof T): Record<PropertyName, T[]>;
+    <T>(collection: CollectionList<T>, iteratee?: ArrayLikeIterator<T, PropertyName> | PropertyName): Record<PropertyName, T[]>;
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: ObjectIterator<T, PropertyName> | keyof T): Record<PropertyName, V[]>;
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: PropertyName): Record<PropertyName, V[]>;
 }
 /**
  * 创建一个组成聚合对象， `key` 是经过 `iteratee` 执行处理 `collection` 中每个元素后返回的结果。分组值的顺序是由他们出现在 `collection` 的顺序确定的。每个键对应的值负责生成 `key` 的元素组成的数组。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
  *
  * @static
  * @alias module:Collection.groupBy
  * @since 1.0.0
  * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
- * @param {Function | string} [iteratee=identity] 迭代函数，用来转换键。
+ * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，用来转换键。
  * @returns {Object} 组成聚合对象。
  * @example
  *

package/types/internals/compare.d.ts

@@ -1,5 +1,3 @@
-export declare function compareAsc(value: any, other: any): 0 | 1 | -1;
-export declare function compareDesc(value: any, other: any): 0 | 1 | -1;
 export type CompareOrderData<T> = {
     criteria: any[];
     index: number;

package/types/internals/createExtremum.d.ts

@@ -1,3 +1,3 @@
-import { IterateeParam } from './types';
-declare function createExtremum<T>(array: T[], comparator: (value: any, other: any) => boolean, iteratee?: IterateeParam<T>): T | undefined;
+import { IterateeParam, WithNullable } from './types';
+declare function createExtremum<T>(array: WithNullable<T[]>, comparator: (value: any, other: any) => boolean, iteratee?: IterateeParam<T>): T | undefined;
 export default createExtremum;

package/types/internals/types.d.ts

@@ -9,14 +9,14 @@ export type ObjectPredicate<T extends object, K extends keyof T = keyof T> = (va
 /**
  * 迭代参数
  */
-export type IterateeParam<T> = ((value: T, ...args: any[]) => any) | keyof T;
+export type IterateeParam<T> = ((value: T, ...args: any[]) => any) | PropertyName;
 /**
  * 迭代方法
  */
 export type StringIterator<R> = (char: string, index: number, string: string) => R;
 export type ArrayIterator<T, R> = (item: T, index: number, list: T[]) => R;
 export type ArrayLikeIterator<T, R> = (item: T, index: number, list: ArrayLike<T>) => R;
-export type ObjectIterator<T, R> = (value: T[keyof T], key: string, object: T) => R;
+export type ObjectIterator<T, R> = (value: T[keyof T], key: keyof T, object: T) => R;
 export type ReduceStringIterator<R> = (accumulator: R, currentValue: string, currentIndex: number, string: string) => R;
 export type ReduceArrayIterator<T, R> = (accumulator: R, currentValue: T, currentIndex: number, list: T[]) => R;
 export type ReduceArrayLikeIterator<T, R> = (accumulator: R, currentValue: T, currentIndex: number, list: ArrayLike<T>) => R;
@@ -29,3 +29,10 @@ export type CollectionList<T> = WithNullable<ArrayLike<T>>;
  * 集合对象
  */
 export type CollectionObject<T extends object> = WithNullable<T>;
+/**
+ * max、min方法
+ */
+export interface ExtremumFunction {
+    <T extends object>(array: WithNullable<T[]>, iteratee?: ArrayIterator<T, any> | keyof T): T | undefined;
+    <T>(array: WithNullable<T[]>, iteratee?: ArrayIterator<T, any> | PropertyName): T | undefined;
+}

package/types/intersection.d.ts

@@ -1,8 +1,8 @@
 import { IterateeParam } from './internals/types';
 /**
- * 创建唯一值的数组，该数组包含 2 个数组参数都包含的元素（交集）。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
+ * 创建唯一值的数组，该数组包含两个数组参数都包含的元素（交集）。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入一个参数 `value` 。
  *
  * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
  *
@@ -11,7 +11,7 @@ import { IterateeParam } from './internals/types';
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} other 另一个要检查的数组。
- * @param {Function | string} [iteratee=identity] 迭代函数，调用每个元素。
+ * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，调用每个元素。
  * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 包含所有传入数组交集元素的新数组。
  * @example

package/types/invert.d.ts

@@ -1,6 +1,6 @@
 import { ObjectPredicate, PropertyName, WithNullable } from './internals/types';
 /**
- * 创建一个对象，该对象由 `object` 自身可枚举属性（不包含 `Symbol` 属性）和值反转组成。
+ * 创建一个对象，该对象由 `object` 自身可枚举属性（包含 `Symbol` 属性）和值反转组成。
  *
  * @static
  * @alias module:Object.invert

package/types/keyBy.d.ts

@@ -1,18 +1,20 @@
-import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
+import { ArrayLikeIterator, CollectionList, CollectionObject, ObjectIterator, PropertyName } from './internals/types';
 interface KeyBy {
-    <T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): Record<string, T>;
-    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): Record<string, V>;
+    <T extends object>(collection: CollectionList<T>, iteratee?: ArrayLikeIterator<T, PropertyName> | keyof T): Record<PropertyName, T>;
+    <T>(collection: CollectionList<T>, iteratee?: ArrayLikeIterator<T, PropertyName> | PropertyName): Record<PropertyName, T>;
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: ObjectIterator<T, PropertyName> | keyof T): Record<PropertyName, V>;
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: PropertyName): Record<PropertyName, V>;
 }
 /**
  * 创建一个组成聚合对象， `key` 是经过 `iteratee` 执行处理 `collection` 中每个元素后返回的结果。每个 `key` 对应的值是生成 `key` 的最后一个元素。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
  *
  * @function
  * @alias module:Collection.keyBy
  * @since 1.0.0
  * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
- * @param {Function | string} [iteratee=identity] 迭代函数，用来转换键。
+ * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，用来转换键。
  * @returns {Object} 组成聚合对象。
  * @example
  *

package/types/max.d.ts

@@ -1,14 +1,14 @@
-import { IterateeParam } from './internals/types';
+import { ExtremumFunction } from './internals/types';
 /**
  * 调用 `array` 中的每一个元素，来生成其值排序的标准，返回最大的值。
  *
- * `iteratee` 调用时会传入 1 个参数 `value`。
+ * `iteratee` 调用时会传入三个参数 `value` `index` `array` 。
  *
- * @static
+ * @function
  * @alias module:Math.max
  * @since 1.0.0
  * @param {Array} array 要迭代的数组。
- * @param {Function | string} [iteratee] 调用每个元素的迭代函数。
+ * @param {Function | string | number | Symbol} [iteratee] 调用每个元素的迭代函数。
  * @returns {*} 最大的值。
  * @example
  *
@@ -24,5 +24,5 @@ import { IterateeParam } from './internals/types';
  * max(objects, 'n'); // {n: 2};
  *
  */
-declare function max<T>(array: T[], iteratee?: IterateeParam<T>): T | undefined;
+declare const max: ExtremumFunction;
 export default max;

package/types/merge.d.ts

@@ -1,11 +1,11 @@
 type GetKeysMethod = <T extends object>(object: T) => (symbol | string)[];
 type Customizer = (objValue: any, srcValue: any, key: string | symbol, object: any, source: any) => any;
 /**
- * 递归合并 `source` 来源对象自身和继承的可枚举属性（不包含 `Symbol` 属性）到 `object` 目标对象。
+ * 递归合并 `source` 来源对象自身的可枚举属性（包含 `Symbol` 属性）到 `object` 目标对象。
  *
  * 如果目标值存在，被解析为 `undefined` 的 `source` 来源对象属性将被跳过。数组和普通对象会递归合并，其他对象和值会被直接分配覆盖。
  *
- * 如果你需要合并 `Symbol` 属性，第四个参数传入 {@link https://caijf.github.io/ut2/module-Object.html#.allKeysIn | allKeysIn} 方法， `merge(object, source, undefined, allKeysIn)` 。
+ * 如果你需要合并继承的属性，第四个参数传入 {@link https://caijf.github.io/ut2/module-Object.html#.allKeysIn | allKeysIn} 方法， `merge(object, source, undefined, allKeysIn)` 。
  *
  * @static
  * @alias module:Object.merge
@@ -13,7 +13,7 @@ type Customizer = (objValue: any, srcValue: any, key: string | symbol, object: a
  * @param {Object | Array} object 目标对象。
  * @param {Object | Array} source 来源对象。
  * @param {Function} [customizer] 自定义赋值函数。
- * @param {Function} [getKeys=keysIn] 自定义获取对象键方法。
+ * @param {Function} [getKeys=allKeys] 自定义获取对象键方法。
  * @returns {Object} 目标对象。
  * @example
  *

package/types/min.d.ts

@@ -1,14 +1,14 @@
-import { IterateeParam } from './internals/types';
+import { ExtremumFunction } from './internals/types';
 /**
  * 调用 `array` 中的每一个元素，来生成其值排序的标准，返回最小的值。
  *
- * `iteratee` 调用时会传入 1 个参数 `value`。
+ * `iteratee` 调用时会传入三个参数 `value` `index` `array` 。
  *
  * @static
  * @alias module:Math.min
  * @since 1.0.0
  * @param {Array} array 要迭代的数组。
- * @param {Function | string} [iteratee] 调用每个元素的迭代函数。
+ * @param {Function | string | number | Symbol} [iteratee] 调用每个元素的迭代函数。
  * @returns {*} 最小的值。
  * @example
  *
@@ -23,5 +23,5 @@ import { IterateeParam } from './internals/types';
  * // 迭代函数可以直接写入属性。
  * min(objects, 'n'); // {n: 1};
  */
-declare function min<T>(array: T[], iteratee?: IterateeParam<T>): T | undefined;
+declare const min: ExtremumFunction;
 export default min;

package/types/omitBy.d.ts

@@ -2,7 +2,7 @@ import { ObjectPredicate, WithNullable } from './internals/types';
 /**
  * 创建一个对象，该对象忽略 `predicate` （断言函数）判断不是真值的属性后，`object` 自身和继承的可枚举属性组成。与 [`pickBy`](#.pickBy) 相反。
  *
- * `predicate` 调用时会传入 2 个参数 `value` `key` 。
+ * `predicate` 调用时会传入两个参数 `value` `key` 。
  *
  * @static
  * @alias module:Object.omitBy

package/types/orderBy.d.ts

@@ -1,22 +1,24 @@
 import { CompareOrder } from './internals/compare';
-import { CollectionList, CollectionObject, IterateeParam, Many } from './internals/types';
+import { ArrayLikeIterator, CollectionList, CollectionObject, Many, ObjectIterator, PropertyName } from './internals/types';
 interface OrderBy {
-    <T>(collection: CollectionList<T>, iteratee?: Many<IterateeParam<T>>, orders?: Many<CompareOrder>): T[];
-    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<IterateeParam<V>>, orders?: Many<CompareOrder>): V[];
+    <T extends object>(collection: CollectionList<T>, iteratee?: Many<ArrayLikeIterator<T, any> | keyof T>, orders?: Many<CompareOrder>): T[];
+    <T>(collection: CollectionList<T>, iteratee?: Many<ArrayLikeIterator<T, any> | PropertyName>, orders?: Many<CompareOrder>): T[];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<ObjectIterator<T, any> | keyof T>, orders?: Many<CompareOrder>): V[];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<PropertyName>, orders?: Many<CompareOrder>): V[];
 }
 /**
  * 创建一个元素数组，以迭代函数处理的结果排序。如果没有指定排序，默认为升序排序。
  *
  * `asc` 升序， `desc` 降序，默认执行稳定排序，也就是说相同元素会保持原始排序。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
  *
  * @function
  * @alias module:Collection.orderBy
  * @since 1.0.0
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/sort | sort}
  * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
- * @param {Function | string | Array} [iteratees] 排序的迭代函数。
+ * @param {Function | string | number | Symbol | Array} [iteratees] 排序的迭代函数。
  * @param {'asc' | 'desc' | Array} [orders] 迭代函数的排序顺序。
  * @returns {Array} 排序后的新数组。
  * @example

package/types/partition.d.ts

@@ -1,18 +1,20 @@
-import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
+import { ArrayLikeIterator, CollectionList, CollectionObject, ObjectIterator, PropertyName } from './internals/types';
 interface Partition {
-    <T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): [T[], T[]];
-    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): [V[], V[]];
+    <T extends object>(collection: CollectionList<T>, iteratee?: ArrayLikeIterator<T, any> | keyof T): [T[], T[]];
+    <T>(collection: CollectionList<T>, iteratee?: ArrayLikeIterator<T, any> | PropertyName): [T[], T[]];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: ObjectIterator<T, any> | keyof T): [V[], V[]];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: PropertyName): [V[], V[]];
 }
 /**
  * 创建一个分成两组的元素数组，第一组包含 `predicate`（断言函数）返回为 [`truthy`](https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy)（真值）的元素，第二组包含 `predicate`（断言函数）返回为 [`falsy`](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)（假值）的元素。
  *
- * `predicate` 调用时会传入 1 个参数 `value`。
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
  *
  * @static
  * @alias module:Collection.partition
  * @since 1.0.0
  * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
- * @param {Function | string} [predicate=identity] 每次迭代调用的断言函数。
+ * @param {Function | string | number | Symbol | Array} [predicate=identity] 每次迭代调用的断言函数。
  * @returns {Array} 分组后的数组。
  * @example
  *

package/types/pickBy.d.ts

@@ -2,7 +2,7 @@ import { ObjectPredicate, WithNullable } from './internals/types';
 /**
  * 创建一个对象，该对象的属性从 `object` 中经 `predicate` （断言函数）判断为真值的属性。
  *
- * `predicate` 调用时会传入 2 个参数 `value` `key` 。
+ * `predicate` 调用时会传入两个参数 `value` `key` 。
  *
  * @static
  * @alias module:Object.pickBy

package/types/reduce.d.ts

@@ -3,7 +3,7 @@
  *
  * 如果没有提供第三个参数值，则集合中的第一个元素将用作初始值。
  *
- * `iteratee` 调用时会传入四个参数 `accumulator`、`value`、`index|key`、`collection` 。
+ * `iteratee` 调用时会传入四个参数 `accumulator` `value` `index|key` `collection` 。
  *
  * @function
  * @alias module:Collection.reduce

package/types/reduceRight.d.ts

@@ -3,7 +3,7 @@
  *
  * 如果没有提供第三个参数值，则集合中的第一个元素将用作初始值。
  *
- * `iteratee` 调用时会传入四个参数 `accumulator`、`value`、`index|key`、`collection` 。
+ * `iteratee` 调用时会传入四个参数 `accumulator` `value` `index|key` `collection` 。
  *
  * @function
  * @alias module:Collection.reduceRight

package/types/times.d.ts

@@ -5,7 +5,7 @@ interface Times {
 /**
  * 调用 `iteratee` `n` 次，每次调用返回的结果存入到数组中。
  *
- * `iteratee` 调用传入 1 个参数 `index` 。
+ * `iteratee` 调用传入一个参数 `index` 。
  *
  * @function
  * @alias module:Util.times

package/types/union.d.ts

@@ -2,7 +2,7 @@ import { IterateeParam } from './internals/types';
 /**
  * 创建一个按顺序排列的唯一值的数组（并集）。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。与 [`uniq`](#.uniq) 相似。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入一个参数 `value` 。
  *
  * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
  *
@@ -11,7 +11,7 @@ import { IterateeParam } from './internals/types';
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} [other=[]] 另一个要检查的数组。
- * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
+ * @param {Function | string | number | Symbol} [iteratee] 迭代函数，调用每个元素。
  * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 新的联合数组。
  * @example

package/types/uniq.d.ts

@@ -2,7 +2,7 @@ import { IterateeParam } from './internals/types';
 /**
  * 创建一个去重后的数组副本。只有第一次出现的元素才会被保留。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入一个参数 `value` 。
  *
  * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
  *
@@ -10,7 +10,7 @@ import { IterateeParam } from './internals/types';
  * @alias module:Array.uniq
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
- * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
+ * @param {Function | string | number | Symbol} [iteratee] 迭代函数，调用每个元素。
  * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 去重后的新数组。
  * @example

package/types/xor.d.ts

@@ -1,8 +1,8 @@
 import { IterateeParam } from './internals/types';
 /**
- * 创建一个唯一值的数组（并集-交集），该数组包含 2 个数组参数中不相同的元素。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
+ * 创建一个唯一值的数组（并集-交集），该数组包含两个数组参数中不相同的元素。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
+ * `iteratee` 调用时会传入一个参数 `value` 。
  *
  * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
  *
@@ -11,7 +11,7 @@ import { IterateeParam } from './internals/types';
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} [other=[]] 另一个要检查的数组。
- * @param {Function | string} [iteratee={@link https://caijf.github.io/ut2/module-Util.html#.identity | identity}] 迭代函数，调用每个元素。
+ * @param {Function | string | number | Symbol} [iteratee={@link https://caijf.github.io/ut2/module-Util.html#.identity | identity}] 迭代函数，调用每个元素。
  * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 过滤值后的新数组。
  * @example

package/es/internals/isPrototype.js

@@ -1,12 +0,0 @@
-import { objectProto } from './native.js';
-
-function isPrototype(value) {
-    if (typeof value !== 'object') {
-        return false;
-    }
-    var Ctor = value.constructor;
-    var proto = typeof Ctor === 'function' ? Ctor.prototype : objectProto;
-    return value === proto;
-}
-
-export { isPrototype as default };

package/es/internals/specialKeys.js

@@ -1,17 +0,0 @@
-import isPrototype from './isPrototype.js';
-import { objectKeys, objectProtoHasOwnProperty } from './native.js';
-
-function keys(value) {
-    if (!isPrototype(value)) {
-        return objectKeys(value);
-    }
-    var result = [];
-    for (var key in Object(value)) {
-        if (objectProtoHasOwnProperty.call(value, key) && key !== 'constructor') {
-            result.push(key);
-        }
-    }
-    return result;
-}
-
-export { keys as default };

package/lib/internals/isPrototype.js

@@ -1,14 +0,0 @@
-'use strict';
-
-var native = require('./native.js');
-
-function isPrototype(value) {
-    if (typeof value !== 'object') {
-        return false;
-    }
-    var Ctor = value.constructor;
-    var proto = typeof Ctor === 'function' ? Ctor.prototype : native.objectProto;
-    return value === proto;
-}
-
-module.exports = isPrototype;

package/lib/internals/specialKeys.js

@@ -1,19 +0,0 @@
-'use strict';
-
-var isPrototype = require('./isPrototype.js');
-var native = require('./native.js');
-
-function keys(value) {
-    if (!isPrototype(value)) {
-        return native.objectKeys(value);
-    }
-    var result = [];
-    for (var key in Object(value)) {
-        if (native.objectProtoHasOwnProperty.call(value, key) && key !== 'constructor') {
-            result.push(key);
-        }
-    }
-    return result;
-}
-
-module.exports = keys;

package/types/internals/isPrototype.d.ts

@@ -1,9 +0,0 @@
-/**
- * 检测值是否为原型对象。
- *
- * @private
- * @param {*} value 要检查的值。
- * @returns {boolean} 是否为原型对象。
- */
-declare function isPrototype(value: any): boolean;
-export default isPrototype;

package/types/internals/specialKeys.d.ts

@@ -1,9 +0,0 @@
-/**
- * 获取对象的键，忽略 `constructor` 。
- *
- * @private
- * @param value 对象
- * @returns 可枚举的键
- */
-declare function keys(value: object): string[];
-export default keys;