Skip to content

Commit c4e5362

Browse files
uhyouhyo
committed
docs: build diff
1 parent 2e2ec06 commit c4e5362

File tree

2 files changed

+333
-0
lines changed

2 files changed

+333
-0
lines changed

‎docs/diff.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,3 +24,4 @@ The following files are improved in better-typescript-lib:
2424
- [es2021.promise.d.ts](./diff/es2021.promise.d.ts.md)
2525
- [es2022.object.d.ts](./diff/es2022.object.d.ts.md)
2626
- [esnext.disposable.d.ts](./diff/esnext.disposable.d.ts.md)
27+
- [esnext.float16.d.ts](./diff/esnext.float16.d.ts.md)

‎docs/diff/esnext.float16.d.ts.md‎

Lines changed: 332 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,332 @@
1+
# esnext.float16.d.ts Diffs
2+
3+
```diff
4+
Index: esnext.float16.d.ts
5+
===================================================================
6+
--- esnext.float16.d.ts
7+
+++ esnext.float16.d.ts
8+
@@ -41,20 +41,24 @@
9+
* is treated as length+end.
10+
* @param end If not specified, length of the this object is used as its default value.
11+
*/
12+
copyWithin(target: number, start: number, end?: number): this;
13+
-
14+
/**
15+
* Determines whether all the members of an array satisfy the specified test.
16+
* @param predicate A function that accepts up to three arguments. The every method calls
17+
* the predicate function for each element in the array until the predicate returns a value
18+
* which is coercible to the Boolean value false, or until the end of the array.
19+
* @param thisArg An object to which the this keyword can refer in the predicate function.
20+
* If thisArg is omitted, undefined is used as the this value.
21+
*/
22+
- every(
23+
- predicate: (value: number, index: number, array: this) => unknown,
24+
- thisArg?: any,
25+
+ every<This = undefined>(
26+
+ predicate: (
27+
+ this: This,
28+
+ value: number,
29+
+ index: number,
30+
+ array: this,
31+
+ ) => boolean,
32+
+ thisArg?: This,
33+
): boolean;
34+
35+
/**
36+
* Changes all array elements from `start` to `end` index to a static `value` and returns the modified array
37+
@@ -64,21 +68,24 @@
38+
* @param end index to stop filling the array at. If end is negative, it is treated as
39+
* length+end.
40+
*/
41+
fill(value: number, start?: number, end?: number): this;
42+
-
43+
/**
44+
* Returns the elements of an array that meet the condition specified in a callback function.
45+
* @param predicate A function that accepts up to three arguments. The filter method calls
46+
* the predicate function one time for each element in the array.
47+
* @param thisArg An object to which the this keyword can refer in the predicate function.
48+
* If thisArg is omitted, undefined is used as the this value.
49+
*/
50+
- filter(
51+
- predicate: (value: number, index: number, array: this) => any,
52+
- thisArg?: any,
53+
- ): Float16Array<ArrayBuffer>;
54+
-
55+
+ filter<This = undefined>(
56+
+ predicate: (
57+
+ this: This,
58+
+ value: number,
59+
+ index: number,
60+
+ array: this,
61+
+ ) => boolean,
62+
+ thisArg?: This,
63+
+ ): Float16Array;
64+
/**
65+
* Returns the value of the first element in the array where predicate is true, and undefined
66+
* otherwise.
67+
* @param predicate find calls predicate once for each element of the array, in ascending
68+
@@ -86,13 +93,12 @@
69+
* immediately returns that element value. Otherwise, find returns undefined.
70+
* @param thisArg If provided, it will be used as the this value for each invocation of
71+
* predicate. If it is not provided, undefined is used instead.
72+
*/
73+
- find(
74+
- predicate: (value: number, index: number, obj: this) => boolean,
75+
- thisArg?: any,
76+
+ find<This = undefined>(
77+
+ predicate: (this: This, value: number, index: number, obj: this) => boolean,
78+
+ thisArg?: This,
79+
): number | undefined;
80+
-
81+
/**
82+
* Returns the index of the first element in the array where predicate is true, and -1
83+
* otherwise.
84+
* @param predicate find calls predicate once for each element of the array, in ascending
85+
@@ -100,11 +106,11 @@
86+
* findIndex immediately returns that element index. Otherwise, findIndex returns -1.
87+
* @param thisArg If provided, it will be used as the this value for each invocation of
88+
* predicate. If it is not provided, undefined is used instead.
89+
*/
90+
- findIndex(
91+
- predicate: (value: number, index: number, obj: this) => boolean,
92+
- thisArg?: any,
93+
+ findIndex<This = undefined>(
94+
+ predicate: (this: This, value: number, index: number, obj: this) => boolean,
95+
+ thisArg?: This,
96+
): number;
97+
98+
/**
99+
* Returns the value of the last element in the array where predicate is true, and undefined
100+
@@ -136,19 +142,18 @@
101+
findLastIndex(
102+
predicate: (value: number, index: number, array: this) => unknown,
103+
thisArg?: any,
104+
): number;
105+
-
106+
/**
107+
* Performs the specified action for each element in an array.
108+
- * @param callbackfn A function that accepts up to three arguments. forEach calls the
109+
+ * @param callbackfn A function that accepts up to three arguments. forEach calls the
110+
* callbackfn function one time for each element in the array.
111+
- * @param thisArg An object to which the this keyword can refer in the callbackfn function.
112+
+ * @param thisArg An object to which the this keyword can refer in the callbackfn function.
113+
* If thisArg is omitted, undefined is used as the this value.
114+
*/
115+
- forEach(
116+
- callbackfn: (value: number, index: number, array: this) => void,
117+
- thisArg?: any,
118+
+ forEach<This = undefined>(
119+
+ callbackfn: (this: This, value: number, index: number, array: this) => void,
120+
+ thisArg?: This,
121+
): void;
122+
123+
/**
124+
* Determines whether an array includes a certain element, returning true or false as appropriate.
125+
@@ -183,50 +188,40 @@
126+
/**
127+
* The length of the array.
128+
*/
129+
readonly length: number;
130+
-
131+
/**
132+
* Calls a defined callback function on each element of an array, and returns an array that
133+
* contains the results.
134+
* @param callbackfn A function that accepts up to three arguments. The map method calls the
135+
* callbackfn function one time for each element in the array.
136+
* @param thisArg An object to which the this keyword can refer in the callbackfn function.
137+
* If thisArg is omitted, undefined is used as the this value.
138+
*/
139+
- map(
140+
- callbackfn: (value: number, index: number, array: this) => number,
141+
- thisArg?: any,
142+
- ): Float16Array<ArrayBuffer>;
143+
-
144+
+ map<This = undefined>(
145+
+ callbackfn: (
146+
+ this: This,
147+
+ value: number,
148+
+ index: number,
149+
+ array: this,
150+
+ ) => number,
151+
+ thisArg?: This,
152+
+ ): Float16Array;
153+
/**
154+
* Calls the specified callback function for all the elements in an array. The return value of
155+
* the callback function is the accumulated result, and is provided as an argument in the next
156+
* call to the callback function.
157+
* @param callbackfn A function that accepts up to four arguments. The reduce method calls the
158+
* callbackfn function one time for each element in the array.
159+
- * @param initialValue If initialValue is specified, it is used as the initial value to start
160+
- * the accumulation. The first call to the callbackfn function provides this value as an argument
161+
- * instead of an array value.
162+
*/
163+
- reduce(
164+
+ reduce<U = number>(
165+
callbackfn: (
166+
- previousValue: number,
167+
+ previousValue: number | U,
168+
currentValue: number,
169+
currentIndex: number,
170+
array: this,
171+
- ) => number,
172+
- ): number;
173+
- reduce(
174+
- callbackfn: (
175+
- previousValue: number,
176+
- currentValue: number,
177+
- currentIndex: number,
178+
- array: this,
179+
- ) => number,
180+
- initialValue: number,
181+
- ): number;
182+
-
183+
+ ) => U,
184+
+ ): number | U;
185+
/**
186+
* Calls the specified callback function for all the elements in an array. The return value of
187+
* the callback function is the accumulated result, and is provided as an argument in the next
188+
* call to the callback function.
189+
@@ -235,46 +230,32 @@
190+
* @param initialValue If initialValue is specified, it is used as the initial value to start
191+
* the accumulation. The first call to the callbackfn function provides this value as an argument
192+
* instead of an array value.
193+
*/
194+
- reduce<U>(
195+
+ reduce<U = number>(
196+
callbackfn: (
197+
previousValue: U,
198+
currentValue: number,
199+
currentIndex: number,
200+
array: this,
201+
) => U,
202+
initialValue: U,
203+
): U;
204+
-
205+
/**
206+
* Calls the specified callback function for all the elements in an array, in descending order.
207+
* The return value of the callback function is the accumulated result, and is provided as an
208+
* argument in the next call to the callback function.
209+
* @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
210+
* the callbackfn function one time for each element in the array.
211+
- * @param initialValue If initialValue is specified, it is used as the initial value to start
212+
- * the accumulation. The first call to the callbackfn function provides this value as an
213+
- * argument instead of an array value.
214+
*/
215+
- reduceRight(
216+
+ reduceRight<U = number>(
217+
callbackfn: (
218+
- previousValue: number,
219+
+ previousValue: number | U,
220+
currentValue: number,
221+
currentIndex: number,
222+
array: this,
223+
- ) => number,
224+
- ): number;
225+
- reduceRight(
226+
- callbackfn: (
227+
- previousValue: number,
228+
- currentValue: number,
229+
- currentIndex: number,
230+
- array: this,
231+
- ) => number,
232+
- initialValue: number,
233+
- ): number;
234+
-
235+
+ ) => U,
236+
+ ): number | U;
237+
/**
238+
* Calls the specified callback function for all the elements in an array, in descending order.
239+
* The return value of the callback function is the accumulated result, and is provided as an
240+
* argument in the next call to the callback function.
241+
@@ -283,9 +264,9 @@
242+
* @param initialValue If initialValue is specified, it is used as the initial value to start
243+
* the accumulation. The first call to the callbackfn function provides this value as an argument
244+
* instead of an array value.
245+
*/
246+
- reduceRight<U>(
247+
+ reduceRight<U = number>(
248+
callbackfn: (
249+
previousValue: U,
250+
currentValue: number,
251+
currentIndex: number,
252+
@@ -311,20 +292,24 @@
253+
* @param start The beginning of the specified portion of the array.
254+
* @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
255+
*/
256+
slice(start?: number, end?: number): Float16Array<ArrayBuffer>;
257+
-
258+
/**
259+
* Determines whether the specified callback function returns true for any element of an array.
260+
* @param predicate A function that accepts up to three arguments. The some method calls
261+
* the predicate function for each element in the array until the predicate returns a value
262+
* which is coercible to the Boolean value true, or until the end of the array.
263+
* @param thisArg An object to which the this keyword can refer in the predicate function.
264+
* If thisArg is omitted, undefined is used as the this value.
265+
*/
266+
- some(
267+
- predicate: (value: number, index: number, array: this) => unknown,
268+
- thisArg?: any,
269+
+ some<This = undefined>(
270+
+ predicate: (
271+
+ this: This,
272+
+ value: number,
273+
+ index: number,
274+
+ array: this,
275+
+ ) => boolean,
276+
+ thisArg?: This,
277+
): boolean;
278+
279+
/**
280+
* Sorts an array.
281+
@@ -430,44 +415,24 @@
282+
* Returns a new array from a set of elements.
283+
* @param items A set of elements to include in the new array object.
284+
*/
285+
of(...items: number[]): Float16Array<ArrayBuffer>;
286+
-
287+
/**
288+
* Creates an array from an array-like or iterable object.
289+
- * @param arrayLike An array-like object to convert to an array.
290+
+ * @param arrayLike An array-like or iterable object to convert to an array.
291+
*/
292+
from(arrayLike: ArrayLike<number>): Float16Array<ArrayBuffer>;
293+
-
294+
/**
295+
* Creates an array from an array-like or iterable object.
296+
- * @param arrayLike An array-like object to convert to an array.
297+
+ * @param arrayLike An array-like or iterable object to convert to an array.
298+
* @param mapfn A mapping function to call on every element of the array.
299+
* @param thisArg Value of 'this' used to invoke the mapfn.
300+
*/
301+
- from<T>(
302+
+ from<T, This = undefined>(
303+
arrayLike: ArrayLike<T>,
304+
- mapfn: (v: T, k: number) => number,
305+
- thisArg?: any,
306+
+ mapfn: (this: This, v: T, k: number) => number,
307+
+ thisArg?: This,
308+
): Float16Array<ArrayBuffer>;
309+
-
310+
- /**
311+
- * Creates an array from an array-like or iterable object.
312+
- * @param elements An iterable object to convert to an array.
313+
- */
314+
- from(elements: Iterable<number>): Float16Array<ArrayBuffer>;
315+
-
316+
- /**
317+
- * Creates an array from an array-like or iterable object.
318+
- * @param elements An iterable object to convert to an array.
319+
- * @param mapfn A mapping function to call on every element of the array.
320+
- * @param thisArg Value of 'this' used to invoke the mapfn.
321+
- */
322+
- from<T>(
323+
- elements: Iterable<T>,
324+
- mapfn?: (v: T, k: number) => number,
325+
- thisArg?: any,
326+
- ): Float16Array<ArrayBuffer>;
327+
}
328+
declare var Float16Array: Float16ArrayConstructor;
329+
330+
interface Math {
331+
332+
```

0 commit comments

Comments
 (0)