type github.com/evanw/esbuild/internal/logger.Range

117 uses

	github.com/evanw/esbuild/internal/logger (current package)
		logger.go#L93: type Range struct {
		logger.go#L98: func (r Range) End() int32 {
		logger.go#L230: func (s *Source) TextForRange(r Range) string {
		logger.go#L234: func (s *Source) RangeOfOperatorBefore(loc Loc, op string) Range {
		logger.go#L238: 		return Range{Loc: Loc{Start: int32(index)}, Len: int32(len(op))}
		logger.go#L240: 	return Range{Loc: loc}
		logger.go#L243: func (s *Source) RangeOfOperatorAfter(loc Loc, op string) Range {
		logger.go#L247: 		return Range{Loc: Loc{Start: loc.Start + int32(index)}, Len: int32(len(op))}
		logger.go#L249: 	return Range{Loc: loc}
		logger.go#L252: func (s *Source) RangeOfString(loc Loc) Range {
		logger.go#L255: 		return Range{Loc: loc, Len: 0}
		logger.go#L264: 				return Range{Loc: loc, Len: int32(i + 1)}
		logger.go#L271: 	return Range{Loc: loc, Len: 0}
		logger.go#L274: func (s *Source) RangeOfNumber(loc Loc) (r Range) {
		logger.go#L276: 	r = Range{Loc: loc, Len: 0}
		logger.go#L293: func (s *Source) RangeOfLegacyOctalEscape(loc Loc) (r Range) {
		logger.go#L295: 	r = Range{Loc: loc, Len: 0}
		logger.go#L1029: func LocationOrNil(source *Source, r Range) *MsgLocation {
		logger.go#L1232: 		Data: RangeData(source, Range{Loc: loc}, text),
		logger.go#L1239: 		Data:  RangeData(source, Range{Loc: loc}, text),
		logger.go#L1247: 		Data: RangeData(source, Range{Loc: loc}, text),
		logger.go#L1251: func (log Log) AddRangeError(source *Source, r Range, text string) {
		logger.go#L1258: func (log Log) AddRangeWarning(source *Source, r Range, text string) {
		logger.go#L1265: func (log Log) AddRangeErrorWithNotes(source *Source, r Range, text string, notes []MsgData) {
		logger.go#L1273: func (log Log) AddRangeWarningWithNotes(source *Source, r Range, text string, notes []MsgData) {
		logger.go#L1281: func RangeData(source *Source, r Range, text string) MsgData {

	github.com/evanw/esbuild/internal/ast
		ast.go#L60: 	Range logger.Range

	github.com/evanw/esbuild/internal/bundler
		bundler.go#L139: 	importPathRange    logger.Range
		bundler.go#L576: 	importPathRange logger.Range,
		bundler.go#L631: 	importPathRange logger.Range,
		bundler.go#L738: 	importPathRange logger.Range,
		bundler.go#L938: 	importPathRange logger.Range,
		bundler.go#L1112: 		s.maybeParseFile(*resolveResult, prettyPath, nil, logger.Range{}, nil, inputKindNormal, channel)
		bundler.go#L1147: 		sourceIndex := s.maybeParseFile(resolveResult, s.res.PrettyPath(stdinPath), nil, logger.Range{}, nil, inputKindStdin, nil)
		bundler.go#L1192: 				logger.Range{},
		bundler.go#L1223: 			sourceIndex := s.maybeParseFile(*resolveResult, prettyPath, nil, logger.Range{}, resolveResult.PluginData, inputKindEntryPoint, nil)
		linker.go#L585: func (c *linkerContext) addRangeError(source logger.Source, r logger.Range, text string) {
		linker.go#L590: func (c *linkerContext) addRangeErrorWithNotes(source logger.Source, r logger.Range, text string, notes []logger.MsgData) {

	github.com/evanw/esbuild/internal/css_ast
		css_ast.go#L139: 	KeyRange  logger.Range

	github.com/evanw/esbuild/internal/css_lexer
		css_lexer.go#L108: 	Range      logger.Range // 8 bytes
		css_lexer.go#L198: 		lexer.Token = Token{Range: logger.Range{Loc: logger.Loc{Start: lexer.Token.Range.End()}}}
		css_lexer.go#L224: 					startRange := logger.Range{Loc: logger.Loc{Start: lexer.Token.Range.End()}, Len: 2}
		css_lexer.go#L399: func (lexer *lexer) consumeToEndOfMultiLineComment(startRange logger.Range) {
		css_lexer.go#L602: 			r := logger.Range{Loc: logger.Loc{Start: lexer.Token.Range.End()}, Len: 1}
		css_lexer.go#L608: 				r := logger.Range{Loc: logger.Loc{Start: lexer.Token.Range.End()}, Len: 1}
		css_lexer.go#L616: 				r := logger.Range{Loc: logger.Loc{Start: lexer.Token.Range.End()}, Len: 1}

	github.com/evanw/esbuild/internal/css_parser
		css_parser.go#L67: 			Range: logger.Range{Loc: p.tokens[p.end].Range.Loc},
		css_parser.go#L72: 		Range: logger.Range{Loc: logger.Loc{Start: int32(len(p.source.Contents))}},
		css_parser.go#L180: 							[]logger.MsgData{logger.RangeData(&p.source, logger.Range{Loc: locs[len(locs)-1]},
		css_parser.go#L193: 									[]logger.MsgData{logger.RangeData(&p.source, logger.Range{Loc: locs[i]},
		css_parser.go#L252: func (p *parser) parseURLOrString() (string, logger.Range, bool) {
		css_parser.go#L276: 	return "", logger.Range{}, false
		css_parser.go#L279: func (p *parser) expectURLOrString() (url string, r logger.Range, ok bool) {

	github.com/evanw/esbuild/internal/js_ast
		js_ast.go#L258: 	Range logger.Range
		js_ast.go#L334: 	ClassKeyword logger.Range
		js_ast.go#L1593: 	ImportKeyword        logger.Range // Does not include TypeScript-specific syntax or "import()"
		js_ast.go#L1594: 	ExportKeyword        logger.Range // Does not include TypeScript-specific syntax
		js_ast.go#L1595: 	TopLevelAwaitKeyword logger.Range

	github.com/evanw/esbuild/internal/js_lexer
		js_lexer.go#L293: func (lexer *Lexer) Range() logger.Range {
		js_lexer.go#L294: 	return logger.Range{Loc: logger.Loc{Start: int32(lexer.start)}, Len: int32(lexer.end - lexer.start)}
		js_lexer.go#L641: func RangeOfIdentifier(source logger.Source, loc logger.Loc) logger.Range {
		js_lexer.go#L644: 		return logger.Range{Loc: loc, Len: 0}
		js_lexer.go#L675: 				return logger.Range{Loc: loc, Len: int32(i)}
		js_lexer.go#L1623: 		lexer.addRangeError(logger.Range{Loc: logger.Loc{Start: int32(lexer.start)}, Len: int32(lexer.end - lexer.start)},
		js_lexer.go#L2262: 						lexer.addRangeError(logger.Range{Loc: logger.Loc{Start: int32(start + hexStart)}, Len: int32(i - hexStart)},
		js_lexer.go#L2397: func (lexer *Lexer) addRangeError(r logger.Range, text string) {
		js_lexer.go#L2470: 		Range: logger.Range{

	github.com/evanw/esbuild/internal/js_parser
		js_parser.go#L45: 	topLevelAwaitKeyword     logger.Range
		js_parser.go#L70: 	legacyOctalLiterals      map[js_ast.E]logger.Range
		js_parser.go#L110: 	es6ImportKeyword        logger.Range
		js_parser.go#L111: 	es6ExportKeyword        logger.Range
		js_parser.go#L112: 	enclosingClassKeyword   logger.Range
		js_parser.go#L385: 	asyncRange          logger.Range
		js_parser.go#L1599: 	invalidExprDefaultValue  logger.Range
		js_parser.go#L1600: 	invalidExprAfterQuestion logger.Range
		js_parser.go#L1601: 	arraySpreadFeature       logger.Range
		js_parser.go#L1654: 	invalidExprAwait logger.Range
		js_parser.go#L1655: 	invalidExprYield logger.Range
		js_parser.go#L1683: 			p.legacyOctalLiterals = make(map[js_ast.E]logger.Range)
		js_parser.go#L1706: 	asyncRange  logger.Range
		js_parser.go#L2187: func (p *parser) parseAsyncPrefixExpr(asyncRange logger.Range, level js_ast.L) js_ast.Expr {
		js_parser.go#L2242: func (p *parser) parseFnExpr(loc logger.Loc, isAsync bool, asyncRange logger.Range) js_ast.Expr {
		js_parser.go#L2282: 	asyncRange   logger.Range
		js_parser.go#L2292: 	spreadRange := logger.Range{}
		js_parser.go#L2293: 	typeColonRange := logger.Range{}
		js_parser.go#L2400: 				p.log.AddRangeError(&p.source, logger.Range{Loc: commaAfterSpread, Len: 1}, "Unexpected \",\" after rest pattern")
		js_parser.go#L2843: 				r := logger.Range{Loc: index.Index.Loc, Len: int32(len(name))}
		js_parser.go#L2890: 		return p.parseFnExpr(loc, false /* isAsync */, logger.Range{})
		js_parser.go#L2925: 			r := logger.Range{Loc: loc, Len: p.lexer.Range().End() - loc.Start}
		js_parser.go#L3249: 				r = logger.Range{Loc: loc, Len: r.End() - loc.Start}
		js_parser.go#L4029: func (p *parser) parseJSXTag() (logger.Range, string, *js_ast.Expr) {
		js_parser.go#L4034: 		return logger.Range{Loc: loc, Len: 0}, "", nil
		js_parser.go#L4796: func (p *parser) parseClass(classKeyword logger.Range, name *js_ast.LocRef, classOpts parseClassOpts) js_ast.Class {
		js_parser.go#L4916: func (p *parser) parseFnStmt(loc logger.Loc, opts parseStmtOpts, isAsync bool, asyncRange logger.Range) js_ast.Stmt {
		js_parser.go#L5342: 		return p.parseFnStmt(loc, opts, false /* isAsync */, logger.Range{})
		js_parser.go#L5640: 		var badLetRange logger.Range
		js_parser.go#L5667: 				badLetRange = logger.Range{}
		js_parser.go#L9318: 			r := logger.Range{Loc: value.Loc, Len: 0}
		js_parser.go#L9360: func (p *parser) warnAboutLackOfDefine(name string, r logger.Range) {
		js_parser.go#L10522: 				r := logger.Range{Loc: e.Index.Loc, Len: int32(len(name))}
		js_parser.go#L10526: 					r := logger.Range{Loc: e.Index.Loc, Len: int32(len(name))}
		js_parser.go#L10529: 					r := logger.Range{Loc: e.Index.Loc, Len: int32(len(name))}
		js_parser.go#L10763: 						r = logger.Range{Loc: expr.Loc, Len: r.End() - expr.Loc.Start}
		js_parser.go#L10907: 				p.log.AddRangeError(&p.source, logger.Range{Loc: e.CommaAfterSpread, Len: 1}, "Unexpected \",\" after rest pattern")
		js_parser.go#L10909: 			p.markSyntaxFeature(compat.Destructuring, logger.Range{Loc: expr.Loc, Len: 1})
		js_parser.go#L10946: 				p.log.AddRangeError(&p.source, logger.Range{Loc: e.CommaAfterSpread, Len: 1}, "Unexpected \",\" after rest pattern")
		js_parser.go#L10948: 			p.markSyntaxFeature(compat.Destructuring, logger.Range{Loc: expr.Loc, Len: 1})
		js_parser.go#L11498: 							logger.Range{Loc: star.Loc, Len: js_lexer.RangeOfIdentifier(p.source, member.Loc).End() - star.Loc.Start},
		js_parser_lower.go#L17: func (p *parser) markSyntaxFeature(feature compat.JSFeature, r logger.Range) (didGenerateError bool) {
		js_parser_lower.go#L141: func (p *parser) markStrictModeFeature(feature strictModeFeature, r logger.Range, detail string) {
		js_parser_lower.go#L168: 		var keywordRange logger.Range
		js_parser_lower.go#L196: func (p *parser) markLoweredSyntaxFeature(feature compat.JSFeature, r logger.Range, loweredFeature compat.JSFeature) {
		sourcemap_parser.go#L219: 		r := logger.Range{Loc: logger.Loc{Start: mappingsStart + int32(current)}, Len: int32(errorLen)}

	github.com/evanw/esbuild/internal/resolver
		resolver.go#L82: 	Range  logger.Range
		resolver.go#L696: 	result := ParseTSConfigJSON(r.log, source, &r.caches.JSONCache, func(extends string, extendsRange logger.Range) *TSConfigJSON {
		resolver.go#L916: 	toAbsPath := func(pathText string, pathRange logger.Range) *string {
		tsconfig_json.go#L43: 	extends func(string, logger.Range) *TSConfigJSON,