typescript-bot
diff --git a/‎src/compiler/checker.ts
+1-1 b/‎src/compiler/checker.ts
+1-1
diff --git a/‎src/compiler/core.ts
+22-1 b/‎src/compiler/core.ts
+22-1
diff --git a/‎src/compiler/emitter.ts
+52-284 b/‎src/compiler/emitter.ts
+52-284
@@ -19632,7 +19632,7 @@ namespace ts {
 
         function isNameOfModuleOrEnumDeclaration(node: Identifier) {
             const parent = node.parent;
-            return isModuleOrEnumDeclaration(parent) && node === parent.name;
+            return parent && isModuleOrEnumDeclaration(parent) && node === parent.name;
         }
 
         // When resolved as an expression identifier, if the given node references an exported entity, return the declaration
 
@@ -571,7 +571,7 @@ namespace ts {
      */
     export function append<T>(to: T[] | undefined, value: T | undefined): T[] | undefined {
         if (value === undefined) return to;
-        if (to === undefined) to = [];
+        if (to === undefined) return [value];
         to.push(value);
         return to;
     }
@@ -592,6 +592,16 @@ namespace ts {
         return to;
     }
 
+    /**
+     * Stable sort of an array. Elements equal to each other maintain their relative position in the array.
+     */
+    export function stableSort<T>(array: T[], comparer: (x: T, y: T) => Comparison = compareValues) {
+        return array
+            .map((_, i) => i) // create array of indices
+            .sort((x, y) => comparer(array[x], array[y]) || compareValues(x, y)) // sort indices by value then position
+            .map(i => array[i]); // get sorted array
+    }
+
     export function rangeEquals<T>(array1: T[], array2: T[], pos: number, end: number) {
         while (pos < end) {
             if (array1[pos] !== array2[pos]) {
@@ -2099,6 +2109,17 @@ namespace ts {
     }
 
     /** Remove an item from an array, moving everything to its right one space left. */
+    export function orderedRemoveItem<T>(array: T[], item: T): boolean {
+        for (let i = 0; i < array.length; i++) {
+            if (array[i] === item) {
+                orderedRemoveItemAt(array, i);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /** Remove an item by index from an array, moving everything to its right one space left. */
     export function orderedRemoveItemAt<T>(array: T[], index: number): void {
         // This seems to be faster than either `array.splice(i, 1)` or `array.copyWithin(i, i+ 1)`.
         for (let i = index; i < array.length - 1; i++) {
Original file line number	Diff line number	Diff line change
`@@ -19632,7 +19632,7 @@ namespace ts {`
`19632`	`19632`
`19633`	`19633`	`function isNameOfModuleOrEnumDeclaration(node: Identifier) {`
`19634`	`19634`	`const parent = node.parent;`
`19635`		`- return isModuleOrEnumDeclaration(parent) && node === parent.name;`
	`19635`	`+ return parent && isModuleOrEnumDeclaration(parent) && node === parent.name;`
`19636`	`19636`	`}`
`19637`	`19637`
`19638`	`19638`	`// When resolved as an expression identifier, if the given node references an exported entity, return the declaration`