"path/filepath"

	"sort"

	"strconv"

	// Byte order mark character

	bom = "\xef\xbb\xbf"

// Load is a function to load a file or multiple files and then export the valid variables into environment variables if they do not exist.

// When it's called with no argument, it will load `.env` file on the current path and set the environment variables.

// Otherwise, it will loop over the filenames parameter and set the proper environment variables.

// OverLoad is a function to load a file or multiple files and then export and override the valid variables into environment variables.

// Must is wrapper function that will panic when supplied function returns an error.

// Apply is a function to load an io Reader then export the valid variables into environment variables if they do not exist.

// OverApply is a function to load an io Reader then export and override the valid variables into environment variables.

		f.Close()

	env, err := strictParse(r, override)

	env, _ := strictParse(r, false)

	return strictParse(r, false)

}

// Read is a function to parse a file line by line and returns the valid Env key/value pair of valid variables.

// It expands the value of a variable from the environment variable but does not set the value to the environment itself.

// This function is skipping any invalid lines and only processing the valid one.

func Read(filename string) (Env, error) {

	f, err := os.Open(filename)

	if err != nil {

		return nil, err

	}

	defer f.Close()

	return strictParse(f, false)

}

// Unmarshal reads a string line by line and returns the valid Env key/value pair of valid variables.

// It expands the value of a variable from the environment variable but does not set the value to the environment itself.

// This function is returning an error if there are any invalid lines.

func Unmarshal(str string) (Env, error) {

	return strictParse(strings.NewReader(str), false)

}

// Marshal outputs the given environment as a env file.

// Variables will be sorted by name.

func Marshal(env Env) (string, error) {

	lines := make([]string, 0, len(env))

	for k, v := range env {

		if d, err := strconv.Atoi(v); err == nil {

			lines = append(lines, fmt.Sprintf(`%s=%d`, k, d))

		} else {

			lines = append(lines, fmt.Sprintf(`%s=%q`, k, v))

		}

	}

	sort.Strings(lines)

	return strings.Join(lines, "\n"), nil

}

// Write serializes the given environment and writes it to a file

func Write(env Env, filename string) error {

	content, err := Marshal(env)

	if err != nil {

		return err

	}

	// ensure the path exists

	if err := os.MkdirAll(filepath.Dir(filename), 0o775); err != nil {

		return err

	}

	// create or truncate the file

	file, err := os.Create(filename)

	if err != nil {

		return err

	}

	defer file.Close()

	_, err = file.WriteString(content + "\n")

	if err != nil {

		return err

	}

	return file.Sync()

}

func strictParse(r io.Reader, override bool) (Env, error) {

	firstLine := true

		line := strings.TrimSpace(scanner.Text())

		if firstLine {

			firstLine = false

		}

		if line == "" || line[0] == '#' {

			continue

		quote := ""

		// look for the delimiter character

		idx := strings.Index(line, "=")

		if idx == -1 {

			idx = strings.Index(line, ":")

		}

		// look for a quote character

		if idx > 0 && idx < len(line)-1 {

			val := strings.TrimSpace(line[idx+1:])

			if val[0] == '"' || val[0] == '\'' {

				quote = val[:1]

				// look for the closing quote character within the same line

				idx = strings.LastIndex(strings.TrimSpace(val[1:]), quote)

				if idx >= 0 && val[idx] != '\\' {

					quote = ""

				}

			}

		}

		// look for the closing quote character

		for quote != "" && scanner.Scan() {

			l := scanner.Text()

			line += "\n" + l

			idx := strings.LastIndex(l, quote)

			if idx > 0 && l[idx-1] == '\\' {

				// foud a matching quote character but it's escaped

				continue

			}

			if idx >= 0 {

				// foud a matching quote

				quote = ""

			}

		}

		if quote != "" {

			return env, fmt.Errorf("missing quotes")

		}

		err := parseLine(line, env, override)

var (

	lineRgx     = regexp.MustCompile(linePattern)

	unescapeRgx = regexp.MustCompile(`\\([^$])`)

	varRgx      = regexp.MustCompile(variablePattern)

)

func parseLine(s string, env Env, override bool) error {

	rm := lineRgx.FindStringSubmatch(s)

	key := strings.TrimSpace(rm[1])

	val := strings.TrimSpace(rm[2])

	var hsq, hdq bool

	// check if the value is quoted

	if l := len(val); l >= 2 {

		l -= 1

		// has double quotes

		hdq = val[0] == '"' && val[l] == '"'

		// has single quotes

		hsq = val[0] == '\'' && val[l] == '\''

		// remove quotes '' or ""

		if hsq || hdq {

			val = val[1:l]

		}

	}

		val = strings.ReplaceAll(val, `\n`, "\n")

		val = strings.ReplaceAll(val, `\r`, "\r")

		val = unescapeRgx.ReplaceAllString(val, "$1")

	if !hsq {

		fv := func(s string) string {

			return varReplacement(s, hsq, env, override)

		}

		val = varRgx.ReplaceAllStringFunc(val, fv)

		val = parseVal(val, env, hdq, override)

var varNameRgx = regexp.MustCompile(`(\$)(\{?([A-Z0-9_]+)\}?)`)

func varReplacement(s string, hsq bool, env Env, override bool) string {

	if s == "" {

		return s

	}

	if s[0] == '\\' {

		// the dollar sign is escaped

		return s[1:]

	mn := varNameRgx.FindStringSubmatch(s)

	if replace, ok := os.LookupEnv(v); ok && !override {

		return replace

	if replace, ok := env[v]; ok {

		return replace

	}

	return os.Getenv(v)

	if st == "" || st[0] == '#' {

func parseVal(val string, env Env, ignoreNewlines bool, override bool) string {

	if strings.Contains(val, "=") && !ignoreNewlines {

		kv := strings.Split(val, "\r")

		if len(kv) > 1 {

			val = kv[0]

			for _, l := range kv[1:] {

				_ = parseLine(l, env, override)