typescript - npm Package Compare versions

Comparing version 5.1.6 to 5.3.2

lib/cancellationToken.js

@@ -63,3 +63,3 @@ /*! *****************************************************************************
     const namePrefix = cancellationPipeName.slice(0, -1);
-    if (namePrefix.length === 0 || namePrefix.indexOf("*") >= 0) {
+    if (namePrefix.length === 0 || namePrefix.includes("*")) {
       throw new Error("Invalid name for template cancellation pipe: it should have length greater than 2 characters and contain only one '*'.");
@@ -66,0 +66,0 @@ }

lib/lib.decorators.d.ts

@@ -27,4 +27,3 @@ /*! *****************************************************************************
     | ClassFieldDecoratorContext
-    | ClassAccessorDecoratorContext
-    ;
+    | ClassAccessorDecoratorContext;
 
@@ -36,5 +35,8 @@ /**
     | ClassDecoratorContext
-    | ClassMemberDecoratorContext
-    ;
+    | ClassMemberDecoratorContext;
 
+type DecoratorMetadataObject = Record<PropertyKey, unknown> & object;
+
+type DecoratorMetadata = typeof globalThis extends { Symbol: { readonly metadata: symbol; }; } ? DecoratorMetadataObject : DecoratorMetadataObject | undefined;
+
 /**
@@ -71,2 +73,4 @@ * Context provided to a class decorator.
     addInitializer(initializer: (this: Class) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -136,2 +140,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -182,2 +188,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -228,2 +236,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -283,2 +293,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }
@@ -379,2 +391,4 @@
     addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
 }

lib/lib.es2015.collection.d.ts

@@ -20,3 +20,2 @@ /*! *****************************************************************************
 interface Map<K, V> {
-
     clear(): void;
@@ -51,3 +50,3 @@ /**
 interface MapConstructor {
-    new(): Map<any, any>;
+    new (): Map<any, any>;
     new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
@@ -65,3 +64,3 @@ readonly prototype: Map<any, any>;
 
-interface WeakMap<K extends object, V> {
+interface WeakMap<K extends WeakKey, V> {
     /**
@@ -82,3 +81,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.
      */
@@ -89,4 +88,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>;
 }
@@ -133,5 +132,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.
      */
@@ -145,3 +144,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.
      */
@@ -152,5 +151,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;
 }
@@ -557,3 +557,3 @@
      */
-    raw(template: { raw: readonly string[] | ArrayLike<string>}, ...substitutions: any[]): string;
+    raw(template: { raw: readonly string[] | ArrayLike<string>; }, ...substitutions: any[]): string;
 }

lib/lib.es2015.iterable.d.ts

@@ -158,10 +158,10 @@ /*! *****************************************************************************
 interface MapConstructor {
-    new(): Map<any, any>;
+    new (): Map<any, any>;
     new <K, V>(iterable?: Iterable<readonly [K, V]> | null): Map<K, V>;
 }
 
-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,9 +211,9 @@
 
-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>;
 }
 
-interface Promise<T> { }
+interface Promise<T> {}
 
@@ -320,3 +320,2 @@ interface PromiseConstructor {
 
-
     /**
@@ -323,0 +322,0 @@ * Creates an array from an array-like or iterable object.

lib/lib.es2015.promise.d.ts

@@ -39,3 +39,3 @@ /*! *****************************************************************************
      */
-    all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;
+    all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
 
@@ -42,0 +42,0 @@ // see: lib.es2015.iterable.d.ts

lib/lib.es2015.symbol.d.ts

