@stencil/core 4.38.0 → 4.38.1

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

@@ -269,46 +269,46 @@ interface String {
 }
 
 interface ArrayBuffer {
-    readonly [Symbol.toStringTag]: string;
+    readonly [Symbol.toStringTag]: "ArrayBuffer";
 }
 
-interface DataView {
+interface DataView<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: string;
 }
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Int8Array";
 }
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint8Array";
 }
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint8ClampedArray";
 }
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Int16Array";
 }
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint16Array";
 }
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Int32Array";
 }
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint32Array";
 }
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Float32Array";
 }
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Float64Array";
 }
 

package/compiler/lib.es2016.array.include.d.ts

@@ -34,7 +34,7 @@ interface ReadonlyArray<T> {
     includes(searchElement: T, fromIndex?: number): boolean;
 }
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -43,7 +43,7 @@ interface Int8Array {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -52,7 +52,7 @@ interface Uint8Array {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -61,7 +61,7 @@ interface Uint8ClampedArray {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -70,7 +70,7 @@ interface Int16Array {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -79,7 +79,7 @@ interface Uint16Array {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -88,7 +88,7 @@ interface Int32Array {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -97,7 +97,7 @@ interface Uint32Array {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -106,7 +106,7 @@ interface Float32Array {
     includes(searchElement: number, fromIndex?: number): boolean;
 }
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.

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

@@ -22,7 +22,7 @@ declare namespace Intl {
      * the canonical locale names. Duplicates will be omitted and elements
      * will be validated as structurally valid language tags.
      *
-     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales)
+     * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales)
      *
      * @param locale A list of String values for which to get the canonical locale names
      * @returns An array containing the canonical and validated locale names.

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

@@ -0,0 +1,21 @@
+/*! *****************************************************************************
+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 ArrayBufferConstructor {
+    new (): ArrayBuffer;
+}

package/compiler/lib.es2017.d.ts

@@ -17,9 +17,10 @@ and limitations under the License.
 /// <reference no-default-lib="true"/>
 
 /// <reference lib="es2016" />
+/// <reference lib="es2017.arraybuffer" />
+/// <reference lib="es2017.date" />
+/// <reference lib="es2017.intl" />
 /// <reference lib="es2017.object" />
 /// <reference lib="es2017.sharedmemory" />
 /// <reference lib="es2017.string" />
-/// <reference lib="es2017.intl" />
 /// <reference lib="es2017.typedarrays" />
-/// <reference lib="es2017.date" />

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

@@ -18,25 +18,25 @@ and limitations under the License.
 
 interface ObjectConstructor {
     /**
-     * Returns an array of values of the enumerable properties of an object
+     * Returns an array of values of the enumerable own properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
     values<T>(o: { [s: string]: T; } | ArrayLike<T>): T[];
 
     /**
-     * Returns an array of values of the enumerable properties of an object
+     * Returns an array of values of the enumerable own properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
     values(o: {}): any[];
 
     /**
-     * Returns an array of key/values of the enumerable properties of an object
+     * Returns an array of key/values of the enumerable own properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
     entries<T>(o: { [s: string]: T; } | ArrayLike<T>): [string, T][];
 
     /**
-     * Returns an array of key/values of the enumerable properties of an object
+     * Returns an array of key/values of the enumerable own properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
     entries(o: {}): [string, any][];

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

@@ -28,14 +28,14 @@ interface SharedArrayBuffer {
     /**
      * Returns a section of an SharedArrayBuffer.
      */
-    slice(begin: number, end?: number): SharedArrayBuffer;
-    readonly [Symbol.species]: SharedArrayBuffer;
+    slice(begin?: number, end?: number): SharedArrayBuffer;
     readonly [Symbol.toStringTag]: "SharedArrayBuffer";
 }
 
 interface SharedArrayBufferConstructor {
     readonly prototype: SharedArrayBuffer;
-    new (byteLength: number): SharedArrayBuffer;
+    new (byteLength?: number): SharedArrayBuffer;
+    readonly [Symbol.species]: SharedArrayBufferConstructor;
 }
 declare var SharedArrayBuffer: SharedArrayBufferConstructor;
 
@@ -49,28 +49,28 @@ interface Atomics {
      * Until this atomic operation completes, any other read or write operation against the array
      * will block.
      */
-    add(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    add(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
     /**
      * Stores the bitwise AND of a value with the value at the given position in the array,
      * returning the original value. Until this atomic operation completes, any other read or
      * write operation against the array will block.
      */
-    and(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    and(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
     /**
      * Replaces the value at the given position in the array if the original value equals the given
      * expected value, returning the original value. Until this atomic operation completes, any
      * other read or write operation against the array will block.
      */
-    compareExchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, expectedValue: number, replacementValue: number): number;
+    compareExchange(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, expectedValue: number, replacementValue: number): number;
 
     /**
      * Replaces the value at the given position in the array, returning the original value. Until
      * this atomic operation completes, any other read or write operation against the array will
      * block.
      */
-    exchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    exchange(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
     /**
      * Returns a value indicating whether high-performance algorithms can use atomic operations
@@ -83,27 +83,27 @@ interface Atomics {
      * Returns the value at the given position in the array. Until this atomic operation completes,
      * any other read or write operation against the array will block.
      */
-    load(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number): number;
+    load(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number): number;
 
     /**
      * Stores the bitwise OR of a value with the value at the given position in the array,
      * returning the original value. Until this atomic operation completes, any other read or write
      * operation against the array will block.
      */
-    or(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    or(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
     /**
      * Stores a value at the given position in the array, returning the new value. Until this
      * atomic operation completes, any other read or write operation against the array will block.
      */
-    store(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    store(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
     /**
      * Subtracts a value from the value at the given position in the array, returning the original
      * value. Until this atomic operation completes, any other read or write operation against the
      * array will block.
      */
-    sub(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    sub(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
     /**
      * If the value at the given position in the array is equal to the provided value, the current
@@ -111,23 +111,23 @@ interface Atomics {
      * `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns
      * `"not-equal"`.
      */
-    wait(typedArray: Int32Array, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out";
+    wait(typedArray: Int32Array<ArrayBufferLike>, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out";
 
     /**
      * Wakes up sleeping agents that are waiting on the given index of the array, returning the
      * number of agents that were awoken.
-     * @param typedArray A shared Int32Array.
+     * @param typedArray A shared Int32Array<ArrayBufferLike>.
      * @param index The position in the typedArray to wake up on.
      * @param count The number of sleeping agents to notify. Defaults to +Infinity.
      */
-    notify(typedArray: Int32Array, index: number, count?: number): number;
+    notify(typedArray: Int32Array<ArrayBufferLike>, index: number, count?: number): number;
 
     /**
      * Stores the bitwise XOR of a value with the value at the given position in the array,
      * returning the original value. Until this atomic operation completes, any other read or write
      * operation against the array will block.
      */
-    xor(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    xor(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
     readonly [Symbol.toStringTag]: "Atomics";
 }

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

@@ -17,37 +17,37 @@ and limitations under the License.
 /// <reference no-default-lib="true"/>
 
 interface Int8ArrayConstructor {
-    new (): Int8Array;
+    new (): Int8Array<ArrayBuffer>;
 }
 
 interface Uint8ArrayConstructor {
-    new (): Uint8Array;
+    new (): Uint8Array<ArrayBuffer>;
 }
 
 interface Uint8ClampedArrayConstructor {
-    new (): Uint8ClampedArray;
+    new (): Uint8ClampedArray<ArrayBuffer>;
 }
 
 interface Int16ArrayConstructor {
-    new (): Int16Array;
+    new (): Int16Array<ArrayBuffer>;
 }
 
 interface Uint16ArrayConstructor {
-    new (): Uint16Array;
+    new (): Uint16Array<ArrayBuffer>;
 }
 
 interface Int32ArrayConstructor {
-    new (): Int32Array;
+    new (): Int32Array<ArrayBuffer>;
 }
 
 interface Uint32ArrayConstructor {
-    new (): Uint32Array;
+    new (): Uint32Array<ArrayBuffer>;
 }
 
 interface Float32ArrayConstructor {
-    new (): Float32Array;
+    new (): Float32Array<ArrayBuffer>;
 }
 
 interface Float64ArrayConstructor {
-    new (): Float64Array;
+    new (): Float64Array<ArrayBuffer>;
 }

package/compiler/lib.es2018.asyncgenerator.d.ts

@@ -18,9 +18,9 @@ and limitations under the License.
 
 /// <reference lib="es2018.asynciterable" />
 
-interface AsyncGenerator<T = unknown, TReturn = any, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+interface AsyncGenerator<T = unknown, TReturn = any, TNext = any> extends AsyncIteratorObject<T, TReturn, TNext> {
     // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
-    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
     return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
     throw(e: any): Promise<IteratorResult<T, TReturn>>;
     [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;

package/compiler/lib.es2018.asynciterable.d.ts

@@ -27,17 +27,27 @@ interface SymbolConstructor {
     readonly asyncIterator: unique symbol;
 }
 
-interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+interface AsyncIterator<T, TReturn = any, TNext = any> {
     // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
-    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
     return?(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
     throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
 }
 
-interface AsyncIterable<T> {
-    [Symbol.asyncIterator](): AsyncIterator<T>;
+interface AsyncIterable<T, TReturn = any, TNext = any> {
+    [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>;
 }
 
-interface AsyncIterableIterator<T> extends AsyncIterator<T> {
-    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+/**
+ * Describes a user-defined {@link AsyncIterator} that is also async iterable.
+ */
+interface AsyncIterableIterator<T, TReturn = any, TNext = any> extends AsyncIterator<T, TReturn, TNext> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
+}
+
+/**
+ * Describes an {@link AsyncIterator} produced by the runtime that inherits from the intrinsic `AsyncIterator.prototype`.
+ */
+interface AsyncIteratorObject<T, TReturn = unknown, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+    [Symbol.asyncIterator](): AsyncIteratorObject<T, TReturn, TNext>;
 }