typescript 5.0.0-dev.20230102 → 5.0.0-dev.20230104
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/lib.es2022.d.ts +1 -0
- package/lib/lib.es2022.regexp.d.ts +41 -0
- package/lib/tsc.js +34 -6
- package/lib/tsserver.js +34 -6
- package/lib/tsserverlibrary.js +34 -6
- package/lib/typescript.js +34 -6
- package/lib/typingsInstaller.js +2 -1
- package/package.json +1 -1
package/lib/lib.es2022.d.ts
CHANGED
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
/*! *****************************************************************************
|
|
2
|
+
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
3
|
+
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
4
|
+
this file except in compliance with the License. You may obtain a copy of the
|
|
5
|
+
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
6
|
+
|
|
7
|
+
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
8
|
+
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
9
|
+
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
10
|
+
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
11
|
+
|
|
12
|
+
See the Apache Version 2.0 License for specific language governing permissions
|
|
13
|
+
and limitations under the License.
|
|
14
|
+
***************************************************************************** */
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
/// <reference no-default-lib="true"/>
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
interface RegExpMatchArray {
|
|
22
|
+
indices?: RegExpIndicesArray;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
interface RegExpExecArray {
|
|
26
|
+
indices?: RegExpIndicesArray;
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
interface RegExpIndicesArray extends Array<[number, number]> {
|
|
30
|
+
groups?: {
|
|
31
|
+
[key: string]: [number, number];
|
|
32
|
+
};
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
interface RegExp {
|
|
36
|
+
/**
|
|
37
|
+
* Returns a Boolean value indicating the state of the hasIndices flag (d) used with with a regular expression.
|
|
38
|
+
* Default is false. Read-only.
|
|
39
|
+
*/
|
|
40
|
+
readonly hasIndices: boolean;
|
|
41
|
+
}
|
package/lib/tsc.js
CHANGED
|
@@ -23,7 +23,7 @@ var __export = (target, all) => {
|
|
|
23
23
|
|
|
24
24
|
// src/compiler/corePublic.ts
|
|
25
25
|
var versionMajorMinor = "5.0";
|
|
26
|
-
var version = `${versionMajorMinor}.0-dev.
|
|
26
|
+
var version = `${versionMajorMinor}.0-dev.20230104`;
|
|
27
27
|
|
|
28
28
|
// src/compiler/core.ts
|
|
29
29
|
var emptyArray = [];
|
|
@@ -30425,6 +30425,7 @@ var libEntries = [
|
|
|
30425
30425
|
["es2022.object", "lib.es2022.object.d.ts"],
|
|
30426
30426
|
["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
|
|
30427
30427
|
["es2022.string", "lib.es2022.string.d.ts"],
|
|
30428
|
+
["es2022.regexp", "lib.es2022.regexp.d.ts"],
|
|
30428
30429
|
["esnext.array", "lib.es2022.array.d.ts"],
|
|
30429
30430
|
["esnext.symbol", "lib.es2019.symbol.d.ts"],
|
|
30430
30431
|
["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
|
@@ -56605,6 +56606,7 @@ function createTypeChecker(host) {
|
|
|
56605
56606
|
}
|
|
56606
56607
|
}
|
|
56607
56608
|
function inferFromObjectTypes(source, target) {
|
|
56609
|
+
var _a2, _b;
|
|
56608
56610
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
|
|
56609
56611
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
56610
56612
|
return;
|
|
@@ -56651,11 +56653,37 @@ function createTypeChecker(host) {
|
|
|
56651
56653
|
}
|
|
56652
56654
|
} else {
|
|
56653
56655
|
const middleLength = targetArity - startLength - endLength;
|
|
56654
|
-
if (middleLength === 2
|
|
56655
|
-
|
|
56656
|
-
|
|
56657
|
-
|
|
56658
|
-
|
|
56656
|
+
if (middleLength === 2) {
|
|
56657
|
+
if (elementFlags[startLength] & elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
56658
|
+
const targetInfo = getInferenceInfoForType(elementTypes[startLength]);
|
|
56659
|
+
if (targetInfo && targetInfo.impliedArity !== void 0) {
|
|
56660
|
+
inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]);
|
|
56661
|
+
inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]);
|
|
56662
|
+
}
|
|
56663
|
+
} else if (elementFlags[startLength] & 8 /* Variadic */ && elementFlags[startLength + 1] & 4 /* Rest */) {
|
|
56664
|
+
const param = (_a2 = getInferenceInfoForType(elementTypes[startLength])) == null ? void 0 : _a2.typeParameter;
|
|
56665
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
56666
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
56667
|
+
const impliedArity = constraint.target.fixedLength;
|
|
56668
|
+
inferFromTypes(sliceTupleType(source, startLength, sourceArity - (startLength + impliedArity)), elementTypes[startLength]);
|
|
56669
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength + impliedArity, endLength), elementTypes[startLength + 1]);
|
|
56670
|
+
}
|
|
56671
|
+
} else if (elementFlags[startLength] & 4 /* Rest */ && elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
56672
|
+
const param = (_b = getInferenceInfoForType(elementTypes[startLength + 1])) == null ? void 0 : _b.typeParameter;
|
|
56673
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
56674
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
56675
|
+
const impliedArity = constraint.target.fixedLength;
|
|
56676
|
+
const endIndex = sourceArity - getEndElementCount(target.target, 3 /* Fixed */);
|
|
56677
|
+
const startIndex = endIndex - impliedArity;
|
|
56678
|
+
const trailingSlice = createTupleType(
|
|
56679
|
+
getTypeArguments(source).slice(startIndex, endIndex),
|
|
56680
|
+
source.target.elementFlags.slice(startIndex, endIndex),
|
|
56681
|
+
false,
|
|
56682
|
+
source.target.labeledElementDeclarations && source.target.labeledElementDeclarations.slice(startIndex, endIndex)
|
|
56683
|
+
);
|
|
56684
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength, endLength + impliedArity), elementTypes[startLength]);
|
|
56685
|
+
inferFromTypes(trailingSlice, elementTypes[startLength + 1]);
|
|
56686
|
+
}
|
|
56659
56687
|
}
|
|
56660
56688
|
} else if (middleLength === 1 && elementFlags[startLength] & 8 /* Variadic */) {
|
|
56661
56689
|
const endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* Optional */;
|
package/lib/tsserver.js
CHANGED
|
@@ -2670,7 +2670,7 @@ __export(ts_server_exports3, {
|
|
|
2670
2670
|
|
|
2671
2671
|
// src/compiler/corePublic.ts
|
|
2672
2672
|
var versionMajorMinor = "5.0";
|
|
2673
|
-
var version = `${versionMajorMinor}.0-dev.
|
|
2673
|
+
var version = `${versionMajorMinor}.0-dev.20230104`;
|
|
2674
2674
|
var Comparison = /* @__PURE__ */ ((Comparison3) => {
|
|
2675
2675
|
Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
|
|
2676
2676
|
Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
|
|
@@ -35202,6 +35202,7 @@ var libEntries = [
|
|
|
35202
35202
|
["es2022.object", "lib.es2022.object.d.ts"],
|
|
35203
35203
|
["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
|
|
35204
35204
|
["es2022.string", "lib.es2022.string.d.ts"],
|
|
35205
|
+
["es2022.regexp", "lib.es2022.regexp.d.ts"],
|
|
35205
35206
|
["esnext.array", "lib.es2022.array.d.ts"],
|
|
35206
35207
|
["esnext.symbol", "lib.es2019.symbol.d.ts"],
|
|
35207
35208
|
["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
|
@@ -61581,6 +61582,7 @@ function createTypeChecker(host) {
|
|
|
61581
61582
|
}
|
|
61582
61583
|
}
|
|
61583
61584
|
function inferFromObjectTypes(source, target) {
|
|
61585
|
+
var _a2, _b;
|
|
61584
61586
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
|
|
61585
61587
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
61586
61588
|
return;
|
|
@@ -61627,11 +61629,37 @@ function createTypeChecker(host) {
|
|
|
61627
61629
|
}
|
|
61628
61630
|
} else {
|
|
61629
61631
|
const middleLength = targetArity - startLength - endLength;
|
|
61630
|
-
if (middleLength === 2
|
|
61631
|
-
|
|
61632
|
-
|
|
61633
|
-
|
|
61634
|
-
|
|
61632
|
+
if (middleLength === 2) {
|
|
61633
|
+
if (elementFlags[startLength] & elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
61634
|
+
const targetInfo = getInferenceInfoForType(elementTypes[startLength]);
|
|
61635
|
+
if (targetInfo && targetInfo.impliedArity !== void 0) {
|
|
61636
|
+
inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]);
|
|
61637
|
+
inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]);
|
|
61638
|
+
}
|
|
61639
|
+
} else if (elementFlags[startLength] & 8 /* Variadic */ && elementFlags[startLength + 1] & 4 /* Rest */) {
|
|
61640
|
+
const param = (_a2 = getInferenceInfoForType(elementTypes[startLength])) == null ? void 0 : _a2.typeParameter;
|
|
61641
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
61642
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
61643
|
+
const impliedArity = constraint.target.fixedLength;
|
|
61644
|
+
inferFromTypes(sliceTupleType(source, startLength, sourceArity - (startLength + impliedArity)), elementTypes[startLength]);
|
|
61645
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength + impliedArity, endLength), elementTypes[startLength + 1]);
|
|
61646
|
+
}
|
|
61647
|
+
} else if (elementFlags[startLength] & 4 /* Rest */ && elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
61648
|
+
const param = (_b = getInferenceInfoForType(elementTypes[startLength + 1])) == null ? void 0 : _b.typeParameter;
|
|
61649
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
61650
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
61651
|
+
const impliedArity = constraint.target.fixedLength;
|
|
61652
|
+
const endIndex = sourceArity - getEndElementCount(target.target, 3 /* Fixed */);
|
|
61653
|
+
const startIndex = endIndex - impliedArity;
|
|
61654
|
+
const trailingSlice = createTupleType(
|
|
61655
|
+
getTypeArguments(source).slice(startIndex, endIndex),
|
|
61656
|
+
source.target.elementFlags.slice(startIndex, endIndex),
|
|
61657
|
+
false,
|
|
61658
|
+
source.target.labeledElementDeclarations && source.target.labeledElementDeclarations.slice(startIndex, endIndex)
|
|
61659
|
+
);
|
|
61660
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength, endLength + impliedArity), elementTypes[startLength]);
|
|
61661
|
+
inferFromTypes(trailingSlice, elementTypes[startLength + 1]);
|
|
61662
|
+
}
|
|
61635
61663
|
}
|
|
61636
61664
|
} else if (middleLength === 1 && elementFlags[startLength] & 8 /* Variadic */) {
|
|
61637
61665
|
const endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* Optional */;
|
package/lib/tsserverlibrary.js
CHANGED
|
@@ -42,7 +42,7 @@ var ts = (() => {
|
|
|
42
42
|
"src/compiler/corePublic.ts"() {
|
|
43
43
|
"use strict";
|
|
44
44
|
versionMajorMinor = "5.0";
|
|
45
|
-
version = `${versionMajorMinor}.0-dev.
|
|
45
|
+
version = `${versionMajorMinor}.0-dev.20230104`;
|
|
46
46
|
Comparison = /* @__PURE__ */ ((Comparison3) => {
|
|
47
47
|
Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
|
|
48
48
|
Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
|
|
@@ -34371,6 +34371,7 @@ ${lanes.join("\n")}
|
|
|
34371
34371
|
["es2022.object", "lib.es2022.object.d.ts"],
|
|
34372
34372
|
["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
|
|
34373
34373
|
["es2022.string", "lib.es2022.string.d.ts"],
|
|
34374
|
+
["es2022.regexp", "lib.es2022.regexp.d.ts"],
|
|
34374
34375
|
["esnext.array", "lib.es2022.array.d.ts"],
|
|
34375
34376
|
["esnext.symbol", "lib.es2019.symbol.d.ts"],
|
|
34376
34377
|
["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
|
@@ -59015,6 +59016,7 @@ ${lanes.join("\n")}
|
|
|
59015
59016
|
}
|
|
59016
59017
|
}
|
|
59017
59018
|
function inferFromObjectTypes(source, target) {
|
|
59019
|
+
var _a2, _b;
|
|
59018
59020
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
|
|
59019
59021
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
59020
59022
|
return;
|
|
@@ -59061,11 +59063,37 @@ ${lanes.join("\n")}
|
|
|
59061
59063
|
}
|
|
59062
59064
|
} else {
|
|
59063
59065
|
const middleLength = targetArity - startLength - endLength;
|
|
59064
|
-
if (middleLength === 2
|
|
59065
|
-
|
|
59066
|
-
|
|
59067
|
-
|
|
59068
|
-
|
|
59066
|
+
if (middleLength === 2) {
|
|
59067
|
+
if (elementFlags[startLength] & elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
59068
|
+
const targetInfo = getInferenceInfoForType(elementTypes[startLength]);
|
|
59069
|
+
if (targetInfo && targetInfo.impliedArity !== void 0) {
|
|
59070
|
+
inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]);
|
|
59071
|
+
inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]);
|
|
59072
|
+
}
|
|
59073
|
+
} else if (elementFlags[startLength] & 8 /* Variadic */ && elementFlags[startLength + 1] & 4 /* Rest */) {
|
|
59074
|
+
const param = (_a2 = getInferenceInfoForType(elementTypes[startLength])) == null ? void 0 : _a2.typeParameter;
|
|
59075
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
59076
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
59077
|
+
const impliedArity = constraint.target.fixedLength;
|
|
59078
|
+
inferFromTypes(sliceTupleType(source, startLength, sourceArity - (startLength + impliedArity)), elementTypes[startLength]);
|
|
59079
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength + impliedArity, endLength), elementTypes[startLength + 1]);
|
|
59080
|
+
}
|
|
59081
|
+
} else if (elementFlags[startLength] & 4 /* Rest */ && elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
59082
|
+
const param = (_b = getInferenceInfoForType(elementTypes[startLength + 1])) == null ? void 0 : _b.typeParameter;
|
|
59083
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
59084
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
59085
|
+
const impliedArity = constraint.target.fixedLength;
|
|
59086
|
+
const endIndex = sourceArity - getEndElementCount(target.target, 3 /* Fixed */);
|
|
59087
|
+
const startIndex = endIndex - impliedArity;
|
|
59088
|
+
const trailingSlice = createTupleType(
|
|
59089
|
+
getTypeArguments(source).slice(startIndex, endIndex),
|
|
59090
|
+
source.target.elementFlags.slice(startIndex, endIndex),
|
|
59091
|
+
false,
|
|
59092
|
+
source.target.labeledElementDeclarations && source.target.labeledElementDeclarations.slice(startIndex, endIndex)
|
|
59093
|
+
);
|
|
59094
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength, endLength + impliedArity), elementTypes[startLength]);
|
|
59095
|
+
inferFromTypes(trailingSlice, elementTypes[startLength + 1]);
|
|
59096
|
+
}
|
|
59069
59097
|
}
|
|
59070
59098
|
} else if (middleLength === 1 && elementFlags[startLength] & 8 /* Variadic */) {
|
|
59071
59099
|
const endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* Optional */;
|
package/lib/typescript.js
CHANGED
|
@@ -42,7 +42,7 @@ var ts = (() => {
|
|
|
42
42
|
"src/compiler/corePublic.ts"() {
|
|
43
43
|
"use strict";
|
|
44
44
|
versionMajorMinor = "5.0";
|
|
45
|
-
version = `${versionMajorMinor}.0-dev.
|
|
45
|
+
version = `${versionMajorMinor}.0-dev.20230104`;
|
|
46
46
|
Comparison = /* @__PURE__ */ ((Comparison3) => {
|
|
47
47
|
Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
|
|
48
48
|
Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
|
|
@@ -34371,6 +34371,7 @@ ${lanes.join("\n")}
|
|
|
34371
34371
|
["es2022.object", "lib.es2022.object.d.ts"],
|
|
34372
34372
|
["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
|
|
34373
34373
|
["es2022.string", "lib.es2022.string.d.ts"],
|
|
34374
|
+
["es2022.regexp", "lib.es2022.regexp.d.ts"],
|
|
34374
34375
|
["esnext.array", "lib.es2022.array.d.ts"],
|
|
34375
34376
|
["esnext.symbol", "lib.es2019.symbol.d.ts"],
|
|
34376
34377
|
["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
|
@@ -59015,6 +59016,7 @@ ${lanes.join("\n")}
|
|
|
59015
59016
|
}
|
|
59016
59017
|
}
|
|
59017
59018
|
function inferFromObjectTypes(source, target) {
|
|
59019
|
+
var _a2, _b;
|
|
59018
59020
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
|
|
59019
59021
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
59020
59022
|
return;
|
|
@@ -59061,11 +59063,37 @@ ${lanes.join("\n")}
|
|
|
59061
59063
|
}
|
|
59062
59064
|
} else {
|
|
59063
59065
|
const middleLength = targetArity - startLength - endLength;
|
|
59064
|
-
if (middleLength === 2
|
|
59065
|
-
|
|
59066
|
-
|
|
59067
|
-
|
|
59068
|
-
|
|
59066
|
+
if (middleLength === 2) {
|
|
59067
|
+
if (elementFlags[startLength] & elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
59068
|
+
const targetInfo = getInferenceInfoForType(elementTypes[startLength]);
|
|
59069
|
+
if (targetInfo && targetInfo.impliedArity !== void 0) {
|
|
59070
|
+
inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]);
|
|
59071
|
+
inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]);
|
|
59072
|
+
}
|
|
59073
|
+
} else if (elementFlags[startLength] & 8 /* Variadic */ && elementFlags[startLength + 1] & 4 /* Rest */) {
|
|
59074
|
+
const param = (_a2 = getInferenceInfoForType(elementTypes[startLength])) == null ? void 0 : _a2.typeParameter;
|
|
59075
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
59076
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
59077
|
+
const impliedArity = constraint.target.fixedLength;
|
|
59078
|
+
inferFromTypes(sliceTupleType(source, startLength, sourceArity - (startLength + impliedArity)), elementTypes[startLength]);
|
|
59079
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength + impliedArity, endLength), elementTypes[startLength + 1]);
|
|
59080
|
+
}
|
|
59081
|
+
} else if (elementFlags[startLength] & 4 /* Rest */ && elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
59082
|
+
const param = (_b = getInferenceInfoForType(elementTypes[startLength + 1])) == null ? void 0 : _b.typeParameter;
|
|
59083
|
+
const constraint = param && getBaseConstraintOfType(param);
|
|
59084
|
+
if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
|
|
59085
|
+
const impliedArity = constraint.target.fixedLength;
|
|
59086
|
+
const endIndex = sourceArity - getEndElementCount(target.target, 3 /* Fixed */);
|
|
59087
|
+
const startIndex = endIndex - impliedArity;
|
|
59088
|
+
const trailingSlice = createTupleType(
|
|
59089
|
+
getTypeArguments(source).slice(startIndex, endIndex),
|
|
59090
|
+
source.target.elementFlags.slice(startIndex, endIndex),
|
|
59091
|
+
false,
|
|
59092
|
+
source.target.labeledElementDeclarations && source.target.labeledElementDeclarations.slice(startIndex, endIndex)
|
|
59093
|
+
);
|
|
59094
|
+
inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength, endLength + impliedArity), elementTypes[startLength]);
|
|
59095
|
+
inferFromTypes(trailingSlice, elementTypes[startLength + 1]);
|
|
59096
|
+
}
|
|
59069
59097
|
}
|
|
59070
59098
|
} else if (middleLength === 1 && elementFlags[startLength] & 8 /* Variadic */) {
|
|
59071
59099
|
const endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* Optional */;
|
package/lib/typingsInstaller.js
CHANGED
|
@@ -50,7 +50,7 @@ var path = __toESM(require("path"));
|
|
|
50
50
|
|
|
51
51
|
// src/compiler/corePublic.ts
|
|
52
52
|
var versionMajorMinor = "5.0";
|
|
53
|
-
var version = `${versionMajorMinor}.0-dev.
|
|
53
|
+
var version = `${versionMajorMinor}.0-dev.20230104`;
|
|
54
54
|
|
|
55
55
|
// src/compiler/core.ts
|
|
56
56
|
var emptyArray = [];
|
|
@@ -24478,6 +24478,7 @@ var libEntries = [
|
|
|
24478
24478
|
["es2022.object", "lib.es2022.object.d.ts"],
|
|
24479
24479
|
["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
|
|
24480
24480
|
["es2022.string", "lib.es2022.string.d.ts"],
|
|
24481
|
+
["es2022.regexp", "lib.es2022.regexp.d.ts"],
|
|
24481
24482
|
["esnext.array", "lib.es2022.array.d.ts"],
|
|
24482
24483
|
["esnext.symbol", "lib.es2019.symbol.d.ts"],
|
|
24483
24484
|
["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
package/package.json
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
"name": "typescript",
|
|
3
3
|
"author": "Microsoft Corp.",
|
|
4
4
|
"homepage": "https://www.typescriptlang.org/",
|
|
5
|
-
"version": "5.0.0-dev.
|
|
5
|
+
"version": "5.0.0-dev.20230104",
|
|
6
6
|
"license": "Apache-2.0",
|
|
7
7
|
"description": "TypeScript is a language for application scale JavaScript development",
|
|
8
8
|
"keywords": [
|