@produck/charon - npm Package Compare versions

Comparing version 0.2.2 to 0.3.0

index.d.ts

@@ -0,11 +1,19 @@
+/**
+ * library for optimization output file
+ * @packageDocumentation
+ */
+
 import * as Lang from './src/Lang';
 import * as Type from './src/Type';
 import * as Console from './src/Console';
-import Object from './src/Object';
-import Reflect from './src/Reflect';
-import { CharonMath } from './src/Math';
+import * as Array from './src/Array';
+import * as Object from './src/Object';
+import * as Reflect from './src/Reflect';
+import * as Math from './src/Math';
 
-export { Lang, Type, Console, Object, Reflect };
-export function NOOP(): void;
+export { Lang, Type, Console, Array, Object, Reflect, Math };
 
-export const Math: CharonMath;
+/**
+ * noop function
+ */
+export function NOOP(): void;

index.js

 import * as Lang from './src/Lang/index.js';
 import * as Type from './src/Type/index.js';
-import * as Console from './src/Console/index.js';
+import * as Console from './src/Console.js';
 import * as Math from './src/Math.js';
 import * as Object from './src/Object.js';
 import * as Reflect from './src/Reflect.js';
+import * as Array from './src/Array/index.js';
 
-export { Lang, Type, Console, Math, Object, Reflect };
+export { Lang, Type, Console, Math, Object, Reflect, Array };
 export const NOOP = () => {};

