diff --git a/internal/ast/ast.go b/internal/ast/ast.go
index 6aa647cdf1..848c717a96 100644
--- a/internal/ast/ast.go
+++ b/internal/ast/ast.go
@@ -10724,10 +10724,10 @@ type SourceFile struct {
 	ClassifiableNames         collections.Set[string]
 	PatternAmbientModules     []*PatternAmbientModule
 
-	// Fields set by LineMap
+	// Fields set by ECMALineMap
 
-	lineMapMu sync.RWMutex
-	lineMap   []core.TextPos
+	ecmaLineMapMu sync.RWMutex
+	ecmaLineMap   []core.TextPos
 
 	// Fields set by language service
 
@@ -10862,17 +10862,17 @@ func (f *NodeFactory) UpdateSourceFile(node *SourceFile, statements *StatementLi
 	return node.AsNode()
 }
 
-func (node *SourceFile) LineMap() []core.TextPos {
-	node.lineMapMu.RLock()
-	lineMap := node.lineMap
-	node.lineMapMu.RUnlock()
+func (node *SourceFile) ECMALineMap() []core.TextPos {
+	node.ecmaLineMapMu.RLock()
+	lineMap := node.ecmaLineMap
+	node.ecmaLineMapMu.RUnlock()
 	if lineMap == nil {
-		node.lineMapMu.Lock()
-		defer node.lineMapMu.Unlock()
-		lineMap = node.lineMap
+		node.ecmaLineMapMu.Lock()
+		defer node.ecmaLineMapMu.Unlock()
+		lineMap = node.ecmaLineMap
 		if lineMap == nil {
-			lineMap = core.ComputeLineStarts(node.Text())
-			node.lineMap = lineMap
+			lineMap = core.ComputeECMALineStarts(node.Text())
+			node.ecmaLineMap = lineMap
 		}
 	}
 	return lineMap
@@ -11054,7 +11054,7 @@ func getDeclarationName(declaration *Node) string {
 
 type SourceFileLike interface {
 	Text() string
-	LineMap() []core.TextPos
+	ECMALineMap() []core.TextPos
 }
 
 type CommentRange struct {
diff --git a/internal/astnav/tokens_test.go b/internal/astnav/tokens_test.go
index b2ea39491a..b5eb7ba39f 100644
--- a/internal/astnav/tokens_test.go
+++ b/internal/astnav/tokens_test.go
@@ -240,7 +240,7 @@ func tsGetTouchingPropertyName(t testing.TB, fileText string, positions []int) [
 }
 
 func writeRangeDiff(output *strings.Builder, file *ast.SourceFile, diff tokenDiff, rng core.TextRange, position int) {
-	lines := file.LineMap()
+	lines := file.ECMALineMap()
 
 	tsTokenPos := position
 	goTokenPos := position
diff --git a/internal/checker/grammarchecks.go b/internal/checker/grammarchecks.go
index dc98b20881..ee64d4072b 100644
--- a/internal/checker/grammarchecks.go
+++ b/internal/checker/grammarchecks.go
@@ -814,8 +814,8 @@ func (c *Checker) checkGrammarArrowFunction(node *ast.Node, file *ast.SourceFile
 	}
 
 	equalsGreaterThanToken := arrowFunc.EqualsGreaterThanToken
-	startLine, _ := scanner.GetLineAndCharacterOfPosition(file, equalsGreaterThanToken.Pos())
-	endLine, _ := scanner.GetLineAndCharacterOfPosition(file, equalsGreaterThanToken.End())
+	startLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, equalsGreaterThanToken.Pos())
+	endLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, equalsGreaterThanToken.End())
 	return startLine != endLine && c.grammarErrorOnNode(equalsGreaterThanToken, diagnostics.Line_terminator_not_permitted_before_arrow)
 }
 
diff --git a/internal/compiler/program.go b/internal/compiler/program.go
index 0ae09543f6..b70a00197f 100644
--- a/internal/compiler/program.go
+++ b/internal/compiler/program.go
@@ -1074,10 +1074,10 @@ func (p *Program) getDiagnosticsWithPrecedingDirectives(sourceFile *ast.SourceFi
 	// Build map of directives by line number
 	directivesByLine := make(map[int]ast.CommentDirective)
 	for _, directive := range sourceFile.CommentDirectives {
-		line, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, directive.Loc.Pos())
+		line, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, directive.Loc.Pos())
 		directivesByLine[line] = directive
 	}
-	lineStarts := scanner.GetLineStarts(sourceFile)
+	lineStarts := scanner.GetECMALineStarts(sourceFile)
 	filtered := make([]*ast.Diagnostic, 0, len(diags))
 	for _, diagnostic := range diags {
 		ignoreDiagnostic := false
@@ -1225,7 +1225,7 @@ func (p *Program) getDiagnosticsHelper(ctx context.Context, sourceFile *ast.Sour
 func (p *Program) LineCount() int {
 	var count int
 	for _, file := range p.files {
-		count += len(file.LineMap())
+		count += len(file.ECMALineMap())
 	}
 	return count
 }
diff --git a/internal/core/core.go b/internal/core/core.go
index 45198a0370..6a78811d69 100644
--- a/internal/core/core.go
+++ b/internal/core/core.go
@@ -362,12 +362,12 @@ func Coalesce[T *U, U any](a T, b T) T {
 	}
 }
 
-func ComputeLineStarts(text string) []TextPos {
+func ComputeECMALineStarts(text string) []TextPos {
 	result := make([]TextPos, 0, strings.Count(text, "\n")+1)
-	return slices.AppendSeq(result, ComputeLineStartsSeq(text))
+	return slices.AppendSeq(result, ComputeECMALineStartsSeq(text))
 }
 
-func ComputeLineStartsSeq(text string) iter.Seq[TextPos] {
+func ComputeECMALineStartsSeq(text string) iter.Seq[TextPos] {
 	return func(yield func(TextPos) bool) {
 		textLen := TextPos(len(text))
 		var pos TextPos
diff --git a/internal/diagnosticwriter/diagnosticwriter.go b/internal/diagnosticwriter/diagnosticwriter.go
index b4d879d224..9603935457 100644
--- a/internal/diagnosticwriter/diagnosticwriter.go
+++ b/internal/diagnosticwriter/diagnosticwriter.go
@@ -84,13 +84,13 @@ func FormatDiagnosticWithColorAndContext(output io.Writer, diagnostic *ast.Diagn
 }
 
 func writeCodeSnippet(writer io.Writer, sourceFile *ast.SourceFile, start int, length int, squiggleColor string, indent string, formatOpts *FormattingOptions) {
-	firstLine, firstLineChar := scanner.GetLineAndCharacterOfPosition(sourceFile, start)
-	lastLine, lastLineChar := scanner.GetLineAndCharacterOfPosition(sourceFile, start+length)
+	firstLine, firstLineChar := scanner.GetECMALineAndCharacterOfPosition(sourceFile, start)
+	lastLine, lastLineChar := scanner.GetECMALineAndCharacterOfPosition(sourceFile, start+length)
 	if length == 0 {
 		lastLineChar++ // When length is zero, squiggle the character right after the start position.
 	}
 
-	lastLineOfFile, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, len(sourceFile.Text()))
+	lastLineOfFile, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, len(sourceFile.Text()))
 
 	hasMoreThanFiveLines := lastLine-firstLine >= 4
 	gutterWidth := len(strconv.Itoa(lastLine + 1))
@@ -113,10 +113,10 @@ func writeCodeSnippet(writer io.Writer, sourceFile *ast.SourceFile, start int, l
 			i = lastLine - 1
 		}
 
-		lineStart := scanner.GetPositionOfLineAndCharacter(sourceFile, i, 0)
+		lineStart := scanner.GetECMAPositionOfLineAndCharacter(sourceFile, i, 0)
 		var lineEnd int
 		if i < lastLineOfFile {
-			lineEnd = scanner.GetPositionOfLineAndCharacter(sourceFile, i+1, 0)
+			lineEnd = scanner.GetECMAPositionOfLineAndCharacter(sourceFile, i+1, 0)
 		} else {
 			lineEnd = sourceFile.Loc.End()
 		}
@@ -216,7 +216,7 @@ func writeWithStyleAndReset(output io.Writer, text string, formatStyle string) {
 }
 
 func WriteLocation(output io.Writer, file *ast.SourceFile, pos int, formatOpts *FormattingOptions, writeWithStyleAndReset FormattedWriter) {
-	firstLine, firstChar := scanner.GetLineAndCharacterOfPosition(file, pos)
+	firstLine, firstChar := scanner.GetECMALineAndCharacterOfPosition(file, pos)
 	var relativeFileName string
 	if formatOpts != nil {
 		relativeFileName = tspath.ConvertToRelativePath(file.FileName(), formatOpts.ComparePathsOptions)
@@ -357,7 +357,7 @@ func prettyPathForFileError(file *ast.SourceFile, fileErrors []*ast.Diagnostic,
 	if file == nil || len(fileErrors) == 0 {
 		return ""
 	}
-	line, _ := scanner.GetLineAndCharacterOfPosition(file, fileErrors[0].Loc().Pos())
+	line, _ := scanner.GetECMALineAndCharacterOfPosition(file, fileErrors[0].Loc().Pos())
 	fileName := file.FileName()
 	if tspath.PathIsAbsolute(fileName) && tspath.PathIsAbsolute(formatOpts.CurrentDirectory) {
 		fileName = tspath.ConvertToRelativePath(file.FileName(), formatOpts.ComparePathsOptions)
@@ -378,7 +378,7 @@ func WriteFormatDiagnostics(output io.Writer, diagnostics []*ast.Diagnostic, for
 
 func WriteFormatDiagnostic(output io.Writer, diagnostic *ast.Diagnostic, formatOpts *FormattingOptions) {
 	if diagnostic.File() != nil {
-		line, character := scanner.GetLineAndCharacterOfPosition(diagnostic.File(), diagnostic.Loc().Pos())
+		line, character := scanner.GetECMALineAndCharacterOfPosition(diagnostic.File(), diagnostic.Loc().Pos())
 		fileName := diagnostic.File().FileName()
 		relativeFileName := tspath.ConvertToRelativePath(fileName, formatOpts.ComparePathsOptions)
 		fmt.Fprintf(output, "%s(%d,%d): ", relativeFileName, line+1, character+1)
diff --git a/internal/format/api.go b/internal/format/api.go
index 77be9feece..f9262cd76b 100644
--- a/internal/format/api.go
+++ b/internal/format/api.go
@@ -146,18 +146,18 @@ func FormatOnSemicolon(ctx context.Context, sourceFile *ast.SourceFile, position
 }
 
 func FormatOnEnter(ctx context.Context, sourceFile *ast.SourceFile, position int) []core.TextChange {
-	line, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, position)
+	line, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, position)
 	if line == 0 {
 		return nil
 	}
 	// get start position for the previous line
-	startPos := int(scanner.GetLineStarts(sourceFile)[line-1])
+	startPos := int(scanner.GetECMALineStarts(sourceFile)[line-1])
 	// After the enter key, the cursor is now at a new line. The new line may or may not contain non-whitespace characters.
 	// If the new line has only whitespaces, we won't want to format this line, because that would remove the indentation as
 	// trailing whitespaces. So the end of the formatting span should be the later one between:
 	//  1. the end of the previous line
 	//  2. the last non-whitespace character in the current line
-	endOfFormatSpan := scanner.GetEndLinePosition(sourceFile, line)
+	endOfFormatSpan := scanner.GetECMAEndLinePosition(sourceFile, line)
 	for endOfFormatSpan > startPos {
 		ch, s := utf8.DecodeRuneInString(sourceFile.Text()[endOfFormatSpan:])
 		if s == 0 || stringutil.IsWhiteSpaceSingleLine(ch) { // on multibyte character keep backing up
diff --git a/internal/format/indent.go b/internal/format/indent.go
index 589a160032..ee8649fe7a 100644
--- a/internal/format/indent.go
+++ b/internal/format/indent.go
@@ -13,7 +13,7 @@ import (
 )
 
 func GetIndentationForNode(n *ast.Node, ignoreActualIndentationRange *core.TextRange, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
-	startline, startpos := scanner.GetLineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(n, sourceFile, false))
+	startline, startpos := scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(n, sourceFile, false))
 	return getIndentationForNodeWorker(n, startline, startpos, ignoreActualIndentationRange /*indentationDelta*/, 0, sourceFile /*isNextChild*/, false, options)
 }
 
@@ -100,7 +100,7 @@ func getIndentationForNodeWorker(
 		parent = current.Parent
 
 		if useTrueStart {
-			currentStartLine, currentStartCharacter = scanner.GetLineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(current, sourceFile, false))
+			currentStartLine, currentStartCharacter = scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(current, sourceFile, false))
 		} else {
 			currentStartLine = containingListOrParentStartLine
 			currentStartCharacter = containingListOrParentStartCharacter
@@ -131,7 +131,7 @@ func isArgumentAndStartLineOverlapsExpressionBeingCalled(parent *ast.Node, child
 		return false
 	}
 	expressionOfCallExpressionEnd := parent.Expression().End()
-	expressionOfCallExpressionEndLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, expressionOfCallExpressionEnd)
+	expressionOfCallExpressionEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, expressionOfCallExpressionEnd)
 	return expressionOfCallExpressionEndLine == childStartLine
 }
 
@@ -166,7 +166,7 @@ func getActualIndentationForListStartLine(list *ast.NodeList, sourceFile *ast.So
 	if list == nil {
 		return -1
 	}
-	line, char := scanner.GetLineAndCharacterOfPosition(sourceFile, list.Loc.Pos())
+	line, char := scanner.GetECMALineAndCharacterOfPosition(sourceFile, list.Loc.Pos())
 	return findColumnForFirstNonWhitespaceCharacterInLine(line, char, sourceFile, options)
 }
 
@@ -185,7 +185,7 @@ func deriveActualIndentationFromList(list *ast.NodeList, index int, sourceFile *
 			continue
 		}
 		// skip list items that ends on the same line with the current list element
-		prevEndLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, list.Nodes[i].End())
+		prevEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, list.Nodes[i].End())
 		if prevEndLine != line {
 			return findColumnForFirstNonWhitespaceCharacterInLine(line, char, sourceFile, options)
 		}
@@ -196,7 +196,7 @@ func deriveActualIndentationFromList(list *ast.NodeList, index int, sourceFile *
 }
 
 func findColumnForFirstNonWhitespaceCharacterInLine(line int, char int, sourceFile *ast.SourceFile, options *FormatCodeSettings) int {
-	lineStart := scanner.GetPositionOfLineAndCharacter(sourceFile, line, 0)
+	lineStart := scanner.GetECMAPositionOfLineAndCharacter(sourceFile, line, 0)
 	return FindFirstNonWhitespaceColumn(lineStart, lineStart+char, sourceFile, options)
 }
 
@@ -247,7 +247,7 @@ func childStartsOnTheSameLineWithElseInIfStatement(parent *ast.Node, child *ast.
 }
 
 func getStartLineAndCharacterForNode(n *ast.Node, sourceFile *ast.SourceFile) (line int, character int) {
-	return scanner.GetLineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(n, sourceFile, false))
+	return scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.GetTokenPosOfNode(n, sourceFile, false))
 }
 
 func GetContainingList(node *ast.Node, sourceFile *ast.SourceFile) *ast.NodeList {
@@ -356,7 +356,7 @@ func getContainingListOrParentStart(parent *ast.Node, child *ast.Node, sourceFil
 	} else {
 		startPos = scanner.GetTokenPosOfNode(parent, sourceFile, false)
 	}
-	return scanner.GetLineAndCharacterOfPosition(sourceFile, startPos)
+	return scanner.GetECMALineAndCharacterOfPosition(sourceFile, startPos)
 }
 
 func isControlFlowEndingStatement(kind ast.Kind, parentKind ast.Kind) bool {
@@ -439,8 +439,8 @@ func NodeWillIndentChild(settings *FormatCodeSettings, parent *ast.Node, child *
 			return rangeIsOnOneLine(child.Loc, sourceFile)
 		}
 		if parent.Kind == ast.KindBinaryExpression && sourceFile != nil && childKind == ast.KindJsxElement {
-			parentStartLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, scanner.SkipTrivia(sourceFile.Text(), parent.Pos()))
-			childStartLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, scanner.SkipTrivia(sourceFile.Text(), child.Pos()))
+			parentStartLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.SkipTrivia(sourceFile.Text(), parent.Pos()))
+			childStartLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, scanner.SkipTrivia(sourceFile.Text(), child.Pos()))
 			return parentStartLine != childStartLine
 		}
 		if parent.Kind != ast.KindBinaryExpression {
@@ -516,7 +516,7 @@ func NodeWillIndentChild(settings *FormatCodeSettings, parent *ast.Node, child *
 // branch beginning on the line that the whenTrue branch ends.
 func childIsUnindentedBranchOfConditionalExpression(parent *ast.Node, child *ast.Node, childStartLine int, sourceFile *ast.SourceFile) bool {
 	if parent.Kind == ast.KindConditionalExpression && (child == parent.AsConditionalExpression().WhenTrue || child == parent.AsConditionalExpression().WhenFalse) {
-		conditionEndLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, parent.AsConditionalExpression().Condition.End())
+		conditionEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, parent.AsConditionalExpression().Condition.End())
 		if child == parent.AsConditionalExpression().WhenTrue {
 			return childStartLine == conditionEndLine
 		} else {
@@ -528,7 +528,7 @@ func childIsUnindentedBranchOfConditionalExpression(parent *ast.Node, child *ast
 			//     0              L2: indented two stops, one because whenTrue was indented
 			//   );                   and one because of the parentheses spanning multiple lines
 			trueStartLine, _ := getStartLineAndCharacterForNode(parent.AsConditionalExpression().WhenTrue, sourceFile)
-			trueEndLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, parent.AsConditionalExpression().WhenTrue.End())
+			trueEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, parent.AsConditionalExpression().WhenTrue.End())
 			return conditionEndLine == trueStartLine && trueEndLine == childStartLine
 		}
 	}
@@ -550,7 +550,7 @@ func argumentStartsOnSameLineAsPreviousArgument(parent *ast.Node, child *ast.Nod
 		}
 
 		previousNode := parent.Arguments()[currentIndex-1]
-		lineOfPreviousNode, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, previousNode.End())
+		lineOfPreviousNode, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, previousNode.End())
 		if childStartLine == lineOfPreviousNode {
 			return true
 		}
