@typespec/compiler 1.15.0-dev.16 → 1.15.0-dev.18

package/dist/src/core/scanner.js

@@ -1,4 +1,4 @@
-import { codePointBefore, isAsciiIdentifierContinue, isAsciiIdentifierStart, isBinaryDigit, isDigit, isHexDigit, isIdentifierContinue, isIdentifierStart, isLineBreak, isLowercaseAsciiLetter, isNonAsciiIdentifierCharacter, isNonAsciiWhiteSpaceSingleLine, isWhiteSpace, isWhiteSpaceSingleLine, utf16CodeUnits, } from "./charcode.js";
+import { CharCode, codePointBefore, isAsciiIdentifierContinue, isAsciiIdentifierStart, isBinaryDigit, isDigit, isHexDigit, isIdentifierContinue, isIdentifierStart, isLineBreak, isLowercaseAsciiLetter, isNonAsciiIdentifierCharacter, isNonAsciiWhiteSpaceSingleLine, isWhiteSpace, isWhiteSpaceSingleLine, utf16CodeUnits, } from "./charcode.js";
 import { createTripleQuoteIndentCodeFix } from "./compiler-code-fixes/triple-quote-indent.codefix.js";
 import { compilerAssert } from "./diagnostics.js";
 import { createDiagnostic } from "./messages.js";
@@ -401,6 +401,12 @@ export const ReservedKeywords = new Map([
     ["local", Token.LocalKeyword],
     ["async", Token.AsyncKeyword],
 ]);
