jaaJSU.js

/* jshint esversion: 6,-W097, -W040, browser: true, expr: true, undef: true, maxcomplexity: 21, maxparams: 8, maxdepth: 4, latedef: false */
/* gulp *//* global gulp_place, define, module *///gulp.keep.line
/**
 * @module jaaJSU
 * @version 2.0.0
 */
(function(module_name, factory) {
	'use strict';
	let window_export;
	if (typeof define === 'function' && define.amd) {
		define([], function(){
			return factory(window, document);
		});
	} else if (typeof exports !== 'undefined') {
		module.exports = factory(window, document);
	} else {
		window_export= factory(window, document);
		Object.keys(window_export).forEach(key=> window[key]= window_export[key]);
		window[module_name+"_version"]= "2.0.0";
	}
})("jaaJSU", function(window, document){
	'use strict';
	const _public= {};
	_public.$array= {};
	 
	function __eachInArrayLike(iterable, i_function, scope, share){
	    const key_length= iterable.length;
	    for(let key=0, j=key_length-1; key<key_length; key++, j--){
	        share= i_function.call(scope, { item: iterable[key], last: !j, key, share });
	    }
	    return share;
	}
	function __eachInArrayLikeDynamic(iterable, i_function, scope, share){
	    for(let key=0; key<iterable.length; key++){
	        share= i_function.call(scope, { item: iterable[key], key, share });
	    }
	    return share;
	}
	 
	_public.$array.each= __eachInArrayLike;
	_public.$array.eachDynamic= __eachInArrayLikeDynamic;
 
	_public.$array.partition= function(arr){
		if(!Array.isArray(arr))
			arr= Array.from(arr);
		return {
			head: function(){ const [x, ...xs]= arr; return [x, xs]; },
			tail: function(){ let local_arr= [...arr]; const last= local_arr.pop(); return [local_arr, last]; },
			onIndex: function(index){ return [arr.slice(0,index), arr.slice(index)]; },
			byCondition: function(fn){ return arr.reduce((out, item, key)=> ( out[+!Boolean(fn(item, key))].push(item), out ), [ [], [] ]); }
		};
	};
 
	_public.$array.arrayIndex= function(i,s,l){ return (l+i+(s%l))%l; };
 
	_public.$array.getLast= function(arr){ return arr[arr.length-1]; };
 
	_public.$array.removeItem= function(arr, item){
		let p_arr= [...arr];
		var i = 0;
		while (i < p_arr.length) {
			if (p_arr[i] === item) p_arr.splice(i, 1);
			else i++;
		}
		return p_arr;
	};
 
	_public.$array.sortRandom= function(){ return Math.random() - 0.5; };

	/* 
		join concurrent/serial [fork-join.mjs](https://gist.github.com/rauschma/bdc56a046b18528959ad1db3eed05386)
		[debug-promise.js](https://gist.github.com/jaandrle/9714466561b86412a30dd7b0b73fea8c)
	*/
	_public.$async= {};
	 
	_public.$async.each_= function(...functions){return function(...input){
		return Promise.all(functions.map(f=>f(...input)));
	};};
 
	_public.$async.CANCEL= Symbol("$async.CANCEL");
	_public.$async.iterateMixed_= function(...tasks){
		return new Promise(function(resolve, reject){
			return (function run(result){
				if(!tasks.length) return resolve(result);
				const task= tasks.shift();
				const value= typeof task==='function' ? task(result):task;
				// check against nil values
				if(value!==null){
					if(value===_public.$async.CANCEL) return;
					if(value.then) return value.then(run);
				}
				return Promise.resolve(run(value));
			})();
		});
	};
 
	_public.$async.iterate_= function(iterablePromises){
		let p= Promise.resolve();
		for(let i= 0, { length }= iterablePromises; i < length; i++)
			p= p.then(iterablePromises[i]);
		return p;
	};
 
	_public.$async.sequention= function(...functions){
		return function(input){
			let p= Promise.resolve(input);
			for(let i= 0, { length }= functions; i < length; i++)
				p= p.then(functions[i]);
			return p;
		};
	};
 
	_public.$async.serialize= (function(){
		const concat = list => Array.prototype.concat.bind(list);
		const promiseConcat = f => x => f().then(concat(x));
		const promiseReduce = (acc, f) => acc.then(promiseConcat(f));
		return funcs => funcs.reduce(promiseReduce, Promise.resolve([]));
	})();
	_public.$async.serialize_= _public.$async.serialize;

	_public.$dom= {};
	 
 
	_public.$dom.each= __eachInArrayLike;
	_public.$dom.eachDynamic= __eachInArrayLikeDynamic;
 
	_public.$dom.toggleAttribute= function(element, attribute_name, attribute_a, attribute_b){
		const attribute_new= element.getAttribute(attribute_name) === attribute_a ? attribute_b : attribute_a;
		element.setAttribute(attribute_name, attribute_new);
		return attribute_new;
	};
 
 
	_public.$dom.empty= function(container){
		let len = container.childNodes.length;
		while(len--){ container.removeChild(container.lastChild); }
	};
 

	_public.$dom.mount= function(element_target, type= "childLast"){
		return function mount_inner(element){
			if(!(element instanceof Element)){
				if(typeof element.mount !== "function") throw new TypeError("`element` must be instance of `Element` or `$dom.component`.");
				return element.mount(element_target, type);
			}
			switch ( type ){
				case "after":
					const { parentNode, nextSibling }= element_target;
					if(nextSibling) parentNode.insertBefore(element, nextSibling);
					else parentNode.appendChild(element);
					break;
				case "before":
					element_target.parentNode.insertBefore(element, element_target);
					break;
				case "replace":
					element_target.parentNode.insertBefore(element, element_target);
					element_target.remove();
					break;
				case "replaceContent":
					_public.$dom.empty(element_target);
					element_target.appendChild(element);
					break;
				default:
					if(type==="childFirst" && element_target.childNodes.length) element_target.insertBefore(element, element_target.childNodes[0]);
					else element_target.appendChild(element);
					break;
			}
			return element;
		};
	};
	(function(){
		const $dom= _public.$dom;
		const component_utils= Object.freeze({
			registerToMap: function(store, current, indexGenerator){
				let current_index= -1;
				for(const [i, v] of store){
					if(v===current) current_index= i;
					if(current_index!==-1) break;
				}
				if(current_index!==-1) return current_index;
				current_index= indexGenerator();
				store.set(current_index, current);
				return current_index;
			},
			indexGenerator: (index= 0)=> ()=> index++
		});
		
		const $dom_emptyPseudoComponent= (function(){
			const share= { mount, update, destroy, ondestroy, isStatic };
			let component_out= { add, component, mount, update, ondestroy, share };
			return component_out;
			function mount(element, type= "childLast"){
				// let temp_el;
				switch ( type ) {
					case "replace":
						element.remove();
						break;
					case "replaceContent":
						$dom.empty(element);
						break;
					// case "before":
					//	   temp_el= element.previousElementSibling;
					//	   if(temp_el) temp_el.remove();
					//	   break;
					// case "after":
					//	   temp_el= element.nextElementSibling;
					//	   if(temp_el) temp_el.remove();
					//	   break;
					// default:
					//	   if(element.childNodes.length) element.childNodes[type==="childFirst" ? 0 : element.childNodes.length-1].remove();
					//	   break;
				}
				return null;
			}
			function add(){ return component_out; }
			function component(){ return component_out; }
			function update(){ return true; }
			function isStatic(){ return true; }
			function ondestroy(){ return true; }
			function destroy(){ component_out= null; return null; }
		})();
		 
		const special_components_names= { empty: [ "", "empty" ], fragment: [ "<>", "fragment" ] };
		function isInternalElement( target, candidate, safe_only ){
			const [ short, long ]= special_components_names[target];
			if(safe_only) return short===candidate;
			return short===candidate||long===candidate.toLowerCase();
		}
		 
		$dom.component= function(el_name, attrs, { mapUpdate, namespace_group, safe_el_name_only }={}){
			if(!el_name||isInternalElement("empty", el_name, safe_el_name_only)) return $dom_emptyPseudoComponent;
			if(el_name==="svg") namespace_group= "SVG";
			let assign, createElement;
			if(namespace_group==="SVG"){
				assign= $dom.assignNS.bind(null, "SVG");
				createElement= document.createElementNS.bind(document, "http://www.w3.org/2000/svg");
			} else {
				assign= $dom.assign;
				createElement= document.createElement.bind(document);
			}
			let /* holds `initStorage()` if `onupdate` was registered and other component related listeners */
				internal_storage= null,
				on_destroy_funs= null,
				/* on first mount */
				on_mount_funs= null,
				observer= null;
			let /* main parent (wrapper), container for children elements */
				container,
				/* store for all registered elements */
				els= [], all_els_counter= 0,
				/* current elements deep which holds indicies of elements:
					- add(...);add(...); = final deep=[0,1];
					- add(...);add(...,-1);add(...) = final deep=[1,2]; (by steps: [0], [0,1], [1,2])
					- see `shift` in `add`
				*/
				deep= [];
			const share= { mount, update, destroy, ondestroy, isStatic };
			let component_out= { add, addText, component, dynamicComponent, setShift, mount, update, ondestroy, share };
			let add_out_methods= {
				getReference: function(add_out, el){ return el; },
				on: function(add_out, el, ...listeners){
					listeners.forEach(([ event_name, args ]= [])=> event_name && add_out[event_name].apply(this, args));
					return add_out;
				},
				oninit: function(add_out, el, fn){ fn.call(add_out, el); return add_out; },
				onmount: function(add_out, el, onMountFunction){
					if(!on_mount_funs) on_mount_funs= new Map();
					on_mount_funs.set(el, onMountFunction);
					return add_out;
				},
				onupdate: function(add_out, el, data, onUpdateFunction){
					if(!data) return add_out;
					if(!internal_storage) internal_storage= initStorage();
					assign(el, internal_storage.register(el, data, onUpdateFunction));
					return add_out;
				}
			};
			
			/**
			 * Its purpose is to make easy transfering methods somewhere else (like for using in another component, see {@link module:jaaJSU~$dom~instance_component.component} method).
			 * @typedef share
			 * @memberof module:jaaJSU~$dom~instance_component
			 * @borrows module:jaaJSU~$dom~instance_component.mount as mount
			 * @borrows module:jaaJSU~$dom~instance_component.update as update
			 * @type {Object}
			 */
			/**
			 * This is minimal export of "functional class" {@link module:jaaJSU~$dom.component} and its methods (if they are chainable).
			 * @typedef instance_component
			 * @memberof module:jaaJSU~$dom
			 * @category types descriptions
			 * @inner
			 * @type {Object}
			 */
			if(!isInternalElement("fragment", el_name, safe_el_name_only)) return add(el_name, attrs);
			return _addElement(document.createDocumentFragment(), attrs, 0);
			function add(el_name, attrs, shift= 0){ return _addElement(createElement(el_name), attrs, shift); }
			function _addElement(el, attrs, shift){
				recalculateDeep(shift);
				attrs= attrs || {};
				if(!all_els_counter) container= els[0]= el;
				else els[all_els_counter]= getParentElement().appendChild(el);
				el= els[all_els_counter];
				all_els_counter+= 1;
				assign(el, attrs);
				const add_out= Object.create(component_out);
				
				add_out.getReference= add_out_methods.getReference.bind(null, add_out, el);
				add_out.on= add_out_methods.on.bind(null, add_out, el);
				add_out.oninit= add_out_methods.oninit.bind(null, add_out, el);
				add_out.onmount= add_out_methods.onmount.bind(null, add_out, el);
				add_out.onupdate= add_out_methods.onupdate.bind(null, add_out, el);
				
				return add_out;
			}
			
			
			function addText(text= "", shift= 0){
				recalculateDeep(shift);
				const text_node= document.createTextNode(text);
				let el= els[all_els_counter]= getParentElement().appendChild(text_node);
				all_els_counter+= 1;
				const add_out= Object.create(component_out);
				
				add_out.getReference= add_out_methods.getReference.bind(null, add_out, el);
				add_out.on= add_out_methods.on.bind(null, add_out, el);
				add_out.oninit= add_out_methods.oninit.bind(null, add_out, el);
				add_out.onmount= add_out_methods.onmount.bind(null, add_out, el);
				add_out.onupdate= add_out_methods.onupdate.bind(null, add_out, el);
				
				return add_out;
			}
			
			
			function component({ mount, update, isStatic: isStaticCandidate, destroy: destroyCandidate }, shift= 0){
				recalculateDeep(shift);
				const el_parent= getParentElement();
				els[all_els_counter]= mount(el_parent);
				if(el_parent instanceof DocumentFragment) ondestroy(destroyCandidate);
				if(!isStaticCandidate()){
					if(isStatic()) internal_storage= initStorage();
					internal_storage.registerComponent(update);
				}
				all_els_counter+= 1;
				return component_out;
			}
			
			
			function dynamicComponent(data, generator, shift= 0){
				recalculateDeep(shift);
				const parent= getParentElement();
				let current_value= null, current_component= null, current_element= null;
				return add_out_methods.onupdate(component_out, parent, data, function(data){
					current_value= generator.call(parent, mount, current_component, data, current_value);
				});
				function mount(component_share){
					current_component= component_share;
					if(current_element){
						current_element= current_component.mount(current_element, "replace");
					} else {
						current_element= current_component.mount(parent);
					}
				}
			}
			
			
			function mount(element, type= "childLast"){
				if(observer) observer.disconnect();
				$dom.mount(element, type)(container);
				const parent_node= type==="after"||type==="before" ? element.parentNode : element;
				if(!(element instanceof DocumentFragment)){//TODO/WIP
					const [ el_c, el_p ]= __observedEls(container, parent_node);
					observer= new MutationObserver(mutations=> mutations.forEach(function(record){
						if(!record.removedNodes||Array.prototype.indexOf.call(record.removedNodes, el_c)===-1) return false;
						destroy();
					}));
					observer.observe(el_p, { childList: true, subtree: true, attributes: false, characterData: false });
				}
				if(on_mount_funs){
					on_mount_funs.forEach(onMountFunctionCall);
					on_mount_funs= undefined;
				}
			
				function __observedEls(container, parent_node){
					if(!(container instanceof DocumentFragment)) return [ container, parent_node ];
					return [ parent_node, parent_node.parentNode ];
				}
				return container;
				function onMountFunctionCall(onMountFunction, el){ return assign(el, onMountFunction.call(el, element, type)); }
			}
			
			
			function destroy(){
				if(on_destroy_funs) on_destroy_funs.forEach(onDestroyFunction=> onDestroyFunction.call(container));
			
				if(container) {
					if(!(container instanceof DocumentFragment)) container.remove();
					els= [];
				}
				if(observer) observer.disconnect();
				observer= undefined;
				on_destroy_funs= undefined;
				assign= undefined;
				createElement= undefined;
				container= undefined;
				if(internal_storage&&internal_storage.clear){
					internal_storage.clear();
					internal_storage= undefined;
				}
				component_out= undefined;
				add_out_methods= undefined;
				return null;
			}
			
			
			function ondestroy(onDestroyFunction){
				if(!on_destroy_funs) on_destroy_funs= new Set();
				on_destroy_funs.add(onDestroyFunction);
				return component_out;
			}
			
			
			function recalculateDeep(shift){
				if(!shift) deep.push(all_els_counter);
				else { deep.splice(deep.length+1+shift); deep[deep.length-1]= all_els_counter; }
			}
			
			
			function getParentElement(){
				return els[deep[deep.length-2]] || container;
			}
			
			
			function setShift(shift= 0){
				let last;
				if(!shift){ last= deep.pop(); deep.push(last, last); }
				else deep.splice(deep.length+1+shift);
				return component_out;
			}
			
			
			function initStorage(){
				const
					{ registerToMap, indexGenerator }= component_utils;
				let /* storage for component, functions for updates and mapping data keys and corresponding elements */
					data, components, els, functions, listeners, getIndex;
				internalVars(indexGenerator(0));
				return {
					register: function(el, init_data, fun){
						Object.assign(data, init_data);
						const ids= registerToMap(els, el, getIndex)+"_"+registerToMap(functions, fun, getIndex);
						const init_data_keys= Object.keys(init_data);
						for(let i=0, i_key, i_length= init_data_keys.length; i<i_length; i++){
							i_key= init_data_keys[i];
							if(!listeners.has(i_key)) listeners.set(i_key, [ ids ]);
							else listeners.get(i_key).push(ids);
						}
						return fun.call(el, init_data) || {};
					},
					registerComponent: function(update){
						if(components.indexOf(update)===-1) components.push(update);
					},
					update: function(new_data_input){
						const new_data= typeof mapUpdate==="function" ? mapUpdate(new_data_input) : new_data_input;
						let out= false;
						for(let i=0, i_length= components.length; i<i_length; i++){ if(components[i](new_data)&&!out){out=true;} }
						if(!listeners.size) return out;
						const /* keys to update (subscribers exits and was changed) */
							new_data_keys= Object.keys(new_data)
								.filter(key=>listeners.has(key)&&data[key]!==new_data[key]),
							new_data_keys_length= new_data_keys.length;
						if(!new_data_keys_length) return out;
						Object.assign(data, new_data);
						const els_for_redraw= [];
						for(let i=0, i_listeners; i<new_data_keys_length; i++){
							i_listeners= listeners.get(new_data_keys[i]);
							for(let j=0, ji_listener, j_length= i_listeners.length; j<j_length; j++){
								ji_listener= i_listeners[j];
								if(els_for_redraw.indexOf(ji_listener)===-1) els_for_redraw.push(ji_listener);
							}
						}
						for(let i=0, i_length= els_for_redraw.length; i<i_length; i++){ processChanges(els_for_redraw[i]); }
						return true;
						
						function processChanges(ids){
							const [ el_id, fun_id ]= ids.split("_").map(Number);
							const el= els.get(el_id);
							const new_data= functions.get(fun_id).call(el, data) || {};
							if(el.parentNode===null) return unregister(el_id, fun_id, new_data_keys);
							assign(el, new_data);
						}
					},
					clear: function(){
						internalVars();
					},
					getData: function(){
						return data;
					},
					unregister
				};
				function internalVars(initIndex){
					data= {};
					
					components= [];
					els= new Map();
					
					functions= new Map();
					listeners= new Map();
					
					getIndex= initIndex;
				}
				function unregister(el_id, fun_id, data_keys){
					let funcs_counter= 0;
					els.delete(el_id);
					listeners.forEach(function(listeners_arr, i_key){
						if(data_keys.indexOf(i_key)===-1) return listeners_arr.forEach(function(ids){ if(Number(ids.split("_")[1])===fun_id){ funcs_counter+= 1; } });
						
						if(listeners_arr.length===1) listeners.delete(i_key);
						else listeners.set(i_key, listeners_arr.filter(el_idFilter));
					});
					if(!funcs_counter) functions.delete(fun_id);
					function el_idFilter(ids){ return Number(ids.split("_")[0])!==el_id; }
				}
			}
			
			
			function update(new_data){
				if(!internal_storage) return false;
				return internal_storage.update(typeof new_data==="function" ? new_data(internal_storage.getData()) : new_data);
			}
			
			
			function isStatic(){
				return !internal_storage;
			}
			
			
		};
		$dom.componentListener= (function(){
			const internal_component_events= [ "oninit", "onmount", "onupdate" ];
			const EventListener_interface= {
				/*
				 api: {},
				 event_function: listener function,
				 */
				registerListener: function(target_element, api, event_name, event_function, event_options= { passive: true }){
					this.api= { getReference: api.getReference, update: api.update, removeEventListener: this.removeEventListener.bind(this) };
					this.event_name= event_name;
					this.event_function= event_function;
					target_element.addEventListener(event_name, this, event_options);
				},
				removeEventListener: function(){ this.api.getReference().removeEventListener(this.event_name, this); },
				handleEvent: function(event){ this.event_function.call(this.api, event); }
			};
			
			return function(event_name, ...args){
				const event_name_id= internal_component_events.indexOf((/^on/g.test(event_name) ? "" : "on")+event_name);
				if(event_name_id===-1) return Object.freeze([ "oninit", [ function(el){ Object.create(EventListener_interface).registerListener(el, this, event_name, ...args); } ] ]);
				return Object.freeze([ internal_component_events[event_name_id], args ]);
			};
		})();
		
		$dom.assign= function(element, ...objects_attributes){
			const object_attributes= Object.assign({}, ...objects_attributes);
			const object_attributes_keys= Object.keys(object_attributes);
			for(let i=0, key, attr, i_length= object_attributes_keys.length; i<i_length; i++){
				key= object_attributes_keys[i];
				attr= object_attributes[key];
				const key_aria_data= /(aria|data)([A-Z])/.test(key) ? key.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase() : false;
				if(typeof attr==="undefined"){
					if(key_aria_data) element.removeAttribute(key_aria_data);
					if(Reflect.has(element, key)) Reflect.deleteProperty(element, key);
					continue;
				}
				switch(key){
					case "style":
						if(typeof attr==="string") element.setAttribute("style", attr);
						else for(let k=0, k_key, k_keys= Object.keys(attr), k_length= k_keys.length; k<k_length; k++){ k_key= k_keys[k]; element.style.setProperty(k_key, attr[k_key]); }
						break;
					case "style_vars":
						for(let k=0, k_key, k_keys= Object.keys(attr), k_length= k_keys.length; k<k_length; k++){ k_key= k_keys[k]; element.style.setProperty(k_key, attr[k_key]); }
						break;
					case "classList":
						if(!element[key].toggle) break;
						for(let k=0, k_key, k_attr, k_keys= Object.keys(attr), k_length= k_keys.length; k<k_length; k++){
							k_key= k_keys[k]; k_attr= attr[k_key];
							if(k_attr===-1) element.classList.toggle(k_key);
							else element.classList.toggle(k_key, Boolean(k_attr));
						}
						break;
					case "dataset":
						for(let k=0, k_key, k_keys= Object.keys(attr), k_length= k_keys.length; k<k_length; k++){ k_key= k_keys[k]; element.dataset[k_key]= attr[k_key]; }
						break;
					case "href" || "src" || "class":
						element.setAttribute(key, attr);
						break;
					default:
						if(key_aria_data) element.setAttribute(key_aria_data, attr);
						else element[key]= attr;
						break;
				}
			}
			return element;
		};
		
		$dom.assignNS= function(namespace, element, ...objects_attributes){
			const on_keys_regexp= /^on[a-z]+/;
			const object_attributes= Object.assign({}, ...objects_attributes);
			const object_attributes_keys= Object.keys(object_attributes);
			for(let i=0, key, attr, i_length= object_attributes_keys.length; i<i_length; i++){
				key= object_attributes_keys[i];
				attr= object_attributes[key];
				if(typeof attr==="undefined"){ if(element.hasAttributeNS(null, key)){ element.removeAttributeNS(null, key); } continue; }
				switch(key){
					case "textContent" || "innerText":
						element.appendChild(document.createTextNode(attr));
						break;
					case "style":
						if(typeof attr==="string") element.setAttributeNS(null, "style", attr);
						else for(let k=0, k_key, k_keys= Object.keys(attr), k_length= k_keys.length; k<k_length; k++){ k_key= k_keys[k]; element.style.setProperty(k_key, attr[k_key]); }
						break;
					case "style_vars":
						for(let k=0, k_key, k_keys= Object.keys(attr), k_length= k_keys.length; k<k_length; k++){ k_key= k_keys[k]; element.style.setProperty(k_key, attr[k_key]); }
						break;
					case "className":
						element.setAttributeNS(null, "class", attr);
						break;
					case "classList":
						if(!element[key].toggle) break;
						for(let k=0, k_key, k_attr, k_keys= Object.keys(attr), k_length= k_keys.length; k<k_length; k++){
							k_key= k_keys[k]; k_attr= attr[k_key];
							if(k_attr===-1) element.classList.toggle(k_key);
							else element.classList.toggle(k_key, Boolean(k_attr));
						}
						break;
					case "xlink:href":
						element.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", attr);
						break;
					default:
						if(on_keys_regexp.test(key)) element[key]= attr;
						else element.setAttributeNS(null, key, attr);
						break;
				}
			}
			return element;
		};
		
		
		
	})();
 
	_public.$dom.elementReady_= function(el_selector, parent= document){
		const sel_key= Object.keys(el_selector)[0];
		const sel_val= el_selector[sel_key];
		return new Promise(function(resolve){
			function check(){
				const el= parent[sel_key](sel_val);
				if(el) resolve(el);
				else requestAnimationFrame(check); //...zajistuje cyklus
			}
			requestAnimationFrame(check);
		});
	};

 
	_public.$dom.forceRedraw= function(element= document.body){
	    let d= element.style.display;
	    element.style.display= 'none';
	    let trick= element.offsetHeight;
	    element.style.display= d;
	    //v2
	    //document.documentElement.style.paddingRight = '1px';
	    //setTimeout(()=>{document.documentElement.style.paddingRight = '';}, 0);
	};

 
	_public.$dom.ready_= function(...args){ return new Promise(function(resolve){
		if(document.readyState!=='loading')
			return resolve(...args);
		document.addEventListener('readystatechange', checkState);
		
		function checkState() {
			if(document.readyState==='loading') return;
			document.removeEventListener('readystatechange', checkState);
			resolve(...args);
		}
	}); };
 
	_public.$dom.removeElements= function(els_to_delete,from_index,to_index){
		from_index= from_index || 0;
		to_index= to_index || els_to_delete.length;
		let els_array= [];
		let j= 0;
		for(let i= from_index; i < to_index; i++){els_array[j++]= els_to_delete[i];}
		for(let i= 0, i_length= els_array.length; i < i_length; i++){els_array[i].remove();}
	};

	_public.$function= {};
	 
	_public.$function.arguments= function(fun, ...indicies){
		if(!indicies.length) return function(...args){ return fun.apply(this, args); };
		return function(...args){ return fun.apply(this, indicies.map(v=> args[v])); };
	};
 
	_public.$function.bindRight= function(fun, context, ...currentArgs){
		return function partiallyApplied(...laterArgs){ return fun.call(context, ...laterArgs, ...currentArgs); };
	};
 
	_public.$function.branches= function(reduceFun= (acc, res)=> (acc.push(res), acc), reduceInitValueCreator= ()=> []){
		return function mapFunctions(...functions){
			return function inputProccess(...inputs){
				const finalReduceFun= (acc, fun)=> reduceFun(acc, fun(...inputs));
				return functions.reduce(finalReduceFun, typeof reduceInitValueCreator==="function" ? reduceInitValueCreator() : reduceInitValueCreator);
			};
		};
	};
 
	_public.$function.call= function(...args){ return function(fun){ return fun.call(this, ...args); }; };
 
	_public.$function.conditionalCall= function(mixed,fun){
		if(!mixed) return false;
		if(typeof fun === "function") return fun(mixed);
		return mixed;
	};
 
	_public.$function.constant= constantArg=> ()=> constantArg;
 
	_public.$function.each= function(...functions){ return function(input){ for(let i=0, i_length= functions.length; i<i_length; i++){ functions[i](input); } }; };
 
	_public.$function.exception= function(_throw){ throw _throw; };
 
	_public.$function.exceptionError= function(message){ throw new Error(message); };
 
	_public.$function.gather= function(fun, ...spliced){
		if(!spliced.length) return function(...args){ return fun.call(this, args); };
		return function(...args){ args.splice(...spliced); return fun.call(this, args); };
	};
 
	_public.$function.identity= id=> id;
 
	_public.$function.ifElse= function(onTrue, onFalse= v=> v, onTest= Boolean){
		return function(...val){
			if(onTest(...val)) return onTrue(...val);
			if(typeof onFalse==="function") return onFalse(...val);
		};
	};
 
	_public.$function.partial= function(fn, ...currentArgs){
		return function partiallyApplied(...laterArgs){ return fn.call(this, ...currentArgs, ...laterArgs); };
	};
 
	_public.$function.partialRight= function(fn, ...currentArgs){
		return function partiallyApplied(...laterArgs){ return fn.call(this, ...laterArgs, ...currentArgs); };
	};
 

	_public.$optimizier= {};
	 
	_public.$optimizier.timeoutAnimationFrame= function(f, delay= 150){setTimeout(requestAnimationFrame.bind(null, f),delay);};
	_public.$function.schedule= function(functions, {context= window, delay= 150}= {}){
		_public.$optimizier.timeoutAnimationFrame(function loop(){
			let process= functions.shift();
			process.call(context);
			if(functions.length > 0) _public.$optimizier.timeoutAnimationFrame(loop, delay);
		}, delay);
	};
 
	_public.$function.self= function(){ return this; };
 
	_public.$function.sequention= function(...functions){return function(input){
		let current= input;
		for(let i=0, i_length= functions.length; i<i_length; i++)
			current= functions[i].call(this, current);
		return current;
	}; };
 

	class __sequentionCatch__{
	    constructor(callback){ this.callback= callback; }
	    call(context, input){ return this.callback.call(context, input); }
	}
	_public.$function.sequentionCatch= function(fun= _public.$function.identity){ return new __sequentionCatch__(fun); };
	_public.$function.sequentionTry= function(...functions){
		const i_length= functions.length;
		return function(input){
			let current= input, err= false;
			for(let i= 0, is_catch; i<i_length; i++){
				is_catch= functions[i] instanceof __sequentionCatch__;
				if(err&&is_catch){
					try{ current= functions[i].call(this, current); err= false; }
					catch(e){ current= e; }
				} else if(!err&&!is_catch) {
					try{ current= functions[i].call(this, current); }
					catch(e){ current= e; err= true; }
				}
			}
			if(err) throw current;
			return current;
		};
	};
 
	_public.$function.sideEffect= function(callback){ return function(input){ callback.call(this, input); return input; }; };
 
	_public.$function.spread= function(fun, ...spliced){
		if(!spliced.length) return function(args= []){ return fun.apply(this, args); };
		return function(args= []){ args.splice(...spliced); return fun.apply(this, args); };
	};

	_public.$object= {};
	 
	_public.$object.each= __objectEach;
	_public.$object.eachDynamic= __objectEachDynamic;
	function __objectEach(iterable, i_function, scope, share){
	    const iterable_keys= Object.keys(iterable);
	    for(let index=0, index_length= iterable_keys.length, key; index<index_length; index++){ key= iterable_keys[index];
	        share= i_function.call(scope, { item: iterable[key], key, index, share });
	    }
	    return share;
	}
	function __objectEachDynamic(iterable, i_function, scope){
	    let share;
	    for(let key in iterable){
	        if (iterable.hasOwnProperty(key)){
	            share= i_function.call(scope, { item: iterable[key], key, target: iterable, share });
	        }
	    }
	    return share;
	}
 
	_public.$object.assignDescriptor= function(obj, property, descriptor){
		if(typeof descriptor==="function") descriptor= descriptor(property);
		return Object.defineProperty(obj, property,
			Object.assign(Object.getOwnPropertyDescriptor(obj, property), descriptor));
	};
 
	_public.$object.fromArray= function(arr, fun= (acc, curr, i)=> acc[""+i]= curr, default_value= {}){
		return arr.reduce((acc, curr, i)=>{ fun(acc, curr, i); return acc; }, default_value);
	};
 
	_public.$object.hasProp= function(obj, prop){ return Object.prototype.hasOwnProperty.call(obj, prop); };
 
	_public.$object.immutable_keys= function(obj_input={}){
		return new Proxy(Object.keys(obj_input).reduce(function(obj,key){obj[key]= obj_input[key]; return obj;},{}),{
			get(target, command){
				if(Object.keys(target).indexOf(command)!==-1){
					return target[command];
				} else {
					switch(command){
						case "set":
							return setItemFCE(target);
						case "keys":
							return function(){return Object.keys(target);};
						default:
							return;
					}
					
				}
			},
			set(){return false;}
		});
		function setItemFCE(target){
			return function(key, value){
				if(Object.keys(target).indexOf(key)!==-1) return false;
				target[key]= value;
				return true;
			};
		}
	};
 
	_public.$object.method= (methodName, ...args)=> object=> object[methodName](...args);
 
	_public.$object.methodFrom= object=> methodName=> (...args)=> object[methodName](...args);
 
	_public.$object.pluck= key=> object=> object[key];
 
	_public.$object.pluckFrom= object=> key=> object[key];
 
	_public.$object.setter= (setterName, arg)=> object=> (object[setterName]= arg, object);
 
	_public.$object.setterFrom= object=> setter_name=> arg=> (object[setter_name]= arg, object);
 
	_public.$optimizier.debounce= function(func, wait, immediate) {
		if(!wait) wait= 150;
		var timeout, args, context, timestamp;
		return function() {
			context= this; args = [].slice.call(arguments, 0);
			timestamp= new Date();
			let later= function() {
				let time_diff= (new Date()) - timestamp;
				if (time_diff < wait) {
					timeout= setTimeout(later, wait-time_diff);
				} else {
					timeout= null;
					if(!immediate) func.apply(context, args);
				}
			};
			if(immediate&&!timeout) func.apply(context, args);
			if(!timeout) timeout= setTimeout(later, wait);
		};
	};
 
	/* global requestIdleCallback, cancelIdleCallback *///gulp.keep.line
	/* see https://github.com/GoogleChromeLabs/idlize/ */
	const [ rIC, cIC ]= (supports=> {
	    if(supports) return [ requestIdleCallback, cancelIdleCallback ];
	    /* minimal shim */
	    class IdleDeadline {
	        constructor(init_time){ this._init_time= init_time; }
	        get didTimeout(){ return false; }
	        timeRemaining(){ return Math.max(0, 50 - (now() - this._init_time)); }
	    }
	    return [
	        function requestIdleCallback(callback){
	            const deadline= new IdleDeadline(now());
	            return setTimeout(()=> callback(deadline), 0);
	        },
	        function cancelIdleCallback(handle){
	            clearTimeout(handle);
	        }
	    ];
	    function now(){ return +(new Date());}
	})(typeof requestIdleCallback === 'function'); 
	class IdleValue {
	    constructor(init, msg= "IdleValue: `init` argument for class constructor must be a function!"){
	        if(typeof init!=="function") throw new TypeError(msg);
	        this._init= init;
	        this._value= undefined;
	        this._idleHandle= rIC(this.initValue.bind(this));
	    }
	    initValue(){
	        if(!this._init) return this._value;
	        this._value= this._init();
	        this._init= undefined;
	        return this._value;
	    }
	    value(){
	        if(this._value!==undefined) return this._value;
	        this.cancel();
	        return this.initValue();
	    }
	    cancel(){
	        if(this._idleHandle){
	            cIC(this._idleHandle);
	            this._idleHandle= undefined;
	        }
	        return this._value;
	    }
	}
	IdleValue.throwErrorIfNotIdleValue= function(candidat, msg){
	    if(candidat instanceof IdleValue) return true;
	    throw new Error(msg);
	};
	_public.$optimizier.setIdleValue= function(initFunction){ return new IdleValue(initFunction, "`setIdleValue`: `initFunction` argument must be a function!"); };
	_public.$optimizier.getIdleValue= function(idle_value){ if(IdleValue.throwErrorIfNotIdleValue(idle_value, "`getIdleValue`: Argument `idle_value` is not `IdleValue`!")) return idle_value.value(); };
	_public.$optimizier.clearIdleValue= function(idle_value){ if(IdleValue.throwErrorIfNotIdleValue(idle_value, "`clearIdleValue`: Argument `idle_value` is not `IdleValue`!")) idle_value.cancel(); };
 
	_public.$optimizier.once= function(fn, context){
		var result;
		return function(){
			if(fn){
				result= fn.apply(context || this, arguments);
				fn= null;
			}
			return result;
		};
	};
 
	_public.$optimizier.poll_= function(fn, timeout, interval) {
		var endTime= Number(new Date()) + (timeout || 2000);
		interval= interval || 100;
		var checkCondition= function(resolve, reject) {
			var result = fn();
			if(result) {
				resolve(result);
			}
			else if (Number(new Date()) < endTime) {
				setTimeout(checkCondition, interval, resolve, reject);
			}
			else {
				reject(new Error('timed out for ' + fn + ': ' + arguments));
			}
		};
		return new Promise(checkCondition);
	};
 
	_public.$optimizier.requestAnimationFrame_= function(input){ return new Promise(function(resolve){ requestAnimationFrame(resolve.bind(this, input)); }); };
 
	_public.$optimizier.setTimeout_= function(timeout= 0){ return (...params)=> new Promise(function(resolve){ setTimeout(resolve, timeout, ...params); }); };

 
	_public.$optimizier.trottle= function(func, cycles_leap){
		if(!cycles_leap) cycles_leap= 1;
		var args, context, cycle, counter= 0;
		function check(){
			if(counter===cycles_leap){
				counter= 0;
				cancelAnimationFrame(cycle);
			} else {
				cycle= requestAnimationFrame(check);
			}
		}
		return function(){
			context= this; args = [].slice.call(arguments, 0);
			if(!counter){
				counter++;
				func.apply(context, args);
				cycle= requestAnimationFrame(check);
			}
		};
	};

	_public.$string= {};
	 
	_public.$string.clearSpaces= function(str) {
		if(typeof str !== "string") return false;
		return str.replace(/\s+/g, "");
	};
 
	_public.$string.containsRepeatingChars= function(str, quantity= 2){
		if(typeof str !== "string") return false;
		let re= new RegExp("(\\S)(\\1{"+quantity+",})","g");
		str= str.replace(/\s+/g,"_");
		return re.test(str);
	};
 
	_public.$string.containsSequential= function(str, quantity){
		if(typeof str !== "string") return false;
		quantity= quantity || 2;
		let out= false;
		let seq= +str[0], repeat_count=1;
		for(let i= 1, i_length= str.length; i < i_length; i++){
			if(+str[i]-repeat_count===seq&&!out){
				if(++repeat_count>quantity){
					out= true;
				}
			} else if(!out) {
				seq= +str[i];
				repeat_count= 1;
			}
		}
		if(!out){
			seq= String.fromCharCode(str.charCodeAt(0));
			repeat_count=1;
			for(let i= 1, i_length= str.length; i < i_length; i++){
				if(this.letterInc(String.fromCharCode(str.charCodeAt(i)),-repeat_count)===seq&&!out){
					if(++repeat_count>quantity){
						out= true;
					}
				} else if(!out) {
					seq= String.fromCharCode(str.charCodeAt(i));
					repeat_count= 1;
				}
			}
		}
		return out;
	};
 
	_public.$string.getSubstring= function(str, len, start= 0) {
		if(start < 0) start= 0;
		if (str.length > len+start) {str = str.substring(start, len);}
		return str;
	};
 
	_public.$string.isEmail= function(email_candidate){
		/*_@_*/ let e= email_candidate.split("@"); if(e.length!==2) return false;
		/*_@_._*/ e= [e[0], ...e[1].split(".")]; if(e.length<3) return false;
		const _e= !/(#|\?|!|\\|\/|\||\.\.)/i.test(e[0]); return _e && e.reduce((r,o)=>r&&o.length>1&&!/\s/.test(o), _e);
	};
 
	_public.$string.isFilled= function(str){
		if(typeof str !== "string") return false;
		return str.trim() ? Boolean(str) : false;
	};
 
	_public.$string.toCamelCase= function(str){ // in fact upper only first letter and keep other characters
		/* not string or empty */ if(typeof str !== "string") throw Error("Type of 'str' is not string!"); if(!str) return str;
		let [ firstLetter, ...rest ]= str.split("");
		return ([ firstLetter.toUpperCase(), ...rest ]).join("");
	};
 
	_public.$string.clearHTML= function(str){
		const div= document.createElement('div');
		div.innerHTML= str;
		return div.textContent;
	};
 
	_public.$string.concatLeft= function(text_right){ return function(text_left){ return String(text_left)+text_right; }; };
 
	_public.$string.concatRight= function(text_left){ return function(text_right){ return String(text_left)+text_right; }; };
 
	_public.$string.countChars= function(str){
		if(typeof str !== "string") return false;
		const str_length= str.length;
		let counter= 0;
		let char_code;
		for(let i=0; i<str_length; i++){
			char_code= str.charCodeAt(i);
			counter+= (char_code==94 || char_code>127) ? 2 : 1;
		}
		return counter;
	};
 
	_public.$string.escapeHTML= function(str){
		const pre= document.createElement("pre");
		pre.textContent= str;
		return pre.innerHTML;
	};
 
	_public.$string.generateUnique= function(){
		return (new Date()).getTime()+"_"+(performance.now().toString(36)+Math.random().toString(36)).replace(/\./g, (""+Math.random()).charAt(0)).slice(0, 10);
	};
 
	_public.$string.letterInc= function(str, inc, pos){
		if(typeof pos === "undefined") pos= str.length-1;
		let ch= str.charCodeAt(pos);
		if(!inc) inc= 1;
		let ch_out, output;
		
		if(!ch) ch=0;
		else if(ch<65) ch=65;
		else if(ch>90&&ch<97) ch=97;
		else if(ch>122) ch=122;
		ch_out= ch+inc;
		if(ch===0||ch_out<65) output=false;
		else if(ch_out>90&&ch_out<97) output=false;
		else if(ch_out>122) output=false;
		else output= String.fromCharCode(ch_out);
		if(output) str= str.substr(0,pos) + output + str.substr(pos+1);
		return str;
	};
 
	_public.$string.template= function(str, keysFun= Object.keys){
		if(typeof str !== "string") throw Error("Type of 'str' is not string!");
		const reg= /\$\{([\s]*[^;\s\{]+[\s]*)\}/g;
		const _this= Object.freeze({ partial, partialRest, setKeysFilter, isSubstituted, execute });
		return _this;
		function partial(params_obj={}){ str= execute(params_obj); return _this; }
		function partialRest(...args){
			let i= 0, i_length= args.length;
			str= str.replace(reg, replaceHandler);
			return _this;
			function replaceHandler(all){ return i++<i_length ? args[i-1] : all; }
		}
		function setKeysFilter(filterFun){ keysFun= filterFun; return _this; }
		function isSubstituted(){ return !reg.test(str); }
		function execute(params_obj={}){
			const params_obj_keys= keysFun(params_obj);
			if(!params_obj_keys.length) return str;
			return str.replace(reg, replaceHandler);
			function replaceHandler(all, match){ return params_obj_keys.indexOf(match)!==-1 ? params_obj[match] : all; }
		}
	};

	_public.$time= {};
	 
 
	(function(){
		
		const $time= (function $time_iief(){
		    const /* internal store */
		        format_objects= (({ time, date, seconds })=>({
		            time, date,
		            time_seconds: Object.assign(seconds, time),
		            date_time: Object.assign({}, time, date),
		            date_time_seconds: Object.assign({}, Object.assign(seconds, time), date)
		        }))({
		            time: { hour: "2-digit", minute: "2-digit" },
		            date: { year: "numeric", day: "2-digit", month: "2-digit" },
		            seconds: { second: "2-digit" }
		        }),
		        format_arrays= (({ dash, colon, space, two_dig })=>({
		            SQL_DATE: [ ["year", "numeric"], dash, ["month", two_dig], dash, ["day", two_dig] ],
		            SQL_TIME: [ ["hour", two_dig, "h23"], colon, ["minute", two_dig], colon, ["second", two_dig] ],
		            SQL: [ ["year", "numeric"], dash, ["month", two_dig], dash, ["day", two_dig], space, ["hour", two_dig, "h23"], colon, ["minute", two_dig], colon, ["second", two_dig] ]
		        }))({
		            dash: [ "text", "-" ],
		            colon: [ "text", ":" ],
		            space: [ "text", " " ],
		            two_dig: "2-digit"
		        }),
		        ordinal_numbers= [ "th", "st", "nd", "rd" ];
		    const /* validation functions */
		        isDateString= date_string=> date_string.indexOf("-")!==-1,
		        isTimeString= date_string=> date_string.indexOf("T")!==-1;
		    let /* internal variables*/
		        internal_locale= "en-GB",
		        internal_zone= "";
		    const ary_ianna_time_zones= Object.freeze([
		        'Africa/Abidjan',
		        'Africa/Accra',
		        'Africa/Algiers',
		        'Africa/Bissau',
		        'Africa/Cairo',
		        'Africa/Casablanca',
		        'Africa/Ceuta',
		        'Africa/El_Aaiun',
		        'Africa/Johannesburg',
		        'Africa/Juba',
		        'Africa/Khartoum',
		        'Africa/Lagos',
		        'Africa/Maputo',
		        'Africa/Monrovia',
		        'Africa/Nairobi',
		        'Africa/Ndjamena',
		        'Africa/Sao_Tome',
		        'Africa/Tripoli',
		        'Africa/Tunis',
		        'Africa/Windhoek',
		        'America/Adak',
		        'America/Anchorage',
		        'America/Araguaina',
		        'America/Argentina/Buenos_Aires',
		        'America/Argentina/Catamarca',
		        'America/Argentina/Cordoba',
		        'America/Argentina/Jujuy',
		        'America/Argentina/La_Rioja',
		        'America/Argentina/Mendoza',
		        'America/Argentina/Rio_Gallegos',
		        'America/Argentina/Salta',
		        'America/Argentina/San_Juan',
		        'America/Argentina/San_Luis',
		        'America/Argentina/Tucuman',
		        'America/Argentina/Ushuaia',
		        'America/Asuncion',
		        'America/Atikokan',
		        'America/Bahia_Banderas',
		        'America/Bahia',
		        'America/Barbados',
		        'America/Belem',
		        'America/Belize',
		        'America/Blanc-Sablon',
		        'America/Boa_Vista',
		        'America/Bogota',
		        'America/Boise',
		        'America/Cambridge_Bay',
		        'America/Campo_Grande',
		        'America/Cancun',
		        'America/Caracas',
		        'America/Cayenne',
		        'America/Costa_Rica',
		        'America/Creston',
		        'America/Cuiaba',
		        'America/Curacao',
		        'America/Danmarkshavn',
		        'America/Dawson_Creek',
		        'America/Dawson',
		        'America/Denver',
		        'America/Detroit',
		        'America/Edmonton',
		        'America/Eirunepe',
		        'America/El_Salvador',
		        'America/Fort_Nelson',
		        'America/Fortaleza',
		        'America/Glace_Bay',
		        'America/Godthab',
		        'America/Goose_Bay',
		        'America/Grand_Turk',
		        'America/Guatemala',
		        'America/Guayaquil',
		        'America/Guyana',
		        'America/Halifax',
		        'America/Havana',
		        'America/Hermosillo',
		        'America/Chicago',
		        'America/Chihuahua',
		        'America/Indiana/Indianapolis',
		        'America/Indiana/Knox',
		        'America/Indiana/Marengo',
		        'America/Indiana/Petersburg',
		        'America/Indiana/Tell_City',
		        'America/Indiana/Vevay',
		        'America/Indiana/Vincennes',
		        'America/Indiana/Winamac',
		        'America/Inuvik',
		        'America/Iqaluit',
		        'America/Jamaica',
		        'America/Juneau',
		        'America/Kentucky/Louisville',
		        'America/Kentucky/Monticello',
		        'America/La_Paz',
		        'America/Lima',
		        'America/Los_Angeles',
		        'America/Maceio',
		        'America/Managua',
		        'America/Manaus',
		        'America/Martinique',
		        'America/Matamoros',
		        'America/Mazatlan',
		        'America/Menominee',
		        'America/Merida',
		        'America/Metlakatla',
		        'America/Mexico_City',
		        'America/Miquelon',
		        'America/Moncton',
		        'America/Monterrey',
		        'America/Montevideo',
		        'America/Nassau',
		        'America/New_York',
		        'America/Nipigon',
		        'America/Nome',
		        'America/Noronha',
		        'America/North_Dakota/Beulah',
		        'America/North_Dakota/Center',
		        'America/North_Dakota/New_Salem',
		        'America/Ojinaga',
		        'America/Panama',
		        'America/Pangnirtung',
		        'America/Paramaribo',
		        'America/Phoenix',
		        'America/Port_of_Spain',
		        'America/Port-au-Prince',
		        'America/Porto_Velho',
		        'America/Puerto_Rico',
		        'America/Punta_Arenas',
		        'America/Rainy_River',
		        'America/Rankin_Inlet',
		        'America/Recife',
		        'America/Regina',
		        'America/Resolute',
		        'America/Rio_Branco',
		        'America/Santarem',
		        'America/Santiago',
		        'America/Santo_Domingo',
		        'America/Sao_Paulo',
		        'America/Scoresbysund',
		        'America/Sitka',
		        'America/St_Johns',
		        'America/Swift_Current',
		        'America/Tegucigalpa',
		        'America/Thule',
		        'America/Thunder_Bay',
		        'America/Tijuana',
		        'America/Toronto',
		        'America/Vancouver',
		        'America/Whitehorse',
		        'America/Winnipeg',
		        'America/Yakutat',
		        'America/Yellowknife',
		        'Antarctica/Casey',
		        'Antarctica/Davis', //'Antarctica/DumontDUrville', // https://bugs.chromium.org/p/chromium/issues/detail?id=928068
		        'Antarctica/Macquarie',
		        'Antarctica/Mawson',
		        'Antarctica/Palmer',
		        'Antarctica/Rothera',
		        'Antarctica/Syowa',
		        'Antarctica/Troll',
		        'Antarctica/Vostok',
		        'Asia/Almaty',
		        'Asia/Amman',
		        'Asia/Anadyr',
		        'Asia/Aqtau',
		        'Asia/Aqtobe',
		        'Asia/Ashgabat',
		        'Asia/Atyrau',
		        'Asia/Baghdad',
		        'Asia/Baku',
		        'Asia/Bangkok',
		        'Asia/Barnaul',
		        'Asia/Beirut',
		        'Asia/Bishkek',
		        'Asia/Brunei',
		        'Asia/Colombo',
		        'Asia/Damascus',
		        'Asia/Dhaka',
		        'Asia/Dili',
		        'Asia/Dubai',
		        'Asia/Dushanbe',
		        'Asia/Famagusta',
		        'Asia/Gaza',
		        'Asia/Hebron',
		        'Asia/Ho_Chi_Minh',
		        'Asia/Hong_Kong',
		        'Asia/Hovd',
		        'Asia/Chita',
		        'Asia/Choibalsan',
		        'Asia/Irkutsk',
		        'Asia/Jakarta',
		        'Asia/Jayapura',
		        'Asia/Jerusalem',
		        'Asia/Kabul',
		        'Asia/Kamchatka',
		        'Asia/Karachi',
		        'Asia/Kathmandu',
		        'Asia/Khandyga',
		        'Asia/Kolkata',
		        'Asia/Krasnoyarsk',
		        'Asia/Kuala_Lumpur',
		        'Asia/Kuching',
		        'Asia/Macau',
		        'Asia/Magadan',
		        'Asia/Makassar',
		        'Asia/Manila',
		        'Asia/Nicosia',
		        'Asia/Novokuznetsk',
		        'Asia/Novosibirsk',
		        'Asia/Omsk',
		        'Asia/Oral',
		        'Asia/Pontianak',
		        'Asia/Pyongyang',
		        'Asia/Qatar',
		        'Asia/Qyzylorda', //'Asia/Qostanay', // https://bugs.chromium.org/p/chromium/issues/detail?id=928068
		        'Asia/Riyadh',
		        'Asia/Sakhalin',
		        'Asia/Samarkand',
		        'Asia/Seoul',
		        'Asia/Shanghai',
		        'Asia/Singapore',
		        'Asia/Srednekolymsk',
		        'Asia/Taipei',
		        'Asia/Tashkent',
		        'Asia/Tbilisi',
		        'Asia/Tehran',
		        'Asia/Thimphu',
		        'Asia/Tokyo',
		        'Asia/Tomsk',
		        'Asia/Ulaanbaatar',
		        'Asia/Urumqi',
		        'Asia/Ust-Nera',
		        'Asia/Vladivostok',
		        'Asia/Yakutsk',
		        'Asia/Yangon',
		        'Asia/Yekaterinburg',
		        'Asia/Yerevan',
		        'Atlantic/Azores',
		        'Atlantic/Bermuda',
		        'Atlantic/Canary',
		        'Atlantic/Cape_Verde',
		        'Atlantic/Faroe',
		        'Atlantic/Madeira',
		        'Atlantic/Reykjavik',
		        'Atlantic/South_Georgia',
		        'Atlantic/Stanley',
		        'Australia/Adelaide',
		        'Australia/Brisbane',
		        'Australia/Broken_Hill',
		        'Australia/Currie',
		        'Australia/Darwin',
		        'Australia/Eucla',
		        'Australia/Hobart',
		        'Australia/Lindeman',
		        'Australia/Lord_Howe',
		        'Australia/Melbourne',
		        'Australia/Perth',
		        'Australia/Sydney',
		        'Europe/Amsterdam',
		        'Europe/Andorra',
		        'Europe/Astrakhan',
		        'Europe/Athens',
		        'Europe/Belgrade',
		        'Europe/Berlin',
		        'Europe/Brussels',
		        'Europe/Budapest',
		        'Europe/Bucharest',
		        'Europe/Copenhagen',
		        'Europe/Dublin',
		        'Europe/Gibraltar',
		        'Europe/Helsinki',
		        'Europe/Chisinau',
		        'Europe/Istanbul',
		        'Europe/Kaliningrad',
		        'Europe/Kiev',
		        'Europe/Kirov',
		        'Europe/Lisbon',
		        'Europe/London',
		        'Europe/Luxembourg',
		        'Europe/Madrid',
		        'Europe/Malta',
		        'Europe/Minsk',
		        'Europe/Monaco',
		        'Europe/Moscow',
		        'Europe/Oslo',
		        'Europe/Paris',
		        'Europe/Prague',
		        'Europe/Riga',
		        'Europe/Rome',
		        'Europe/Samara',
		        'Europe/Saratov',
		        'Europe/Simferopol',
		        'Europe/Sofia',
		        'Europe/Stockholm',
		        'Europe/Tallinn',
		        'Europe/Tirane',
		        'Europe/Ulyanovsk',
		        'Europe/Uzhgorod',
		        'Europe/Vienna',
		        'Europe/Vilnius',
		        'Europe/Volgograd',
		        'Europe/Warsaw',
		        'Europe/Zaporozhye',
		        'Europe/Zurich',
		        'Indian/Cocos',
		        'Indian/Chagos',
		        'Indian/Christmas',
		        'Indian/Kerguelen',
		        'Indian/Mahe',
		        'Indian/Maldives',
		        'Indian/Mauritius',
		        'Indian/Reunion',
		        'Pacific/Apia',
		        'Pacific/Auckland',
		        'Pacific/Bougainville',
		        'Pacific/Easter',
		        'Pacific/Efate',
		        'Pacific/Enderbury',
		        'Pacific/Fakaofo',
		        'Pacific/Fiji',
		        'Pacific/Funafuti',
		        'Pacific/Galapagos',
		        'Pacific/Gambier',
		        'Pacific/Guadalcanal',
		        'Pacific/Guam',
		        'Pacific/Honolulu',
		        'Pacific/Chatham',
		        'Pacific/Chuuk',
		        'Pacific/Kiritimati',
		        'Pacific/Kosrae',
		        'Pacific/Kwajalein',
		        'Pacific/Majuro',
		        'Pacific/Marquesas',
		        'Pacific/Nauru',
		        'Pacific/Niue',
		        'Pacific/Norfolk',
		        'Pacific/Noumea',
		        'Pacific/Pago_Pago',
		        'Pacific/Palau',
		        'Pacific/Pitcairn',
		        'Pacific/Pohnpei',
		        'Pacific/Port_Moresby',
		        'Pacific/Rarotonga',
		        'Pacific/Tahiti',
		        'Pacific/Tarawa',
		        'Pacific/Tongatapu',
		        'Pacific/Wake',
		        'Pacific/Wallis'
		    ]);
		    /**
		     * This object stores offsets in `ary_ianna_time_zones` (keys) and one corresponding index.
		     * 
		     * So for exmple, `ary_ianna_time_offsets["CET"]` is equal to **284** which is index of `ary_ianna_time_zones[284]==='Europe/Prague'` (in winter "+01:00" and in summer "+02:00").
		     * 
		     * Next example is `ary_ianna_time_offsets["-01:00"]` is equal to **238** which is index of `ary_ianna_time_zones[238]==='Atlantic/Cape_Verde'` (always "-01:00").
		     * 
		     * **IMPORTANT NOTE:** BST, EET, WET hasn't been validated! … idea is to behave the same way like CET
		     * @property {Object} ary_ianna_time_offsets
		     * @private
		     * @memberof module:jaaJSU~$time
		     */
		    const ary_ianna_time_offsets= Object.freeze({
		        '-01:00': 238,
		        '-02:00': 242,
		        '-03:00': 107,
		        '-04:00': 49,
		        '-05:00': 92,
		        '-06:00': 62,
		        '-07:00': 120,
		        '-08:00': 337,
		        '-09:00': 320,
		        '-09:30': 330,
		        '-10:00': 323,
		        '-11:00': 332,
		        '+01:00': 15,
		        '+02:00': 8,
		        '+03:00': 270,
		        '+04:00': 306,
		        '+04:30': 191,
		        '+05:00': 221,
		        '+05:30': 173,
		        '+05:45': 194,
		        '+06:00': 207,
		        '+06:30': 232,
		        '+07:00': 182,
		        '+08:00': 220,
		        '+08:30': 210,
		        '+08:45': 249,
		        '+09:00': 176,
		        '+09:30': 248,
		        '+10:00': 229,
		        '+11:00': 314,
		        '+12:00': 345,
		        '+13:00': 316,
		        '+14:00': 326,
		        BST: 275,
		        CET: 284,
		        CEST: 284,
		        EET: 264,
		        EEST: 264,
		        WET: 274,
		        WEST: 274
		    });
		    
		    function fromDate(date_instance){
		        return toDateArray(date_instance.toISOString());
		    }
		    function fromDateArguments(...args){
		        return toDateArray((args.filter(d=> typeof d!=="undefined").length ? new Date(...args) : new Date()).toISOString());
		    }
		    function fromNow(){
		        return toDateArray((new Date()).toISOString());
		    }
		    function fromString(timestamp_string, timezone= internal_zone){
		        if(!timestamp_string) return fromNow();
		        let date_array= toDateArray(timestamp_string);
		        if(date_array.length!==3){
		            if(!isDateString(date_array[0])) date_array.unshift("");
		            else if(!isTimeString(date_array[1])){
		                date_array[2]= date_array[1] || timezone;
		                date_array[1]= "";
		            } else {
		                date_array[2]= timezone;
		            }
		        } else if(!date_array[2]&&timezone){ date_array[2]= timezone; }
		        return date_array;
		    }
		    function toDateArray(timestamp_string){
		        let /* these hold outputs */
		            date= "", time= "", zone= "";
		        let /* iteration vars: curr letter instring +helpers for timezones */
		            letter, acc= "", substr_index;
		        while(timestamp_string.length){
		            letter= timestamp_string[0];
		            if(/\d/.test(letter)){
		                if(!timestamp_string.search(/\d\d\d\d-\d\d-\d\d/)){
		                    date= timestamp_string.substr(0, 10);
		                    timestamp_string= timestamp_string.substr(10);
		                } else if(!timestamp_string.search(/\d\d\/\d\d\/\d\d\d\d/)){
		                    date= timestamp_string.substr(0, 10).split("/").sort(()=> -1).join("-");
		                    timestamp_string= timestamp_string.substr(10);
		                } else if(!timestamp_string.search(/\d\d:\d\d:\d\d/)){
		                    time= "T"+timestamp_string.substr(0, 8);
		                    timestamp_string= timestamp_string.substr(8);
		                } else if(!timestamp_string.search(/\d\d:\d\d/)){
		                    time= "T"+timestamp_string.substr(0, 5)+":00";
		                    timestamp_string= timestamp_string.substr(5);
		                } else {
		                    timestamp_string= timestamp_string.substr(1);
		                }
		            } else if(/[ ,\._]/.test(letter)||!timestamp_string.substring(0, 2).search(/T\d/)){
		                timestamp_string= timestamp_string.substr(1);
		            } else if(!timestamp_string.search(/[\+\-]\d\d:\d\d/)){
		                acc= timestamp_string.substr(0, 6);
		                timestamp_string= timestamp_string.substr(6);
		                if(Reflect.has(ary_ianna_time_offsets, acc)){
		                    zone= acc;
		                    acc= "";
		                } else if(acc.substr(1,5)==="00:00"){
		                    zone= "Z";
		                    acc= "";
		                }
		            } else if(!timestamp_string.search(/[A-Z]{2,}/)){
		                substr_index= timestamp_string.search(/[^A-Z]/);
		                acc= substr_index===-1 ? timestamp_string : timestamp_string.substr(0, substr_index);
		                timestamp_string= timestamp_string.substr(acc.length);
		                if(acc==="CET"){//Reflect.has(ary_ianna_time_offsets, acc)
		                    zone= acc;
		                    acc= "";
		                }
		            } else if(letter==="Z"){
		                zone= "Z";
		                timestamp_string= timestamp_string.substr(1);
		            } else {
		                timestamp_string= timestamp_string.substr(1);
		            }
		            if(date&&time&&zone){ timestamp_string= ""; }
		        }
		        return [ date, time, zone ];
		    }
		    function toStringFromObject(format= format_arrays.SQL, { locale= internal_locale, declension= true, timeZone= internal_zone }= {}){
		        return date_array=> format.map(evaluateFormatObject(toDate(date_array), locale, timeZone, declension)).join("");
		    }
		    function evaluateFormatObject(date, locale, timeZone, declension){
		        const localeObj= generateTimeZoneFormatObject.bind(null, timeZone);
		        return function([type, value, modify]){
		            let out= evaluateNthFromObject(date, type, value, modify, declension, locale, timeZone, localeObj);
		            if(value==="2-digit"&&String(out).length===1) out= "0"+out; //fix
		            if(modify==="two_letters") out= out.substr(0,2);
		            else if(modify==="ordinal_number"&&locale.indexOf("en")!==-1) out= getOrdinalSuffix(out);
		            return out;
		        };
		    }
		    function evaluateNthFromObject(date, type, value, modify, declension, locale, timeZone, localeObj){
		        switch (true){
		            case type==="text":                                     return value;
		            case type==="week":                                     return getWeekNumber(!timeZone ? date: new Date(( (l, timeZone, two)=> l({ timeZone, year: "numeric" })+"-"+double(l({ timeZone, month: two }))+"-"+double(l({ timeZone, day: two }))+"T"+double(l({ timeZone, hour: two }))+":"+double(l({ timeZone, minute: two }))+":"+double(l({ timeZone, second: two })) )( Date.prototype.toLocaleString.bind(date, "en-GB"), timeZone, "2-digit" )));
		            case type==="weekday"&&value==="numeric":               return getWeekDay()(date);
		            case type==="month"&&value==="long"&&declension:        return date.toLocaleString(locale,localeObj({ [type]: value, day: "numeric" })).replace(/[\d \.\/\\]/g, "");
		            case type==="hour"&&modify.toLowerCase()==="a":         return date.toLocaleString(modify==="A" ? "en-US" : "en-GB",localeObj({ [type]: value, hourCycle: "h12" })).replace(/[\d \.\/\\]/g, "");
		            case type==="hour":                                     return date.toLocaleString(locale,localeObj({ [type]: value, hourCycle: modify })).replace(/[ \.\/\\pam]/ig, "");
		            default:                                                return date.toLocaleString(locale,localeObj({ [type]: value }));
		        }
		    }
		    
		    function getFormatObject(format_string= ""){
		        let out= [], out_last_index, letter;
		        while(format_string.length){
		            switch(format_string[0]){
		                case "M": handleM();                            break;
		                case "d": handled();                            break;
		                case "W": handleWD("week", "W");                break;
		                case "Y": handleY();                            break;
		                case "D": handleWD("day", "D");                 break;
		                case "H": handleHh("hour", "H", "h23");         break;
		                case "k": handleHh("hour", "k", "h24");         break;
		                case "h": handleHh("hour", "h", "h12");         break;
		                case "A": handleAa("A");                        break;
		                case "a": handleAa("a");                        break;
		                case "m": handle("minute", "m");                break;
		                case "s": handle("second", "s");                break;
		                case "[": handleText();                         break;
		                default:
		                    letter= format_string[0];
		                    out_last_index= out.length-1;
		                    if(out_last_index>-1&&out[out_last_index][0]==="text") out[out_last_index][1]+= letter;
		                    else out.push(["text", letter]);
		                    format_string= format_string.substring(1);
		            }
		        }
		        function handleM(){
		            let type= "numeric";
		            if(!format_string.search(/MMMM/)){
		                type= "long";
		                format_string= format_string.substring(4);
		            } else if(!format_string.search(/MMM/)){
		                type= "short";
		                format_string= format_string.substring(3);
		            } else if(!format_string.search(/MM/)){
		                type= "2-digit";
		                format_string= format_string.substring(2);
		            } else if(!format_string.search(/Mo/)){
		                format_string= format_string.substring(2);
		                return out.push(["month", type, "ordinal_number"]);
		            } else {
		                format_string= format_string.substring(1);
		            }
		            out.push(["month", type]);
		        }
		        function handled(){
		            let type= "numeric";
		            if(!format_string.search(/dddd/)){
		                type= "long";
		                format_string= format_string.substring(4);
		            } else if(!format_string.search(/ddd/)){
		                type= "short";
		                format_string= format_string.substring(3);
		            } else if(!format_string.search(/dd/)){
		                type= "short";
		                format_string= format_string.substring(2);
		                return out.push(["weekday", type, "two_letters"]);
		            } else {
		                format_string= format_string.substring(1);
		            }
		            out.push(["weekday", type]);
		        }
		        function handleY(){
		            let type= "2-digit";
		            if(!format_string.search(/YYYY/)){
		                type= "numeric";
		                format_string= format_string.substring(4);
		            } else {
		                format_string= format_string.substring(2);
		            }
		            out.push(["year", type]);
		        }
		        function handleWD(out_key, letter){
		            let type= "numeric";
		            if(!format_string.search(new RegExp(letter+"o"))){
		                format_string= format_string.substring(2);
		                return out.push([out_key, type, "ordinal_number"]);
		            } else if(!format_string.search(new RegExp(letter+letter))){
		                type= "2-digit";
		                format_string= format_string.substring(2);
		            } else {
		                format_string= format_string.substring(1);
		            }
		            out.push([out_key, type]);
		        }
		        function handleHh(out_key, letter, hourCycle){
		            let type= "numeric";
		            if(!format_string.search(new RegExp(letter+letter))){
		                type= "2-digit";
		                format_string= format_string.substring(2);
		            } else {
		                format_string= format_string.substring(1);
		            }
		            out.push([out_key, type, hourCycle]);
		        }
		        function handleAa(modify){
		            format_string= format_string.substring(1);
		            out.push(["hour", "numeric", modify]);
		        }
		        function handle(out_key, letter){
		            let type= "numeric";
		            if(!format_string.search(new RegExp(letter+letter))){
		                type= "2-digit";
		                format_string= format_string.substring(2);
		            } else {
		                format_string= format_string.substring(1);
		            }
		            out.push([out_key, type]);
		        }
		        function handleText(){
		            const text_end= format_string.indexOf("]");
		            if(text_end===-1){
		                format_string= format_string.substring(1);
		                return false;
		            }
		            out.push(["text", format_string.substr(1,text_end-1)]);
		            format_string= format_string.substr(text_end+1);
		        }
		        return out;
		    }
		    function toDate(date_array){
		        if(!date_array||!Array.isArray(date_array)) return new Date();
		        
		        let [ date, time, zone ]= date_array;
		        if(!date) date= fromNow()[0];
		        if(!time) time= "T00:00:00";
		        if(!zone) zone= getTimeZoneOffsetString(date);
		        if(zone==="CET"||zone==="CEST") zone= getCETOffset([ date, time ]);
		        return new Date(date+time+zone);
		    }
		    function toLocaleString(format_object_name= "date_time", { locale= internal_locale, timeZone= internal_zone }= {}){
		        return date_array=> toDate(date_array).toLocaleString(locale, generateTimeZoneFormatObject(timeZone, format_objects[format_object_name]));
		    }
		    function toRelative(reference_date_array){
		        return date_array=> getRelative(getDiffMs(reference_date_array)(date_array));
		    }
		    function getDiff(reference_time, output_measure_string= "seconds", full_precision= false){
		        const c_measure= { seconds: 1000, minutes: 60000 /* 60*sec */, hours: 3600000 /* 60*mins */, days: 86400000 /* 24*days */, weeks: 604800000 /* 7*days */, months: 2419200000 /* 4*weeks */, years: 29030400000 /* 12*months */ };
		        const diffFun= getDiffMs(reference_time, -c_measure[output_measure_string]);
		        return function diff(target_time){
		            const diff_val= diffFun(target_time);
		            return full_precision ? diff_val : Math.floor(diff_val);
		        };
		    }
		    function getDiffMs(reference_time, output_measure= 1){
		        const reference_time_ms= reference_time ? toDate(reference_time).getTime() : false;
		        return function diff(target_time){ return (toDate(target_time).getTime()-(reference_time_ms ? reference_time_ms : toDate(fromNow()).getTime()))/output_measure; };
		    }
		    function getRelative(ms_diff){
		        const { abs, floor, round }= Math;
		        const out_text= ms_diff < 0 ? "%s ago" : "in %s";
		        ms_diff= abs(ms_diff);
		        if(ms_diff<1500) return "now";
		        ms_diff= floor(ms_diff/1000);
		        if(ms_diff<10) return out_text.replace("%s", "a few seconds");
		        if(ms_diff<60) return out_text.replace("%s", ms_diff+" seconds");
		        ms_diff= floor(ms_diff/60);
		        if(ms_diff===1) return out_text.replace("%s", "a minute");
		        if(ms_diff<60) return out_text.replace("%s", ms_diff+" minutes");
		        ms_diff= round(ms_diff/60);
		        if(ms_diff===1) return out_text.replace("%s", "an hour");
		        if(ms_diff<24) return out_text.replace("%s", ms_diff+" hours");
		        ms_diff= ms_diff/24;
		        if(round(ms_diff)===1) return out_text.replace("%s", "a day");
		        if(ms_diff<29.5) return out_text.replace("%s", round(ms_diff)+" days");
		        ms_diff= ms_diff/30.41666; //avg per month
		        if(round(ms_diff)===1) return out_text.replace("%s", "a month");
		        if(ms_diff<12) return out_text.replace("%s", round(ms_diff)+" months");
		        ms_diff= round(ms_diff/12);
		        if(ms_diff===1) return out_text.replace("%s", "a year");
		        return out_text.replace("%s", ms_diff+" years");
		    }
		    function toString(format, params_obj){
		        return toStringFromObject(Array.isArray(format) ? format : format ? getFormatObject(format) : undefined, params_obj);
		    }
		    function getCETOffset([ date, time ]= []){
		        if(!date||!time){
		            let curr= fromNow();
		            if(!date) date= curr[0];
		            if(!time) time= curr[1].replace(/\.\d+/, "");
		        }
		        const /* repeting things for getting nexts consts group (line 1), for comparing in return (line 2) */
		            timeZone= "Europe/Prague", locale= "en-GB", date_and_time= date+time,
		            en_date_version= date.split("-").reverse().join("/")+", "+time.replace("T", "");
		        const /* for comparing in return */
		            [ date_one_hour, date_two_hours ]= [ "+01:00", "+02:00" ].map(offset=> new Date(date_and_time+offset).toLocaleString(locale, { timeZone }));
		        return en_date_version===date_one_hour ? "+01:00" : en_date_version===date_two_hours ? "+02:00" : "Z";
		    }
		    function getTimeZone(date, { locale= internal_locale, description= "long", offset= false }= {}){
		        description= description.toLocaleLowerCase();
		        const [ date_part, time_part, offset_part ]= getDateArrayFromMixed(date), date_instance= new Date([ date_part, time_part, offset_part ].join(""));
		        const locale_param= Object.keys(ary_ianna_time_offsets).indexOf(offset_part)!==-1 ? { timeZone: ary_ianna_time_zones[ary_ianna_time_offsets[offset_part]] } : {};
		        let out_description= description==="none" ? "" : date_instance.toLocaleString(locale, Object.assign({ timeZoneName: description }, locale_param)).replace(date_instance.toLocaleString(locale, locale_param), "").trim();
		        const out_offset= !offset ? "" : "UTC"+(offset_part==="Z" ? getTimeZoneOffsetStringFromOffset(date_instance.getTimezoneOffset()) : date_instance.toLocaleString(locale, Object.assign({ timeZoneName: "short" }, locale_param)).replace(date_instance.toLocaleString(locale, locale_param), "").replace(/[^\d\+\-\:]/g, "").trim());
		        if(out_description&&out_offset) out_description= " ("+out_description+")";
		        return out_offset+out_description;
		    }
		    function getCurrentTimeZone({ locale= internal_locale, description= "long", offset= false }= {}){
		        description= description.toLocaleLowerCase();
		        if(description!=="ianna") return getTimeZone(undefined, { locale, description, offset });
		        let out_description= "", dtf, dtf_ro;
		        if(typeof Intl!=='undefined'&&typeof Intl.DateTimeFormat==='function'){
		            dtf= Intl.DateTimeFormat() || {};
		            if(typeof dtf.resolvedOptions!=="function") return undefined;
		            dtf_ro= dtf.resolvedOptions().timeZone;
		            out_description= Object.keys(ary_ianna_time_offsets).indexOf(dtf_ro)!==-1 ? ary_ianna_time_zones[ary_ianna_time_offsets[dtf_ro]] : dtf_ro;
		        }
		        const out_offset= !offset ? "" : getTimeZone(undefined, { locale, description: "none", offset: true });
		        if(out_description&&out_offset) out_description= " ("+out_description+")";
		        return out_offset+out_description;
		    }
		    function getTimeZoneOffset(date, timeZone= internal_zone){
		        const date_instance= new Date(getDateArrayFromMixed(date).join(""));
		        if(timeZone) return getTimeZoneDiffOffset(date_instance, timeZone);
		        return date_instance.getTimezoneOffset();
		    }
		    function getTimeZoneDiffOffset(date_instance, timeZone= internal_zone){
		        const [ sign= "+", hours= 0, minutes= 0 ]= date_instance.toLocaleString('en-GB', { timeZone, weekday: "short", timeZoneName: "short" }).replace(/(\+|\-)/g, (_, m)=> m+":").replace(/[^\d:\+\-]/g, "").split(":");
		        const target_offset= ( sign==="-" ? -1 : 1 )*(Number(hours)*60+Number(minutes));
		        return target_offset+date_instance.getTimezoneOffset();
		    }
		    function getTimeZoneOffsetString(date){
		         return getTimeZoneOffsetStringFromOffset(getTimeZoneOffset(date));
		    }
		    function generateTimeZoneFormatObject(timeZone, format_object){
		        if(!timeZone) return format_object;
		        if(ary_ianna_time_zones.indexOf(timeZone)!==-1) return Object.assign({ timeZone }, format_object);
		        if(typeof ary_ianna_time_offsets[timeZone]!=="undefined") return Object.assign({ timeZone: ary_ianna_time_zones[ary_ianna_time_offsets[timeZone]] }, format_object);
		        return format_object;
		    }
		    function getDateArrayFromMixed(date_string){
		        if(!date_string) return fromNow();
		        if(!Array.isArray(date_string)) return toDateArray(date_string);
		        return date_string;
		    }
		    function getTimeZoneOffsetStringFromOffset(offset){
		        const { floor, abs }= Math;
		        let out= offset > 0 ? "-" : "+";
		        offset= abs(offset);
		        out+= double(floor(offset/60))+":"+double(offset%60);
		        return out;
		    }
		    function addDays(days_num){
		        return date_instance=> (date_instance.setDate(date_instance.getDate()+days_num), date_instance);
		    }
		    function addMonths(months_num){
		        return date_instance=> (date_instance.setMonth(date_instance.getMonth()+months_num), date_instance);
		    }
		    function getWeekDay(type= "numeric", { locale= internal_locale, timeZone= internal_zone }= {}){
		        return type==="numeric" ? date_instance=> date_instance.getDay() : date_instance=> date_instance.toLocaleString(locale, timeZone ? { timeZone, weekday: type } : { timeZone, weekday: type });
		    }
		    function getWeekNumber(date_instance){
		        const tdt= new Date(date_instance.valueOf());
		        tdt.setDate(tdt.getDate() + 3 - (date_instance.getDay() + 6) % 7);
		        var firstThursday = tdt.valueOf();
		        tdt.setMonth(0, 1);
		        if(tdt.getDay() !== 4){
		            tdt.setMonth(0, 1 + ((4 - tdt.getDay()) + 7) % 7);
		        }
		        return 1 + Math.ceil((firstThursday - tdt) / 604800000);
		    }
		    function modify(mod_obj){
		        const operations= Object.keys(mod_obj);
		        return function(date_array){
		            const dateObject= toDate(date_array);
		            for(let i=0, operation; ( operation= operations[i] ); i++){
		                if(operation==="addDays") addDays(mod_obj[operation])(dateObject);
		                else if(operation.substr(0,3)==="add") modifyAdditions(operation, mod_obj[operation], dateObject);
		                else if(operation==="setMonth") dateObject.setMonth(mod_obj[operation]-1);
		                else if(Reflect.has(dateObject, operation)) dateObject[operation](mod_obj[operation]);
		                else if(operation==="setDay") dateObject.setDate(mod_obj[operation]);
		            }
		            return fromDate(dateObject);
		        };
		    }
		    function modifyAdditions(operation, value, dateObject){
		        const cmd= operation.substr(3); /* addMonth=> ...Month => (set/get)Month */
		        dateObject["set"+cmd](dateObject["get"+cmd]()+value);
		        return dateObject;
		    }
		    function redefineTimeZone(zone= internal_zone){
		        return ([ date= "", time= "" ]= [])=> [ date, time, zone ];
		    }
		    const Date_utils= { getWeekDay, getWeekNumber, addDays, addMonths };
		    
		    /**
		    * *Backward compatibility* 
		    * Function adds leading zero to the `time`. [It can be replaced in future: see `padStart`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart).
		    * @method double
		    * @memberof module:jaaJSU~$time
		    * @public
		    * @param {Number|String} time
		    * @return {String}
		    *  * 00, 01, 02, ..., 09, 10, ..., 100, ...
		    */
		    function double(n){
		        n= String(n);
		        return n.length===1 ? "0"+n : n;
		    }
		    /**
		     * Returns number of days in given month (and year)
		     * @method daysInMonth
		     * @memberof module:jaaJSU~$time
		     * @public
		     * @param {String|Number} month ISO number of month (eg 01 or 1 for January)
		     * @param {String|Number} [year=">>current year<<"]  ISO nimber of year (eg. 2019)
		     * @returns {Number} total of days
		     */
		    function daysInMonth(month, year= (new Date()).getFullYear()){/* months indexing from 0 */
		        return new Date(+year, +month, 0 /* last in prev month */).getDate();
		    }
		    /**
		     * Returns number of days in given month
		     * @method getDaysInMonth
		     * @memberof module:jaaJSU~$time
		     * @public
		     * @param {module:jaaJSU~$time.types~DateArray} [date_array=">>current year<<"]
		     * @returns {Number} total of days
		     */
		    function getDaysInMonth([ date= fromNow()[0] ]= []){
		        const [ _, month, year ]= date.split("-").map(Number);
		        return daysInMonth(month, year);
		    }
		    /**
		    * *Backward compatibility* 
		    * @method getMonthName
		    * @memberof module:jaaJSU~$time
		    * @public
		    * @param {Number} n Month number (typically [1-12]); Works cyclically `13===1, ...`
		    * @param {Number|Boolean} [l=undefined] Length of output Month name
		    * @return {String} English month name
		    * @example
		    * console.log($time.getMonthName(5));//"May"
		    * console.log($time.getMonthName(24, 4));//"Dece"
		    */
		    function getMonthName(n,l) {
		        if(typeof n!=="number") n= parseInt(n);
		        if(isNaN(n)) return false;
		        let s= ["December","January","February","March","April","May","June", "July","August","September","October","November"];
		        let v= s[n%12];
		        if(l){
		            if(l===-1){l=3; if(v.length===4) l=4;}
		            v= v.substring(0,l);
		        }
		        return v;
		    }
		    /**
		     * *Backward compatibility* 
		     * See {@link module:jaaJSU~$time.ordinal_numbers}.
		     * @method getOrdinalSuffix
		     * @memberof module:jaaJSU~$time
		     * @public
		     * @param {Number} n
		     * @return {String} `n`+English suffix
		     * @example
		     * console.log($time.getOrdinalSuffix(1));//"1st"
		     */
		    function getOrdinalSuffix(n_orig) {
		        const n= typeof n_orig==="number" ? n_orig : parseInt(n_orig);
		        if(isNaN(n)) return n_orig;
		        let v= n%100;
		        return n_orig+(ordinal_numbers[(v-20)%10]||ordinal_numbers[v]||ordinal_numbers[0]);
		    }
		    
		    const _= void(0);
		    const formats= format_arrays;
		    
		    const getTimeZones= ()=> ary_ianna_time_zones;
		    const isTimeZone= candidate=> ary_ianna_time_zones.indexOf(candidate)!==-1;
		    const setInternalZone= zone=> internal_zone= zone;
		    const setInternalLocale= locale=> internal_locale= locale;
		    return { fromDate, fromDateArguments, fromNow, fromString, toDate, toLocaleString, toRelative, getDiff, getRelative, toString, getCETOffset, getTimeZone, getCurrentTimeZone, getTimeZoneOffset, getTimeZoneOffsetString, modify, redefineTimeZone, Date_utils, double, daysInMonth, getDaysInMonth, getMonthName, getOrdinalSuffix, _, formats, getTimeZones, isTimeZone, setInternalZone, setInternalLocale };
		})();
		 
		Object.assign(_public.$time, $time);
	})();
	_public.$time.getDateStamp= t=> _public.$time.toString(_public.$time.formats.SQL_DATE)(_public.$time.fromDateArguments(t));
 

	_public.$time.getTimeStamp= t=> _public.$time.toString(_public.$time.formats.SQL)(_public.$time.fromDateArguments(t));


	return _public;
});