diff --git a/internal/format/rulecontext.go b/internal/format/rulecontext.go
index 0e57e24d38..7b91c7bfff 100644
--- a/internal/format/rulecontext.go
+++ b/internal/format/rulecontext.go
@@ -584,8 +584,8 @@ func isSemicolonDeletionContext(context *formattingContext) bool {
 		nextTokenStart = scanner.GetTokenPosOfNode(nextRealToken, context.SourceFile, false)
 	}
 
-	startLine, _ := scanner.GetLineAndCharacterOfPosition(context.SourceFile, context.currentTokenSpan.Loc.Pos())
-	endLine, _ := scanner.GetLineAndCharacterOfPosition(context.SourceFile, nextTokenStart)
+	startLine, _ := scanner.GetECMALineAndCharacterOfPosition(context.SourceFile, context.currentTokenSpan.Loc.Pos())
+	endLine, _ := scanner.GetECMALineAndCharacterOfPosition(context.SourceFile, nextTokenStart)
 	if startLine == endLine {
 		return nextTokenKind == ast.KindCloseBraceToken || nextTokenKind == ast.KindEndOfFile
 	}
diff --git a/internal/format/span.go b/internal/format/span.go
index 7276a97ebf..4657949f7e 100644
--- a/internal/format/span.go
+++ b/internal/format/span.go
@@ -85,7 +85,7 @@ func getOwnOrInheritedDelta(n *ast.Node, options *FormatCodeSettings, sourceFile
 	previousLine := -1
 	var child *ast.Node
 	for n != nil {
-		line, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, withTokenStart(n, sourceFile).Pos())
+		line, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, withTokenStart(n, sourceFile).Pos())
 		if previousLine != -1 && line != previousLine {
 			break
 		}
