typescript - npm Package Compare versions

Comparing version 5.1.6 to 5.2.2

lib/lib.decorators.d.ts

@@ -38,2 +38,7 @@ /*! *****************************************************************************
 
+type DecoratorMetadataObject = Record<PropertyKey, unknown> & object;
+
+type DecoratorMetadata =
+    typeof globalThis extends { Symbol: { readonly metadata: symbol } } ? DecoratorMetadataObject : DecoratorMetadataObject | undefined;
+
 /**
@@ -70,2 +75,4 @@ * Context provided to a class decorator.
     addInitializer(initializer: (this: Class) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -135,2 +142,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -181,2 +190,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -227,2 +238,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -282,2 +295,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -378,2 +393,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }

lib/lib.es2015.collection.d.ts

@@ -63,3 +63,3 @@ /*! *****************************************************************************
 
-interface WeakMap<K extends object, V> {
+interface WeakMap<K extends WeakKey, V> {
     /**
@@ -80,3 +80,3 @@ * Removes the specified element from the WeakMap.
      * Adds a new element with a specified key and value.
-     * @param key Must be an object.
+     * @param key Must be an object or symbol.
      */
@@ -87,4 +87,4 @@ set(key: K, value: V): this;
 interface WeakMapConstructor {
-    new <K extends object = object, V = any>(entries?: readonly (readonly [K, V])[] | null): WeakMap<K, V>;
-    readonly prototype: WeakMap<object, any>;
+    new <K extends WeakKey = WeakKey, V = any>(entries?: readonly (readonly [K, V])[] | null): WeakMap<K, V>;
+    readonly prototype: WeakMap<WeakKey, any>;
 }
@@ -131,5 +131,5 @@ declare var WeakMap: WeakMapConstructor;
 