+/** @internal */
+export var KeywordLimit;
+(function (KeywordLimit) {
+    KeywordLimit[KeywordLimit["MinLength"] = 2] = "MinLength";
+    KeywordLimit[KeywordLimit["MaxLength"] = 12] = "MaxLength";
+})(KeywordLimit || (KeywordLimit = {}));
 export var TokenFlags;
 (function (TokenFlags) {
     TokenFlags[TokenFlags["None"] = 0] = "None";
@@ -442,7 +448,7 @@ export function createScanner(source, diagnosticHandler) {
     let tokenPosition = -1;
     let tokenFlags = TokenFlags.None;
     // Skip BOM
-    if (position < endPosition && input.charCodeAt(position) === 65279 /* CharCode.ByteOrderMark */) {
+    if (position < endPosition && input.charCodeAt(position) === CharCode.ByteOrderMark) {
         position++;
     }
     return {
@@ -503,125 +509,125 @@ export function createScanner(source, diagnosticHandler) {
         if (!eof()) {
             const ch = input.charCodeAt(position);
             switch (ch) {
-                case 13 /* CharCode.CarriageReturn */:
-                    if (lookAhead(1) === 10 /* CharCode.LineFeed */) {
+                case CharCode.CarriageReturn:
+                    if (lookAhead(1) === CharCode.LineFeed) {
                         position++;
                     }
                 // fallthrough
-                case 10 /* CharCode.LineFeed */:
+                case CharCode.LineFeed:
                     return next(Token.NewLine);
-                case 32 /* CharCode.Space */:
-                case 9 /* CharCode.Tab */:
-                case 11 /* CharCode.VerticalTab */:
-                case 12 /* CharCode.FormFeed */:
+                case CharCode.Space:
+                case CharCode.Tab:
+                case CharCode.VerticalTab:
+                case CharCode.FormFeed:
                     return scanWhitespace();
-                case 40 /* CharCode.OpenParen */:
+                case CharCode.OpenParen:
                     return next(Token.OpenParen);
-                case 41 /* CharCode.CloseParen */:
+                case CharCode.CloseParen:
                     return next(Token.CloseParen);
-                case 44 /* CharCode.Comma */:
+                case CharCode.Comma:
                     return next(Token.Comma);
-                case 58 /* CharCode.Colon */:
-                    return lookAhead(1) === 58 /* CharCode.Colon */ ? next(Token.ColonColon, 2) : next(Token.Colon);
-                case 59 /* CharCode.Semicolon */:
+                case CharCode.Colon:
+                    return lookAhead(1) === CharCode.Colon ? next(Token.ColonColon, 2) : next(Token.Colon);
+                case CharCode.Semicolon:
                     return next(Token.Semicolon);
-                case 91 /* CharCode.OpenBracket */:
+                case CharCode.OpenBracket:
                     return next(Token.OpenBracket);
-                case 93 /* CharCode.CloseBracket */:
+                case CharCode.CloseBracket:
                     return next(Token.CloseBracket);
-                case 123 /* CharCode.OpenBrace */:
+                case CharCode.OpenBrace:
                     return next(Token.OpenBrace);
-                case 125 /* CharCode.CloseBrace */:
+                case CharCode.CloseBrace:
                     return next(Token.CloseBrace);
-                case 64 /* CharCode.At */:
-                    return lookAhead(1) === 64 /* CharCode.At */ ? next(Token.AtAt, 2) : next(Token.At);
-                case 35 /* CharCode.Hash */:
+                case CharCode.At:
+                    return lookAhead(1) === CharCode.At ? next(Token.AtAt, 2) : next(Token.At);
+                case CharCode.Hash:
                     const ahead = lookAhead(1);
                     switch (ahead) {
-                        case 123 /* CharCode.OpenBrace */:
+                        case CharCode.OpenBrace:
                             return next(Token.HashBrace, 2);
-                        case 91 /* CharCode.OpenBracket */:
+                        case CharCode.OpenBracket:
                             return next(Token.HashBracket, 2);
                         default:
                             return next(Token.Hash);
                     }
-                case 43 /* CharCode.Plus */:
+                case CharCode.Plus:
                     return isDigit(lookAhead(1)) ? scanSignedNumber() : next(Token.Plus);
-                case 45 /* CharCode.Minus */:
+                case CharCode.Minus:
                     return isDigit(lookAhead(1)) ? scanSignedNumber() : next(Token.Hyphen);
-                case 42 /* CharCode.Asterisk */:
+                case CharCode.Asterisk:
                     return next(Token.Star);
-                case 63 /* CharCode.Question */:
+                case CharCode.Question:
                     return next(Token.Question);
-                case 38 /* CharCode.Ampersand */:
-                    return lookAhead(1) === 38 /* CharCode.Ampersand */
+                case CharCode.Ampersand:
+                    return lookAhead(1) === CharCode.Ampersand
                         ? next(Token.AmpsersandAmpersand, 2)
                         : next(Token.Ampersand);
-                case 46 /* CharCode.Dot */:
-                    return lookAhead(1) === 46 /* CharCode.Dot */ && lookAhead(2) === 46 /* CharCode.Dot */
+                case CharCode.Dot:
+                    return lookAhead(1) === CharCode.Dot && lookAhead(2) === CharCode.Dot
                         ? next(Token.Ellipsis, 3)
                         : next(Token.Dot);
-                case 47 /* CharCode.Slash */:
+                case CharCode.Slash:
                     switch (lookAhead(1)) {
-                        case 47 /* CharCode.Slash */:
+                        case CharCode.Slash:
                             return scanSingleLineComment();
-                        case 42 /* CharCode.Asterisk */:
+                        case CharCode.Asterisk:
                             return scanMultiLineComment();
                     }
                     return next(Token.ForwardSlash);
-                case 48 /* CharCode._0 */:
+                case CharCode._0:
                     switch (lookAhead(1)) {
-                        case 120 /* CharCode.x */:
+                        case CharCode.x:
                             return scanHexNumber();
-                        case 98 /* CharCode.b */:
+                        case CharCode.b:
                             return scanBinaryNumber();
                     }
                 // fallthrough
-                case 49 /* CharCode._1 */:
-                case 50 /* CharCode._2 */:
-                case 51 /* CharCode._3 */:
-                case 52 /* CharCode._4 */:
-                case 53 /* CharCode._5 */:
-                case 54 /* CharCode._6 */:
-                case 55 /* CharCode._7 */:
-                case 56 /* CharCode._8 */:
-                case 57 /* CharCode._9 */:
+                case CharCode._1:
+                case CharCode._2:
+                case CharCode._3:
+                case CharCode._4:
+                case CharCode._5:
+                case CharCode._6:
+                case CharCode._7:
+                case CharCode._8:
+                case CharCode._9:
                     return scanNumber();
-                case 60 /* CharCode.LessThan */:
+                case CharCode.LessThan:
                     if (atConflictMarker())
                         return scanConflictMarker();
-                    return lookAhead(1) === 61 /* CharCode.Equals */
+                    return lookAhead(1) === CharCode.Equals
                         ? next(Token.LessThanEquals, 2)
                         : next(Token.LessThan);
-                case 62 /* CharCode.GreaterThan */:
+                case CharCode.GreaterThan:
                     if (atConflictMarker())
                         return scanConflictMarker();
-                    return lookAhead(1) === 61 /* CharCode.Equals */
+                    return lookAhead(1) === CharCode.Equals
                         ? next(Token.GreaterThanEquals, 2)
                         : next(Token.GreaterThan);
-                case 61 /* CharCode.Equals */:
+                case CharCode.Equals:
                     if (atConflictMarker())
                         return scanConflictMarker();
                     switch (lookAhead(1)) {
-                        case 61 /* CharCode.Equals */:
+                        case CharCode.Equals:
                             return next(Token.EqualsEquals, 2);
-                        case 62 /* CharCode.GreaterThan */:
+                        case CharCode.GreaterThan:
                             return next(Token.EqualsGreaterThan, 2);
                     }
                     return next(Token.Equals);
-                case 124 /* CharCode.Bar */:
+                case CharCode.Bar:
                     if (atConflictMarker())
                         return scanConflictMarker();
-                    return lookAhead(1) === 124 /* CharCode.Bar */ ? next(Token.BarBar, 2) : next(Token.Bar);
-                case 34 /* CharCode.DoubleQuote */:
-                    return lookAhead(1) === 34 /* CharCode.DoubleQuote */ && lookAhead(2) === 34 /* CharCode.DoubleQuote */
+                    return lookAhead(1) === CharCode.Bar ? next(Token.BarBar, 2) : next(Token.Bar);
+                case CharCode.DoubleQuote:
+                    return lookAhead(1) === CharCode.DoubleQuote && lookAhead(2) === CharCode.DoubleQuote
                         ? scanString(TokenFlags.TripleQuoted)
                         : scanString(TokenFlags.None);
-                case 33 /* CharCode.Exclamation */:
-                    return lookAhead(1) === 61 /* CharCode.Equals */
+                case CharCode.Exclamation:
+                    return lookAhead(1) === CharCode.Equals
                         ? next(Token.ExclamationEquals, 2)
                         : next(Token.Exclamation);
-                case 96 /* CharCode.Backtick */:
+                case CharCode.Backtick:
                     return scanBacktickedIdentifier();
                 default:
                     if (isLowercaseAsciiLetter(ch)) {
@@ -630,7 +636,7 @@ export function createScanner(source, diagnosticHandler) {
                     if (isAsciiIdentifierStart(ch)) {
                         return scanIdentifier();
                     }
-                    if (ch <= 127 /* CharCode.MaxAscii */) {
+                    if (ch <= CharCode.MaxAscii) {
                         return scanInvalidCharacter();
                     }
                     return scanNonAsciiToken();
@@ -644,48 +650,48 @@ export function createScanner(source, diagnosticHandler) {
         if (!eof()) {
             const ch = input.charCodeAt(position);
             switch (ch) {
-                case 13 /* CharCode.CarriageReturn */:
-                    if (lookAhead(1) === 10 /* CharCode.LineFeed */) {
+                case CharCode.CarriageReturn:
+                    if (lookAhead(1) === CharCode.LineFeed) {
                         position++;
                     }
                 // fallthrough
-                case 10 /* CharCode.LineFeed */:
+                case CharCode.LineFeed:
                     return next(Token.NewLine);
-                case 92 /* CharCode.Backslash */:
-                    if (lookAhead(1) === 64 /* CharCode.At */) {
+                case CharCode.Backslash:
+                    if (lookAhead(1) === CharCode.At) {
                         tokenFlags |= TokenFlags.Escaped;
                         return next(Token.DocText, 2);
                     }
                     return next(Token.DocText);
-                case 32 /* CharCode.Space */:
-                case 9 /* CharCode.Tab */:
-                case 11 /* CharCode.VerticalTab */:
-                case 12 /* CharCode.FormFeed */:
+                case CharCode.Space:
+                case CharCode.Tab:
+                case CharCode.VerticalTab:
+                case CharCode.FormFeed:
                     return scanWhitespace();
-                case 125 /* CharCode.CloseBrace */:
+                case CharCode.CloseBrace:
                     return next(Token.CloseBrace);
-                case 64 /* CharCode.At */:
+                case CharCode.At:
                     return next(Token.At);
-                case 42 /* CharCode.Asterisk */:
+                case CharCode.Asterisk:
                     return next(Token.Star);
-                case 96 /* CharCode.Backtick */:
-                    return lookAhead(1) === 96 /* CharCode.Backtick */ && lookAhead(2) === 96 /* CharCode.Backtick */
+                case CharCode.Backtick:
+                    return lookAhead(1) === CharCode.Backtick && lookAhead(2) === CharCode.Backtick
                         ? next(Token.DocCodeFenceDelimiter, 3)
                         : scanDocCodeSpan();
-                case 60 /* CharCode.LessThan */:
-                case 62 /* CharCode.GreaterThan */:
-                case 61 /* CharCode.Equals */:
-                case 124 /* CharCode.Bar */:
+                case CharCode.LessThan:
+                case CharCode.GreaterThan:
+                case CharCode.Equals:
+                case CharCode.Bar:
                     if (atConflictMarker())
                         return scanConflictMarker();
                     return next(Token.DocText);
-                case 45 /* CharCode.Minus */:
+                case CharCode.Minus:
                     return next(Token.Hyphen);
             }
             if (isAsciiIdentifierStart(ch)) {
                 return scanIdentifier();
             }
-            if (ch <= 127 /* CharCode.MaxAscii */) {
+            if (ch <= CharCode.MaxAscii) {
                 return next(Token.DocText);
             }
             const cp = input.codePointAt(position);
@@ -769,14 +775,14 @@ export function createScanner(source, diagnosticHandler) {
     }
     function scanNumber() {
         scanKnownDigits();
-        if (!eof() && input.charCodeAt(position) === 46 /* CharCode.Dot */) {
+        if (!eof() && input.charCodeAt(position) === CharCode.Dot) {
             position++;
             scanRequiredDigits();
         }
-        if (!eof() && input.charCodeAt(position) === 101 /* CharCode.e */) {
+        if (!eof() && input.charCodeAt(position) === CharCode.e) {
             position++;
             const ch = input.charCodeAt(position);
-            if (ch === 43 /* CharCode.Plus */ || ch === 45 /* CharCode.Minus */) {
+            if (ch === CharCode.Plus || ch === CharCode.Minus) {
                 position++;
             }
             scanRequiredDigits();
@@ -823,7 +829,7 @@ export function createScanner(source, diagnosticHandler) {
     }
     function scanMultiLineComment() {
         token = Token.MultiLineComment;
-        if (lookAhead(2) === 42 /* CharCode.Asterisk */) {
+        if (lookAhead(2) === CharCode.Asterisk) {
             tokenFlags |= TokenFlags.DocComment;
         }
         const [newPosition, terminated] = skipMultiLineComment(input, position);
@@ -835,11 +841,11 @@ export function createScanner(source, diagnosticHandler) {
         loop: for (; !eof(); position++) {
             const ch = input.charCodeAt(position);
             switch (ch) {
-                case 96 /* CharCode.Backtick */:
+                case CharCode.Backtick:
                     position++;
                     return (token = Token.DocCodeSpan);
-                case 13 /* CharCode.CarriageReturn */:
-                case 10 /* CharCode.LineFeed */:
+                case CharCode.CarriageReturn:
+                case CharCode.LineFeed:
                     break loop;
             }
         }
@@ -864,16 +870,16 @@ export function createScanner(source, diagnosticHandler) {
         loop: for (; !eof(); position++) {
             const ch = input.charCodeAt(position);
             switch (ch) {
-                case 92 /* CharCode.Backslash */:
+                case CharCode.Backslash:
                     tokenFlags |= TokenFlags.Escaped;
                     position++;
                     if (eof()) {
                         break loop;
                     }
                     continue;
-                case 34 /* CharCode.DoubleQuote */:
+                case CharCode.DoubleQuote:
                     if (multiLine) {
-                        if (lookAhead(1) === 34 /* CharCode.DoubleQuote */ && lookAhead(2) === 34 /* CharCode.DoubleQuote */) {
+                        if (lookAhead(1) === CharCode.DoubleQuote && lookAhead(2) === CharCode.DoubleQuote) {
                             position += 3;
                             token = tail;
                             return tail;
@@ -887,15 +893,15 @@ export function createScanner(source, diagnosticHandler) {
                         token = tail;
                         return tail;
                     }
-                case 36 /* CharCode.$ */:
-                    if (lookAhead(1) === 123 /* CharCode.OpenBrace */) {
+                case CharCode.$:
+                    if (lookAhead(1) === CharCode.OpenBrace) {
                         position += 2;
                         token = template;
                         return template;
                     }
                     continue;
-                case 13 /* CharCode.CarriageReturn */:
-                case 10 /* CharCode.LineFeed */:
+                case CharCode.CarriageReturn:
+                case CharCode.LineFeed:
                     if (multiLine) {
                         continue;
                     }
@@ -959,7 +965,7 @@ export function createScanner(source, diagnosticHandler) {
             let pos = start;
             while (pos < end) {
                 const ch = input.charCodeAt(pos);
-                if (ch !== 92 /* CharCode.Backslash */) {
+                if (ch !== CharCode.Backslash) {
                     pos++;
                     continue;
                 }
@@ -968,7 +974,7 @@ export function createScanner(source, diagnosticHandler) {
                 }
                 result += input.substring(start, pos);
                 switch (input.charCodeAt(pos + 1)) {
-                    case 64 /* CharCode.At */:
+                    case CharCode.At:
                         result += "@";
                         break;
                     default:
@@ -1064,7 +1070,7 @@ export function createScanner(source, diagnosticHandler) {
             }
             let ch;
             while (pos < end && !isLineBreak((ch = input.charCodeAt(pos)))) {
-                if (ch !== 92 /* CharCode.Backslash */) {
+                if (ch !== CharCode.Backslash) {
                     pos++;
                     continue;
                 }
@@ -1100,8 +1106,8 @@ export function createScanner(source, diagnosticHandler) {
     function isCrlf(pos, start, end) {
         return (pos >= start &&
             pos < end - 1 &&
-            input.charCodeAt(pos) === 13 /* CharCode.CarriageReturn */ &&
-            input.charCodeAt(pos + 1) === 10 /* CharCode.LineFeed */);
+            input.charCodeAt(pos) === CharCode.CarriageReturn &&
+            input.charCodeAt(pos + 1) === CharCode.LineFeed);
     }
     function skipMatchingIndentation(pos, end, indentationStart, indentationEnd) {
         let indentationPos = indentationStart;
@@ -1129,7 +1135,7 @@ export function createScanner(source, diagnosticHandler) {
         let pos = start;
         while (pos < end) {
             const ch = input.charCodeAt(pos);
-            if (ch !== 92 /* CharCode.Backslash */) {
+            if (ch !== CharCode.Backslash) {
                 pos++;
                 continue;
             }
@@ -1148,21 +1154,21 @@ export function createScanner(source, diagnosticHandler) {
     function unescapeOne(pos) {
         const ch = input.charCodeAt(pos + 1);
         switch (ch) {
-            case 114 /* CharCode.r */:
+            case CharCode.r:
                 return "\r";
-            case 110 /* CharCode.n */:
+            case CharCode.n:
                 return "\n";
-            case 116 /* CharCode.t */:
+            case CharCode.t:
                 return "\t";
-            case 34 /* CharCode.DoubleQuote */:
+            case CharCode.DoubleQuote:
                 return '"';
-            case 92 /* CharCode.Backslash */:
+            case CharCode.Backslash:
                 return "\\";
-            case 36 /* CharCode.$ */:
+            case CharCode.$:
                 return "$";
-            case 64 /* CharCode.At */:
+            case CharCode.At:
                 return "@";
-            case 96 /* CharCode.Backtick */:
+            case CharCode.Backtick:
                 return "`";
             default:
                 error({ code: "invalid-escape-sequence" }, pos, pos + 2);
@@ -1178,13 +1184,13 @@ export function createScanner(source, diagnosticHandler) {
                 break;
             }
             const ch = input.charCodeAt(position);
-            if (count < 12 /* KeywordLimit.MaxLength */ && isLowercaseAsciiLetter(ch)) {
+            if (count < KeywordLimit.MaxLength && isLowercaseAsciiLetter(ch)) {
                 continue;
             }
             if (isAsciiIdentifierContinue(ch)) {
                 return scanIdentifier();
             }
-            if (ch > 127 /* CharCode.MaxAscii */) {
+            if (ch > CharCode.MaxAscii) {
                 const cp = input.codePointAt(position);
                 if (isNonAsciiIdentifierCharacter(cp)) {
                     return scanNonAsciiIdentifier(cp);
@@ -1192,7 +1198,7 @@ export function createScanner(source, diagnosticHandler) {
             }
             break;
         }
-        if (count >= 2 /* KeywordLimit.MinLength */ && count <= 12 /* KeywordLimit.MaxLength */) {
+        if (count >= KeywordLimit.MinLength && count <= KeywordLimit.MaxLength) {
             const keyword = Keywords.get(getTokenText());
             if (keyword) {
                 return (token = keyword);
@@ -1208,7 +1214,7 @@ export function createScanner(source, diagnosticHandler) {
                 return (token = Token.Identifier);
             }
         } while (isAsciiIdentifierContinue((ch = input.charCodeAt(position))));
-        if (ch > 127 /* CharCode.MaxAscii */) {
+        if (ch > CharCode.MaxAscii) {
             const cp = input.codePointAt(position);
             if (isNonAsciiIdentifierCharacter(cp)) {
                 return scanNonAsciiIdentifier(cp);
@@ -1222,18 +1228,18 @@ export function createScanner(source, diagnosticHandler) {
         loop: for (; !eof(); position++) {
             const ch = input.charCodeAt(position);
             switch (ch) {
-                case 92 /* CharCode.Backslash */:
+                case CharCode.Backslash:
                     position++;
                     tokenFlags |= TokenFlags.Escaped;
                     continue;
-                case 96 /* CharCode.Backtick */:
+                case CharCode.Backtick:
                     position++;
                     return (token = Token.Identifier);
-                case 13 /* CharCode.CarriageReturn */:
-                case 10 /* CharCode.LineFeed */:
+                case CharCode.CarriageReturn:
+                case CharCode.LineFeed:
                     break loop;
                 default:
-                    if (ch > 127 /* CharCode.MaxAscii */) {
+                    if (ch > CharCode.MaxAscii) {
                         tokenFlags |= TokenFlags.NonAscii;
                     }
             }
@@ -1255,7 +1261,7 @@ export function createScanner(source, diagnosticHandler) {
         const marker = input.charCodeAt(position);
         position += mergeConflictMarkerLength;
         error({ code: "conflict-marker" });
-        if (marker === 60 /* CharCode.LessThan */ || marker === 62 /* CharCode.GreaterThan */) {
+        if (marker === CharCode.LessThan || marker === CharCode.GreaterThan) {
             // Consume everything from >>>>>>> or <<<<<<< to the end of the line.
             while (position < endPosition && !isLineBreak(input.charCodeAt(position))) {
                 position++;
@@ -1266,7 +1272,7 @@ export function createScanner(source, diagnosticHandler) {
             // marker to the start of the next ======= or >>>>>>> marker.
             while (position < endPosition) {
                 const ch = input.charCodeAt(position);
-                if ((ch === 61 /* CharCode.Equals */ || ch === 62 /* CharCode.GreaterThan */) &&
+                if ((ch === CharCode.Equals || ch === CharCode.GreaterThan) &&
                     ch !== marker &&
                     isConflictMarker(input, position, endPosition)) {
                     break;
@@ -1326,12 +1332,12 @@ export function skipTrivia(input, position, endPosition = input.length) {
             position++;
             continue;
         }
-        if (ch === 47 /* CharCode.Slash */) {
+        if (ch === CharCode.Slash) {
             switch (input.charCodeAt(position + 1)) {
-                case 47 /* CharCode.Slash */:
+                case CharCode.Slash:
                     position = skipSingleLineComment(input, position, endPosition);
                     continue;
-                case 42 /* CharCode.Asterisk */:
+                case CharCode.Asterisk:
                     position = skipMultiLineComment(input, position, endPosition)[0];
                     continue;
             }
@@ -1362,8 +1368,8 @@ function skipSingleLineComment(input, position, endPosition = input.length) {
 function skipMultiLineComment(input, position, endPosition = input.length) {
     position += 2; // consume '/*'
     for (; position < endPosition; position++) {
-        if (input.charCodeAt(position) === 42 /* CharCode.Asterisk */ &&
-            input.charCodeAt(position + 1) === 47 /* CharCode.Slash */) {
+        if (input.charCodeAt(position) === CharCode.Asterisk &&
+            input.charCodeAt(position + 1) === CharCode.Slash) {
             return [position + 2, true];
         }
     }
@@ -1392,8 +1398,8 @@ function isConflictMarker(input, position, endPosition = input.length) {
                     return false;
                 }
             }
-            return (ch === 61 /* CharCode.Equals */ ||
-                input.charCodeAt(position + mergeConflictMarkerLength) === 32 /* CharCode.Space */);
+            return (ch === CharCode.Equals ||
+                input.charCodeAt(position + mergeConflictMarkerLength) === CharCode.Space);
         }
     }
     return false;