@@ -46,2 +46,2 @@ /*! *****************************************************************************
 
-declare var Symbol: SymbolConstructor;
+declare var Symbol: SymbolConstructor;

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.es2016.array.include.d.ts

@@ -116,2 +116,2 @@ /*! *****************************************************************************
     includes(searchElement: number, fromIndex?: number): boolean;
-}
+}

lib/lib.es2016.d.ts

@@ -20,2 +20,2 @@ /*! *****************************************************************************
 /// <reference lib="es2015" />
-/// <reference lib="es2016.array.include" />
+/// <reference lib="es2016.array.include" />

lib/lib.es2016.full.d.ts

@@ -23,2 +23,2 @@ /*! *****************************************************************************
 /// <reference lib="scripthost" />
-/// <reference lib="dom.iterable" />
+/// <reference lib="dom.iterable" />

lib/lib.es2017.d.ts

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

lib/lib.es2017.full.d.ts

@@ -23,2 +23,2 @@ /*! *****************************************************************************
 /// <reference lib="scripthost" />
-/// <reference lib="dom.iterable" />
+/// <reference lib="dom.iterable" />

lib/lib.es2017.intl.d.ts

@@ -20,15 +20,14 @@ /*! *****************************************************************************
 declare namespace Intl {
-
     interface DateTimeFormatPartTypesRegistry {
-        day: any
-        dayPeriod: any
-        era: any
-        hour: any
-        literal: any
-        minute: any
-        month: any
-        second: any
-        timeZoneName: any
-        weekday: any
-        year: any
+        day: any;
+        dayPeriod: any;
+        era: any;
+        hour: any;
+        literal: any;
+        minute: any;
+        month: any;
+        second: any;
+        timeZoneName: any;
+        weekday: any;
+        year: any;
     }
@@ -35,0 +34,0 @@

lib/lib.es2017.object.d.ts

@@ -24,3 +24,3 @@ /*! *****************************************************************************
      */
-    values<T>(o: { [s: string]: T } | ArrayLike<T>): T[];
+    values<T>(o: { [s: string]: T; } | ArrayLike<T>): T[];
 
@@ -37,3 +37,3 @@ /**
      */
-    entries<T>(o: { [s: string]: T } | ArrayLike<T>): [string, T][];
+    entries<T>(o: { [s: string]: T; } | ArrayLike<T>): [string, T][];
 
@@ -50,3 +50,3 @@ /**
      */
-    getOwnPropertyDescriptors<T>(o: T): {[P in keyof T]: TypedPropertyDescriptor<T[P]>} & { [x: string]: PropertyDescriptor };
+    getOwnPropertyDescriptors<T>(o: T): { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & { [x: string]: PropertyDescriptor; };
 }

lib/lib.es2018.asynciterable.d.ts

@@ -43,2 +43,2 @@ /*! *****************************************************************************
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
-}
+}

lib/lib.es2018.full.d.ts

@@ -23,2 +23,2 @@ /*! *****************************************************************************
 /// <reference lib="scripthost" />
-/// <reference lib="dom.iterable" />
+/// <reference lib="dom.iterable" />

lib/lib.es2018.intl.d.ts

@@ -20,3 +20,2 @@ /*! *****************************************************************************
 declare namespace Intl {
-
     // http://cldr.unicode.org/index/cldr-spec/plural-rules#TOC-Determining-Plural-Categories
@@ -56,3 +55,3 @@ type LDMLPluralRule = "zero" | "one" | "two" | "few" | "many" | "other";
 
-        supportedLocalesOf(locales: string | string[], options?: { localeMatcher?: "lookup" | "best fit" }): string[];
+        supportedLocalesOf(locales: string | string[], options?: { localeMatcher?: "lookup" | "best fit"; }): string[];
     };
@@ -59,0 +58,0 @@

lib/lib.es2018.promise.d.ts

@@ -29,3 +29,3 @@ /*! *****************************************************************************
      */
-    finally(onfinally?: (() => void) | undefined | null): Promise<T>
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
 }

lib/lib.es2018.regexp.d.ts