-interface WeakSet<T extends object> {
+interface WeakSet<T extends WeakKey> {
     /**
-     * Appends a new object to the end of the WeakSet.
+     * Appends a new value to the end of the WeakSet.
      */
@@ -143,3 +143,3 @@ add(value: T): this;
     /**
-     * @returns a boolean indicating whether an object exists in the WeakSet or not.
+     * @returns a boolean indicating whether a value exists in the WeakSet or not.
      */
@@ -150,5 +150,5 @@ has(value: T): boolean;
 interface WeakSetConstructor {
-    new <T extends object = object>(values?: readonly T[] | null): WeakSet<T>;
-    readonly prototype: WeakSet<object>;
+    new <T extends WeakKey = WeakKey>(values?: readonly T[] | null): WeakSet<T>;
+    readonly prototype: WeakSet<WeakKey>;
 }
 declare var WeakSet: WeakSetConstructor;

lib/lib.es2015.core.d.ts

@@ -59,6 +59,6 @@ /*! *****************************************************************************
      * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end. If start is omitted, `0` is used.
+     * is treated as length+end.
      * @param end If not specified, length of the this object is used as its default value.
      */
-    copyWithin(target: number, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
 }
@@ -65,0 +65,0 @@

lib/lib.es2015.iterable.d.ts

@@ -162,6 +162,6 @@ /*! *****************************************************************************
 
-interface WeakMap<K extends object, V> { }
+interface WeakMap<K extends WeakKey, V> { }
 
 interface WeakMapConstructor {
-    new <K extends object, V>(iterable: Iterable<readonly [K, V]>): WeakMap<K, V>;
+    new <K extends WeakKey, V>(iterable: Iterable<readonly [K, V]>): WeakMap<K, V>;
 }
@@ -211,6 +211,6 @@
 
-interface WeakSet<T extends object> { }
+interface WeakSet<T extends WeakKey> { }
 
 interface WeakSetConstructor {
-    new <T extends object = object>(iterable: Iterable<T>): WeakSet<T>;
+    new <T extends WeakKey = WeakKey>(iterable: Iterable<T>): WeakSet<T>;
 }
@@ -217,0 +217,0 @@

lib/lib.es2015.symbol.wellknown.d.ts

@@ -140,3 +140,3 @@ /*! *****************************************************************************
 
-interface WeakMap<K extends object, V> {
+interface WeakMap<K extends WeakKey, V> {
     readonly [Symbol.toStringTag]: string;
@@ -149,3 +149,3 @@ }
 
-interface WeakSet<T extends object> {
+interface WeakSet<T extends WeakKey> {
     readonly [Symbol.toStringTag]: string;
@@ -152,0 +152,0 @@ }

lib/lib.es2017.d.ts

@@ -25,1 +25,2 @@ /*! *****************************************************************************
 /// <reference lib="es2017.typedarrays" />
+/// <reference lib="es2017.date" />

lib/lib.es2020.bigint.d.ts

@@ -168,6 +168,6 @@ /*! *****************************************************************************
      * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end. If start is omitted, `0` is used.
+     * is treated as length+end.
      * @param end If not specified, length of the this object is used as its default value.
      */
-    copyWithin(target: number, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
 
@@ -441,6 +441,6 @@ /** Yields index, value pairs for every entry in the array. */
      * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end. If start is omitted, `0` is used.
+     * is treated as length+end.
      * @param end If not specified, length of the this object is used as its default value.
      */
-    copyWithin(target: number, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
 
@@ -447,0 +447,0 @@ /** Yields index, value pairs for every entry in the array. */

lib/lib.es2021.weakref.d.ts

@@ -19,8 +19,9 @@ /*! *****************************************************************************
 
-interface WeakRef<T extends object> {
+interface WeakRef<T extends WeakKey> {
     readonly [Symbol.toStringTag]: "WeakRef";
 
     /**
-     * Returns the WeakRef instance's target object, or undefined if the target object has been
+     * Returns the WeakRef instance's target value, or undefined if the target value has been
      * reclaimed.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
      */
@@ -34,6 +35,7 @@ deref(): T | undefined;
     /**
-     * Creates a WeakRef instance for the given target object.
-     * @param target The target object for the WeakRef instance.
+     * Creates a WeakRef instance for the given target value.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
+     * @param target The target value for the WeakRef instance.
      */
-    new<T extends object>(target: T): WeakRef<T>;
+    new<T extends WeakKey>(target: T): WeakRef<T>;
 }
@@ -47,18 +49,19 @@
     /**
-     * Registers an object with the registry.
-     * @param target The target object to register.
-     * @param heldValue The value to pass to the finalizer for this object. This cannot be the
-     * target object.
+     * Registers a value with the registry.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
+     * @param target The target value to register.
+     * @param heldValue The value to pass to the finalizer for this value. This cannot be the
+     * target value.
      * @param unregisterToken The token to pass to the unregister method to unregister the target
-     * object. If provided (and not undefined), this must be an object. If not provided, the target
-     * cannot be unregistered.
+     * value. If not provided, the target cannot be unregistered.
      */
-    register(target: object, heldValue: T, unregisterToken?: object): void;
+    register(target: WeakKey, heldValue: T, unregisterToken?: WeakKey): void;
 
     /**
-     * Unregisters an object from the registry.
+     * Unregisters a value from the registry.
+     * In es2023 the value can be either a symbol or an object, in previous versions only object is permissible.
      * @param unregisterToken The token that was used as the unregisterToken argument when calling
-     * register to register the target object.
+     * register to register the target value.
      */
-    unregister(unregisterToken: object): void;
+    unregister(unregisterToken: WeakKey): void;
 }
@@ -71,3 +74,3 @@
      * Creates a finalization registry with an associated cleanup callback
-     * @param cleanupCallback The callback to call after an object in the registry has been reclaimed.
+     * @param cleanupCallback The callback to call after a value in the registry has been reclaimed.
      */
@@ -74,0 +77,0 @@ new<T>(cleanupCallback: (heldValue: T) => void): FinalizationRegistry<T>;

lib/lib.es2023.array.d.ts

@@ -42,2 +42,46 @@ /*! *****************************************************************************
     findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number;
+
+    /**
+     * Returns a copy of an array with its elements reversed.
+     */
+    toReversed(): T[];
+
+    /**
+     * Returns a copy of an array with its elements sorted.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]
+     * ```
+     */
+    toSorted(compareFn?: (a: T, b: T) => number): T[];
+
+    /**
+     * Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.
+     * @param start The zero-based location in the array from which to start removing elements.
+     * @param deleteCount The number of elements to remove.
+     * @param items Elements to insert into the copied array in place of the deleted elements.
+     * @returns The copied array.
+     */
+    toSpliced(start: number, deleteCount: number, ...items: T[]): T[];
+
+    /**
+     * Copies an array and removes elements while returning the remaining elements.
+     * @param start The zero-based location in the array from which to start removing elements.
+     * @param deleteCount The number of elements to remove.
+     * @returns A copy of the original array with the remaining elements.
+     */
+    toSpliced(start: number, deleteCount?: number): T[];
+
+    /**
+     * Copies an array, then overwrites the value at the provided index with the
+     * given value. If the index is negative, then it replaces from the end
+     * of the array.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to write into the copied array.
+     * @returns The copied array with the updated value.
+     */
+    with(index: number, value: T): T[];
 }
@@ -55,4 +99,10 @@
      */
-    findLast<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
+    findLast<S extends T>(
+        predicate: (value: T, index: number, array: readonly T[]) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (value: T, index: number, array: readonly T[]) => unknown,
+        thisArg?: any
+    ): T | undefined;
 
@@ -68,3 +118,50 @@ /**
      */
-    findLastIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (value: T, index: number, array: readonly T[]) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copied array with all of its elements reversed.
+     */
+    toReversed(): T[];
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]
+     * ```
+     */
+    toSorted(compareFn?: (a: T, b: T) => number): T[];
+
+    /**
+     * Copies an array and removes elements while, if necessary, inserting new elements in their place, returning the remaining elements.
+     * @param start The zero-based location in the array from which to start removing elements.
+     * @param deleteCount The number of elements to remove.
+     * @param items Elements to insert into the copied array in place of the deleted elements.
+     * @returns A copy of the original array with the remaining elements.
+     */
+    toSpliced(start: number, deleteCount: number, ...items: T[]): T[];
+
+    /**
+     * Copies an array and removes elements while returning the remaining elements.
+     * @param start The zero-based location in the array from which to start removing elements.
+     * @param deleteCount The number of elements to remove.
+     * @returns A copy of the original array with the remaining elements.
+     */
+    toSpliced(start: number, deleteCount?: number): T[];
+
+    /**
+     * Copies an array, then overwrites the value at the provided index with the
+     * given value. If the index is negative, then it replaces from the end
+     * of the array
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: T): T[];
 }
@@ -82,4 +179,14 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Int8Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (value: number, index: number, array: Int8Array) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -95,3 +202,32 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (value: number, index: number, array: Int8Array) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Uint8Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Uint8Array.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Uint8Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Uint8Array;
 }
@@ -109,4 +245,14 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint8Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (value: number, index: number, array: Uint8Array) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -122,3 +268,32 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (value: number, index: number, array: Uint8Array) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Uint8Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Uint8Array.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Uint8Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Uint8Array;
 }
@@ -136,4 +311,18 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint8ClampedArray
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint8ClampedArray
+        ) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -149,3 +338,36 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint8ClampedArray
+        ) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Uint8ClampedArray;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Uint8ClampedArray.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint8ClampedArray(4) [1, 2, 11, 22]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Uint8ClampedArray;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Uint8ClampedArray;
 }
@@ -163,4 +385,14 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Int16Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (value: number, index: number, array: Int16Array) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -176,3 +408,32 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (value: number, index: number, array: Int16Array) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Int16Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Int16Array.from([11, 2, -22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Int16Array(4) [-22, 1, 2, 11]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Int16Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Int16Array;
 }
@@ -190,4 +451,18 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint16Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint16Array
+        ) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -203,3 +478,36 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint16Array
+        ) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Uint16Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Uint16Array.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint16Array(4) [1, 2, 11, 22]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Uint16Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Uint16Array;
 }
@@ -217,4 +525,14 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Int32Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (value: number, index: number, array: Int32Array) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -230,3 +548,32 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (value: number, index: number, array: Int32Array) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Int32Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Int32Array.from([11, 2, -22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Int32Array(4) [-22, 1, 2, 11]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Int32Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Int32Array;
 }
@@ -244,4 +591,18 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint32Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint32Array
+        ) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -257,3 +618,36 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (
+            value: number,
+            index: number,
+            array: Uint32Array
+        ) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Uint32Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Uint32Array.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint32Array(4) [1, 2, 11, 22]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Uint32Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Uint32Array;
 }
@@ -271,4 +665,18 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Float32Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (
+            value: number,
+            index: number,
+            array: Float32Array
+        ) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -284,3 +692,36 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (
+            value: number,
+            index: number,
+            array: Float32Array
+        ) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Float32Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Float32Array.from([11.25, 2, -22.5, 1]);
+     * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.5]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Float32Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Float32Array;
 }
@@ -298,4 +739,18 @@
      */
-    findLast<S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined;
+    findLast<S extends number>(
+        predicate: (
+            value: number,
+            index: number,
+            array: Float64Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (
+            value: number,
+            index: number,
+            array: Float64Array
+        ) => unknown,
+        thisArg?: any
+    ): number | undefined;
 
@@ -311,3 +766,36 @@ /**
      */
-    findLastIndex(predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (
+            value: number,
+            index: number,
+            array: Float64Array
+        ) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): Float64Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = Float64Array.from([11.25, 2, -22.5, 1]);
+     * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.5]
+     * ```
+     */
+    toSorted(compareFn?: (a: number, b: number) => number): Float64Array;
+
+    /**
+     * Copies the array and inserts the given number at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: number): Float64Array;
 }
@@ -325,4 +813,18 @@
      */
