export var ObjectKeys = Object.keys || (object => {
	let keys = []
	for (let key in object) keys.push(key)
	return keys
})

export var ObjectValues = Object.values || (object => {
	let values = []
	for (let key in object) values.push(object[key])
	return values
})

export var ObjectEntries = Object.entries || (object => {
	let entries = []
	for (let key in object) entries.push([key, object[key]])
	return entries
})

export var ObjectAssign = Object.assign || ((target, ...objects) => {
	objects.forEach(object => {
		for (let key in object)
			target[key] = object[key]
	})
	return target
})

export var ObjectFromEntries = Object.fromEntries || (entries => {
	let object = {}
	// not using for-of because it would transpile to use of Symbol.iterator
	ArrayFrom(entries).forEach(([key, val]) => {
		object[key] = val
	})
	return object
})

export var ArrayFrom = Array.from || (arg => {
	if (arg instanceof Map) {
		let entries = []
		arg.forEach((val, key) => entries.push([key, val]))
		return entries
		// todo iterators (map.keys(), map.values())
	} else {
		return Array.prototype.slice.call(arg)
		//return [].slice.call(arg)
	}
})

function includes(item) {
	return this.indexOf(item) !== -1
}

if (!Array.prototype.includes)  Array.prototype.includes  = includes
if (!String.prototype.includes) String.prototype.includes = includes
if (!String.prototype.startsWith) String.prototype.startsWith = function(search, pos = 0) {
	return this.substring(pos, pos + search.length) === search
}
if (!String.prototype.endsWith) String.prototype.endsWith = function(search, len = this.length) {
	return this.substring(len - search.length, len) === search
}

let theGlobal = typeof self !== 'undefined' ? self : global

export var fetch = theGlobal.fetch || function(url, options = {}) {
	return new Promise((resolve, reject) => {
		const xhr = new XMLHttpRequest()
		xhr.open('get', url, true)
		xhr.responseType = 'arraybuffer'
		xhr.onerror = reject
		if (options.headers)
			for (const key in options.headers)
				xhr.setRequestHeader(key, options.headers[key])
		xhr.onload = () => {
			resolve({
				ok: xhr.status >= 200 && xhr.status < 300,
				status: xhr.status,
				arrayBuffer: () => Promise.resolve(xhr.response),
			})
		}
		xhr.send(null)
	})
}



// IE doesnt support initialization with constructor argument
export var NewSet = arr => {
	let set = []
	Object.defineProperties(set, {
		size: {
			get() {
				return this.length
			}
		},
		has: {
			value(item) {
				return this.indexOf(item) !== -1
			}
		},
		add: {
			value(item) {
				if (!this.has(item)) this.push(item)
			}
		},
		delete: {
			value(item) {
				if (this.has(item)) {
					let index = this.indexOf(item)
					this.splice(index, 1)
				}
			}
		},
	})
	if (Array.isArray(arr))
		for (let i = 0; i < arr.length; i++)
			set.add(arr[i])
	return set
}

export var NewMap = arr => {
	return new Map(arr)
}

var hasFullyImplementedMap = typeof theGlobal.Map !== 'undefined' && theGlobal.Map.prototype.keys !== undefined
export var Map = hasFullyImplementedMap ? theGlobal.Map : class Map {

	constructor(init) {
		this.clear()
		if (init)
			for (var i = 0; i < init.length; i++)
				this.set(init[i][0], init[i][1])
	}

	clear() {
		this._map = {}
		this._keys = []
	}

	get size() {
		return this._keys.length
	}

	get(key) {
		return this._map["map_"+key];
	}

	set(key, value) {
		this._map["map_"+key]=value;
		if(this._keys.indexOf(key)<0)this._keys.push(key);
		return this;
	}

	has(key) {
		return this._keys.indexOf(key)>=0;
	}

	delete(key) {
		var idx=this._keys.indexOf(key)
		if (idx < 0) return false
		delete this._map["map_" + key]
		this._keys.splice(idx, 1)
		return true
	}

	keys() {
		return this._keys.slice(0)
	}

	values() {
		return this._keys.map(key => this.get(key))
	}

	entries() {
		return this._keys.map(key => [key, this.get(key)])
	}

	forEach(callback, thisArg) {
		for (var i = 0; i < this._keys.length; i++)
		callback.call(thisArg, this._map["map_" + this._keys[i]], this._keys[i], this);
	}

}