@@ -21,4 +21,4 @@ /*! *****************************************************************************
     groups?: {
-        [key: string]: string
-    }
+        [key: string]: string;
+    };
 }
@@ -28,4 +28,4 @@
     groups?: {
-        [key: string]: string
-    }
+        [key: string]: string;
+    };
 }
@@ -39,2 +39,2 @@
     readonly dotAll: boolean;
-}
+}

lib/lib.es2019.array.d.ts

@@ -20,10 +20,8 @@ /*! *****************************************************************************
 type FlatArray<Arr, Depth extends number> = {
-    "done": Arr,
-    "recur": Arr extends ReadonlyArray<infer InnerArr>
-        ? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
-        : Arr
+    done: Arr;
+    recur: Arr extends ReadonlyArray<infer InnerArr> ? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
+        : Arr;
 }[Depth extends -1 ? "done" : "recur"];
 
 interface ReadonlyArray<T> {
-
     /**
@@ -39,8 +37,7 @@ * Calls a defined callback function on each element of an array. Then, flattens the result into
      */
-    flatMap<U, This = undefined> (
+    flatMap<U, This = undefined>(
         callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray<U>,
-        thisArg?: This
-    ): U[]
+        thisArg?: This,
+    ): U[];
 
-
     /**
@@ -54,8 +51,7 @@ * Returns a new array with all sub-array elements concatenated into it recursively up to the
         this: A,
-        depth?: D
-    ): FlatArray<A, D>[]
-  }
+        depth?: D,
+    ): FlatArray<A, D>[];
+}
 
 interface Array<T> {
-
     /**
@@ -71,6 +67,6 @@ * Calls a defined callback function on each element of an array. Then, flattens the result into
      */
-    flatMap<U, This = undefined> (
+    flatMap<U, This = undefined>(
         callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray<U>,
-        thisArg?: This
-    ): U[]
+        thisArg?: This,
+    ): U[];
 
@@ -85,4 +81,4 @@ /**
         this: A,
-        depth?: D
-    ): FlatArray<A, D>[]
+        depth?: D,
+    ): FlatArray<A, D>[];
 }

lib/lib.es2019.intl.d.ts

@@ -21,4 +21,4 @@ /*! *****************************************************************************
     interface DateTimeFormatPartTypesRegistry {
-        unknown: any
+        unknown: any;
     }
 }

lib/lib.es2019.object.d.ts

@@ -26,3 +26,3 @@ /*! *****************************************************************************
      */
-    fromEntries<T = any>(entries: Iterable<readonly [PropertyKey, T]>): { [k: string]: T };
+    fromEntries<T = any>(entries: Iterable<readonly [PropertyKey, T]>): { [k: string]: T; };
 
@@ -29,0 +29,0 @@ /**

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;
 
@@ -393,5 +393,5 @@ /** Yields index, value pairs for every entry in the array. */
     readonly prototype: BigInt64Array;
-    new(length?: number): BigInt64Array;
-    new(array: Iterable<bigint>): BigInt64Array;
-    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigInt64Array;
+    new (length?: number): BigInt64Array;
+    new (array: Iterable<bigint>): BigInt64Array;
+    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigInt64Array;
 
@@ -442,6 +442,6 @@ /** The size in bytes of each element 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;
 
@@ -667,5 +667,5 @@ /** Yields index, value pairs for every entry in the array. */
     readonly prototype: BigUint64Array;
-    new(length?: number): BigUint64Array;
-    new(array: Iterable<bigint>): BigUint64Array;
-    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigUint64Array;
+    new (length?: number): BigUint64Array;
+    new (array: Iterable<bigint>): BigUint64Array;
+    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigUint64Array;
 
@@ -727,3 +727,3 @@ /** The size in bytes of each element in the array. */
 
