re-organized js files, first attempt of adding Vue SFC

public/js/vendor/httpVueLoader.js

@@ -0,0 +1,478 @@
+(function umd(root,factory){
+	if(typeof module==='object' && typeof exports === 'object' )
+		module.exports=factory()
+	else if(typeof define==='function' && define.amd)
+		define([],factory)
+	else
+		root.httpVueLoader=factory()
+})(this,function factory() {
+	'use strict';
+
+	var scopeIndex = 0;
+
+	StyleContext.prototype = {
+
+		withBase: function(callback) {
+
+			var tmpBaseElt;
+			if ( this.component.baseURI ) {
+
+				// firefox and chrome need the <base> to be set while inserting or modifying <style> in a document.
+				tmpBaseElt = document.createElement('base');
+				tmpBaseElt.href = this.component.baseURI;
+
+				var headElt = this.component.getHead();
+				headElt.insertBefore(tmpBaseElt, headElt.firstChild);
+			}
+
+			callback.call(this);
+
+			if ( tmpBaseElt )
+				this.component.getHead().removeChild(tmpBaseElt);
+		},
+
+		scopeStyles: function(styleElt, scopeName) {
+
+			function process() {
+
+				var sheet = styleElt.sheet;
+				var rules = sheet.cssRules;
+
+				for ( var i = 0; i < rules.length; ++i ) {
+
+					var rule = rules[i];
+					if ( rule.type !== 1 )
+						continue;
+
+					var scopedSelectors = [];
+
+					rule.selectorText.split(/\s*,\s*/).forEach(function(sel) {
+
+						scopedSelectors.push(scopeName+' '+sel);
+						var segments = sel.match(/([^ :]+)(.+)?/);
+						scopedSelectors.push(segments[1] + scopeName + (segments[2]||''));
+					});
+
+					var scopedRule = scopedSelectors.join(',') + rule.cssText.substr(rule.selectorText.length);
+					sheet.deleteRule(i);
+					sheet.insertRule(scopedRule, i);
+				}
+			}
+
+			try {
+				// firefox may fail sheet.cssRules with InvalidAccessError
+				process();
+			} catch (ex) {
+
+				if ( ex instanceof DOMException && ex.code === DOMException.INVALID_ACCESS_ERR ) {
+
+					styleElt.sheet.disabled = true;
+					styleElt.addEventListener('load', function onStyleLoaded() {
+
+						styleElt.removeEventListener('load', onStyleLoaded);
+
+						// firefox need this timeout otherwise we have to use document.importNode(style, true)
+						setTimeout(function() {
+
+							process();
+							styleElt.sheet.disabled = false;
+						});
+					});
+					return;
+				}
+
+				throw ex;
+			}
+		},
+
+		compile: function() {
+
+			var hasTemplate = this.template !== null;
+
+			var scoped = this.elt.hasAttribute('scoped');
+
+			if ( scoped ) {
+
+				// no template, no scopable style needed
+				if ( !hasTemplate )
+					return;
+
+				// firefox does not tolerate this attribute
+				this.elt.removeAttribute('scoped');
+			}
+
+			this.withBase(function() {
+
+				this.component.getHead().appendChild(this.elt);
+			});
+
+			if ( scoped )
+				this.scopeStyles(this.elt, '['+this.component.getScopeId()+']');
+
+			return Promise.resolve();
+		},
+
+		getContent: function() {
+
+			return this.elt.textContent;
+		},
+
+		setContent: function(content) {
+
+			this.withBase(function() {
+
+				this.elt.textContent = content;
+			});
+		}
+	};
+
+	function StyleContext(component, elt) {
+
+		this.component = component;
+		this.elt = elt;
+	}
+
+
+	ScriptContext.prototype = {
+
+		getContent: function() {
+
+			return this.elt.textContent;
+		},
+
+		setContent: function(content) {
+
+			this.elt.textContent = content;
+		},
+
+		compile: function(module) {
+
+			var childModuleRequire = function(childURL) {
+
+				return httpVueLoader.require(resolveURL(this.component.baseURI, childURL));
+			}.bind(this);
+
+			var childLoader = function(childURL, childName) {
+
+				return httpVueLoader(resolveURL(this.component.baseURI, childURL), childName);
+			}.bind(this);
+
+			try {
+				Function('exports', 'require', 'httpVueLoader', 'module', this.getContent()).call(this.module.exports, this.module.exports, childModuleRequire, childLoader, this.module);
+			} catch(ex) {
+
+				if ( !('lineNumber' in ex) ) {
+
+					return Promise.reject(ex);
+				}
+				var vueFileData = responseText.replace(/\r?\n/g, '\n');
+				var lineNumber = vueFileData.substr(0, vueFileData.indexOf(script)).split('\n').length + ex.lineNumber - 1;
+				throw new (ex.constructor)(ex.message, url, lineNumber);
+			}
+
+			return Promise.resolve(this.module.exports)
+			.then(httpVueLoader.scriptExportsHandler.bind(this))
+			.then(function(exports) {
+
+				this.module.exports = exports;
+			}.bind(this));
+		}
+	};
+
+	function ScriptContext(component, elt) {
+
+		this.component = component;
+		this.elt = elt;
+		this.module = { exports:{} };
+	}
+
+
+	TemplateContext.prototype = {
+
+		getContent: function() {
+
+			return this.elt.innerHTML;
+		},
+
+		setContent: function(content) {
+
+			this.elt.innerHTML = content;
+		},
+
+		getRootElt: function() {
+
+			var tplElt = this.elt.content || this.elt;
+
+			if ( 'firstElementChild' in tplElt )
+				return tplElt.firstElementChild;
+
+			for ( tplElt = tplElt.firstChild; tplElt !== null; tplElt = tplElt.nextSibling )
+				if ( tplElt.nodeType === Node.ELEMENT_NODE )
+					return tplElt;
+
+			return null;
+		},
+
+		compile: function() {
+
+			return Promise.resolve();
+		}
+	};
+
+	function TemplateContext(component, elt) {
+
+		this.component = component;
+		this.elt = elt;
+	}
+
+
+
+	Component.prototype = {
+
+		getHead: function() {
+
+			return document.head || document.getElementsByTagName('head')[0];
+		},
+
+		getScopeId: function() {
+
+			if ( this._scopeId === '' ) {
+
+				this._scopeId = 'data-s-' + (scopeIndex++).toString(36);
+				this.template.getRootElt().setAttribute(this._scopeId, '');
+			}
+			return this._scopeId;
+		},
+
+		load: function(componentURL) {
+
+			return httpVueLoader.httpRequest(componentURL)
+			.then(function(responseText) {
+
+				this.baseURI = componentURL.substr(0, componentURL.lastIndexOf('/')+1);
+				var doc = document.implementation.createHTMLDocument('');
+
+				// IE requires the <base> to come with <style>
+				doc.body.innerHTML = (this.baseURI ? '<base href="'+this.baseURI+'">' : '') + responseText;
+
+				for ( var it = doc.body.firstChild; it; it = it.nextSibling ) {
+
+					switch ( it.nodeName ) {
+						case 'TEMPLATE':
+							this.template = new TemplateContext(this, it);
+							break;
+						case 'SCRIPT':
+							this.script = new ScriptContext(this, it);
+							break;
+						case 'STYLE':
+							this.styles.push(new StyleContext(this, it));
+							break;
+					}
+				}
+
+				return this;
+			}.bind(this));
+		},
+
+		_normalizeSection: function(eltCx) {
+
+			var p;
+
+			if ( eltCx === null || !eltCx.elt.hasAttribute('src') ) {
+
+				p = Promise.resolve(null);
+			} else {
+
+				p = httpVueLoader.httpRequest(eltCx.elt.getAttribute('src'))
+				.then(function(content) {
+
+					eltCx.elt.removeAttribute('src');
+					return content;
+				});
+			}
+
+			return p
+			.then(function(content) {
+
+				if ( eltCx !== null && eltCx.elt.hasAttribute('lang') ) {
+
+					var lang = eltCx.elt.getAttribute('lang');
+					eltCx.elt.removeAttribute('lang');
+					return httpVueLoader.langProcessor[lang.toLowerCase()].call(this, content === null ? eltCx.getContent() : content);
+				}
+				return content;
+			}.bind(this))
+			.then(function(content) {
+
+				if ( content !== null )
+					eltCx.setContent(content);
+			});
+		},
+
+		normalize: function() {
+
+			return Promise.all(Array.prototype.concat(
+				this._normalizeSection(this.template),
+				this._normalizeSection(this.script),
+				this.styles.map(this._normalizeSection)
+			))
+			.then(function() {
+
+				return this;
+			}.bind(this));
+		},
+
+		compile: function() {
+
+			return Promise.all(Array.prototype.concat(
+				this.template && this.template.compile(),
+				this.script && this.script.compile(),
+				this.styles.map(function(style) { return style.compile(); })
+			))
+			.then(function() {
+
+				return this;
+			}.bind(this));
+		}
+	};
+
+	function Component(name) {
+
+		this.name = name;
+		this.template = null;
+		this.script = null;
+		this.styles = [];
+		this._scopeId = '';
+	}
+
+	function identity(value) {
+
+		return value;
+	}
+
+	function parseComponentURL(url) {
+
+		var comp = url.match(/(.*?)([^/]+?)\/?(\.vue)?(\?.*|#.*|$)/);
+		return {
+			name: comp[2],
+			url: comp[1] + comp[2] + (comp[3] === undefined ? '/index.vue' : comp[3]) + comp[4]
+		};
+	}
+
+	function resolveURL(baseURL, url) {
+
+		if (url.substr(0, 2) === './' || url.substr(0, 3) === '../') {
+			return baseURL + url;
+		}
+		return url;
+	}
+
+
+	httpVueLoader.load = function(url, name) {
+
+		return function() {
+
+			return new Component(name).load(url)
+			.then(function(component) {
+
+				return component.normalize();
+			})
+			.then(function(component) {
+
+				return component.compile();
+			})
+			.then(function(component) {
+
+				var exports = component.script !== null ? component.script.module.exports : {};
+
+				if ( component.template !== null )
+					exports.template = component.template.getContent();
+
+				if ( exports.name === undefined )
+					if ( component.name !== undefined )
+						exports.name = component.name;
+
+				exports._baseURI = component.baseURI;
+
+				return exports;
+			});
+		};
+	};
+
+
+	httpVueLoader.register = function(Vue, url) {
+
+		var comp = parseComponentURL(url);
+		Vue.component(comp.name, httpVueLoader.load(comp.url));
+	};
+
+	httpVueLoader.install = function(Vue) {
+
+		Vue.mixin({
+
+			beforeCreate: function () {
+
+				var components = this.$options.components;
+
+				for ( var componentName in components ) {
+
+					if ( typeof(components[componentName]) === 'string' && components[componentName].substr(0, 4) === 'url:' ) {
+
+						var comp = parseComponentURL(components[componentName].substr(4));
+
+						var componentURL = ('_baseURI' in this.$options) ? resolveURL(this.$options._baseURI, comp.url) : comp.url;
+
+						if ( isNaN(componentName) )
+							components[componentName] = httpVueLoader.load(componentURL, componentName);
+						else
+							components[componentName] = Vue.component(comp.name, httpVueLoader.load(componentURL, comp.name));
+					}
+				}
+			}
+		});
+	};
+
+	httpVueLoader.require = function(moduleName) {
+
+		return window[moduleName];
+	};
+
+	httpVueLoader.httpRequest = function(url) {
+
+		return new Promise(function(resolve, reject) {
+
+			var xhr = new XMLHttpRequest();
+			xhr.open('GET', url);
+            		xhr.responseType = 'text';
+
+			xhr.onreadystatechange = function() {
+
+				if ( xhr.readyState === 4 ) {
+
+					if ( xhr.status >= 200 && xhr.status < 300 )
+						resolve(xhr.responseText);
+					else
+						reject(xhr.status);
+				}
+			};
+
+			xhr.send(null);
+		});
+	};
+
+	httpVueLoader.langProcessor = {
+		html: identity,
+		js: identity,
+		css: identity
+	};
+
+	httpVueLoader.scriptExportsHandler = identity;
+
+	function httpVueLoader(url, name) {
+
+		var comp = parseComponentURL(url);
+		return httpVueLoader.load(comp.url, name);
+	}
+
+	return httpVueLoader;
+});

public/js/vendor/i18n.min.js

@@ -0,0 +1 @@
+(function(){var e,t,n,r=function(e,t){return function(){return e.apply(t,arguments)}};e=function(){function e(){this.translate=r(this.translate,this);this.data={values:{},contexts:[]};this.globalContext={}}e.prototype.translate=function(e,t,n,r,i){var s,o,u,a;if(i==null){i=this.globalContext}u=function(e){var t;t=typeof e;return t==="function"||t==="object"&&!!e};if(u(t)){s=null;a=null;o=t;i=n||this.globalContext}else{if(typeof t==="number"){s=null;a=t;o=n;i=r||this.globalContext}else{s=t;if(typeof n==="number"){a=n;o=r;i=i}else{a=null;o=n;i=r||this.globalContext}}}if(u(e)){if(u(e["i18n"])){e=e["i18n"]}return this.translateHash(e,i)}else{return this.translateText(e,a,o,i,s)}};e.prototype.add=function(e){var t,n,r,i,s,o,u,a;if(e.values!=null){o=e.values;for(n in o){r=o[n];this.data.values[n]=r}}if(e.contexts!=null){u=e.contexts;a=[];for(i=0,s=u.length;i<s;i++){t=u[i];a.push(this.data.contexts.push(t))}return a}};e.prototype.setContext=function(e,t){return this.globalContext[e]=t};e.prototype.clearContext=function(e){return this.lobalContext[e]=null};e.prototype.reset=function(){this.data={values:{},contexts:[]};return this.globalContext={}};e.prototype.resetData=function(){return this.data={values:{},contexts:[]}};e.prototype.resetContext=function(){return this.globalContext={}};e.prototype.translateHash=function(e,t){var n,r;for(n in e){r=e[n];if(typeof r==="string"){e[n]=this.translateText(r,null,null,t)}}return e};e.prototype.translateText=function(e,t,n,r,i){var s,o;if(r==null){r=this.globalContext}if(this.data==null){return this.useOriginalText(i||e,t,n)}s=this.getContextData(this.data,r);if(s!=null){o=this.findTranslation(e,t,n,s.values,i)}if(o==null){o=this.findTranslation(e,t,n,this.data.values,i)}if(o==null){return this.useOriginalText(i||e,t,n)}return o};e.prototype.findTranslation=function(e,t,n,r){var i,s,o,u,a;o=r[e];if(o==null){return null}if(t==null){if(typeof o==="string"){return this.applyFormatting(o,t,n)}}else{if(o instanceof Array||o.length){for(u=0,a=o.length;u<a;u++){s=o[u];if((t>=s[0]||s[0]===null)&&(t<=s[1]||s[1]===null)){i=this.applyFormatting(s[2].replace("-%n",String(-t)),t,n);return this.applyFormatting(i.replace("%n",String(t)),t,n)}}}}return null};e.prototype.getContextData=function(e,t){var n,r,i,s,o,u,a,f;if(e.contexts==null){return null}a=e.contexts;for(o=0,u=a.length;o<u;o++){n=a[o];r=true;f=n.matches;for(i in f){s=f[i];r=r&&s===t[i]}if(r){return n}}return null};e.prototype.useOriginalText=function(e,t,n){if(t==null){return this.applyFormatting(e,t,n)}return this.applyFormatting(e.replace("%n",String(t)),t,n)};e.prototype.applyFormatting=function(e,t,n){var r,i;for(r in n){i=new RegExp("%{"+r+"}","g");e=e.replace(i,n[r])}return e};return e}();n=new e;t=n.translate;t.translator=n;t.create=function(n){var r;r=new e;if(n!=null){r.add(n)}r.translate.create=t.create;return r.translate};(typeof module!=="undefined"&&module!==null?module.exports=t:void 0)||(this.i18n=t)}).call(this)

public/js/vendor/toastify.js

@@ -0,0 +1,351 @@
+/*!
+ * Toastify js 1.7.0
+ * https://github.com/apvarun/toastify-js
+ * @license MIT licensed
+ *
+ * Copyright (C) 2018 Varun A P
+ */
+(function(root, factory) {
+  if (typeof module === "object" && module.exports) {
+    module.exports = factory();
+  } else {
+    root.Toastify = factory();
+  }
+})(this, function(global) {
+  // Object initialization
+  var Toastify = function(options) {
+      // Returning a new init object
+      return new Toastify.lib.init(options);
+    },
+    // Library version
+    version = "1.7.0";
+
+  // Defining the prototype of the object
+  Toastify.lib = Toastify.prototype = {
+    toastify: version,
+
+    constructor: Toastify,
+
+    // Initializing the object with required parameters
+    init: function(options) {
+      // Verifying and validating the input object
+      if (!options) {
+        options = {};
+      }
+
+      // Creating the options object
+      this.options = {};
+
+      this.toastElement = null;
+
+      // Validating the options
+      this.options.text = options.text || "Hi there!"; // Display message
+      this.options.duration = options.duration === 0 ? 0 : options.duration || 3000; // Display duration
+      this.options.selector = options.selector; // Parent selector
+      this.options.callback = options.callback || function() {}; // Callback after display
+      this.options.destination = options.destination; // On-click destination
+      this.options.newWindow = options.newWindow || false; // Open destination in new window
+      this.options.close = options.close || false; // Show toast close icon
+      this.options.gravity = options.gravity === "bottom" ? "toastify-bottom" : "toastify-top"; // toast position - top or bottom
+      this.options.positionLeft = options.positionLeft || false; // toast position - left or right
+      this.options.position = options.position || ''; // toast position - left or right
+      this.options.backgroundColor = options.backgroundColor; // toast background color
+      this.options.avatar = options.avatar || ""; // img element src - url or a path
+      this.options.className = options.className || ""; // additional class names for the toast
+      this.options.stopOnFocus = options.stopOnFocus === undefined? true: options.stopOnFocus; // stop timeout on focus
+      this.options.onClick = options.onClick; // Callback after click
+
+      // Returning the current object for chaining functions
+      return this;
+    },
+
+    // Building the DOM element
+    buildToast: function() {
+      // Validating if the options are defined
+      if (!this.options) {
+        throw "Toastify is not initialized";
+      }
+
+      // Creating the DOM object
+      var divElement = document.createElement("div");
+      divElement.className = "toastify on " + this.options.className;
+
+      // Positioning toast to left or right or center
+      if (!!this.options.position) {
+        divElement.className += " toastify-" + this.options.position;
+      } else {
+        // To be depreciated in further versions
+        if (this.options.positionLeft === true) {
+          divElement.className += " toastify-left";
+          console.warn('Property `positionLeft` will be depreciated in further versions. Please use `position` instead.')
+        } else {
+          // Default position
+          divElement.className += " toastify-right";
+        }
+      }
+
+      // Assigning gravity of element
+      divElement.className += " " + this.options.gravity;
+
+      if (this.options.backgroundColor) {
+        divElement.style.background = this.options.backgroundColor;
+      }
+
+      // Adding the toast message
+      divElement.innerHTML = this.options.text;
+
+      if (this.options.avatar !== "") {
+        var avatarElement = document.createElement("img");
+        avatarElement.src = this.options.avatar;
+
+        avatarElement.className = "toastify-avatar";
+
+        if (this.options.position == "left" || this.options.positionLeft === true) {
+          // Adding close icon on the left of content
+          divElement.appendChild(avatarElement);
+        } else {
+          // Adding close icon on the right of content
+          divElement.insertAdjacentElement("beforeend", avatarElement);
+        }
+      }
+
+      // Adding a close icon to the toast
+      if (this.options.close === true) {
+        // Create a span for close element
+        var closeElement = document.createElement("span");
+        closeElement.innerHTML = "✖";
+
+        closeElement.className = "toast-close";
+
+        // Triggering the removal of toast from DOM on close click
+        closeElement.addEventListener(
+          "click",
+          function(event) {
+            event.stopPropagation();
+            this.removeElement(this.toastElement);
+            window.clearTimeout(this.toastElement.timeOutValue);
+          }.bind(this)
+        );
+
+        //Calculating screen width
+        var width = window.innerWidth > 0 ? window.innerWidth : screen.width;
+
+        // Adding the close icon to the toast element
+        // Display on the right if screen width is less than or equal to 360px
+        if ((this.options.position == "left" || this.options.positionLeft === true) && width > 360) {
+          // Adding close icon on the left of content
+          divElement.insertAdjacentElement("afterbegin", closeElement);
+        } else {
+          // Adding close icon on the right of content
+          divElement.appendChild(closeElement);
+        }
+      }
+
+      // Clear timeout while toast is focused
+      if (this.options.stopOnFocus && this.options.duration > 0) {
+        const self = this;
+        // stop countdown
+        divElement.addEventListener(
+          "mouseover",
+          function(event) {
+            window.clearTimeout(divElement.timeOutValue);
+          }
+        )
+        // add back the timeout
+        divElement.addEventListener(
+          "mouseleave",
+          function() {
+            divElement.timeOutValue = window.setTimeout(
+              function() {
+                // Remove the toast from DOM
+                self.removeElement(divElement);
+              },
+              self.options.duration
+            )
+          }
+        )
+      }
+      
+      // Adding an on-click destination path
+      if (typeof this.options.destination !== "undefined") {
+        divElement.addEventListener(
+          "click",
+          function(event) {
+            event.stopPropagation();
+            if (this.options.newWindow === true) {
+              window.open(this.options.destination, "_blank");
+            } else {
+              window.location = this.options.destination;
+            }
+          }.bind(this)
+        );
+      }
+
+      if (typeof this.options.onClick === "function" && typeof this.options.destination === "undefined") {
+        divElement.addEventListener(
+          "click",
+          function(event) {
+            event.stopPropagation();
+            this.options.onClick();            
+          }.bind(this)
+        );
+      }
+
+      // Returning the generated element
+      return divElement;
+    },
+
+    // Displaying the toast
+    showToast: function() {
+      // Creating the DOM object for the toast
+      this.toastElement = this.buildToast();
+
+      // Getting the root element to with the toast needs to be added
+      var rootElement;
+      if (typeof this.options.selector === "undefined") {
+        rootElement = document.body;
+      } else {
+        rootElement = document.getElementById(this.options.selector);
+      }
+
+      // Validating if root element is present in DOM
+      if (!rootElement) {
+        throw "Root element is not defined";
+      }
+
+      // Adding the DOM element
+      rootElement.insertBefore(this.toastElement, rootElement.firstChild);
+
+      // Repositioning the toasts in case multiple toasts are present
+      Toastify.reposition();
+
+      if (this.options.duration > 0) {
+        this.toastElement.timeOutValue = window.setTimeout(
+          function() {
+            // Remove the toast from DOM
+            this.removeElement(this.toastElement);
+          }.bind(this),
+          this.options.duration
+        ); // Binding `this` for function invocation
+      }
+
+      // Supporting function chaining
+      return this;
+    },
+
+    hideToast: function() {
+      if (this.toastElement.timeOutValue) {
+        clearTimeout(this.toastElement.timeOutValue);
+      }
+      this.removeElement(this.toastElement);
+    },
+
+    // Removing the element from the DOM
+    removeElement: function(toastElement) {
+      // Hiding the element
+      // toastElement.classList.remove("on");
+      toastElement.className = toastElement.className.replace(" on", "");
+
+      // Removing the element from DOM after transition end
+      window.setTimeout(
+        function() {
+          // Remove the elemenf from the DOM, only when the parent node was not removed before.
+          if (toastElement.parentNode) {
+            toastElement.parentNode.removeChild(toastElement);
+          }
+
+          // Calling the callback function
+          this.options.callback.call(toastElement);
+
+          // Repositioning the toasts again
+          Toastify.reposition();
+        }.bind(this),
+        400
+      ); // Binding `this` for function invocation
+    },
+  };
+
+  // Positioning the toasts on the DOM
+  Toastify.reposition = function() {
+    // Top margins with gravity
+    var topLeftOffsetSize = {
+      top: 15,
+      bottom: 15,
+    };
+    var topRightOffsetSize = {
+      top: 15,
+      bottom: 15,
+    };
+    var offsetSize = {
+      top: 15,
+      bottom: 15,
+    };
+
+    // Get all toast messages on the DOM
+    var allToasts = document.getElementsByClassName("toastify");
+
+    var classUsed;
+
+    // Modifying the position of each toast element
+    for (var i = 0; i < allToasts.length; i++) {
+      // Getting the applied gravity
+      if (containsClass(allToasts[i], "toastify-top") === true) {
+        classUsed = "toastify-top";
+      } else {
+        classUsed = "toastify-bottom";
+      }
+
+      var height = allToasts[i].offsetHeight;
+      classUsed = classUsed.substr(9, classUsed.length-1)
+      // Spacing between toasts
+      var offset = 15;
+
+      var width = window.innerWidth > 0 ? window.innerWidth : screen.width;
+
+      // Show toast in center if screen with less than or qual to 360px
+      if (width <= 360) {
+        // Setting the position
+        allToasts[i].style[classUsed] = offsetSize[classUsed] + "px";
+
+        offsetSize[classUsed] += height + offset;
+      } else {
+        if (containsClass(allToasts[i], "toastify-left") === true) {
+          // Setting the position
+          allToasts[i].style[classUsed] = topLeftOffsetSize[classUsed] + "px";
+
+          topLeftOffsetSize[classUsed] += height + offset;
+        } else {
+          // Setting the position
+          allToasts[i].style[classUsed] = topRightOffsetSize[classUsed] + "px";
+
+          topRightOffsetSize[classUsed] += height + offset;
+        }
+      }
+    }
+
+    // Supporting function chaining
+    return this;
+  };
+
+  function containsClass(elem, yourClass) {
+    if (!elem || typeof yourClass !== "string") {
+      return false;
+    } else if (
+      elem.className &&
+      elem.className
+        .trim()
+        .split(/\s+/gi)
+        .indexOf(yourClass) > -1
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // Setting up the prototype for the init object
+  Toastify.lib.init.prototype = Toastify.lib;
+
+  // Returning the Toastify function to be assigned to the window object/module
+  return Toastify;
+});