@stencil/core 2.19.2 → 2.20.0

package/compiler/lib.dom.iterable.d.ts

@@ -121,7 +121,7 @@ interface Headers {
 
 interface IDBDatabase {
     /** Returns a new transaction with the given mode ("readonly" or "readwrite") and scope which can be a single object store name or an array of names. */
-    transaction(storeNames: string | Iterable<string>, mode?: IDBTransactionMode): IDBTransaction;
+    transaction(storeNames: string | Iterable<string>, mode?: IDBTransactionMode, options?: IDBTransactionOptions): IDBTransaction;
 }
 
 interface IDBObjectStore {
@@ -133,16 +133,6 @@ interface IDBObjectStore {
     createIndex(name: string, keyPath: string | Iterable<string>, options?: IDBIndexParameters): IDBIndex;
 }
 
-interface MIDIInputMap extends ReadonlyMap<string, MIDIInput> {
-}
-
-interface MIDIOutput {
-    send(data: Iterable<number>, timestamp?: DOMHighResTimeStamp): void;
-}
-
-interface MIDIOutputMap extends ReadonlyMap<string, MIDIOutput> {
-}
-
 interface MediaKeyStatusMap {
     [Symbol.iterator](): IterableIterator<[BufferSource, MediaKeyStatus]>;
     entries(): IterableIterator<[BufferSource, MediaKeyStatus]>;

package/compiler/lib.es2015.collection.d.ts

@@ -19,18 +19,38 @@ and limitations under the License.
 
 
 interface Map<K, V> {
+
     clear(): void;
+    /**
+     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+     */
     delete(key: K): boolean;
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     */
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    /**
+     * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
+     * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+     */
     get(key: K): V | undefined;
+    /**
+     * @returns boolean indicating whether an element with the specified key exists or not.
+     */
     has(key: K): boolean;
+    /**
+     * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
+     */
     set(key: K, value: V): this;
+    /**
+     * @returns the number of elements in the Map.
+     */
     readonly size: number;
 }
 
 interface MapConstructor {
     new(): Map<any, any>;
-    new<K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
     readonly prototype: Map<any, any>;
 }
 declare var Map: MapConstructor;
@@ -43,9 +63,23 @@ interface ReadonlyMap<K, V> {
 }
 
 interface WeakMap<K extends object, V> {
+    /**
+     * Removes the specified element from the WeakMap.
+     * @returns true if the element was successfully removed, or false if it was not present.
+     */
     delete(key: K): boolean;
+    /**
+     * @returns a specified element.
+     */
     get(key: K): V | undefined;
+    /**
+     * @returns a boolean indicating whether an element with the specified key exists or not.
+     */
     has(key: K): boolean;
+    /**
+     * Adds a new element with a specified key and value.
+     * @param key Must be an object.
+     */
     set(key: K, value: V): this;
 }
 
@@ -56,11 +90,28 @@ interface WeakMapConstructor {
 declare var WeakMap: WeakMapConstructor;
 
 interface Set<T> {
+    /**
+     * Appends a new element with a specified value to the end of the Set.
+     */
     add(value: T): this;
+
     clear(): void;
+    /**
+     * Removes a specified value from the Set.
+     * @returns Returns true if an element in the Set existed and has been removed, or false if the element does not exist.
+     */
     delete(value: T): boolean;
+    /**
+     * Executes a provided function once per each value in the Set object, in insertion order.
+     */
     forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    /**
+     * @returns a boolean indicating whether an element with the specified value exists in the Set or not.
+     */
     has(value: T): boolean;
+    /**
+     * @returns the number of (unique) elements in Set.
+     */
     readonly size: number;
 }
 
@@ -77,8 +128,18 @@ interface ReadonlySet<T> {
 }
 
 interface WeakSet<T extends object> {
+    /**
+     * Appends a new object to the end of the WeakSet.
+     */
     add(value: T): this;
+    /**
+     * Removes the specified element from the WeakSet.
+     * @returns Returns true if the element existed and has been removed, or false if the element does not exist.
+     */
     delete(value: T): boolean;
+    /**
+     * @returns a boolean indicating whether an object exists in the WeakSet or not.
+     */
     has(value: T): boolean;
 }
 

package/compiler/lib.es2015.proxy.d.ts

@@ -19,23 +19,112 @@ and limitations under the License.
 
 
 interface ProxyHandler<T extends object> {
+    /**
+     * A trap method for a function call.
+     * @param target The original callable object which is being proxied.
+     */
     apply?(target: T, thisArg: any, argArray: any[]): any;
+
+    /**
+     * A trap for the `new` operator.
+     * @param target The original object which is being proxied.
+     * @param newTarget The constructor that was originally called.
+     */
     construct?(target: T, argArray: any[], newTarget: Function): object;
-    defineProperty?(target: T, p: string | symbol, attributes: PropertyDescriptor): boolean;
+
+    /**
+     * A trap for `Object.defineProperty()`.
+     * @param target The original object which is being proxied.
+     * @returns A `Boolean` indicating whether or not the property has been defined.
+     */
+    defineProperty?(target: T, property: string | symbol, attributes: PropertyDescriptor): boolean;
+
+    /**
+     * A trap for the `delete` operator.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to delete.
+     * @returns A `Boolean` indicating whether or not the property was deleted.
+     */
     deleteProperty?(target: T, p: string | symbol): boolean;
+
+    /**
+     * A trap for getting a property value.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to get.
+     * @param receiver The proxy or an object that inherits from the proxy.
+     */
     get?(target: T, p: string | symbol, receiver: any): any;
+
+    /**
+     * A trap for `Object.getOwnPropertyDescriptor()`.
+     * @param target The original object which is being proxied.
+     * @param p The name of the property whose description should be retrieved.
+     */
     getOwnPropertyDescriptor?(target: T, p: string | symbol): PropertyDescriptor | undefined;
+
+    /**
+     * A trap for the `[[GetPrototypeOf]]` internal method.
+     * @param target The original object which is being proxied.
+     */
     getPrototypeOf?(target: T): object | null;
+
+    /**
+     * A trap for the `in` operator.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to check for existence.
+     */
     has?(target: T, p: string | symbol): boolean;
+
+    /**
+     * A trap for `Object.isExtensible()`.
+     * @param target The original object which is being proxied.
+     */
     isExtensible?(target: T): boolean;
+
+    /**
+     * A trap for `Reflect.ownKeys()`.
+     * @param target The original object which is being proxied.
+     */
     ownKeys?(target: T): ArrayLike<string | symbol>;
+
+    /**
+     * A trap for `Object.preventExtensions()`.
+     * @param target The original object which is being proxied.
+     */
     preventExtensions?(target: T): boolean;
-    set?(target: T, p: string | symbol, value: any, receiver: any): boolean;
+
+    /**
+     * A trap for setting a property value.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to set.
+     * @param receiver The object to which the assignment was originally directed.
+     * @returns `A `Boolean` indicating whether or not the property was set.
+     */
+    set?(target: T, p: string | symbol, newValue: any, receiver: any): boolean;
+
+    /**
+     * A trap for `Object.setPrototypeOf()`.
+     * @param target The original object which is being proxied.
+     * @param newPrototype The object's new prototype or `null`.
+     */
     setPrototypeOf?(target: T, v: object | null): boolean;
 }
 
 interface ProxyConstructor {
+    /**
+     * Creates a revocable Proxy object.
+     * @param target A target object to wrap with Proxy.
+     * @param handler An object whose properties define the behavior of Proxy when an operation is attempted on it.
+     */
     revocable<T extends object>(target: T, handler: ProxyHandler<T>): { proxy: T; revoke: () => void; };
+
+    /**
+     * Creates a Proxy object. The Proxy object allows you to create an object that can be used in place of the
+     * original object, but which may redefine fundamental Object operations like getting, setting, and defining
+     * properties. Proxy objects are commonly used to log property accesses, validate, format, or sanitize inputs.
+     * @param target A target object to wrap with Proxy.
+     * @param handler An object whose properties define the behavior of Proxy when an operation is attempted on it.
+     */
     new <T extends object>(target: T, handler: ProxyHandler<T>): T;
 }
 declare var Proxy: ProxyConstructor;

package/compiler/lib.es2017.intl.d.ts

@@ -19,7 +19,22 @@ and limitations under the License.
 
 
 declare namespace Intl {
-    type DateTimeFormatPartTypes = "day" | "dayPeriod" | "era" | "hour" | "literal" | "minute" | "month" | "second" | "timeZoneName" | "weekday" | "year";
+
+    interface DateTimeFormatPartTypesRegistry {
+        day: any
+        dayPeriod: any
+        era: any
+        hour: any
+        literal: any
+        minute: any
+        month: any
+        second: any
+        timeZoneName: any
+        weekday: any
+        year: any
+    }
+
+    type DateTimeFormatPartTypes = keyof DateTimeFormatPartTypesRegistry;
 
     interface DateTimeFormatPart {
         type: DateTimeFormatPartTypes;

package/compiler/lib.es2020.intl.d.ts

@@ -18,6 +18,7 @@ and limitations under the License.
 /// <reference no-default-lib="true"/>
 
 
+/// <reference lib="es2018.intl" />
 declare namespace Intl {
 
     /**
@@ -50,6 +51,25 @@ declare namespace Intl {
         | "second"
         | "seconds";
 
+    /**
+     * Value of the `unit` property in objects returned by
+     * `Intl.RelativeTimeFormat.prototype.formatToParts()`. `formatToParts` and
+     * `format` methods accept either singular or plural unit names as input,
+     * but `formatToParts` only outputs singular (e.g. "day") not plural (e.g.
+     * "days").
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts#Using_formatToParts).
+     */
+     type RelativeTimeFormatUnitSingular =
+        | "year"
+        | "quarter"
+        | "month"
+        | "week"
+        | "day"
+        | "hour"
+        | "minute"
+        | "second";
+
     /**
      * The locale matching algorithm to use.
      *
@@ -120,11 +140,16 @@ declare namespace Intl {
      *
      * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts#Using_formatToParts).
      */
-    interface RelativeTimeFormatPart {
-        type: string;
-        value: string;
-        unit?: RelativeTimeFormatUnit;
-    }
+    type RelativeTimeFormatPart =
+        | {
+              type: "literal";
+              value: string;
+          }
+        | {
+              type: Exclude<NumberFormatPartTypes, "literal">;
+              value: string;
+              unit: RelativeTimeFormatUnitSingular;
+          };
 
     interface RelativeTimeFormat {
         /**

package/compiler/lib.es2021.intl.d.ts

@@ -20,17 +20,25 @@ and limitations under the License.
 
 declare namespace Intl {
 
+    interface DateTimeFormatPartTypesRegistry {
+        fractionalSecond: any
+     }
+
     interface DateTimeFormatOptions {
         formatMatcher?: "basic" | "best fit" | "best fit" | undefined;
         dateStyle?: "full" | "long" | "medium" | "short" | undefined;
         timeStyle?: "full" | "long" | "medium" | "short" | undefined;
         dayPeriod?: "narrow" | "short" | "long" | undefined;
-        fractionalSecondDigits?: 0 | 1 | 2 | 3 | undefined;
+        fractionalSecondDigits?: 1 | 2 | 3 | undefined;
+    }
+
+    interface DateTimeRangeFormatPart extends DateTimeFormatPart {
+        source: "startRange" | "endRange" | "shared"
     }
 
     interface DateTimeFormat {
         formatRange(startDate: Date | number | bigint, endDate: Date | number | bigint): string;
-        formatRangeToParts(startDate: Date | number | bigint, endDate: Date | number | bigint): DateTimeFormatPart[];
+        formatRangeToParts(startDate: Date | number | bigint, endDate: Date | number | bigint): DateTimeRangeFormatPart[];
     }
 
     interface ResolvedDateTimeFormatOptions {
@@ -39,7 +47,7 @@ declare namespace Intl {
         timeStyle?: "full" | "long" | "medium" | "short";
         hourCycle?: "h11" | "h12" | "h23" | "h24";
         dayPeriod?: "narrow" | "short" | "long";
-        fractionalSecondDigits?: 0 | 1 | 2 | 3;
+        fractionalSecondDigits?: 1 | 2 | 3;
     }
 
     /**

package/compiler/lib.es2022.d.ts

@@ -23,4 +23,5 @@ and limitations under the License.
 /// <reference lib="es2022.error" />
 /// <reference lib="es2022.intl" />
 /// <reference lib="es2022.object" />
+/// <reference lib="es2022.sharedmemory" />
 /// <reference lib="es2022.string" />

package/compiler/lib.es2022.error.d.ts

@@ -19,11 +19,11 @@ and limitations under the License.
 
 
 interface ErrorOptions {
-    cause?: Error;
+    cause?: unknown;
 }
 
 interface Error {
-    cause?: Error;
+    cause?: unknown;
 }
 
 interface ErrorConstructor {

package/compiler/lib.es2022.sharedmemory.d.ts

@@ -0,0 +1,27 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+
+/// <reference no-default-lib="true"/>
+
+
+interface Atomics {
+    /**
+     * A non-blocking, asynchronous version of wait which is usable on the main thread.
+     * Waits asynchronously on a shared memory location and returns a Promise
+     */
+    waitAsync(typedArray: BigInt64Array | Int32Array, index: number, value: bigint, timeout?: number): { async: false, value: "ok" | "not-equal" | "timed-out" } | { async: true, value: Promise<"ok" | "not-equal" | "timed-out"> };
+}

package/compiler/lib.es5.d.ts

@@ -933,12 +933,24 @@ interface DateConstructor {
 declare var Date: DateConstructor;
 
 interface RegExpMatchArray extends Array<string> {
+    /**
+     * The index of the search at which the result was found.
+     */
     index?: number;
+    /**
+     * A copy of the search string.
+     */
     input?: string;
 }
 
 interface RegExpExecArray extends Array<string> {
+    /**
+     * The index of the search at which the result was found.
+     */
     index: number;
+    /**
+     * A copy of the search string.
+     */
     input: string;
 }
 
@@ -1584,7 +1596,7 @@ type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
 /**
  * Exclude null and undefined from T
  */
-type NonNullable<T> = T extends null | undefined ? never : T;
+type NonNullable<T> = T & {};
 
 /**
  * Obtain the parameters of a function type in a tuple

package/compiler/lib.esnext.intl.d.ts

@@ -19,8 +19,12 @@ and limitations under the License.
 
 
 declare namespace Intl {
+  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): NumberFormatPart[];
+    formatRangeToParts(start: number | bigint, end: number | bigint): NumberRangeFormatPart[];
   }
 }