-declare namespace Intl{
+declare namespace Intl {
     interface NumberFormat {
@@ -730,0 +730,0 @@ format(value: number | bigint): string;

lib/lib.es2020.date.d.ts

@@ -42,2 +42,2 @@ /*! *****************************************************************************
     toLocaleTimeString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-}
+}

lib/lib.es2020.intl.d.ts

@@ -21,3 +21,2 @@ /*! *****************************************************************************
 declare namespace Intl {
-
     /**
@@ -62,3 +61,3 @@ * [Unicode BCP 47 Locale Identifiers](https://unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers) definition.
      */
-     type RelativeTimeFormatUnitSingular =
+    type RelativeTimeFormatUnitSingular =
         | "year"
@@ -145,10 +144,10 @@ | "quarter"
         | {
-              type: "literal";
-              value: string;
-          }
+            type: "literal";
+            value: string;
+        }
         | {
-              type: Exclude<NumberFormatPartTypes, "literal">;
-              value: string;
-              unit: RelativeTimeFormatUnitSingular;
-          };
+            type: Exclude<NumberFormatPartTypes, "literal">;
+            value: string;
+            unit: RelativeTimeFormatUnitSingular;
+        };
 
@@ -224,3 +223,3 @@ interface RelativeTimeFormat {
          */
-        new(
+        new (
             locales?: UnicodeBCP47LocaleIdentifier | UnicodeBCP47LocaleIdentifier[],
@@ -417,3 +416,3 @@ options?: RelativeTimeFormatOptions,
          */
-        new(locales: LocalesArgument, options: DisplayNamesOptions): DisplayNames;
+        new (locales: LocalesArgument, options: DisplayNamesOptions): DisplayNames;
 
@@ -433,5 +432,4 @@ /**
          */
-        supportedLocalesOf(locales?: LocalesArgument, options?: { localeMatcher?: RelativeTimeFormatLocaleMatcher }): BCP47LanguageTag[];
+        supportedLocalesOf(locales?: LocalesArgument, options?: { localeMatcher?: RelativeTimeFormatLocaleMatcher; }): BCP47LanguageTag[];
     };
-
 }

lib/lib.es2020.promise.d.ts

@@ -38,3 +38,3 @@ /*! *****************************************************************************
      */
-    allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>> }>;
+    allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
 
@@ -41,0 +41,0 @@ /**

lib/lib.es2021.intl.d.ts

@@ -20,6 +20,5 @@ /*! *****************************************************************************
 declare namespace Intl {
-
     interface DateTimeFormatPartTypesRegistry {
-        fractionalSecond: any
-     }
+        fractionalSecond: any;
+    }
 
@@ -35,3 +34,3 @@ interface DateTimeFormatOptions {
     interface DateTimeRangeFormatPart extends DateTimeFormatPart {
-        source: "startRange" | "endRange" | "shared"
+        source: "startRange" | "endRange" | "shared";
     }
@@ -119,3 +118,3 @@
          */
-        formatToParts(list: Iterable<string>): { type: "element" | "literal", value: string; }[];
+        formatToParts(list: Iterable<string>): { type: "element" | "literal"; value: string; }[];
 
@@ -150,3 +149,3 @@ /**
          */
-        new(locales?: BCP47LanguageTag | BCP47LanguageTag[], options?: ListFormatOptions): ListFormat;
+        new (locales?: BCP47LanguageTag | BCP47LanguageTag[], options?: ListFormatOptions): ListFormat;
 
@@ -153,0 +152,0 @@ /**

lib/lib.es2021.promise.d.ts

@@ -20,7 +20,7 @@ /*! *****************************************************************************
 interface AggregateError extends Error {
-    errors: any[]
+    errors: any[];
 }
 
 interface AggregateErrorConstructor {
-    new(errors: Iterable<any>, message?: string): AggregateError;
+    new (errors: Iterable<any>, message?: string): AggregateError;
     (errors: Iterable<any>, message?: string): AggregateError;
@@ -48,3 +48,3 @@ readonly prototype: AggregateError;
      */
-    any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>
+    any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
 }

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,7 +74,7 @@
      * 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.
      */
-    new<T>(cleanupCallback: (heldValue: T) => void): FinalizationRegistry<T>;
+    new <T>(cleanupCallback: (heldValue: T) => void): FinalizationRegistry<T>;
 }
 
 declare var FinalizationRegistry: FinalizationRegistryConstructor;

lib/lib.es2022.error.d.ts

