const (
	// These are arranged such that ESNext is the default zero value and such
	// that earlier releases are less than later releases
	ES2015 = -6
	ES2016 = -5
	ES2017 = -4
	ES2018 = -3
	ES2019 = -2
	ES2020 = -1
	ESNext = 0
)

type DefineFunc func(FindSymbol) ast.E

type DotDefine struct {
	Parts      []string
	DefineFunc DefineFunc

	// This is used to whitelist certain functions that are known to be safe to
	// remove if their result is unused
	CanBeRemovedIfUnused bool
}

type FindSymbol func(name string) ast.Ref

type JSXOptions struct {
	Parse    bool
	Factory  []string
	Fragment []string
}

type LanguageTarget int8

type ParseJSONOptions struct {
	AllowComments       bool
	AllowTrailingCommas bool
}

type ParseOptions struct {
	// true: imports are scanned and bundled along with the file
	// false: imports are left alone and the file is passed through as-is
	IsBundling bool

	MangleSyntax bool
	Strict       StrictOptions
	Defines      *ProcessedDefines
	TS           TypeScriptOptions
	JSX          JSXOptions
	Target       LanguageTarget
	Platform     Platform
}

type Platform uint8

const (
	PlatformBrowser Platform = iota
	PlatformNode
)

type ProcessedDefines struct {
	IdentifierDefines map[string]DefineFunc
	DotDefines        map[string][]DotDefine
}

type StrictOptions struct {
	// Loose:  "a ?? b" => "a != null ? a : b"
	// Strict: "a ?? b" => "a !== null && a !== void 0 ? a : b"
	//
	// The disadvantage of strictness here is code bloat. The only observable
	// difference between the two is when the left operand is the bizarre legacy
	// value "document.all". This value is special-cased in the standard for
	// legacy reasons such that "document.all != null" is false even though it's
	// not "null" or "undefined".
	NullishCoalescing bool

	// Loose:  "class Foo { foo = 1 }" => "class Foo { constructor() { this.foo = 1; } }"
	// Strict: "class Foo { foo = 1 }" => "class Foo { constructor() { __publicField(this, 'foo', 1); } }"
	//
	// The disadvantage of strictness here is code bloat and performance. The
	// advantage is following the class field specification accurately. For
	// example, loose mode will incorrectly trigger setter methods while strict
	// mode won't.
	ClassFields bool
}

type TypeScriptOptions struct {
	Parse bool
}