-    findLast<S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined;
+    findLast<S extends bigint>(
+        predicate: (
+            value: bigint,
+            index: number,
+            array: BigInt64Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (
+            value: bigint,
+            index: number,
+            array: BigInt64Array
+        ) => unknown,
+        thisArg?: any
+    ): bigint | undefined;
 
@@ -338,3 +840,36 @@ /**
      */
-    findLastIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (
+            value: bigint,
+            index: number,
+            array: BigInt64Array
+        ) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): BigInt64Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = BigInt64Array.from([11n, 2n, -22n, 1n]);
+     * myNums.toSorted((a, b) => Number(a - b)) // BigInt64Array(4) [-22n, 1n, 2n, 11n]
+     * ```
+     */
+    toSorted(compareFn?: (a: bigint, b: bigint) => number): BigInt64Array;
+
+    /**
+     * Copies the array and inserts the given bigint at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: bigint): BigInt64Array;
 }
@@ -352,4 +887,18 @@
      */
-    findLast<S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined;
+    findLast<S extends bigint>(
+        predicate: (
+            value: bigint,
+            index: number,
+            array: BigUint64Array
+        ) => value is S,
+        thisArg?: any
+    ): S | undefined;
+    findLast(
+        predicate: (
+            value: bigint,
+            index: number,
+            array: BigUint64Array
+        ) => unknown,
+        thisArg?: any
+    ): bigint | undefined;
 
@@ -365,3 +914,36 @@ /**
      */
-    findLastIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): number;
+    findLastIndex(
+        predicate: (
+            value: bigint,
+            index: number,
+            array: BigUint64Array
+        ) => unknown,
+        thisArg?: any
+    ): number;
+
+    /**
+     * Copies the array and returns the copy with the elements in reverse order.
+     */
+    toReversed(): BigUint64Array;
+
+    /**
+     * Copies and sorts the array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+     * ```ts
+     * const myNums = BigUint64Array.from([11n, 2n, 22n, 1n]);
+     * myNums.toSorted((a, b) => Number(a - b)) // BigUint64Array(4) [1n, 2n, 11n, 22n]
+     * ```
+     */
+    toSorted(compareFn?: (a: bigint, b: bigint) => number): BigUint64Array;
+
+    /**
+     * Copies the array and inserts the given bigint at the provided index.
+     * @param index The index of the value to overwrite. If the index is
+     * negative, then it replaces from the end of the array.
+     * @param value The value to insert into the copied array.
+     * @returns A copy of the original array with the inserted value.
+     */
+    with(index: number, value: bigint): BigUint64Array;
 }

lib/lib.es2023.d.ts

@@ -21,1 +21,2 @@ /*! *****************************************************************************
 /// <reference lib="es2023.array" />
+/// <reference lib="es2023.collection" />

lib/lib.esnext.d.ts

@@ -21,1 +21,3 @@ /*! *****************************************************************************
 /// <reference lib="esnext.intl" />
+/// <reference lib="esnext.decorators" />
+/// <reference lib="esnext.disposable" />

package.json

@@ -5,3 +5,3 @@ {
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.1.6",
+    "version": "5.2.2",
     "license": "Apache-2.0",
@@ -44,3 +44,3 @@ "description": "TypeScript is a language for application scale JavaScript development",
         "@esfx/canceltoken": "^1.0.0",
-        "@octokit/rest": "latest",
+        "@octokit/rest": "^19.0.13",
         "@types/chai": "^4.3.4",
@@ -56,6 +56,7 @@ "@types/fs-extra": "^9.0.13",
         "@types/which": "^2.0.1",
-        "@typescript-eslint/eslint-plugin": "^5.33.1",
-        "@typescript-eslint/parser": "^5.33.1",
-        "@typescript-eslint/utils": "^5.33.1",
+        "@typescript-eslint/eslint-plugin": "^6.0.0",
+        "@typescript-eslint/parser": "^6.0.0",
+        "@typescript-eslint/utils": "^6.0.0",
         "azure-devops-node-api": "^12.0.0",
+        "c8": "^7.14.0",
         "chai": "^4.3.7",
@@ -66,6 +67,5 @@ "chalk": "^4.1.2",
         "diff": "^5.1.0",
-        "esbuild": "^0.17.2",
+        "esbuild": "^0.18.1",
         "eslint": "^8.22.0",
         "eslint-formatter-autolinkable-stylish": "^1.2.0",
-        "eslint-plugin-import": "^2.26.0",
         "eslint-plugin-local": "^1.0.0",
@@ -72,0 +72,0 @@ "eslint-plugin-no-null": "^1.0.2",

No alert changes

Improved metrics

Total package byte prevSize

40607327

increased by1.28%

Number of package files

110

increased by3.77%

Lines of code

128536

increased by1.11%

No dependency changes