@@ -242,10 +242,10 @@ func (w *formatSpanWorker) execute(s *formattingScanner) []core.TextChange {
 	w.formattingScanner.advance()
 
 	if w.formattingScanner.isOnToken() {
-		startLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, withTokenStart(w.enclosingNode, w.sourceFile).Pos())
+		startLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, withTokenStart(w.enclosingNode, w.sourceFile).Pos())
 		undecoratedStartLine := startLine
 		if ast.HasDecorators(w.enclosingNode) {
-			undecoratedStartLine, _ = scanner.GetLineAndCharacterOfPosition(w.sourceFile, getNonDecoratorTokenPosOfNode(w.enclosingNode, w.sourceFile))
+			undecoratedStartLine, _ = scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, getNonDecoratorTokenPosOfNode(w.enclosingNode, w.sourceFile))
 		}
 
 		w.processNode(w.enclosingNode, w.enclosingNode, startLine, undecoratedStartLine, w.initialIndentation, w.delta)
@@ -262,7 +262,7 @@ func (w *formatSpanWorker) execute(s *formattingScanner) []core.TextChange {
 		}
 
 		w.indentTriviaItems(remainingTrivia, indentation, true, func(item TextRangeWithKind) {
-			startLine, startChar := scanner.GetLineAndCharacterOfPosition(w.sourceFile, item.Loc.Pos())
+			startLine, startChar := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, item.Loc.Pos())
 			w.processRange(item, startLine, startChar, w.enclosingNode, w.enclosingNode, nil)
 			w.insertIndentation(item.Loc.Pos(), indentation, false)
 		})
@@ -305,7 +305,7 @@ func (w *formatSpanWorker) execute(s *formattingScanner) []core.TextChange {
 			if parent == nil {
 				parent = w.previousParent
 			}
-			line, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, tokenInfo.Loc.Pos())
+			line, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, tokenInfo.Loc.Pos())
 			w.processPair(
 				tokenInfo,
 				line,
@@ -343,11 +343,11 @@ func (w *formatSpanWorker) processChildNode(
 	}
 
 	childStartPos := scanner.GetTokenPosOfNode(child, w.sourceFile, false)
-	childStartLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, childStartPos)
+	childStartLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, childStartPos)
 
 	undecoratedChildStartLine := childStartLine
 	if ast.HasDecorators(child) {
-		undecoratedChildStartLine, _ = scanner.GetLineAndCharacterOfPosition(w.sourceFile, getNonDecoratorTokenPosOfNode(child, w.sourceFile))
+		undecoratedChildStartLine, _ = scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, getNonDecoratorTokenPosOfNode(child, w.sourceFile))
 	}
 
 	// if child is a list item - try to get its indentation, only if parent is within the original range.
@@ -457,7 +457,7 @@ func (w *formatSpanWorker) processChildNodes(
 				break
 			} else if tokenInfo.token.Kind == listStartToken {
 				// consume list start token
-				startLine, _ = scanner.GetLineAndCharacterOfPosition(w.sourceFile, tokenInfo.token.Loc.Pos())
+				startLine, _ = scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, tokenInfo.token.Loc.Pos())
 
 				w.consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation, parent, false)
 