package.json

 {
 	"name": "@produck/charon",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"description": "Doing small thing for compressing bundle by tree shaking",
@@ -33,3 +33,9 @@ "files": [
 		"lint": "eslint --fix ./**/*.js",
-		"prepublish": "npm run lint"
+		"prepublish": "npm run lint",
+		"build:sample": "rollup -c scripts/rollup.sample.js && node scripts/updatemd.cjs",
+		"api:md": "api-documenter markdown -i docs/.vuepress/temp -o docs/charon",
+		"copy:md": "cp -r docs/charon/ docs/zh/",
+		"api:docs": "node ./scripts/extractor.cjs && npm run api:md && npm run copy:md && npm run build:sample",
+		"doc:dev": "vuepress dev ./docs",
+		"doc:build": "npm run api:docs && vuepress build ./docs"
 	},
@@ -40,5 +46,13 @@ "bugs": {
 	"devDependencies": {
-		"eslint": "^8.5.0"
+		"@microsoft/api-documenter": "^7.17.9",
+		"@microsoft/api-extractor": "^7.22.2",
+		"@rollup/plugin-alias": "^3.1.9",
+		"@rollup/plugin-node-resolve": "^13.2.1",
+		"@vuepress/plugin-back-to-top": "^1.9.7",
+		"eslint": "^8.5.0",
+		"rollup": "^2.70.2",
+		"rollup-plugin-terser": "^7.0.2",
+		"vuepress": "^1.9.7"
 	},
-	"gitHead": "0f6c48cec36ff72f401df9300978e6ed89c2c5d8"
+	"gitHead": "375d4b45f1da3ab41ed03d55db4ba9e2baf85ae8"
 }

src/Array/index.js

@@ -0,1 +1,7 @@
+const ARRAY = Array;
+
+export const of = ARRAY.of;
+export const from = ARRAY.from;
+export const isArray = ARRAY.isArray;
+
 export { empty } from './empty.js';

src/Lang/instanceOf.d.ts

@@ -0,1 +1,6 @@
+/**
+ * return object instanceof constructor
+ * @param {object} object object
+ * @param {function} constructor a contructor function
+ */
 export function instanceOf(object: object, constructor: Function): boolean;

src/Lang/Throw/throwError.d.ts

@@ -0,1 +1,6 @@
+/**
+ * throw Error
+ * @param {string} message - to print message
+ * @param {function} ErrorType - error type function
+ */
 export function throwError(message: string, ErrorType?: Function): unknown;

src/Lang/Throw/throwEvalError.d.ts

@@ -0,1 +1,5 @@
+/**
+ * throw EvalError
+ * @param {string} message - to print message
+ */
 export function throwEvalError(message: string): unknown;

src/Lang/Throw/throwRangeError.d.ts

@@ -0,1 +1,5 @@
+/**
+ * throw RangeError
+ * @param {string} message - to print message
+ */
 export function throwRangeError(message: string): unknown;

src/Lang/Throw/throwReferenceError.d.ts

@@ -0,1 +1,5 @@
+/**
+ * throw ReferenceError
+ * @param {string} message - to print the message
+ */
 export function throwReferenceError(message: string): unknown;

src/Lang/Throw/throwSyntaxError.d.ts

@@ -0,1 +1,5 @@
+/**
+ * throw SyntaxError
+ * @param {string} message - to print the message
+ */
 export function throwSyntaxError(message: string): unknown;

src/Lang/Throw/throwTypeError.d.ts

@@ -0,1 +1,5 @@
+/**
+ * throw TypeError
+ * @param {string} message - to print message
+ */
 export function throwTypeError(message: string): unknown;

src/Lang/Throw/throwURIError.d.ts

@@ -0,1 +1,5 @@
+/**
+ * throw URIError
+ * @param {string} message - to print the message
+ */
 export function throwURIError(message: string): unknown;

src/Lang/typeOf.d.ts

@@ -0,1 +1,5 @@
+/**
+ * return typeof operand
+ * @param {any} operand
+ */
 export function typeOf(operand: any): string;

src/Lang/typeOfEquel.d.ts

@@ -0,1 +1,6 @@
+/**
+ * return typeof operand equal type
+ * @param {any} operand any type
+ * @param {string} type type
+ */
 export function typeOfEquel(operand: any, type: string): boolean;

src/Math.d.ts

@@ -1,5 +0,201 @@
-export type CharonMath = Math & {
-	atan2xy: typeof atan2xy
-};
+/** The mathematical constant e. This is Euler's number, the base of natural logarithms. */
+export const E: number;
+/** The natural logarithm of 10. */
+export const LN10: number;
+/** The natural logarithm of 2. */
+export const LN2: number;
+/** The base-2 logarithm of e. */
+export const LOG2E: number;
+/** The base-10 logarithm of e. */
+export const LOG10E: number;
+/** Pi. This is the ratio of the circumference of a circle to its diameter. */
+export const PI: number;
+/** The square root of 0.5, or, equivalently, one divided by the square root of 2. */
+export const SQRT1_2: number;
+/** The square root of 2. */
+export const SQRT2: number;
+/**
+ * Returns the absolute value of a number (the value without regard to whether it is positive or negative).
+ * For example, the absolute value of -5 is the same as the absolute value of 5.
+ * @param {number} x A numeric expression for which the absolute value is needed.
+ */
+export function abs(x: number): number;
+/**
+ * Returns the arc cosine (or inverse cosine) of a number.
+ * @param {number} x A numeric expression.
+ */
+export function acos(x: number): number;
+/**
+ * Returns the inverse hyperbolic cosine of a number.
+ * @param {number} x A numeric expression that contains an angle measured in radians.
+ */
+export function acosh(x: number): number;
+/**
+ * Returns the arcsine of a number.
+ * @param {number} x A numeric expression.
+ */
+export function asin(x: number): number;
+/**
+ * Returns the inverse hyperbolic sine of a number.
+ * @param {number} x A numeric expression that contains an angle measured in radians.
+ */
+export function asinh(x: number): number;
+/**
+ * Returns the arctangent of a number.
+ * @param {number} x A numeric expression for which the arctangent is needed.
+ */
+export function atan(x: number): number;
+/**
+ * Returns the angle (in radians) from the X axis to a point.
+ * @param {number} y A numeric expression representing the cartesian y-coordinate.
+ * @param {number} x A numeric expression representing the cartesian x-coordinate.
+ */
+export function atan2(y: number, x: number): number;
+/**
+	* Returns the inverse hyperbolic tangent of a number.
+	* @param {number} x A numeric expression that contains an angle measured in radians.
+	*/
+export function atanh(x: number): number;
+/**
+	 * Returns an implementation-dependent approximation to the cube root of number.
+	 * @param {number} x A numeric expression.
+	 */
+export function cbrt(x: number): number;
+/**
+ * Returns the smallest integer greater than or equal to its numeric argument.
+ * @param {number} x A numeric expression.
+ */
+export function ceil(x: number): number;
+/**
+ * Returns the number of leading zero bits in the 32-bit binary representation of a number.
+ * @param {number} x A numeric expression.
+ */
+export function clz32(x: number): number;
 
-function atan2xy(x: number, y:number): number;
+/**
+ * Returns the cosine of a number.
+ * @param {number} x A numeric expression that contains an angle measured in radians.
+ */
+export function cos(x: number): number;
+/**
+ * Returns the hyperbolic cosine of a number.
+ * @param {number} x A numeric expression that contains an angle measured in radians.
+ */
+export function cosh(x: number): number;
+/**
+ * Returns e (the base of natural logarithms) raised to a power.
+ * @param {number} x A numeric expression representing the power of e.
+ */
+export function exp(x: number): number;
+/**
+	 * Returns the result of (e^x - 1), which is an implementation-dependent approximation to
+	 * subtracting 1 from the exponential function of x (e raised to the power of x, where e
+	 * is the base of the natural logarithms).
+	 * @param {number} x A numeric expression.
+	 */
+export function expm1(x: number): number;
+/**
+ * Returns the greatest integer less than or equal to its numeric argument.
+ * @param {number} x A numeric expression.
+ */
+export function floor(x: number): number;
+/**
+ * Returns the nearest single precision float representation of a number.
+ * @param {number} x A numeric expression.
+ */
+export function fround(x: number): number;
+/**
+ * Returns the square root of the sum of squares of its arguments.
+ * @param {number[]} values Values to compute the square root for.
+ *     If no arguments are passed, the result is +0.
+ *     If there is only one argument, the result is the absolute value.
+ *     If any argument is +Infinity or -Infinity, the result is +Infinity.
+ *     If any argument is NaN, the result is NaN.
+ *     If all arguments are either +0 or −0, the result is +0.
+ */
+export function hypot(...values: number[]): number;
+/**
+ * Returns the result of 32-bit multiplication of two numbers.
+ * @param {number} x First number
+ * @param {number} y Second number
+ */
+export function imul(x: number, y: number): number;
+
+/**
+ * Returns the natural logarithm (base e) of a number.
+ * @param {number} x A numeric expression.
+ */
+export function log(x: number): number;
+/**
+ * Returns the base 2 logarithm of a number.
+ * @param {number} x A numeric expression.
+ */
+export function log2(x: number): number;
+
+/**
+ * Returns the natural logarithm of 1 + x.
+ * @param {number} x A numeric expression.
+ */
+export function log1p(x: number): number;
+/**
+ * Returns the larger of a set of supplied numeric expressions.
+ * @param {number[]} values Numeric expressions to be evaluated.
+ */
+export function max(...values: number[]): number;
+/**
+ * Returns the smaller of a set of supplied numeric expressions.
+ * @param {number[]} values Numeric expressions to be evaluated.
+ */
+export function min(...values: number[]): number;
+/**
+ * Returns the value of a base expression taken to a specified power.
+ * @param {number} x The base value of the expression.
+ * @param {number} y The exponent value of the expression.
+ */
+export function pow(x: number, y: number): number;
+/** Returns a pseudorandom number between 0 and 1. */
+export function random(): number;
+/**
+ * Returns a supplied numeric expression rounded to the nearest integer.
+ * @param {number} x The value to be rounded to the nearest integer.
+ */
+export function round(x: number): number;
+/**
+ * Returns the sine of a number.
+ * @param {number} x A numeric expression that contains an angle measured in radians.
+ */
+export function sin(x: number): number;
+
+/**
+ * Returns the hyperbolic sine of a number.
+ * @param {number} x A numeric expression that contains an angle measured in radians.
+ */
+export function sinh(x: number): number;
+/**
+ * Returns the square root of a number.
+ * @param {number} x A numeric expression.
+ */
+export function sqrt(x: number): number;
+/**
+ * Returns the tangent of a number.
+ * @param {number} x A numeric expression that contains an angle measured in radians.
+ */
+export function tan(x: number): number;
+/**
+	* Returns the hyperbolic tangent of a number.
+	* @param {number} x A numeric expression that contains an angle measured in radians.
+	*/
+export function tanh(x: number): number;
+/**
+ * Returns the integral part of the a numeric expression, x, removing any fractional digits.
+ * If x is already an integer, the result is x.
+ * @param {number} x A numeric expression.
+ */
+export function trunc(x: number): number;
+
+/**
+ * Returns the angle (in radians) from the Y axis to a point
+ * @param {number} x A numeric expression representing the cartesian x-coordinate.
+ * @param {number} y A numeric expression representing the cartesian y-coordinate.
+ */
+export function atan2xy(x: number, y: number): number

src/Object.d.ts

@@ -1,24 +0,203 @@
-export default ObjectConstructor;
+/**
+ * Returns the prototype of an object.
+ * @param {any} o The object that references the prototype.
+ */
+export function getPrototypeOf(o: any): any;
 
-declare var ObjectConstructor: Pick<ObjectConstructor, "assign"
-	| "create"
-	| "defineProperties"
-	| "defineProperty"
-	| "entries"
-	| "freeze"
-	| "fromEntries"
-	| "getOwnPropertyDescriptor"
-	| "setPrototypeOf"
-	| "getOwnPropertyDescriptors"
-	| "getOwnPropertyNames"
-	| "values"
-	| "getOwnPropertySymbols"
-	| "getPrototypeOf"
-	| "is"
-	| "isExtensible"
-	| "isFrozen"
-	| "isSealed"
-	| "keys"
-	| "preventExtensions"
-	| "seal"
->;
+/**
+ * Gets the own property descriptor of the specified object.
+ * An own property descriptor is one that is defined directly on the object and is not inherited from the object's prototype.
+ * @param {any} o Object that contains the property.
+ * @param {PropertyKey} p Name of the property.
+ */
+export function getOwnPropertyDescriptor(o: any, p: PropertyKey): PropertyDescriptor | undefined;
+
+/**
+ * Returns the names of the own properties of an object. The own properties of an object are those that are defined directly
+ * on that object, and are not inherited from the object's prototype. The properties of an object include both fields (objects) and functions.
+ * @param {any} o Object that contains the own properties.
+ */
+export function getOwnPropertyNames(o: any): string[];
+
+/**
+ * Creates an object that has the specified prototype or that has null prototype.
+ * @param {object | null} o Object to use as a prototype. May be null.
+ */
+export function create(o: object | null): any;
+
+/**
+ * Creates an object that has the specified prototype, and that optionally contains specified properties.
+ * @param {object | null} o Object to use as a prototype. May be null
+ * @param {PropertyDescriptorMap} properties JavaScript object that contains one or more property descriptors.
+ */
+export function create(o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+
+/**
+ * Adds a property to an object, or modifies attributes of an existing property.
+ * @param {T} o Object on which to add or modify the property. This can be a native JavaScript object (that is, a user-defined object or a built in object) or a DOM object.
+ * @param {PropertyKey} p The property name.
+ * @param {PropertyDescriptor & ThisType<any>} attributes Descriptor for the property. It can be for a data property or an accessor property.
+ */
+export function defineProperty<T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>): T;
+
+/**
+ * Adds one or more properties to an object, and/or modifies attributes of existing properties.
+ * @param {T} o Object on which to add or modify the properties. This can be a native JavaScript object or a DOM object.
+ * @param {PropertyDescriptorMap & ThisType<any>} properties JavaScript object that contains one or more descriptor objects. Each descriptor object describes a data property or an accessor property.
+ */
+export function defineProperties<T>(o: T, properties: PropertyDescriptorMap & ThisType<any>): T;
+
+/**
+ * Prevents the modification of attributes of existing properties, and prevents the addition of new properties.
+ * @param {T} o Object on which to lock the attributes.
+ */
+export function seal<T>(o: T): T;
+
+/**
+ * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
+ * @param {T} a Object on which to lock the attributes.
+ */
+export function freeze<T>(a: T[]): readonly T[];
+
+/**
+ * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
+ * @param {T} f Object on which to lock the attributes.
+ */
+export function freeze<T extends Function>(f: T): T;
+
+/**
+ * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
+ * @param {T} o Object on which to lock the attributes.
+ */
+export function freeze<T>(o: T): Readonly<T>;
+
+/**
+ * Prevents the addition of new properties to an object.
+ * @param {T} o Object to make non-extensible.
+ */
+export function preventExtensions<T>(o: T): T;
+
+/**
+ * Returns true if existing property attributes cannot be modified in an object and new properties cannot be added to the object.
+ * @param {any} o Object to test.
+ */
+export function isSealed(o: any): boolean;
+
+/**
+ * Returns true if existing property attributes and values cannot be modified in an object, and new properties cannot be added to the object.
+ * @param {any} o Object to test.
+ */
+export function isFrozen(o: any): boolean;
+
+/**
+ * Returns a value that indicates whether new properties can be added to an object.
+ * @param {any} o Object to test.
+ */
+export function isExtensible(o: any): boolean;
+
+/**
+ * Returns the names of the enumerable string properties and methods of an object.
+ * @param {object} o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+ */
+export function keys(o: object): string[];
+/**
+	 * Copy the values of all of the enumerable own properties from one or more source objects to a
+	 * target object. Returns the target object.
+	 * @param {T} target The target object to copy to.
+	 * @param {U} source The source object from which to copy properties.
+	 */
+export function assign<T, U>(target: T, source: U): T & U;
+
+/**
+ * Copy the values of all of the enumerable own properties from one or more source objects to a
+ * target object. Returns the target object.
+ * @param {T} target The target object to copy to.
+ * @param {U} source1 The first source object from which to copy properties.
+ * @param {V} source2 The second source object from which to copy properties.
+ */
+export function assign<T, U, V>(target: T, source1: U, source2: V): T & U & V;
+
+/**
+ * Copy the values of all of the enumerable own properties from one or more source objects to a
+ * target object. Returns the target object.
+ * @param {T} target The target object to copy to.
+ * @param {U} source1 The first source object from which to copy properties.
+ * @param {v} source2 The second source object from which to copy properties.
+ * @param {W} source3 The third source object from which to copy properties.
+ */
+export function assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+
+/**
+ * Copy the values of all of the enumerable own properties from one or more source objects to a
+ * target object. Returns the target object.
+ * @param {object} target The target object to copy to.
+ * @param {any[]} sources One or more source objects from which to copy properties
+ */
+export function assign(target: object, ...sources: any[]): any;
+
+/**
+ * Returns an array of all symbol properties found directly on object o.
+ * @param {any} o Object to retrieve the symbols from.
+ */
+export function getOwnPropertySymbols(o: any): symbol[];
+
+/**
+ * Returns the names of the enumerable string properties and methods of an object.
+ * @param {object} o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+ */
+export function keys(o: {}): string[];
+
+/**
+ * Returns true if the values are the same value, false otherwise.
+ * @param {any} value1 The first value.
+ * @param {any} value2 The second value.
+ */
+export function is(value1: any, value2: any): boolean;
+
+/**
+ * Sets the prototype of a specified object o to object proto or null. Returns the object o.
+ * @param {any} o The object to change its prototype.
+ * @param {object | null} proto The value of the new prototype or null.
+ */
+export function setPrototypeOf(o: any, proto: object | null): any;
+/**
+     * Returns an array of values of the enumerable properties of an object
+     * @param { { [s: string]: T } | ArrayLike<T>} o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+     */
+export function values<T>(o: { [s: string]: T } | ArrayLike<T>): T[];
+
+ /**
+	* Returns an array of values of the enumerable properties of an object
+	* @param {object} o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+	*/
+export function values(o: {}): any[];
+
+ /**
+	* Returns an array of key/values of the enumerable properties of an object
+	* @param { { [s: string]: T } | ArrayLike<T>} o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+	*/
+export function entries<T>(o: { [s: string]: T } | ArrayLike<T>): [string, T][];
+
+ /**
+	* Returns an array of key/values of the enumerable properties of an object
+	* @param {object} o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+	*/
+export function entries(o: {}): [string, any][];
+
+/**
+	* Returns an object containing all own property descriptors of an object
+	* @param {T} o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+	*/
+export function getOwnPropertyDescriptors<T>(o: T): {[P in keyof T]: TypedPropertyDescriptor<T[P]>} & { [x: string]: PropertyDescriptor };
+/**
+ * Returns an object created by key-value entries for properties and methods
+ * @param {Iterable<readonly [PropertyKey, T]>} entries An iterable object that contains key-value entries for properties and methods.
+ */
+export function fromEntries<T = any>(entries: Iterable<readonly [PropertyKey, T]>): { [k: string]: T };
+
+/**
+	* Returns an object created by key-value entries for properties and methods
+	* @param {Iterable<readonly any[]>} entries An iterable object that contains key-value entries for properties and methods.
+	*/
+export function fromEntries(entries: Iterable<readonly any[]>): any;
+

src/Reflect.d.ts

@@ -1,1 +0,101 @@
-export default Reflect;
+/**
+ * Calls the function with the specified object as the this value
+ * and the elements of specified array as the arguments.
+ * @param {function} target The function to call.
+ * @param {any} thisArgument The object to be used as the this object.
+ * @param {ArrayLike<any>} argumentsList An array of argument values to be passed to the function.
+ */
+export function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
+
+/**
+ * Constructs the target with the elements of specified array as the arguments
+ * and the specified constructor as the `new.target` value.
+ * @param {function} target The constructor to invoke.
+ * @param {ArrayLike<any>} argumentsList An array of argument values to be passed to the constructor.
+ * @param {function} newTarget The constructor to be used as the `new.target` object.
+ */
+export function construct(target: Function, argumentsList: ArrayLike<any>, newTarget?: Function): any;
+
+/**
+ * Adds a property to an object, or modifies attributes of an existing property.
+ * @param {object} target Object on which to add or modify the property. This can be a native JavaScript object
+ *        (that is, a user-defined object or a built in object) or a DOM object.
+ * @param {PropertyKey} propertyKey The property name.
+ * @param {PropertyDescriptor} attributes Descriptor for the property. It can be for a data property or an accessor property.
+ */
+export function defineProperty(target: object, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
+
+/**
+ * Removes a property from an object, equivalent to `delete target[propertyKey]`,
+ * except it won't throw if `target[propertyKey]` is non-configurable.
+ * @param {object} target Object from which to remove the own property.
+ * @param {PropertyKey} propertyKey The property name.
+ */
+export function deleteProperty(target: object, propertyKey: PropertyKey): boolean;
+
+/**
+ * Gets the property of target, equivalent to `target[propertyKey]` when `receiver === target`.
+ * @param {object} target Object that contains the property on itself or in its prototype chain.
+ * @param {PropertyKey} propertyKey The property name.
+ * @param {any} receiver The reference to use as the `this` value in the getter function,
+ *        if `target[propertyKey]` is an accessor property.
+ */
+export function get(target: object, propertyKey: PropertyKey, receiver?: any): any;
+
+/**
+ * Gets the own property descriptor of the specified object.
+ * An own property descriptor is one that is defined directly on the object and is not inherited from the object's prototype.
+ * @param {object} target Object that contains the property.
+ * @param {PropertyKey} propertyKey The property name.
+ */
+export function getOwnPropertyDescriptor(target: object, propertyKey: PropertyKey): PropertyDescriptor | undefined;
+
+/**
+ * Returns the prototype of an object.
+ * @param {object} target The object that references the prototype.
+ */
+export function getPrototypeOf(target: object): object | null;
+
+/**
+ * Equivalent to `propertyKey in target`.
+ * @param {object} target Object that contains the property on itself or in its prototype chain.
+ * @param {PropertyKey} propertyKey Name of the property.
+ */
+export function has(target: object, propertyKey: PropertyKey): boolean;
+
+/**
+ * Returns a value that indicates whether new properties can be added to an object.
+ * @param {object} target Object to test.
+ */
+export function isExtensible(target: object): boolean;
+
+/**
+ * Returns the string and symbol keys of the own properties of an object. The own properties of an object
+ * are those that are defined directly on that object, and are not inherited from the object's prototype.
+ * @param {object} target Object that contains the own properties.
+ */
+export function ownKeys(target: object): (string | symbol)[];
+
+/**
+ * Prevents the addition of new properties to an object.
+ * @param {object} target Object to make non-extensible.
+ * @returns Whether the object has been made non-extensible.
+ */
+export function preventExtensions(target: object): boolean;
+
+/**
+ * Sets the property of target, equivalent to `target[propertyKey] = value` when `receiver === target`.
+ * @param {object} target Object that contains the property on itself or in its prototype chain.
+ * @param {PropertyKey} propertyKey Name of the property.
+ * @param {any} receiver The reference to use as the `this` value in the setter function,
+ *        if `target[propertyKey]` is an accessor property.
+ */
+export function set(target: object, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
+
+/**
+ * Sets the prototype of a specified object o to object proto or null.
+ * @param {object} target The object to change its prototype.
+ * @param {object | null} proto The value of the new prototype or null.
+ * @returns Whether setting the prototype was successful.
+ */
+export function setPrototypeOf(target: object, proto: object | null): boolean;

src/Type/Is/isArray.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is array
+ * @param {any} any - any type
+ */
 export function isArray(any: any): boolean;

src/Type/Is/isArray.js

@@ -1,8 +0,1 @@
-/**
- * determines whether a operand is array or not
- * @function
- * @param {any} any
- * @returns {boolean}
- */
-
-export const isArray = Array.isArray;
+export { isArray } from '../../Array/index.js';

src/Type/Is/isArrayBuffer.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is ArrayBuffer
+ * @param {any} operand - any type
+ */
 export function isArrayBuffer(operand: any): boolean;

src/Type/Is/isBigInt.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is BigInt
+ * @param {any} operand - any type
+ */
 export function isBigInt(operand: any): boolean;

src/Type/Is/isBoolean.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Boolean
+ * @param {any} operand - any type
+ */
 export function isBoolean(operand: any): boolean;

src/Type/Is/isDate.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Date
+ * @param {any} operand - any type
+ */
 export function isDate(operand: any): boolean;

src/Type/Is/isFunction.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Function
+ * @param {any} operand - any type
+ */
 export function isFunction(operand: any): boolean;

src/Type/Is/isNaN.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NaN
+ * @param {any} any - any type
+ */
 export function isNaN(any: any): boolean;

src/Type/Is/isNull.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Null
+ * @param {any} operand - any type
+ */
 export function isNull(operand: any): boolean;

src/Type/Is/isNumber.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Number
+ * @param {any} operand - any type
+ */
 export function isNumber(operand: any): boolean;

src/Type/Is/isObject.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Object
+ * @param {any} operand - any type
+ */
 export function isObject(operand: any): boolean;

src/Type/Is/isRegExp.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is RegExp
+ * @param {any} operand - any type
+ */
 export function isRegExp(operand: any): boolean;

src/Type/Is/isString.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is String
+ * @param {any} operand - any type
+ */
 export function isString(operand: any): boolean;

src/Type/Is/isSymbol.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Symbol
+ * @param {any} operand - any type
+ */
 export function isSymbol(operand: any): boolean;

src/Type/Is/isUndefined.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is Undefined
+ * @param {any} operand - any type
+ */
 export function isUndefined(operand: any): boolean;

src/Type/Not/isNotArray.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotArray
+ * @param {any} operand - any type
+ */
 export function isNotArray(operand: any): boolean;

src/Type/Not/isNotArrayBuffer.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotArrayBuffer
+ * @param {any} operand - any type
+ */
 export function isNotArrayBuffer(operand: any): boolean;

src/Type/Not/isNotBigInt.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotBigInt
+ * @param {any} operand - any type
+ */
 export function isNotBigInt(operand: any): boolean;

src/Type/Not/isNotBoolean.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotBoolean
+ * @param {any} operand - any type
+ */
 export function isNotBoolean(operand: any): boolean;

src/Type/Not/isNotDate.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotDate
+ * @param {any} operand - any type
+ */
 export function isNotDate(operand: any): boolean;

src/Type/Not/isNotFunction.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotFunction
+ * @param {any} operand - any type
+ */
 export function isNotFunction(operand: any): boolean;

src/Type/Not/isNotNaN.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotNaN
+ * @param {any} operand - any type
+ */
 export function isNotNaN(operand: any): boolean;

src/Type/Not/isNotNull.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotNull
+ * @param {any} operand - any type
+ */
 export function isNotNull(operand: any): boolean;

src/Type/Not/isNotNumber.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotNumber
+ * @param {any} operand - any type
+ */
 export function isNotNumber(operand: any): boolean;

src/Type/Not/isNotObject.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotObject
+ * @param {any} operand - any type
+ */
 export function isNotObject(operand: any): boolean;

src/Type/Not/isNotRegExp.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotRegExp
+ * @param {any} operand - any type
+ */
 export function isNotRegExp(operand: any): boolean;

src/Type/Not/isNotString.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotString
+ * @param {any} operand - any type
+ */
 export function isNotString(operand: any): boolean;

src/Type/Not/isNotSymbol.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotSymbol
+ * @param {any} operand - any type
+ */
 export function isNotSymbol(operand: any): boolean;

src/Type/Not/isNotUndefined.d.ts

@@ -0,1 +1,5 @@
+/**
+ * determine the operand is NotUndefined
+ * @param {any} operand - any type
+ */
 export function isNotUndefined(operand: any): boolean;

No alert changes

Improved metrics

Total package byte prevSize

52695

increased by104.09%

Lines of code

1189

increased by112.7%

Worsened metrics

Dev dependency count

9

increased by800%

Number of package files

103

decreased by-3.74%

No dependency changes