@@ -66,3 +66,3 @@ /*! *****************************************************************************
         message?: string,
-        options?: ErrorOptions
+        options?: ErrorOptions,
     ): AggregateError;
@@ -72,4 +72,4 @@ (
         message?: string,
-        options?: ErrorOptions
+        options?: ErrorOptions,
     ): AggregateError;
 }

lib/lib.es2022.intl.d.ts

@@ -20,3 +20,2 @@ /*! *****************************************************************************
 declare namespace Intl {
-
     /**
@@ -94,3 +93,3 @@ * An object with some or all properties of the `Intl.Segmenter` constructor `options` parameter.
          */
-        new(locales?: BCP47LanguageTag | BCP47LanguageTag[], options?: SegmenterOptions): Segmenter;
+        new (locales?: BCP47LanguageTag | BCP47LanguageTag[], options?: SegmenterOptions): Segmenter;
 
@@ -97,0 +96,0 @@ /**

lib/lib.es2022.sharedmemory.d.ts

@@ -28,3 +28,3 @@ /*! *****************************************************************************
      */
-    waitAsync(typedArray: Int32Array, index: number, value: number, timeout?: number): { async: false, value: "not-equal" | "timed-out" } | { async: true, value: Promise<"ok" | "timed-out"> };
+    waitAsync(typedArray: Int32Array, index: number, value: number, timeout?: number): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; };
 
@@ -39,3 +39,3 @@ /**
      */
-    waitAsync(typedArray: BigInt64Array, index: number, value: bigint, timeout?: number): { async: false, value: "not-equal" | "timed-out" } | { async: true, value: Promise<"ok" | "timed-out"> };
+    waitAsync(typedArray: BigInt64Array, index: number, value: bigint, timeout?: number): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; };
 }

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 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 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 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 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 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 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 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 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 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 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 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" />

lib/lib.esnext.full.d.ts

