func Load(source interface{}, others ...interface{}) (*File, error) {
	return LoadSources(LoadOptions{}, source, others...)
}
Load loads and parses from INI data sources.
Arguments can be mixed of file name with string type, or raw data in []byte.
It will return error if list contains nonexistent files.
package ini
import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"
)
const (
	DEFAULT_SECTION = "DEFAULT"
	_DEPTH_VALUES = 99
	_VERSION      = "1.25.4"
)
func Version() string {
	return _VERSION
}
var (
	LineBreak = "\n"
	varPattern = regexp.MustCompile(`%\(([^\)]+)\)s`)
	PrettyFormat = true
	DefaultHeader = false
)
func init() {
	if runtime.GOOS == "windows" {
		LineBreak = "\r\n"
	}
}
func inSlice(str string, s []string) bool {
	for _, v := range s {
		if str == v {
			return true
		}
	}
	return false
}
type dataSource interface {
	ReadCloser() (io.ReadCloser, error)
}
type sourceFile struct {
	name string
}
func (s sourceFile) ReadCloser() (_ io.ReadCloser, err error) {
	return os.Open(s.name)
}
type bytesReadCloser struct {
	reader io.Reader
}
func (rc *bytesReadCloser) Read(p []byte) (n int, err error) {
	return rc.reader.Read(p)
}
func (rc *bytesReadCloser) Close() error {
	return nil
}
type sourceData struct {
	data []byte
}
func (s *sourceData) ReadCloser() (io.ReadCloser, error) {
	return ioutil.NopCloser(bytes.NewReader(s.data)), nil
}
type sourceReadCloser struct {
	reader io.ReadCloser
}
func (s *sourceReadCloser) ReadCloser() (io.ReadCloser, error) {
	return s.reader, nil
}
type File struct {
	BlockMode bool
	lock sync.RWMutex
	dataSources []dataSource
	sections map[string]*Section
	sectionList []string
	options LoadOptions
	NameMapper
	ValueMapper
}
func newFile(dataSources []dataSource, opts LoadOptions) *File {
	return &File{
		BlockMode:   true,
		dataSources: dataSources,
		sections:    make(map[string]*Section),
		sectionList: make([]string, 0, 10),
		options:     opts,
	}
}
func parseDataSource(source interface{}) (dataSource, error) {
	switch s := source.(type) {
	case string:
		return sourceFile{s}, nil
	case []byte:
		return &sourceData{s}, nil
	case io.ReadCloser:
		return &sourceReadCloser{s}, nil
	default:
		return nil, fmt.Errorf("error parsing data source: unknown type '%s'", s)
	}
}
type LoadOptions struct {
	Loose bool
	Insensitive bool
	IgnoreContinuation bool
	AllowBooleanKeys bool
	AllowShadows bool
	UnparseableSections []string
}
func LoadSources(opts LoadOptions, source interface{}, others ...interface{}) (_ *File, err error) {
	sources := make([]dataSource, len(others)+1)
	sources[0], err = parseDataSource(source)
	if err != nil {
		return nil, err
	}
	for i := range others {
		sources[i+1], err = parseDataSource(others[i])
		if err != nil {
			return nil, err
		}
	}
	f := newFile(sources, opts)
	if err = f.Reload(); err != nil {
		return nil, err
	}
	return f, nil
}