@@ -578,7 +578,7 @@ func (w *formatSpanWorker) tryComputeIndentationForListItem(startPos int, endPos
 			return inheritedIndentation
 		}
 	} else {
-		startLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, startPos)
+		startLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, startPos)
 		startLinePosition := GetLineStartPositionForPosition(startPos, w.sourceFile)
 		column := FindFirstNonWhitespaceColumn(startLinePosition, startPos, w.sourceFile, w.formattingContext.Options)
 		if startLine != parentStartLine || startPos == column {
@@ -747,7 +747,7 @@ func (w *formatSpanWorker) processRange(r TextRangeWithKind, rangeStartLine int,
 	if !rangeHasError {
 		if w.previousRange == NewTextRangeWithKind(0, 0, 0) {
 			// trim whitespaces starting from the beginning of the span up to the current line
-			originalStartLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, w.originalRange.Pos())
+			originalStartLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, w.originalRange.Pos())
 			w.trimTrailingWhitespacesForLines(originalStartLine, rangeStartLine, NewTextRangeWithKind(0, 0, 0))
 		} else {
 			lineAction = w.processPair(r, rangeStartLine, parent, w.previousRange, w.previousRangeStartLine, w.previousParent, contextNode, dynamicIndentation)
@@ -765,7 +765,7 @@ func (w *formatSpanWorker) processRange(r TextRangeWithKind, rangeStartLine int,
 func (w *formatSpanWorker) processTrivia(trivia []TextRangeWithKind, parent *ast.Node, contextNode *ast.Node, dynamicIndentation *dynamicIndenter) {
 	for _, triviaItem := range trivia {
 		if isComment(triviaItem.Kind) && triviaItem.Loc.ContainedBy(w.originalRange) {
-			triviaItemStartLine, triviaItemStartCharacter := scanner.GetLineAndCharacterOfPosition(w.sourceFile, triviaItem.Loc.Pos())
+			triviaItemStartLine, triviaItemStartCharacter := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, triviaItem.Loc.Pos())
 			w.processRange(triviaItem, triviaItemStartLine, triviaItemStartCharacter, parent, contextNode, dynamicIndentation)
 		}
 	}
@@ -797,17 +797,17 @@ func (w *formatSpanWorker) trimTrailingWhitespacesForRemainingRange(trivias []Te
 }
 
 func (w *formatSpanWorker) trimTrailingWitespacesForPositions(startPos int, endPos int, previousRange TextRangeWithKind) {
-	startLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, startPos)
-	endLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, endPos)
+	startLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, startPos)
+	endLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, endPos)
 
 	w.trimTrailingWhitespacesForLines(startLine, endLine+1, previousRange)
 }
 
 func (w *formatSpanWorker) trimTrailingWhitespacesForLines(line1 int, line2 int, r TextRangeWithKind) {
-	lineStarts := scanner.GetLineStarts(w.sourceFile)
+	lineStarts := scanner.GetECMALineStarts(w.sourceFile)
 	for line := line1; line < line2; line++ {
 		lineStartPosition := int(lineStarts[line])
-		lineEndPosition := scanner.GetEndLinePosition(w.sourceFile, line)
+		lineEndPosition := scanner.GetECMAEndLinePosition(w.sourceFile, line)
 
 		// do not trim whitespaces in comments or template expression
 		if r != NewTextRangeWithKind(0, 0, 0) && (isComment(r.Kind) || isStringOrRegularExpressionOrTemplateLiteral(r.Kind)) && r.Loc.Pos() <= lineEndPosition && r.Loc.End() > lineEndPosition {
@@ -862,8 +862,8 @@ func (w *formatSpanWorker) insertIndentation(pos int, indentation int, lineAdded
 		// insert indentation string at the very beginning of the token
 		w.recordReplace(pos, 0, indentationString)
 	} else {
-		tokenStartLine, tokenStartCharacter := scanner.GetLineAndCharacterOfPosition(w.sourceFile, pos)
-		startLinePosition := int(scanner.GetLineStarts(w.sourceFile)[tokenStartLine])
+		tokenStartLine, tokenStartCharacter := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, pos)
+		startLinePosition := int(scanner.GetECMALineStarts(w.sourceFile)[tokenStartLine])
 		if indentation != w.characterToColumn(startLinePosition, tokenStartCharacter) || w.indentationIsDifferent(indentationString, startLinePosition) {
 			w.recordReplace(startLinePosition, tokenStartCharacter, indentationString)
 		}
@@ -909,8 +909,8 @@ func (w *formatSpanWorker) indentTriviaItems(trivia []TextRangeWithKind, comment
 
 func (w *formatSpanWorker) indentMultilineComment(commentRange core.TextRange, indentation int, firstLineIsIndented bool, indentFinalLine bool) {
 	// split comment in lines
-	startLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, commentRange.Pos())
-	endLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, commentRange.End())
+	startLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, commentRange.Pos())
+	endLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, commentRange.End())
 
 	if startLine == endLine {
 		if !firstLineIsIndented {
@@ -923,9 +923,9 @@ func (w *formatSpanWorker) indentMultilineComment(commentRange core.TextRange, i
 	parts := make([]core.TextRange, 0, strings.Count(w.sourceFile.Text()[commentRange.Pos():commentRange.End()], "\n"))
 	startPos := commentRange.Pos()
 	for line := startLine; line < endLine; line++ {
-		endOfLine := scanner.GetEndLinePosition(w.sourceFile, line)
+		endOfLine := scanner.GetECMAEndLinePosition(w.sourceFile, line)
 		parts = append(parts, core.NewTextRange(startPos, endOfLine))
-		startPos = int(scanner.GetLineStarts(w.sourceFile)[line+1])
+		startPos = int(scanner.GetECMALineStarts(w.sourceFile)[line+1])
 	}
 
 	if indentFinalLine {
@@ -936,7 +936,7 @@ func (w *formatSpanWorker) indentMultilineComment(commentRange core.TextRange, i
 		return
 	}
 
-	startLinePos := int(scanner.GetLineStarts(w.sourceFile)[startLine])
+	startLinePos := int(scanner.GetECMALineStarts(w.sourceFile)[startLine])
 
 	nonWhitespaceInFirstPartCharacter, nonWhitespaceInFirstPartColumn := findFirstNonWhitespaceCharacterAndColumn(startLinePos, parts[0].Pos(), w.sourceFile, w.formattingContext.Options)
 
@@ -950,7 +950,7 @@ func (w *formatSpanWorker) indentMultilineComment(commentRange core.TextRange, i
 	// shift all parts on the delta size
 	delta := indentation - nonWhitespaceInFirstPartColumn
 	for i := startIndex; i < len(parts); i++ {
-		startLinePos := int(scanner.GetLineStarts(w.sourceFile)[startLine])
+		startLinePos := int(scanner.GetECMALineStarts(w.sourceFile)[startLine])
 		nonWhitespaceCharacter := nonWhitespaceInFirstPartCharacter
 		nonWhitespaceColumn := nonWhitespaceInFirstPartColumn
 		if i != 0 {
@@ -1021,7 +1021,7 @@ func (w *formatSpanWorker) consumeTokenAndAdvanceScanner(currentTokenInfo tokenI
 	lineAction := LineActionNone
 	isTokenInRange := currentTokenInfo.token.Loc.ContainedBy(w.originalRange)
 
-	tokenStartLine, tokenStartChar := scanner.GetLineAndCharacterOfPosition(w.sourceFile, currentTokenInfo.token.Loc.Pos())
+	tokenStartLine, tokenStartChar := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, currentTokenInfo.token.Loc.Pos())
 
 	if isTokenInRange {
 		rangeHasError := w.rangeContainsError(currentTokenInfo.token.Loc)
@@ -1033,7 +1033,7 @@ func (w *formatSpanWorker) consumeTokenAndAdvanceScanner(currentTokenInfo tokenI
 			if lineAction == LineActionNone {
 				// indent token only if end line of previous range does not match start line of the token
 				if savePreviousRange != NewTextRangeWithKind(0, 0, 0) {
-					prevEndLine, _ := scanner.GetLineAndCharacterOfPosition(w.sourceFile, savePreviousRange.Loc.End())
+					prevEndLine, _ := scanner.GetECMALineAndCharacterOfPosition(w.sourceFile, savePreviousRange.Loc.End())
 					indentToken = lastTriviaWasNewLine && tokenStartLine != prevEndLine
 				}
 			} else {
diff --git a/internal/format/util.go b/internal/format/util.go
index 4cce2ed250..0bf8bc7048 100644
--- a/internal/format/util.go
+++ b/internal/format/util.go
@@ -10,8 +10,8 @@ import (
 )
 
 func rangeIsOnOneLine(node core.TextRange, file *ast.SourceFile) bool {
-	startLine, _ := scanner.GetLineAndCharacterOfPosition(file, node.Pos())
-	endLine, _ := scanner.GetLineAndCharacterOfPosition(file, node.End())
+	startLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, node.Pos())
+	endLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, node.End())
 	return startLine == endLine
 }
 
@@ -76,8 +76,8 @@ func getCloseTokenForOpenToken(kind ast.Kind) ast.Kind {
 }
 
 func GetLineStartPositionForPosition(position int, sourceFile *ast.SourceFile) int {
-	lineStarts := scanner.GetLineStarts(sourceFile)
-	line, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, position)
+	lineStarts := scanner.GetECMALineStarts(sourceFile)
+	line, _ := scanner.GetECMALineAndCharacterOfPosition(sourceFile, position)
 	return int(lineStarts[line])
 }
 
diff --git a/internal/fourslash/baselineutil.go b/internal/fourslash/baselineutil.go
index fcfbaca77c..83e683b1d4 100644
--- a/internal/fourslash/baselineutil.go
+++ b/internal/fourslash/baselineutil.go
@@ -357,7 +357,7 @@ type textWithContext struct {
 	isLibFile  bool
 	fileName   string
 	content    string // content of the original file
-	lineStarts *ls.LineMap
+	lineStarts *ls.LSPLineMap
 	converters *ls.Converters
 
 	// posLineInfo
@@ -386,10 +386,10 @@ func newTextWithContext(fileName string, content string) *textWithContext {
 		pos:        lsproto.Position{Line: 0, Character: 0},
 		fileName:   fileName,
 		content:    content,
-		lineStarts: ls.ComputeLineStarts(content),
+		lineStarts: ls.ComputeLSPLineStarts(content),
 	}
 
-	t.converters = ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(_ string) *ls.LineMap {
+	t.converters = ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(_ string) *ls.LSPLineMap {
 		return t.lineStarts
 	})
 	t.readableContents.WriteString("// === " + fileName + " ===")
diff --git a/internal/fourslash/fourslash.go b/internal/fourslash/fourslash.go
index 2fff230f31..6b9e932aad 100644
--- a/internal/fourslash/fourslash.go
+++ b/internal/fourslash/fourslash.go
@@ -51,7 +51,7 @@ type FourslashTest struct {
 type scriptInfo struct {
 	fileName string
 	content  string
-	lineMap  *ls.LineMap
+	lineMap  *ls.LSPLineMap
 	version  int32
 }
 
@@ -59,14 +59,14 @@ func newScriptInfo(fileName string, content string) *scriptInfo {
 	return &scriptInfo{
 		fileName: fileName,
 		content:  content,
-		lineMap:  ls.ComputeLineStarts(content),
+		lineMap:  ls.ComputeLSPLineStarts(content),
 		version:  1,
 	}
 }
 
 func (s *scriptInfo) editContent(start int, end int, newText string) {
 	s.content = s.content[:start] + newText + s.content[end:]
-	s.lineMap = ls.ComputeLineStarts(s.content)
+	s.lineMap = ls.ComputeLSPLineStarts(s.content)
 	s.version++
 }
 
@@ -170,7 +170,7 @@ func NewFourslash(t *testing.T, capabilities *lsproto.ClientCapabilities, conten
 		}
 	}()
 
-	converters := ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(fileName string) *ls.LineMap {
+	converters := ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(fileName string) *ls.LSPLineMap {
 		scriptInfo, ok := scriptInfos[fileName]
 		if !ok {
 			return nil
@@ -1484,7 +1484,7 @@ func (f *FourslashTest) BaselineAutoImportsCompletions(t *testing.T, markerNames
 		)))
 
 		currentFile := newScriptInfo(f.activeFilename, fileContent)
-		converters := ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(_ string) *ls.LineMap {
+		converters := ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(_ string) *ls.LSPLineMap {
 			return currentFile.lineMap
 		})
 		var list []*lsproto.CompletionItem
diff --git a/internal/fourslash/test_parser.go b/internal/fourslash/test_parser.go
index 346a5eb811..da8de6fc79 100644
--- a/internal/fourslash/test_parser.go
+++ b/internal/fourslash/test_parser.go
@@ -368,8 +368,8 @@ func parseFileContent(fileName string, content string, fileOptions map[string]st
 
 	outputString := output.String()
 	// Set LS positions for markers
-	lineMap := ls.ComputeLineStarts(outputString)
-	converters := ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(_ string) *ls.LineMap {
+	lineMap := ls.ComputeLSPLineStarts(outputString)
+	converters := ls.NewConverters(lsproto.PositionEncodingKindUTF8, func(_ string) *ls.LSPLineMap {
 		return lineMap
 	})
 
diff --git a/internal/ls/changetrackerimpl.go b/internal/ls/changetrackerimpl.go
index 39e073fad3..e8f3d13e69 100644
--- a/internal/ls/changetrackerimpl.go
+++ b/internal/ls/changetrackerimpl.go
@@ -204,7 +204,7 @@ func (ct *changeTracker) getAdjustedStartPosition(sourceFile *ast.SourceFile, no
 	if fullStart == start {
 		return start
 	}
-	lineStarts := sourceFile.LineMap()
+	lineStarts := sourceFile.ECMALineMap()
 	fullStartLineIndex := scanner.ComputeLineOfPosition(lineStarts, fullStart)
 	fullStartLinePos := int(lineStarts[fullStartLineIndex])
 	if startOfLinePos == fullStartLinePos {
@@ -249,7 +249,7 @@ func (ct *changeTracker) getEndPositionOfMultilineTrailingComment(sourceFile *as
 	if trailingOpt == trailingTriviaOptionInclude {
 		// If the trailing comment is a multiline comment that extends to the next lines,
 		// return the end of the comment and track it for the next nodes to adjust.
-		lineStarts := sourceFile.LineMap()
+		lineStarts := sourceFile.ECMALineMap()
 		nodeEndLine := scanner.ComputeLineOfPosition(lineStarts, node.End())
 		for comment := range scanner.GetTrailingCommentRanges(ct.NodeFactory, sourceFile.Text(), node.End()) {
 			// Single line can break the loop as trivia will only be this line.
@@ -363,7 +363,7 @@ func (ct *changeTracker) getInsertionPositionAtSourceFileTop(sourceFile *ast.Sou
 	firstNodeLine := -1
 
 	lenStatements := len(sourceFile.Statements.Nodes)
-	lineMap := sourceFile.LineMap()
+	lineMap := sourceFile.ECMALineMap()
 	for _, r := range ranges {
 		if r.Kind == ast.KindMultiLineCommentTrivia {
 			if printer.IsPinnedComment(text, r) {
diff --git a/internal/ls/completions.go b/internal/ls/completions.go
index 9a1dc9836d..6966553a1e 100644
--- a/internal/ls/completions.go
+++ b/internal/ls/completions.go
@@ -2541,13 +2541,13 @@ func jsxAttributeCompletionStyleIs(preferenceStyle *JsxAttributeCompletionStyle,
 }
 
 func getLineOfPosition(file *ast.SourceFile, pos int) int {
-	line, _ := scanner.GetLineAndCharacterOfPosition(file, pos)
+	line, _ := scanner.GetECMALineAndCharacterOfPosition(file, pos)
 	return line
 }
 
 func getLineEndOfPosition(file *ast.SourceFile, pos int) int {
 	line := getLineOfPosition(file, pos)
-	lineStarts := scanner.GetLineStarts(file)
+	lineStarts := scanner.GetECMALineStarts(file)
 	var lastCharPos int
 	if line+1 >= len(lineStarts) {
 		lastCharPos = file.End()
@@ -3532,8 +3532,8 @@ func getContextualKeywords(file *ast.SourceFile, contextToken *ast.Node, positio
 	// Source: https://tc39.es/proposal-import-assertions/
 	if contextToken != nil {
 		parent := contextToken.Parent
-		tokenLine, _ := scanner.GetLineAndCharacterOfPosition(file, contextToken.End())
-		currentLine, _ := scanner.GetLineAndCharacterOfPosition(file, position)
+		tokenLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, contextToken.End())
+		currentLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, position)
 		if (ast.IsImportDeclaration(parent) ||
 			ast.IsExportDeclaration(parent) && parent.AsExportDeclaration().ModuleSpecifier != nil) &&
 			contextToken == parent.ModuleSpecifier() &&
diff --git a/internal/ls/converters.go b/internal/ls/converters.go
index af16188501..b7730f3e5d 100644
--- a/internal/ls/converters.go
+++ b/internal/ls/converters.go
@@ -14,7 +14,7 @@ import (
 )
 
 type Converters struct {
-	getLineMap       func(fileName string) *LineMap
+	getLineMap       func(fileName string) *LSPLineMap
 	positionEncoding lsproto.PositionEncodingKind
 }
 
@@ -23,7 +23,7 @@ type Script interface {
 	Text() string
 }
 
-func NewConverters(positionEncoding lsproto.PositionEncodingKind, getLineMap func(fileName string) *LineMap) *Converters {
+func NewConverters(positionEncoding lsproto.PositionEncodingKind, getLineMap func(fileName string) *LSPLineMap) *Converters {
 	return &Converters{
 		getLineMap:       getLineMap,
 		positionEncoding: positionEncoding,
diff --git a/internal/ls/linemap.go b/internal/ls/linemap.go
index 612eca39d0..1c2c05518e 100644
--- a/internal/ls/linemap.go
+++ b/internal/ls/linemap.go
@@ -9,12 +9,12 @@ import (
 	"github.com/microsoft/typescript-go/internal/core"
 )
 
-type LineMap struct {
+type LSPLineMap struct {
 	LineStarts []core.TextPos
 	AsciiOnly  bool // TODO(jakebailey): collect ascii-only info per line
 }
 
-func ComputeLineStarts(text string) *LineMap {
+func ComputeLSPLineStarts(text string) *LSPLineMap {
 	// This is like core.ComputeLineStarts, but only considers "\n", "\r", and "\r\n" as line breaks,
 	// and reports when the text is ASCII-only.
 	lineStarts := make([]core.TextPos, 0, strings.Count(text, "\n")+1)
@@ -45,13 +45,13 @@ func ComputeLineStarts(text string) *LineMap {
 	}
 	lineStarts = append(lineStarts, lineStart)
 
-	return &LineMap{
+	return &LSPLineMap{
 		LineStarts: lineStarts,
 		AsciiOnly:  asciiOnly,
 	}
 }
 
-func (lm *LineMap) ComputeIndexOfLineStart(targetPos core.TextPos) int {
+func (lm *LSPLineMap) ComputeIndexOfLineStart(targetPos core.TextPos) int {
 	// port of computeLineOfPosition(lineStarts: readonly number[], position: number, lowerBound?: number): number {
 	lineNumber, ok := slices.BinarySearchFunc(lm.LineStarts, targetPos, func(p, t core.TextPos) int {
 		return cmp.Compare(int(p), int(t))
diff --git a/internal/ls/utilities.go b/internal/ls/utilities.go
index 0610524c7b..d0078ba56d 100644
--- a/internal/ls/utilities.go
+++ b/internal/ls/utilities.go
@@ -490,10 +490,10 @@ func probablyUsesSemicolons(file *ast.SourceFile) bool {
 			if lastToken != nil && lastToken.Kind == ast.KindSemicolonToken {
 				withSemicolon++
 			} else if lastToken != nil && lastToken.Kind != ast.KindCommaToken {
-				lastTokenLine, _ := scanner.GetLineAndCharacterOfPosition(
+				lastTokenLine, _ := scanner.GetECMALineAndCharacterOfPosition(
 					file,
 					astnav.GetStartOfNode(lastToken, file, false /*includeJSDoc*/))
-				nextTokenLine, _ := scanner.GetLineAndCharacterOfPosition(
+				nextTokenLine, _ := scanner.GetECMALineAndCharacterOfPosition(
 					file,
 					scanner.GetRangeOfTokenAtPosition(file, lastToken.End()).Pos())
 				// Avoid counting missing semicolon in single-line objects:
diff --git a/internal/lsutil/asi.go b/internal/lsutil/asi.go
index 08456f2739..0cea3e6d4d 100644
--- a/internal/lsutil/asi.go
+++ b/internal/lsutil/asi.go
@@ -98,7 +98,7 @@ func NodeIsASICandidate(node *ast.Node, file *ast.SourceFile) bool {
 		return true
 	}
 
-	startLine, _ := scanner.GetLineAndCharacterOfPosition(file, node.End())
-	endLine, _ := scanner.GetLineAndCharacterOfPosition(file, astnav.GetStartOfNode(nextToken, file, false /*includeJSDoc*/))
+	startLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, node.End())
+	endLine, _ := scanner.GetECMALineAndCharacterOfPosition(file, astnav.GetStartOfNode(nextToken, file, false /*includeJSDoc*/))
 	return startLine != endLine
 }
diff --git a/internal/printer/printer.go b/internal/printer/printer.go
index c98583b6cc..f9581f9e10 100644
--- a/internal/printer/printer.go
+++ b/internal/printer/printer.go
@@ -629,7 +629,7 @@ func (p *Printer) writeCommentRange(comment ast.CommentRange) {
 	}
 
 	text := p.currentSourceFile.Text()
-	lineMap := p.currentSourceFile.LineMap()
+	lineMap := p.currentSourceFile.ECMALineMap()
 	p.writeCommentRangeWorker(text, lineMap, comment.Kind, comment.TextRange)
 }
 
@@ -5227,7 +5227,7 @@ func (p *Printer) writeSynthesizedComment(comment SynthesizedComment) {
 	text := formatSynthesizedComment(comment)
 	var lineMap []core.TextPos
 	if comment.Kind == ast.KindMultiLineCommentTrivia {
-		lineMap = core.ComputeLineStarts(text)
+		lineMap = core.ComputeECMALineStarts(text)
 	}
 	p.writeCommentRangeWorker(text, lineMap, comment.Kind, core.NewTextRange(0, len(text)))
 }
@@ -5294,7 +5294,7 @@ func (p *Printer) shouldEmitNewLineBeforeLeadingCommentOfPosition(pos int, comme
 	// If the leading comments start on different line than the start of node, write new line
 	return p.currentSourceFile != nil &&
 		pos != commentPos &&
-		scanner.ComputeLineOfPosition(p.currentSourceFile.LineMap(), pos) != scanner.ComputeLineOfPosition(p.currentSourceFile.LineMap(), commentPos)
+		scanner.ComputeLineOfPosition(p.currentSourceFile.ECMALineMap(), pos) != scanner.ComputeLineOfPosition(p.currentSourceFile.ECMALineMap(), commentPos)
 }
 
 func (p *Printer) emitTrailingComments(pos int, commentSeparator commentSeparator) {
@@ -5329,7 +5329,7 @@ func (p *Printer) emitDetachedComments(textRange core.TextRange) (result detache
 	}
 
 	text := p.currentSourceFile.Text()
-	lineMap := p.currentSourceFile.LineMap()
+	lineMap := p.currentSourceFile.ECMALineMap()
 
 	var leadingComments []ast.CommentRange
 	if p.commentsDisabled {
@@ -5482,7 +5482,7 @@ func (p *Printer) emitPos(pos int) {
 		return
 	}
 
-	sourceLine, sourceCharacter := scanner.GetLineAndCharacterOfPosition(p.sourceMapSource, pos)
+	sourceLine, sourceCharacter := scanner.GetECMALineAndCharacterOfPosition(p.sourceMapSource, pos)
 	if err := p.sourceMapGenerator.AddSourceMapping(
 		p.writer.GetLine(),
 		p.writer.GetColumn(),
diff --git a/internal/printer/textwriter.go b/internal/printer/textwriter.go
index f36742e0a5..6b1bd0252f 100644
--- a/internal/printer/textwriter.go
+++ b/internal/printer/textwriter.go
@@ -89,7 +89,7 @@ func (w *textWriter) updateLineCountAndPosFor(s string) {
 	var count int
 	var lastLineStart core.TextPos
 
-	for lineStart := range core.ComputeLineStartsSeq(s) {
+	for lineStart := range core.ComputeECMALineStartsSeq(s) {
 		count++
 		lastLineStart = lineStart
 	}
diff --git a/internal/printer/utilities.go b/internal/printer/utilities.go
index 0b28e865ab..41f20efb10 100644
--- a/internal/printer/utilities.go
+++ b/internal/printer/utilities.go
@@ -369,7 +369,7 @@ func GetLinesBetweenPositions(sourceFile *ast.SourceFile, pos1 int, pos2 int) in
 	if pos1 == pos2 {
 		return 0
 	}
-	lineStarts := scanner.GetLineStarts(sourceFile)
+	lineStarts := scanner.GetECMALineStarts(sourceFile)
 	lower := core.IfElse(pos1 < pos2, pos1, pos2)
 	isNegative := lower == pos2
 	upper := core.IfElse(isNegative, pos1, pos2)
diff --git a/internal/project/compilerhost.go b/internal/project/compilerhost.go
index 36cf2dfc4c..d58b3522b8 100644
--- a/internal/project/compilerhost.go
+++ b/internal/project/compilerhost.go
@@ -6,7 +6,6 @@ import (
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/compiler"
-	"github.com/microsoft/typescript-go/internal/ls"
 	"github.com/microsoft/typescript-go/internal/project/logging"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
 	"github.com/microsoft/typescript-go/internal/tspath"
@@ -131,13 +130,6 @@ func (c *compilerHost) GetSourceFile(opts ast.SourceFileParseOptions) *ast.Sourc
 	return nil
 }
 
-func (c *compilerHost) GetLineMap(fileName string) *ls.LineMap {
-	if fh := c.compilerFS.source.GetFile(fileName); fh != nil {
-		return fh.LineMap()
-	}
-	return nil
-}
-
 // Trace implements compiler.CompilerHost.
 func (c *compilerHost) Trace(msg string) {
 	panic("unimplemented")
diff --git a/internal/project/overlayfs.go b/internal/project/overlayfs.go
index a59e1a74d6..37cb1ae498 100644
--- a/internal/project/overlayfs.go
+++ b/internal/project/overlayfs.go
@@ -23,7 +23,7 @@ type FileHandle interface {
 	Version() int32
 	MatchesDiskText() bool
 	IsOverlay() bool
-	LineMap() *ls.LineMap
+	LSPLineMap() *ls.LSPLineMap
 	Kind() core.ScriptKind
 }
 
@@ -33,7 +33,7 @@ type fileBase struct {
 	hash     xxh3.Uint128
 
 	lineMapOnce sync.Once
-	lineMap     *ls.LineMap
+	lineMap     *ls.LSPLineMap
 }
 
 func (f *fileBase) FileName() string {
@@ -48,9 +48,9 @@ func (f *fileBase) Content() string {
 	return f.content
 }
 
-func (f *fileBase) LineMap() *ls.LineMap {
+func (f *fileBase) LSPLineMap() *ls.LSPLineMap {
 	f.lineMapOnce.Do(func() {
-		f.lineMap = ls.ComputeLineStarts(f.content)
+		f.lineMap = ls.ComputeLSPLineStarts(f.content)
 	})
 	return f.lineMap
 }
@@ -318,8 +318,8 @@ func (fs *overlayFS) processChanges(changes []FileChange) (FileChangeSummary, ma
 				panic("overlay not found for changed file: " + uri)
 			}
 			for _, change := range events.changes {
-				converters := ls.NewConverters(fs.positionEncoding, func(fileName string) *ls.LineMap {
-					return o.LineMap()
+				converters := ls.NewConverters(fs.positionEncoding, func(fileName string) *ls.LSPLineMap {
+					return o.LSPLineMap()
 				})
 				for _, textChange := range change.Changes {
 					if partialChange := textChange.Partial; partialChange != nil {
diff --git a/internal/project/snapshot.go b/internal/project/snapshot.go
index b5d7d1722e..e53f113df8 100644
--- a/internal/project/snapshot.go
+++ b/internal/project/snapshot.go
@@ -59,7 +59,7 @@ func NewSnapshot(
 		ProjectCollection:                  &ProjectCollection{toPath: toPath},
 		compilerOptionsForInferredProjects: compilerOptionsForInferredProjects,
 	}
-	s.converters = ls.NewConverters(s.sessionOptions.PositionEncoding, s.LineMap)
+	s.converters = ls.NewConverters(s.sessionOptions.PositionEncoding, s.LSPLineMap)
 	s.refCount.Store(1)
 	return s
 }
@@ -74,9 +74,9 @@ func (s *Snapshot) GetFile(fileName string) FileHandle {
 	return s.fs.GetFile(fileName)
 }
 
-func (s *Snapshot) LineMap(fileName string) *ls.LineMap {
+func (s *Snapshot) LSPLineMap(fileName string) *ls.LSPLineMap {
 	if file := s.fs.GetFile(fileName); file != nil {
-		return file.LineMap()
+		return file.LSPLineMap()
 	}
 	return nil
 }
diff --git a/internal/scanner/scanner.go b/internal/scanner/scanner.go
index ede9405f83..90ef2f1aef 100644
--- a/internal/scanner/scanner.go
+++ b/internal/scanner/scanner.go
@@ -2331,12 +2331,12 @@ func getErrorRangeForArrowFunction(sourceFile *ast.SourceFile, node *ast.Node) c
 	pos := SkipTrivia(sourceFile.Text(), node.Pos())
 	body := node.AsArrowFunction().Body
 	if body != nil && body.Kind == ast.KindBlock {
-		startLine, _ := GetLineAndCharacterOfPosition(sourceFile, body.Pos())
-		endLine, _ := GetLineAndCharacterOfPosition(sourceFile, body.End())
+		startLine, _ := GetECMALineAndCharacterOfPosition(sourceFile, body.Pos())
+		endLine, _ := GetECMALineAndCharacterOfPosition(sourceFile, body.End())
 		if startLine < endLine {
 			// The arrow function spans multiple lines,
 			// make the error span be the first line, inclusive.
-			return core.NewTextRange(pos, GetEndLinePosition(sourceFile, startLine))
+			return core.NewTextRange(pos, GetECMAEndLinePosition(sourceFile, startLine))
 		}
 	}
 	return core.NewTextRange(pos, node.End())
@@ -2424,19 +2424,19 @@ func ComputeLineOfPosition(lineStarts []core.TextPos, pos int) int {
 	return low - 1
 }
 
-func GetLineStarts(sourceFile ast.SourceFileLike) []core.TextPos {
-	return sourceFile.LineMap()
+func GetECMALineStarts(sourceFile ast.SourceFileLike) []core.TextPos {
+	return sourceFile.ECMALineMap()
 }
 
-func GetLineAndCharacterOfPosition(sourceFile ast.SourceFileLike, pos int) (line int, character int) {
-	lineMap := GetLineStarts(sourceFile)
+func GetECMALineAndCharacterOfPosition(sourceFile ast.SourceFileLike, pos int) (line int, character int) {
+	lineMap := GetECMALineStarts(sourceFile)
 	line = ComputeLineOfPosition(lineMap, pos)
 	character = utf8.RuneCountInString(sourceFile.Text()[lineMap[line]:pos])
 	return line, character
 }
 
-func GetEndLinePosition(sourceFile *ast.SourceFile, line int) int {
-	pos := int(GetLineStarts(sourceFile)[line])
+func GetECMAEndLinePosition(sourceFile *ast.SourceFile, line int) int {
+	pos := int(GetECMALineStarts(sourceFile)[line])
 	for {
 		ch, size := utf8.DecodeRuneInString(sourceFile.Text()[pos:])
 		if size == 0 || stringutil.IsLineBreak(ch) {
@@ -2446,8 +2446,8 @@ func GetEndLinePosition(sourceFile *ast.SourceFile, line int) int {
 	}
 }
 
-func GetPositionOfLineAndCharacter(sourceFile *ast.SourceFile, line int, character int) int {
-	return ComputePositionOfLineAndCharacter(GetLineStarts(sourceFile), line, character)
+func GetECMAPositionOfLineAndCharacter(sourceFile *ast.SourceFile, line int, character int) int {
+	return ComputePositionOfLineAndCharacter(GetECMALineStarts(sourceFile), line, character)
 }
 
 func ComputePositionOfLineAndCharacter(lineStarts []core.TextPos, line int, character int) int {
diff --git a/internal/sourcemap/lineinfo.go b/internal/sourcemap/lineinfo.go
index 6baf74788e..f3dee2cab1 100644
--- a/internal/sourcemap/lineinfo.go
+++ b/internal/sourcemap/lineinfo.go
@@ -2,23 +2,23 @@ package sourcemap
 
 import "github.com/microsoft/typescript-go/internal/core"
 
-type LineInfo struct {
+type ECMALineInfo struct {
 	text       string
 	lineStarts []core.TextPos
 }
 
-func GetLineInfo(text string, lineStarts []core.TextPos) *LineInfo {
-	return &LineInfo{
+func GetECMALineInfo(text string, lineStarts []core.TextPos) *ECMALineInfo {
+	return &ECMALineInfo{
 		text:       text,
 		lineStarts: lineStarts,
 	}
 }
 
-func (li *LineInfo) LineCount() int {
+func (li *ECMALineInfo) LineCount() int {
 	return len(li.lineStarts)
 }
 
-func (li *LineInfo) LineText(line int) string {
+func (li *ECMALineInfo) LineText(line int) string {
 	pos := li.lineStarts[line]
 	var end core.TextPos
 	if line+1 < len(li.lineStarts) {
diff --git a/internal/sourcemap/source.go b/internal/sourcemap/source.go
index bbc6c7b983..e781e7b874 100644
--- a/internal/sourcemap/source.go
+++ b/internal/sourcemap/source.go
@@ -5,5 +5,5 @@ import "github.com/microsoft/typescript-go/internal/core"
 type Source interface {
 	Text() string
 	FileName() string
-	LineMap() []core.TextPos
+	ECMALineMap() []core.TextPos
 }
diff --git a/internal/sourcemap/util.go b/internal/sourcemap/util.go
index 4ee874ca7a..c36003eec4 100644
--- a/internal/sourcemap/util.go
+++ b/internal/sourcemap/util.go
@@ -8,7 +8,7 @@ import (
 )
 
 // Tries to find the sourceMappingURL comment at the end of a file.
-func TryGetSourceMappingURL(lineInfo *LineInfo) string {
+func TryGetSourceMappingURL(lineInfo *ECMALineInfo) string {
 	for index := lineInfo.LineCount() - 1; index >= 0; index-- {
 		line := lineInfo.LineText(index)
 		line = strings.TrimLeftFunc(line, unicode.IsSpace)
diff --git a/internal/testutil/harnessutil/sourcemap_recorder.go b/internal/testutil/harnessutil/sourcemap_recorder.go
index 48cdf024c6..d5d6521673 100644
--- a/internal/testutil/harnessutil/sourcemap_recorder.go
+++ b/internal/testutil/harnessutil/sourcemap_recorder.go
@@ -94,7 +94,7 @@ func newSourceMapSpanWriter(sourceMapRecorder *writerAggregator, sourceMap *sour
 		sourceMapSources:     sourceMap.Sources,
 		sourceMapNames:       sourceMap.Names,
 		jsFile:               jsFile,
-		jsLineMap:            core.ComputeLineStarts(jsFile.Content),
+		jsLineMap:            core.ComputeECMALineStarts(jsFile.Content),
 		spansOnSingleLine:    make([]sourceMapSpanWithDecodeErrors, 0),
 		prevWrittenSourcePos: 0,
 		nextJsLineToWrite:    0,
@@ -104,7 +104,7 @@ func newSourceMapSpanWriter(sourceMapRecorder *writerAggregator, sourceMap *sour
 
 	sourceMapRecorder.WriteLine("===================================================================")
 	sourceMapRecorder.WriteLineF("JsFile: %s", sourceMap.File)
-	sourceMapRecorder.WriteLineF("mapUrl: %s", sourcemap.TryGetSourceMappingURL(sourcemap.GetLineInfo(jsFile.Content, writer.jsLineMap)))
+	sourceMapRecorder.WriteLineF("mapUrl: %s", sourcemap.TryGetSourceMappingURL(sourcemap.GetECMALineInfo(jsFile.Content, writer.jsLineMap)))
 	sourceMapRecorder.WriteLineF("sourceRoot: %s", sourceMap.SourceRoot)
 	sourceMapRecorder.WriteLineF("sources: %s", strings.Join(sourceMap.Sources, ","))
 	if len(sourceMap.SourcesContent) > 0 {
@@ -187,7 +187,7 @@ func (w *sourceMapSpanWriter) recordNewSourceFileSpan(sourceMapSpan *sourcemap.M
 	w.sourceMapRecorder.WriteLineF("sourceFile:%s", w.sourceMapSources[w.spansOnSingleLine[0].sourceMapSpan.SourceIndex])
 	w.sourceMapRecorder.WriteLine("-------------------------------------------------------------------")
 
-	w.tsLineMap = core.ComputeLineStarts(newSourceFileCode)
+	w.tsLineMap = core.ComputeECMALineStarts(newSourceFileCode)
 	w.tsCode = newSourceFileCode
 	w.prevWrittenSourcePos = 0
 }
@@ -302,7 +302,7 @@ func (sw *recordedSpanWriter) writeSourceMapSourceText(currentSpan *sourceMapSpa
 		sw.w.sourceMapRecorder.WriteLine(decodeError)
 	}
 
-	tsCodeLineMap := core.ComputeLineStarts(sourceText)
+	tsCodeLineMap := core.ComputeECMALineStarts(sourceText)
 	for i := range tsCodeLineMap {
 		if i == 0 {
 			sw.writeSourceMapIndent(sw.prevEmittedCol, sw.markerIds[index])
diff --git a/internal/testutil/tsbaseline/error_baseline.go b/internal/testutil/tsbaseline/error_baseline.go
index 7a27f6067a..1490c267e5 100644
--- a/internal/testutil/tsbaseline/error_baseline.go
+++ b/internal/testutil/tsbaseline/error_baseline.go
@@ -171,7 +171,7 @@ func iterateErrorBaseline(t *testing.T, inputFiles []*harnessutil.TestFile, inpu
 		markedErrorCount := 0
 		// For each line, emit the line followed by any error squiggles matching this line
 
-		lineStarts := core.ComputeLineStarts(inputFile.Content)
+		lineStarts := core.ComputeECMALineStarts(inputFile.Content)
 		lines := lineDelimiter.Split(inputFile.Content, -1)
 
 		for lineIndex, line := range lines {
diff --git a/internal/testutil/tsbaseline/type_symbol_baseline.go b/internal/testutil/tsbaseline/type_symbol_baseline.go
index 414aa04d91..d8f40d133c 100644
--- a/internal/testutil/tsbaseline/type_symbol_baseline.go
+++ b/internal/testutil/tsbaseline/type_symbol_baseline.go
@@ -343,7 +343,7 @@ func forEachASTNode(node *ast.Node) []*ast.Node {
 
 func (walker *typeWriterWalker) writeTypeOrSymbol(node *ast.Node, isSymbolWalk bool) *typeWriterResult {
 	actualPos := scanner.SkipTrivia(walker.currentSourceFile.Text(), node.Pos())
-	line, _ := scanner.GetLineAndCharacterOfPosition(walker.currentSourceFile, actualPos)
+	line, _ := scanner.GetECMALineAndCharacterOfPosition(walker.currentSourceFile, actualPos)
 	sourceText := scanner.GetSourceTextOfNodeFromSourceFile(walker.currentSourceFile, node, false /*includeTrivia*/)
 	fileChecker, done := walker.getTypeCheckerForCurrentFile()
 	defer done()
@@ -434,7 +434,7 @@ func (walker *typeWriterWalker) writeTypeOrSymbol(node *ast.Node, isSymbolWalk b
 		}
 
 		declSourceFile := ast.GetSourceFileOfNode(declaration)
-		declLine, declChar := scanner.GetLineAndCharacterOfPosition(declSourceFile, declaration.Pos())
+		declLine, declChar := scanner.GetECMALineAndCharacterOfPosition(declSourceFile, declaration.Pos())
 		fileName := tspath.GetBaseFileName(declSourceFile.FileName())
 		symbolString.WriteString("Decl(")
 		symbolString.WriteString(fileName)
diff --git a/internal/transformers/jsxtransforms/jsx.go b/internal/transformers/jsxtransforms/jsx.go
index ff9ad4d36b..1b8be9984f 100644
--- a/internal/transformers/jsxtransforms/jsx.go
+++ b/internal/transformers/jsxtransforms/jsx.go
@@ -577,7 +577,7 @@ func (tx *JSXTransformer) visitJsxOpeningLikeElementOrFragmentJSX(
 				args = append(args, tx.Factory().NewFalseExpression())
 			}
 			// __source development flag
-			line, col := scanner.GetLineAndCharacterOfPosition(originalFile.AsSourceFile(), location.Pos())
+			line, col := scanner.GetECMALineAndCharacterOfPosition(originalFile.AsSourceFile(), location.Pos())
 			args = append(args, tx.Factory().NewObjectLiteralExpression(tx.Factory().NewNodeList([]*ast.Node{
 				tx.Factory().NewPropertyAssignment(nil, tx.Factory().NewIdentifier("fileName"), nil, nil, tx.getCurrentFileNameExpression()),
 				tx.Factory().NewPropertyAssignment(nil, tx.Factory().NewIdentifier("lineNumber"), nil, nil, tx.Factory().NewNumericLiteral(strconv.FormatInt(int64(line+1), 10))),
diff --git a/internal/transformers/utilities.go b/internal/transformers/utilities.go
index 6c84728ce6..96bb72c525 100644
--- a/internal/transformers/utilities.go
+++ b/internal/transformers/utilities.go
@@ -259,8 +259,8 @@ func IsOriginalNodeSingleLine(emitContext *printer.EmitContext, node *ast.Node)
 	if source == nil {
 		return false
 	}
-	startLine, _ := scanner.GetLineAndCharacterOfPosition(source, original.Loc.Pos())
-	endLine, _ := scanner.GetLineAndCharacterOfPosition(source, original.Loc.End())
+	startLine, _ := scanner.GetECMALineAndCharacterOfPosition(source, original.Loc.Pos())
+	endLine, _ := scanner.GetECMALineAndCharacterOfPosition(source, original.Loc.End())
 	return startLine == endLine
 }