@@ -23,2 +23,2 @@ /*! *****************************************************************************
 /// <reference lib="scripthost" />
-/// <reference lib="dom.iterable" />
+/// <reference lib="dom.iterable" />

lib/lib.esnext.intl.d.ts

@@ -20,10 +20,10 @@ /*! *****************************************************************************
 declare namespace Intl {
-  interface NumberRangeFormatPart extends NumberFormatPart {
-    source: "startRange" | "endRange" | "shared"
-  }
+    interface NumberRangeFormatPart extends NumberFormatPart {
+        source: "startRange" | "endRange" | "shared";
+    }
 
-  interface NumberFormat {
-    formatRange(start: number | bigint, end: number | bigint): string;
-    formatRangeToParts(start: number | bigint, end: number | bigint): NumberRangeFormatPart[];
-  }
+    interface NumberFormat {
+        formatRange(start: number | bigint, end: number | bigint): string;
+        formatRangeToParts(start: number | bigint, end: number | bigint): NumberRangeFormatPart[];
+    }
 }

lib/lib.scripthost.d.ts

@@ -19,4 +19,2 @@ /*! *****************************************************************************
 
-
-
 /////////////////////////////
@@ -26,3 +24,2 @@ /// Windows Script Host APIS
 
-
 interface ActiveXObject {
@@ -267,3 +264,3 @@ new (s: string): any;
     new <T = any>(safearray: SafeArray<T>): Enumerator<T>;
-    new <T = any>(collection: { Item(index: any): T }): Enumerator<T>;
+    new <T = any>(collection: { Item(index: any): T; }): Enumerator<T>;
     new <T = any>(collection: any): Enumerator<T>;
@@ -270,0 +267,0 @@ }

lib/lib.webworker.importscripts.d.ts

@@ -19,3 +19,2 @@ /*! *****************************************************************************
 
-
 /////////////////////////////
@@ -22,0 +21,0 @@ /// WorkerGlobalScope APIs

lib/typesMap.json

@@ -364,3 +364,3 @@ {
         "path": "pathjs",
-        "pdfkit":"pdfkit",
+        "pdfkit": "pdfkit",
         "peer": "peerjs",
@@ -498,2 +498,2 @@ "peg": "pegjs",
     }
-}
+}

package.json

@@ -5,3 +5,3 @@ {
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.1.6",
+    "version": "5.3.2",
     "license": "Apache-2.0",
@@ -44,5 +44,4 @@ "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",
-        "@types/fs-extra": "^9.0.13",
         "@types/glob": "^8.1.0",
@@ -56,15 +55,15 @@ "@types/microsoft__typescript-etw": "^0.1.1",
         "@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",
         "chalk": "^4.1.2",
         "chokidar": "^3.5.3",
-        "del": "^6.1.1",
         "diff": "^5.1.0",
-        "esbuild": "^0.17.2",
+        "dprint": "^0.42.3",
+        "esbuild": "^0.19.0",
         "eslint": "^8.22.0",
         "eslint-formatter-autolinkable-stylish": "^1.2.0",
-        "eslint-plugin-import": "^2.26.0",
         "eslint-plugin-local": "^1.0.0",
@@ -74,3 +73,2 @@ "eslint-plugin-no-null": "^1.0.2",
         "fast-xml-parser": "^4.0.11",
-        "fs-extra": "^9.1.0",
         "glob": "^8.1.0",
@@ -84,2 +82,3 @@ "hereby": "^1.6.4",
         "node-fetch": "^3.2.10",
+        "playwright": "^1.38.0",
         "source-map-support": "^0.5.21",
@@ -104,2 +103,3 @@ "tslib": "^2.5.0",
         "lint": "hereby lint",
+        "format": "dprint fmt",
         "setup-hooks": "node scripts/link-hooks.mjs"
@@ -115,3 +115,4 @@ },
         "source-map-support": false,
-        "inspector": false
+        "inspector": false,
+        "perf_hooks": false
     },
@@ -118,0 +119,0 @@ "packageManager": "npm@8.19.4",

README.md

@@ -5,3 +5,2 @@
 [![GitHub Actions CI](https://github.com/microsoft/TypeScript/workflows/CI/badge.svg)](https://github.com/microsoft/TypeScript/actions?query=workflow%3ACI)
-[![Devops Build Status](https://dev.azure.com/typescript/TypeScript/_apis/build/status/Typescript/node10)](https://dev.azure.com/typescript/TypeScript/_build?definitionId=7)
 [![npm version](https://badge.fury.io/js/typescript.svg)](https://www.npmjs.com/package/typescript)
@@ -8,0 +7,0 @@ [![Downloads](https://img.shields.io/npm/dm/typescript.svg)](https://www.npmjs.com/package/typescript)

SECURITY.md

@@ -1,8 +0,8 @@
-<!-- BEGIN MICROSOFT SECURITY.MD V0.0.5 BLOCK -->
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.9 BLOCK -->
 
 ## Security
 
-Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet) and [Xamarin](https://github.com/xamarin).
 
-If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)), please report it to us as described below.
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/security.md/definition), please report it to us as described below.
 
@@ -13,5 +13,5 @@ ## Reporting Security Issues
 
-Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/security.md/msrc/create-report).
 
-If you prefer to submit without logging in, send email to [[e-mail]](mailto:[e-mail]).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
+If you prefer to submit without logging in, send email to [[e-mail]](mailto:[e-mail]).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/security.md/msrc/pgp).
 
@@ -32,3 +32,3 @@ You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc).
 
-If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) page for more details about our active programs.
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/security.md/msrc/bounty) page for more details about our active programs.
 
@@ -41,4 +41,4 @@ ## Preferred Languages
 
-Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd).
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/security.md/cvd).
 
 <!-- END MICROSOFT SECURITY.MD BLOCK -->

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Dev dependency count

41

decreased by-2.38%

Number of package files

110

increased by3.77%

Worsened metrics

Total package byte prevSize

32019541

decreased by-20.14%

Lines of code

120710

decreased by-5.04%

Number of lines in readme file

51

decreased by-1.92%

No dependency changes