• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1namespace ts {
2    // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
3    // If changing the text in this section, be sure to test `configurePrerelease` too.
4    export const versionMajorMinor = "4.9";
5    // The following is baselined as a literal template type without intervention
6    /** The version of the TypeScript compiler release */
7    // eslint-disable-next-line @typescript-eslint/no-inferrable-types
8    export const version: string = `${versionMajorMinor}.5`;
9
10    /**
11     * Type of objects whose values are all of the same type.
12     * The `in` and `for-in` operators can *not* be safely used,
13     * since `Object.prototype` may be modified by outside code.
14     */
15    export interface MapLike<T> {
16        [index: string]: T;
17    }
18
19    export interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
20        " __sortedArrayBrand": any;
21    }
22
23    export interface SortedArray<T> extends Array<T> {
24        " __sortedArrayBrand": any;
25    }
26
27    /** Common read methods for ES6 Map/Set. */
28    export interface ReadonlyCollection<K> {
29        readonly size: number;
30        has(key: K): boolean;
31        keys(): Iterator<K>;
32    }
33
34    /** Common write methods for ES6 Map/Set. */
35    export interface Collection<K> extends ReadonlyCollection<K> {
36        delete(key: K): boolean;
37        clear(): void;
38    }
39
40    /** ES6 Map interface, only read methods included. */
41    export interface ReadonlyESMap<K, V> extends ReadonlyCollection<K> {
42        get(key: K): V | undefined;
43        values(): Iterator<V>;
44        entries(): Iterator<[K, V]>;
45        forEach(action: (value: V, key: K) => void): void;
46    }
47
48    /**
49     * ES6 Map interface, only read methods included.
50     */
51    export interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
52    }
53
54    /** ES6 Map interface. */
55    export interface ESMap<K, V> extends ReadonlyESMap<K, V>, Collection<K> {
56        set(key: K, value: V): this;
57    }
58
59    /**
60     * ES6 Map interface.
61     */
62    export interface Map<T> extends ESMap<string, T> {
63    }
64
65    /* @internal */
66    export interface MapConstructor {
67        // eslint-disable-next-line @typescript-eslint/prefer-function-type
68        new <K, V>(iterable?: readonly (readonly [K, V])[] | ReadonlyESMap<K, V>): ESMap<K, V>;
69    }
70
71    /** ES6 Set interface, only read methods included. */
72    export interface ReadonlySet<T> extends ReadonlyCollection<T> {
73        has(value: T): boolean;
74        values(): Iterator<T>;
75        entries(): Iterator<[T, T]>;
76        forEach(action: (value: T, key: T) => void): void;
77    }
78
79    /** ES6 Set interface. */
80    export interface Set<T> extends ReadonlySet<T>, Collection<T> {
81        add(value: T): this;
82        delete(value: T): boolean;
83    }
84
85    /* @internal */
86    export interface SetConstructor {
87        // eslint-disable-next-line @typescript-eslint/prefer-function-type
88        new <T>(iterable?: readonly T[] | ReadonlySet<T>): Set<T>;
89    }
90
91    /** ES6 Iterator type. */
92    export interface Iterator<T> {
93        next(): { value: T, done?: false } | { value: void, done: true };
94    }
95
96    /** Array that is only intended to be pushed to, never read. */
97    export interface Push<T> {
98        push(...values: T[]): void;
99        /* @internal*/ readonly length: number;
100    }
101
102    /* @internal */
103    export type EqualityComparer<T> = (a: T, b: T) => boolean;
104
105    /* @internal */
106    export type Comparer<T> = (a: T, b: T) => Comparison;
107
108    /* @internal */
109    export const enum Comparison {
110        LessThan    = -1,
111        EqualTo     = 0,
112        GreaterThan = 1
113    }
114
115    /* @internal */
116    namespace NativeCollections {
117        declare const self: any;
118
119        const globals = typeof globalThis !== "undefined" ? globalThis :
120                  typeof global !== "undefined" ? global :
121                  typeof self !== "undefined" ? self :
122                  undefined;
123
124        /**
125         * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
126         */
127        export function tryGetNativeMap(): MapConstructor {
128            // Internet Explorer's Map doesn't support iteration, so don't use it.
129            const gMap = globals?.Map;
130            // eslint-disable-next-line local/no-in-operator
131            const constructor = typeof gMap !== "undefined" && "entries" in gMap.prototype && new gMap([[0, 0]]).size === 1 ? gMap : undefined;
132            if (!constructor) {
133                throw new Error("No compatible Map implementation found.");
134            }
135            return constructor;
136        }
137
138        /**
139         * Returns the native Set implementation if it is available and compatible (i.e. supports iteration).
140         */
141        export function tryGetNativeSet(): SetConstructor {
142            // Internet Explorer's Set doesn't support iteration, so don't use it.
143            const gSet = globals?.Set;
144            // eslint-disable-next-line local/no-in-operator
145            const constructor = typeof gSet !== "undefined" && "entries" in gSet.prototype && new gSet([0]).size === 1 ? gSet : undefined;
146            if (!constructor) {
147                throw new Error("No compatible Set implementation found.");
148            }
149            return constructor;
150        }
151    }
152
153    /* @internal */
154    export const Map = NativeCollections.tryGetNativeMap();
155    /* @internal */
156    export const Set = NativeCollections.tryGetNativeSet();
157}
158