☰

JoeSimmons' Library

A JavaScript library used by JoeSimmons

This script should not be not be installed directly. It is a library for other scripts to include with the meta directive // @require https://update.greatest.deepsurf.us/scripts/22443/142782/JoeSimmons%27%20Library.js 

  1. // ==UserScript==
  2. // @name          JoeSimmons' Library
  3. // @namespace     http://userscripts-mirror.org/users/23652
  4. // @description   A JavaScript library used by JoeSimmons
  5. // @include       *
  6. // @copyright     JoeSimmons
  7. // @author        JoeSimmons
  8. // @version       1.3.0
  9. // @license       GPL version 3 or any later version; http://www.gnu.org/copyleft/gpl.html
  10. // @grant         GM_addStyle
  11. // ==/UserScript==
  12.  
  13. /**
  14.     WIKI ==> https://github.com/joesimmons/jsl/wiki/
  15.  
  16.     SOURCE ==> https://raw.githubusercontent.com/joesimmons/jsl/master/versions/jsl-1.3.0.js
  17. **/
  18.  
  19. (function (window, undefined) {
  20.  
  21.     'use strict'; // use strict mode in ECMAScript-5
  22.  
  23.     var version = '1.3.0'; // this will be used for JSL.prototype.version
  24.     var intervals = []; // for the setInterval/clearInterval methods
  25.  
  26.     // regular expressions
  27.     var rSelector = /^\*|^\.[a-z][\w\d-]*|^#[^ ]+|^[a-z]+|^\[a-z]+/i; // matches a CSS selector
  28.     var rXpath = /^\.?\/{1,2}[a-zA-Z\*]+/;                            // matches an XPath query
  29.     var rHTML = /<[^>]+>/;                                            // matches a string of HTML
  30.     var rHyphenated = /-([a-zA-Z])/g;                                 // matches alphabetic, hyphenated strings
  31.     var rElementObject = /^\[object HTML([a-zA-Z]+)?Element\]$/;      // matches the toString value of an element
  32.     var rWindowObject = /^\[object Window\]$/;                        // matches the toString value of a window object
  33.     var rValidVarname = /^[a-zA-Z$_][a-zA-Z0-9$_]*$/;                 // matches a valid variable name
  34.  
  35.     // compatibility methods for browsers that don't support ECMAScript-5 completely
  36.     var compat = {
  37.         'arr_indexOf' : function (searchElement, fromIndex) {
  38.             var index = parseInt(fromIndex || 0, 10), len = this.length;
  39.                 index = index < 0 ? len + index : index; // handle negative fromIndex
  40.                 index = !(index > 0) ? 0 : index; // handle out of range and/or NaN fromIndex
  41.  
  42.             while (index < len && index >= 0) {
  43.                 if (this[index] === searchElement) {
  44.                     return index;
  45.                 }
  46.                 index += 1;
  47.             }
  48.  
  49.             return -1;
  50.         },
  51.         /*
  52.         'filter' : function (fn, oThis) {
  53.             var index, value, len = this.length, ret = [];
  54.  
  55.             for (index = 0; index < len; index += 1) {
  56.                 value = this[index];
  57.                 if ( fn.call(oThis, value, index, this) ) {
  58.                     ret.push(value);
  59.                 }
  60.             }
  61.  
  62.             return ret;
  63.         },
  64.         */
  65.         'forEach' : function (fn, oThis) {
  66.             var index, len;
  67.  
  68.             for (index = 0, len = this.length; index < len; index += 1) {
  69.                 fn.call(oThis, this[index], index, this);
  70.             }
  71.         },
  72.         'map' : function (fn, oThis) {
  73.             var index, newArr = [], len;
  74.  
  75.             for (index = 0, len = this.length; index < len; index += 1) {
  76.                 newArr[index] = fn.call(oThis, this[index], index, this);
  77.             }
  78.  
  79.             return newArr;
  80.         },
  81.         'reduce' : function (fn, initialValue) {
  82.             var index, len, value, isValueSet = false;
  83.  
  84.             if (arguments.length > 1) {
  85.                 value = initialValue;
  86.                 isValueSet = true;
  87.             }
  88.  
  89.             for (index = 0, len = this.length; index < len; index += 1) {
  90.                 if (isValueSet) {
  91.                     value = fn(value, this[index], index, this);
  92.                 } else {
  93.                     value = this[index];
  94.                     isValueSet = true;
  95.                 }
  96.             }
  97.  
  98.             return value;
  99.         }
  100.     };
  101.  
  102.     // gets a method from an object's prototype. returns undefined if not found
  103.     var getMethod = function (obj, method) {
  104.         if (typeof XPCNativeWrapper === 'function' && typeof XPCNativeWrapper.unwrap === 'function') {
  105.             obj = XPCNativeWrapper.unwrap(obj);
  106.         } else if (obj.wrappedJSObject) {
  107.             obj = obj.wrappedJSObject;
  108.         }
  109.  
  110.         if (obj.prototype && typeof obj.prototype[method] === 'function') {
  111.             return obj.prototype[method];
  112.         }
  113.     };
  114.  
  115.     // original methods for some common uses
  116.     var core = {
  117.         // array
  118.         'arr_indexOf' : getMethod(Array, 'indexOf') || compat.arr_indexOf,
  119.         'concat' : getMethod(Array, 'concat'),
  120.         'filter' : getMethod(Array, 'filter') || compat.filter,
  121.         'forEach' : getMethod(Array, 'forEach') || compat.forEach,
  122.         'map' : getMethod(Array, 'map') || compat.map,
  123.         'reduce' : getMethod(Array, 'reduce') || compat.reduce,
  124.         'slice' : getMethod(Array, 'slice'),
  125.  
  126.         // object
  127.         'hasOwnProperty' : getMethod(Object, 'hasOwnProperty'),
  128.         'toString' : getMethod(Object, 'toString'),
  129.     };
  130.  
  131.     var JSL = function JSL(selector, context) {
  132.         return new JSL.fn.init(selector, context);
  133.     };
  134.  
  135.     // a simple class for dealing with event listener handlers
  136.     var handlers = {
  137.         stack : [],
  138.  
  139.         add : function (thisElement, type, fn) {
  140.             this.stack.push({
  141.                 element : thisElement,
  142.                 type : type,
  143.                 fn : fn
  144.             });
  145.         },
  146.  
  147.         get : function (thisElement, type) {
  148.             var events = [];
  149.                 type = typeof type === 'string' ? type : '*';
  150.  
  151.             JSL.each(this.stack, function (thisEventObj) {
  152.                 if (thisElement === thisEventObj.element) {
  153.                     if (type === '*' || thisEventObj.type === type) {
  154.                         events.push(thisEventObj);
  155.                     }
  156.                 }
  157.             });
  158.  
  159.             return events;
  160.         },
  161.  
  162.         remove : function (thisElement, type) {
  163.             var handlerIndices = [], that = this;
  164.  
  165.             // find all the indices of what we need to remove
  166.             JSL.each(handlers.get(thisElement, type), function (thisEventObj, index, array) {
  167.                 handlerIndices.push(
  168.                     core.arr_indexOf.call(that.stack, thisEventObj)
  169.                 );
  170.             });
  171.  
  172.             // remove all the indices here, using a separate array of indices
  173.             // we can't do this as we loop over the (stack) array itself, because
  174.             // we would be removing values as they are being iterated through
  175.             JSL.each(handlerIndices, function (thisIndex) {
  176.                 that.stack.splice(thisIndex, 1);
  177.             });
  178.         }
  179.     };
  180.  
  181.     // Node.prototype.matchesSelector compat for vendor prefixes
  182.     function matchesSelector(element, selector) {
  183.         if (element && typeof selector === 'string') {
  184.             if (typeof element.mozMatchesSelector === 'function') {
  185.                 // Mozilla
  186.                 return element.mozMatchesSelector(selector);
  187.             } else if (typeof element.webkitMatchesSelector === 'function') {
  188.                 // Webkit
  189.                 return element.webkitMatchesSelector(selector);
  190.             } else if (typeof element.oMatchesSelector === 'function') {
  191.                 // Opera
  192.                 return element.oMatchesSelector(selector);
  193.             } else if (typeof element.msMatchesSelector === 'function') {
  194.                 // IE
  195.                 return element.msMatchesSelector(selector);
  196.             }
  197.         }
  198.  
  199.         return false;
  200.     }
  201.  
  202.     // calls 'this' with the first parameter as the first argument 
  203.     function call(a) {
  204.         return this(a);
  205.     }
  206.  
  207.     function toCamelCase(string) {
  208.         return string.replace(rHyphenated, function (fullMatch, firstGroup) {
  209.             return firstGroup.toUpperCase();
  210.         });
  211.     }
  212.  
  213.     // walkTheDom by Douglas Crockford
  214.     function walkTheDom(node, func) {
  215.         func(node);
  216.         node = node.firstChild;
  217.  
  218.         while (node) {
  219.             walkTheDom(node, func);
  220.             node = node.nextSibling;
  221.         }
  222.     }
  223.  
  224.     // can pluck a key out of an object
  225.     function pluck(obj) {
  226.         var subs = this.split('.'),
  227.             ret = obj, i;
  228.  
  229.         for (i = 0; i < subs.length; i += 1) {
  230.             ret = ret[ subs[i] ];
  231.             if (ret == null) {
  232.                 return '';
  233.             }
  234.         }
  235.  
  236.         return ret;
  237.     }
  238.  
  239.     function sum(curValue, nextValue) {
  240.         return curValue + nextValue;
  241.     }
  242.  
  243.     function sumInt(curValue, nextValue) {
  244.         return parseInt(curValue, 10) + parseInt(nextValue, 10);
  245.     }
  246.  
  247.     // internal function for throwing errors, so the user gets
  248.     // some sort of hint as to why their operation failed
  249.     function error(errorString) {
  250.         if (typeof console !== 'undefined' && typeof console.error === 'function') {
  251.             console.error(errorString);
  252.         }
  253.  
  254.         return null; // always return null
  255.     }
  256.  
  257.     // will copy an element and return a new copy with the same event listeners
  258.     function cloneElement(thisElement) {
  259.         var newElement = thisElement.cloneNode(true);
  260.  
  261.         // clone event listeners of element
  262.         JSL.each(handlers.get(thisElement), function (thisEventObj) {
  263.             JSL.addEvent(newElement, thisEventObj.type, thisEventObj.fn);
  264.         });
  265.  
  266.         return newElement;
  267.     }
  268.  
  269.     function getEachElements(array, selector, key, type) {
  270.         var newElementsArray = [],
  271.             isValidSelector = typeof selector === 'string' && selector.trim() !== '';
  272.  
  273.         JSL.each(array, function (currentElement) {
  274.             while ( currentElement = currentElement[key] ) { // note: intentional assignment
  275.                 if (type > 0 ? currentElement.nodeType === type : true) {
  276.                     if ( isValidSelector === false || JSL(currentElement).filter(selector).exists ) {
  277.                         newElementsArray.push(currentElement);
  278.                         return;
  279.                     }
  280.                 }
  281.             }
  282.         });
  283.  
  284.         return newElementsArray;
  285.     }
  286.  
  287.     // this will take 
  288.     function doElementOperationOnEach(args, op) {
  289.         var newElementsArray = [], newElement,
  290.             passedElements = JSL.create.apply(JSL, args);
  291.  
  292.         if (this.exists) {
  293.             if (JSL.typeOf(passedElements) === 'array') {
  294.                 this.each(function (thisElement) {
  295.                     JSL.each(passedElements, function (passedElement) {
  296.                         // clone the element
  297.                         var newElement = cloneElement(passedElement);
  298.  
  299.                         // add the new elements to an array
  300.                         newElementsArray.push(newElement);
  301.  
  302.                         // perform the passed operation on the element
  303.                         op(thisElement, newElement);
  304.                     });
  305.                 });
  306.             } else {
  307.                 this.each(function (thisElement) {
  308.                     // clone the element
  309.                     var newElement = cloneElement(passedElements);
  310.  
  311.                     // add the new elements to an array
  312.                     newElementsArray.push(newElement);
  313.  
  314.                     // perform the passed operation on the element
  315.                     op(thisElement, newElement);
  316.                 });
  317.             }
  318.         }
  319.  
  320.         return newElementsArray;
  321.     }
  322.  
  323.     // define JSL's prototype, aka JSL.fn
  324.     JSL.fn = JSL.prototype = {
  325.         isJSL : true,
  326.         constructor : JSL,
  327.         length : 0,
  328.         version : version,
  329.  
  330.         // similar to jQuery. JSL is just the init constructor
  331.         init : function (selector, context) {
  332.             var selectorStringValue = core.toString.call(selector),
  333.                 that = this,
  334.                 elems = [];
  335.  
  336.             switch (typeof selector) {
  337.                 case 'string': {  // -- STRING --
  338.                     if ( selector.match(rXpath) ) {
  339.                         // handle an XPath expression
  340.                         elems = JSL.xpath({expression : selector, type : 7, context : context});
  341.                     } else if ( selector.match(rHTML) ) {
  342.                         // reserved for html code creation
  343.                         // not sure if I want to implement it
  344.                     } else if ( selector.match(rSelector) ) {
  345.                         if (JSL.typeOf(context) === 'array') {
  346.                             // handle an array being passed as the context
  347.                             return that.find.call(context, selector);
  348.                         } else if (typeof context === 'string') {
  349.                             // handle a selector being passsed as the context
  350.                             context = JSL(context);
  351.                             if (context.exists) {
  352.                                 return JSL(selector, context[0]);
  353.                             }
  354.                         } else if (context != null && context.isJSL === true && context.exists) {
  355.                             // handle a JSL object being passsed as the context
  356.                             return JSL( selector, context[0] );
  357.                         } else {
  358.                             // handle a regular element being passed as the context
  359.                             context = context != null && context.querySelectorAll ? context : document;
  360.                             elems = context.querySelectorAll(selector);
  361.                         }
  362.                     }
  363.                     break;
  364.                 }
  365.                 // ---------------------------------------------------
  366.                 case 'object': {  // -- OBJECT --
  367.                     if (selector != null) {
  368.                         if (selector.isJSL === true) {
  369.                             // handle a JSL object
  370.                             return selector;
  371.                         } else if ( core.hasOwnProperty.call(selector, 'length') ) {
  372.                             // handle an array-like object
  373.                             elems = selector;
  374.                         } else if ( selectorStringValue.match(rElementObject) || selectorStringValue.match(rWindowObject) ) {
  375.                             // handle a single element
  376.                             elems = [selector];
  377.                         }
  378.                     }
  379.                     break;
  380.                 }
  381.                 // ---------------------------------------------------
  382.                 default: {        // -- UNKNOWN --
  383.                     if ( selectorStringValue.match(rElementObject) || selectorStringValue.match(rWindowObject) ) {
  384.                         // handle elements that are typeof === 'function'
  385.                         // e.g., object, applet, embed
  386.                         elems = [selector];
  387.                     }
  388.                 }
  389.             }
  390.  
  391.             // define the length property of our object wrapper
  392.             that.length = elems.length;
  393.  
  394.             // bind the elements to array-like key:value pairs in our wrapper
  395.             // e.g., this[0] ==> element
  396.             JSL.each(elems, function (value, index) {
  397.                 that[index] = value;
  398.             });
  399.  
  400.             return that;
  401.         },
  402.  
  403.         // --- STARTING LINE FOR THE JSL WRAPPER METHODS
  404.         add : function (selector, context) {
  405.             var newElements = JSL(selector, context).raw(),
  406.                 allElements = core.concat.call(this.raw(), newElements);
  407.             return JSL(allElements);
  408.         },
  409.  
  410.         addEvent : function (type, fn) {
  411.             return this.each(function (thisElement) {
  412.                 JSL.addEvent(thisElement, type, fn);
  413.             });
  414.         },
  415.  
  416.         after : function () {
  417.             var newElementsArray = doElementOperationOnEach.call(this, JSL.toArray(arguments), function (baseElement, newElement) {
  418.                 var parent = baseElement.parentNode,
  419.                     next = baseElement.nextSibling;
  420.  
  421.                 if (parent) {
  422.                     if (next) {
  423.                         // add the newElement after the current element
  424.                         parent.insertBefore(newElement, next);
  425.                     } else {
  426.                         // nextSibling didn't exist. just append to its parent
  427.                         parent.appendChild(newElement);
  428.                     }
  429.                 }
  430.             });
  431.  
  432.             return JSL(newElementsArray);
  433.         },
  434.  
  435.         append : function () {
  436.             var newElementsArray = doElementOperationOnEach.call(this, JSL.toArray(arguments), function (baseElement, newElement) {
  437.                 baseElement.appendChild(newElement);
  438.             });
  439.  
  440.             return JSL(newElementsArray);
  441.         },
  442.  
  443.         attribute : function (name, value) {
  444.             var ret = '', valueIsValid = value != null;
  445.  
  446.             if ( typeof name === 'string' && this.exists ) {
  447.                     this.each(function (elem) {
  448.                         if (valueIsValid) {
  449.                             elem.setAttribute(name, value);
  450.                         } else {
  451.                             ret += elem.getAttribute(name) || '';
  452.                         }
  453.                     });
  454.             }
  455.  
  456.             return valueIsValid ? this : ret;
  457.         },
  458.  
  459.         before : function () {
  460.             var newElementsArray = doElementOperationOnEach.call(this, JSL.toArray(arguments), function (baseElement, newElement) {
  461.                 var parent = baseElement.parentNode;
  462.  
  463.                 // add the newElement before the current element
  464.                 if (parent) {
  465.                     parent.insertBefore(newElement, baseElement);
  466.                 }
  467.             });
  468.  
  469.             return JSL(newElementsArray);
  470.         },
  471.  
  472.         center : function () {
  473.             return this.each(function (thisElement) {
  474.                 thisElement = JSL(thisElement);
  475.                 thisElement.css('position', 'fixed');
  476.                 thisElement.css('top', Math.floor( (window.innerHeight - thisElement.height) / 2 ) + 'px');
  477.                 thisElement.css('left', Math.floor( (window.innerWidth - thisElement.width) / 2 ) + 'px');
  478.             });
  479.         },
  480.  
  481.         clone : function () {
  482.             var clonedElements = core.map.call(this, cloneElement); // variable for clarity
  483.             return JSL(clonedElements);
  484.         },
  485.  
  486.         css : function (name, value) {
  487.             if (typeof name === 'string') {
  488.                 // convert the hyphenated string to camel-case
  489.                 name = toCamelCase(name);
  490.  
  491.                 if (typeof value === 'string') {
  492.                     return this.each(function (thisElement) {
  493.                         if (name in thisElement.style) {
  494.                             thisElement.style[name] = value;
  495.                         }
  496.                     });
  497.                 }
  498.  
  499.                 return core.map.call(this, pluck, 'style.' + name).join('');
  500.             } else {
  501.                 return error('.css() was not passed a string for the first argument.');
  502.             }
  503.         },
  504.  
  505.         each : function (fn, oThis) {
  506.             if (this.exists) {
  507.                 JSL.each(this, fn, oThis);
  508.             }
  509.  
  510.             return this;
  511.         },
  512.  
  513.         get exists() {
  514.             return this.length > 0 && this[0] != null;
  515.         },
  516.  
  517.         filter : function (selector) {
  518.             var newElementsArray = [];
  519.  
  520.             if (typeof selector === 'string') {
  521.                 this.each(function (thisElement) {
  522.                     if ( matchesSelector(thisElement, selector) ) {
  523.                         newElementsArray.push(thisElement);
  524.                     }
  525.                 });
  526.             }
  527.  
  528.             // returns an empty JSL object if no elements are matched
  529.             return JSL(newElementsArray);
  530.         },
  531.  
  532.         find : function (selector) {
  533.             var arrayOfMatchesArrays = core.map.call(this, function (thisElement) {
  534.                 var matches = thisElement.querySelectorAll(selector);
  535.                 return JSL.toArray(matches);
  536.             });
  537.             var singleArrayOfMatches = arrayOfMatchesArrays.length > 0 ?
  538.                 core.reduce.call(arrayOfMatchesArrays, function (a, b) {
  539.                     return core.concat.call(a, b);
  540.             }) : [];
  541.  
  542.             return JSL(singleArrayOfMatches);
  543.         },
  544.  
  545.         first : function () {
  546.             return this.get(0);
  547.         },
  548.  
  549.         get : function (index) {
  550.             index = index === 'first' ? 0 : index === 'last' ? -1 : parseInt(index, 10);
  551.  
  552.             if ( !isNaN(index) ) {
  553.                 return JSL( index < 0 ? this[this.length + index] : this[index] );
  554.             }
  555.  
  556.             return JSL.toArray(this);
  557.         },
  558.  
  559.         get height() {
  560.             var arrayOfElemHeights = core.map.call(this, pluck, 'offsetHeight');
  561.             return core.reduce.call(arrayOfElemHeights, sum);
  562.         },
  563.  
  564.         has : function (selector) {
  565.             var newElementsArray = [];
  566.  
  567.             if ( typeof selector === 'string' && selector.match(rSelector) ) {
  568.                 this.each(function (thisElement) {
  569.                     if ( JSL(selector, thisElement).exists ) {
  570.                         newElementsArray.push(thisElement);
  571.                     }
  572.                 });
  573.             }
  574.  
  575.             return JSL(newElementsArray);
  576.         },
  577.  
  578.         hide : function () {
  579.             return this.css('display', 'none');
  580.         },
  581.  
  582.         /*
  583.         get inView(passedContainer) {
  584.             var isInView = false;
  585.             
  586.             this.each(function (thisElement) {
  587.                 var container = passedContainer || thisElement.parentNode;
  588.                 var visible = !!( (container.scrollTop + container.offsetHeight) >= thisElement.offsetTop &&
  589.                            (container.scrollTop - thisElement.offsetHeight) <= thisElement.offsetTop );
  590.  
  591.                 if (visible) {
  592.                     isInView = true;
  593.                     return 'stop';
  594.                 }
  595.             });
  596.  
  597.             return isInView;
  598.         },
  599.         */
  600.  
  601.         is : function (selector) {
  602.             for (var i = 0; i < this.length; i += 1) {
  603.                 if ( matchesSelector(this[i], selector) ) {
  604.                     return true;
  605.                 }
  606.             }
  607.             
  608.             return false;
  609.         },
  610.         
  611.         isnt : function (selector) {
  612.             return !this.is(selector);
  613.         },
  614.  
  615.         last : function (selector) {
  616.             return this.get(-1);
  617.         },
  618.  
  619.         next : function (selector) {
  620.             return JSL( getEachElements(this, selector, 'nextSibling', 1) );
  621.         },
  622.  
  623.         not : function (selector) {
  624.             var newElementsArray = [];
  625.  
  626.             if ( typeof selector === 'string' && selector.match(rSelector) ) {
  627.                 this.each(function (thisElement) {
  628.                     if ( JSL(thisElement).isnt(selector) ) {
  629.                         newElementsArray.push(thisElement);
  630.                     }
  631.                 });
  632.             }
  633.  
  634.             return JSL(newElementsArray);
  635.         },
  636.  
  637.         parent : function (selector) {
  638.             return JSL( getEachElements(this, selector, 'parentNode', 1) );
  639.         },
  640.  
  641.         prepend : function () {
  642.             var newElementsArray = doElementOperationOnEach.call(this, JSL.toArray(arguments), function (baseElement, newElement) {
  643.                 var firstChild = baseElement.firstChild;
  644.  
  645.                 if (firstChild) {
  646.                     baseElement.insertBefore(newElement, firstChild);
  647.                 }
  648.             });
  649.  
  650.             return JSL(newElementsArray);
  651.         },
  652.  
  653.         prev : function (selector) {
  654.             return JSL( getEachElements(this, selector, 'previousSibling', 1) );
  655.         },
  656.  
  657.         prop : function (name, value) {
  658.             var valueIsValid = value != null, ret;
  659.  
  660.             if (typeof name === 'string' && this.exists) {
  661.                     this.each(function (thisElement) {
  662.                         if (valueIsValid) {
  663.                             thisElement[name] = value;
  664.                         } else {
  665.                             if (typeof ret === 'undefined') {
  666.                                 ret = thisElement[name];
  667.                             } else {
  668.                                 ret += thisElement[name];
  669.                             }
  670.                         }
  671.                     });
  672.             }
  673.  
  674.             return valueIsValid ? this : ret;
  675.         },
  676.  
  677.         raw : function () {
  678.             return core.slice.call(this, 0);
  679.         },
  680.  
  681.         remove : function () {
  682.             return this.each(function (element) {
  683.                 var parent = element.parentNode;
  684.  
  685.                 if (element && parent) {
  686.                     parent.removeChild(element);
  687.                 }
  688.             });
  689.         },
  690.  
  691.         removeAttribute : function (attributeName) {
  692.             if (typeof attributeName === 'string') {
  693.                 return this.each(function (thisElement) {
  694.                     thisElement.removeAttribute(attributeName);
  695.                 });
  696.             } else {
  697.                 return error('.removeAttribute() was not passed a string.');
  698.             }
  699.         },
  700.  
  701.         removeEvent : function (type) {
  702.             if (typeof type === 'string') {
  703.                 return this.each(function (thisElement) {
  704.                     JSL.removeEvent(thisElement, type);
  705.                 });
  706.             } else {
  707.                 return error('.removeEvent() was not passed a string.');
  708.             }
  709.         },
  710.  
  711.         replace : function () {
  712.             var newElementsArray = doElementOperationOnEach.call(this, JSL.toArray(arguments), function (baseElement, newElement) {
  713.                 var parent = baseElement.parentNode;
  714.  
  715.                 if (parent) {
  716.                     parent.replaceChild(newElement, baseElement);
  717.                 }
  718.             });
  719.  
  720.             return JSL(newElementsArray);
  721.         },
  722.  
  723.         show : function (value) {
  724.             value = typeof value === 'string' ? value : 'inline';
  725.             return this.css('display', value);
  726.         },
  727.         
  728.         text : function (passedText, append) {
  729.             // handle setting text
  730.             if (typeof passedText === 'string') {
  731.                 if (append !== true) {
  732.                     this.each(function (thisElement) {
  733.                         JSL('.//text()', thisElement).each(function (textNode) {
  734.                             textNode.data = '';
  735.                         });
  736.                     });
  737.                 }
  738.  
  739.                 this.append('text', passedText);
  740.                 return this;
  741.             }
  742.  
  743.             // handle getting text
  744.             return core.reduce.call(this, function (curValue, nextElement) {
  745.                 return curValue + nextElement.textContent;
  746.             }, '');
  747.         },
  748.  
  749.         toggle : function () {
  750.             return this.each(function (thisElement) {
  751.                 thisElement = JSL(thisElement);
  752.  
  753.                 if (thisElement.visible) {
  754.                     thisElement.hide();
  755.                 } else {
  756.                     thisElement.show();
  757.                 }
  758.             });
  759.         },
  760.  
  761.         value : function (passedValue) {
  762.             var elem = this[0],
  763.                 tagName = elem && elem.tagName || '',
  764.                 selectedOptions = [],
  765.                 rInputTypeBlacklist = /button|checkbox|file|image|radio|reset|submit/,
  766.                 passedValueType = JSL.typeOf(passedValue);
  767.  
  768.             if (passedValue == null) {
  769.                 // no arguments were passed, return a value
  770.                     if (tagName === 'SELECT') {
  771.                         if ( elem.hasAttribute('multiple') ) {
  772.                             JSL.each(elem.options, function (thisOption) {
  773.                                 if (thisOption.selected) {
  774.                                     selectedOptions.push(thisOption.value);
  775.                                 }
  776.                             });
  777.  
  778.                             return selectedOptions;
  779.                         } else {
  780.                             return elem.options[elem.selectedIndex].value;
  781.                         }
  782.                     } else if ( tagName === 'INPUT' && !elem.type.match(rInputTypeBlacklist) ) {
  783.                         return elem.value;
  784.                     }
  785.                     if (tagName === 'TEXTAREA') {
  786.                         return elem.value;
  787.                     }
  788.             } else {
  789.                 // an argument was passed, set the value on each element
  790.                 return this.each(function (thisElement) {
  791.                     var tagName = thisElement.tagName;
  792.  
  793.                     if (tagName === 'SELECT') {
  794.                         if (thisElement.hasAttribute('multiple') && passedValueType === 'array') {
  795.                                 JSL.each(thisElement.options, function (thisOption) {
  796.                                     JSL.each(passedValue, function (thisPassedValue) {
  797.                                         if (thisOption.value == thisPassedValue) {
  798.                                             thisOption.selected = true;
  799.                                             return 'stop';
  800.                                         } else {
  801.                                             thisOption.selected = false;
  802.                                         }
  803.                                     });
  804.                                 });
  805.                         } else {
  806.                             JSL.each(thisElement.options, function (thisOption) {
  807.                                 thisOption.selected = thisOption.value == passedValue;
  808.                             });
  809.                         }
  810.                     } else if (tagName === 'INPUT') {
  811.                         if ( !thisElement.type.match(rInputTypeBlacklist) ) {
  812.                             thisElement.value = passedValue;
  813.                         } else if (thisElement.type === 'checkbox' || thisElement.type === 'radio') {
  814.                             if (passedValueType === 'array') {
  815.                                 JSL.each(passedValue, function (thisPassedValue) {
  816.                                     if (thisElement.value == thisPassedValue) {
  817.                                         thisElement.checked = true;
  818.                                         return 'stop';
  819.                                     } else {
  820.                                         thisElement.checked = false;
  821.                                     }
  822.                                 });
  823.                             } else if (thisElement.value == passedValue) {
  824.                                  thisElement.checked = true;
  825.                             }
  826.                         }
  827.                     } else if (tagName === 'TEXTAREA') {
  828.                         thisElement.value = passedValue;
  829.                     }
  830.                 });
  831.             }
  832.  
  833.             return null;
  834.         },
  835.  
  836.         get visible() {
  837.             return Math.max(this.width, this.height) > 0;
  838.         },
  839.  
  840.         get width() {
  841.             var arrayOfElemHeights = core.map.call(this, pluck, 'offsetWidth');
  842.             return core.reduce.call(arrayOfElemHeights, sum);
  843.         },
  844.     };
  845.  
  846.     // give the init function the JSL prototype for later instantiation
  847.     JSL.fn.init.prototype = JSL.fn;
  848.  
  849.     // extend method. can extend any object it's run upon
  850.     JSL.fn.extend = JSL.extend = function (obj) {
  851.         var name, copy;
  852.  
  853.         for (name in obj) {
  854.             copy = obj[name];
  855.  
  856.             if ( !core.hasOwnProperty.call(this, name) && typeof copy !== 'undefined' ) {
  857.                 this[name] = copy;
  858.             }
  859.         }
  860.     };
  861.  
  862.     // --- STARTLING LINE FOR THE DIRECT JSL METHODS
  863.     JSL.extend({
  864.         addEvent : function addEvent(thisElement, type, fn) {
  865.             if (thisElement != null && typeof type === 'string' && typeof fn === 'function') {
  866.                 if (typeof thisElement.addEventListener === 'function') {
  867.                     thisElement.addEventListener(type, fn, false);
  868.                 } else if (typeof thisElement.attachEvent === 'function') {
  869.                     type = 'on' + type;
  870.                     thisElement.attachEvent(type, fn);
  871.                 } else {
  872.                     return;
  873.                 }
  874.  
  875.                 handlers.add(thisElement, type, fn);
  876.             }
  877.         },
  878.  
  879.         addScript : function addScript(contents, id, node) {
  880.             var newElement = document.createElement('script');
  881.             newElement.id = id || ( 'jsl-script-' + JSL.random(999) );
  882.             newElement.innerHTML = contents;
  883.  
  884.             node = node || document.head || document.querySelector('html > head');
  885.             node.appendChild(newElement);
  886.  
  887.             return {
  888.                 remove : function () {
  889.                     node.removeChild(newElement);
  890.                 }
  891.             };
  892.         },
  893.  
  894.         addStyle : function addStyle(css, id, node) {
  895.             id = id || ( 'jsl-style-' + JSL.random(999) );
  896.             node = node || document.head || document.querySelector('html > head');
  897.             if (node) {
  898.                 node.appendChild(
  899.                     JSL.create('style', {id : id, type : 'text/css'}, [ JSL.create('text', css) ] )
  900.                 );
  901.             }
  902.         },
  903.  
  904.         alias : function alias(newAlias) {
  905.             if (typeof newAlias === 'string' && newAlias.match(rValidVarname) && typeof window[newAlias] === 'undefined') {
  906.                 window[newAlias] = JSL;
  907.             }
  908.         },
  909.  
  910.         clearInterval : function clearInterval(index) {
  911.             if (typeof index === 'number' && index < intervals.length) {
  912.                 window.clearTimeout( intervals[index] );
  913.                 intervals[index] = null;
  914.             }
  915.         },
  916.  
  917.         create : function create(elementName, descObj, kidsArray) {
  918.             var argsLength = arguments.length,
  919.                 typeValue, prop, val, HTMLholder, ret, i;
  920.  
  921.             if (argsLength === 2 && elementName === 'text' && typeof descObj === 'string') {
  922.                 // handle text node creation
  923.                 return document.createTextNode(descObj);
  924.             } else if ( argsLength === 1 && typeof elementName === 'string' && elementName.match(rHTML) ) {
  925.                 // handle HTML strings
  926.  
  927.                 // take the HTML string and put it inside a div
  928.                 HTMLholder = document.createElement('div');
  929.                 HTMLholder.innerHTML = elementName;
  930.  
  931.                 // add each childNode to an array to return
  932.                 ret = [];
  933.                 ret.push.apply(ret, HTMLholder.childNodes);
  934.                 return ret.length > 0 ? (ret.length === 1 ? ret[0] : ret) : null;
  935.             } else if (argsLength > 1 && typeof elementName === 'string' && typeof descObj === 'object') {
  936.                 // handle the normal element name and descriptor object
  937.                 ret = document.createElement(elementName + '');
  938.  
  939.                 for (prop in descObj) {
  940.                     if ( core.hasOwnProperty.call(descObj, prop) ) {
  941.                         val = descObj[prop];
  942.                         if (prop.indexOf('on') === 0 && typeof val === 'function') {
  943.                             JSL.addEvent(ret, prop.substring(2), val);
  944.                         } else if ( prop !== 'style' && prop !== 'class' && prop in ret && typeof ret[prop] !== 'undefined' ) {
  945.                             ret[prop] = val;
  946.                         } else {
  947.                             ret.setAttribute(prop, val);
  948.                         }
  949.                     }
  950.                 }
  951.  
  952.                 if (JSL.typeOf(kidsArray) === 'array') {
  953.                     JSL.each(kidsArray, function (kid) {
  954.                         var val, item, i;
  955.  
  956.                         if (typeof kid === 'string') {
  957.                             val = JSL.create(kid)
  958.  
  959.                             if (JSL.typeOf(val) === 'array') {
  960.                                 for (i = 0; i < val.length; i += 1) {
  961.                                     ret.appendChild( val[i] );
  962.                                 }
  963.                             } else if (JSL.typeOf(kid) === 'element') {
  964.                                 ret.appendChild(kid);
  965.                             }
  966.                         } else if (JSL.typeOf(kid) === 'element') {
  967.                             ret.appendChild(kid);
  968.                         }
  969.                     });
  970.                 }
  971.  
  972.                 return ret;
  973.             } else if (argsLength === 1 && JSL.typeOf(elementName) === 'element') {
  974.                 // handle an element
  975.                 return elementName;
  976.             }
  977.         },
  978.  
  979.         each : function each(passedArray, fn, oThis) {
  980.             var isOthisUndefined = typeof oThis !== 'undefined',
  981.                 index, len, otherThis, value;
  982.  
  983.             for (index = 0; index < passedArray.length; index += 1) {
  984.                 value = passedArray[index];
  985.                 otherThis = isOthisUndefined ? oThis : value;
  986.                 if (fn.call(otherThis, value, index, passedArray) === 'stop') {
  987.                     break;
  988.                 }
  989.             }
  990.         },
  991.  
  992.         loop : function loop(maxIterations, fn) {
  993.             var args = JSL.toArray(arguments), i;
  994.  
  995.             if (typeof maxIterations === 'number' && maxIterations > 0 && typeof fn === 'function') {
  996.                 args = args.slice(2);
  997.                 for (i = 0; i < maxIterations; i += 1) {
  998.                     fn.apply(null, args);
  999.                 }
  1000.             }
  1001.         },
  1002.  
  1003.         random : function random(maxInteger, minInteger) {
  1004.             var rand = -1;
  1005.  
  1006.             while (rand < 0 || rand > maxInteger || rand < minInteger) {
  1007.                 rand = Math.floor( Math.random() * maxInteger ) + Math.round( Math.random() );
  1008.             }
  1009.  
  1010.             return rand;
  1011.         },
  1012.  
  1013.         removeEvent : function removeEvent(thisElement, type) {
  1014.             JSL.each(handlers.get(thisElement, type), function (thisEventObj) {
  1015.                 if (typeof thisElement.removeEventListener === 'function') {
  1016.                     thisEventObj.element.removeEventListener(thisEventObj.type, thisEventObj.fn, false);
  1017.                 } else if (typeof thisElement.detachEvent === 'function') {
  1018.                     type = 'on' + type;
  1019.                     thisEventObj.element.detachEvent(thisEventObj.type, thisEventObj.fn);
  1020.                 }
  1021.  
  1022.                 handlers.remove(thisElement, type);
  1023.             });
  1024.         },
  1025.  
  1026.         runAt : function runAt(state, func, oThis) {
  1027.             var args = JSL.toArray(arguments), intv,
  1028.  
  1029.                 // compose a list of the 4 states, to use .indexOf() upon later
  1030.                 states = ['uninitialized', 'loading', 'interactive', 'complete'],
  1031.  
  1032.                 // in-case they pass [start/end] instead of [loading/complete]
  1033.                 state = state.replace('start', 'loading').replace('end', 'complete');
  1034.  
  1035.             // this will run their function with the specified arguments, if any,
  1036.             // and a custom 'this' value, if specified
  1037.             function runFunc() {
  1038.                 func.apply( oThis, args.slice(3) );
  1039.             }
  1040.  
  1041.             // this will run on each state change if the specified state is
  1042.             // not achieved yet. it will run their function when it is achieved
  1043.             function checkState() {
  1044.                 if (document.readyState === state) {
  1045.                     runFunc();
  1046.                     JSL.clearInterval(intv);
  1047.                 }
  1048.             }
  1049.  
  1050.             if ( core.arr_indexOf.call(states, state) <= core.arr_indexOf.call(states, document.readyState) ) {
  1051.                 // we are at, or have missed, our desired state
  1052.                 // run the specified function
  1053.                 runFunc();
  1054.             } else {
  1055.                 intv = JSL.setInterval(checkState, 200);
  1056.             }
  1057.         },
  1058.  
  1059.         setInterval : function setInterval(func, delay) {
  1060.             var index = intervals.length,
  1061.                 delay_orig = delay,
  1062.                 count = 1, startTime;
  1063.  
  1064.             function doRe(func, delay) {
  1065.                 return window.setTimeout(function () {
  1066.                     // drift accomodation
  1067.                     var difference = ( new Date().getTime() ) - startTime,
  1068.                         correctTime = delay_orig * count,
  1069.                         drift = difference - correctTime;
  1070.  
  1071.                     // execute the function before setting a new timeout
  1072.                     func.call(null);
  1073.  
  1074.                     // fix for when a timeout takes longer than double the original delay time to execute
  1075.                     if (drift > delay_orig) {
  1076.                         drift = delay_orig;
  1077.                     }
  1078.  
  1079.                     // save the reference of the new timeout in our 'intervals' stack
  1080.                     if (intervals[index] !== null) {
  1081.                         intervals[index] = doRe(func, delay_orig - drift);
  1082.                     }
  1083.  
  1084.                     count += 1;
  1085.                 }, delay);
  1086.             }
  1087.  
  1088.             startTime = new Date().getTime();
  1089.             intervals[index] = doRe(func, delay_orig);
  1090.  
  1091.             return index;
  1092.         },
  1093.  
  1094.         toArray : function toArray(arr) {
  1095.             var newArr = [], // new array to store the values into
  1096.                 len = arr.length || arr.snapshotLength,
  1097.                 item, i;
  1098.  
  1099.             if (typeof len === 'number' && len > 0) {
  1100.                 if (typeof arr.snapshotItem === 'function') {
  1101.                     for (i = 0; ( item = arr.snapshotItem(i) ); i += 1) {
  1102.                         newArr.push(item);
  1103.                     }
  1104.                 } else {
  1105.                     // if the specified 'list' is array-like, use slice on it
  1106.                     // to convert it to an array
  1107.                     newArr = core.slice.call(arr, 0);
  1108.                 }
  1109.             }
  1110.  
  1111.             return newArr;
  1112.         },
  1113.  
  1114.         toString : function toString(item) {
  1115.             var key, value, values = [];
  1116.  
  1117.             function stringifyValue(val) {
  1118.                 var typeOfVal = JSL.typeOf(val),
  1119.                     toStringValue = core.toString.call(val);
  1120.  
  1121.                 if (typeOfVal === 'null' || typeOfVal === 'undefined') {
  1122.                     val = typeOfVal;
  1123.                 } else if (typeof val === 'string') {
  1124.                     if (val.length > 15) { // truncate strings longer than 15 characters
  1125.                         val = '"' + val.substring(0, 12) + '"...';
  1126.                     } else {
  1127.                         val = '"' + val + '"';
  1128.                     }
  1129.                 } else if (typeOfVal === 'function') {
  1130.                     val = val.toString().substring(0, 20);
  1131.                 } else if (typeOfVal !== 'number' && typeOfVal !== 'boolean') {
  1132.                     val = toStringValue;
  1133.                 }
  1134.  
  1135.                 return val;
  1136.             }
  1137.  
  1138.             switch( JSL.typeOf(item) ) {
  1139.                 case 'object': {
  1140.                     for (key in item) {
  1141.                         if ( item.hasOwnProperty(key) ) {
  1142.                             value = stringifyValue( item[key] );
  1143.                             values.push( '"' + key + '" : ' + value );
  1144.                         }
  1145.                     }
  1146.                     return '{\n    ' + values.join(',\n    ') + '\n}';
  1147.                 }
  1148.                 // --------------------------------------
  1149.                 case 'array': {
  1150.                     item = core.map.call(item, function (thisValue) {
  1151.                         return stringifyValue(thisValue);
  1152.                     });
  1153.                     return '[\n    ' + item.join(',\n    ') + '\n]';
  1154.                 }
  1155.                 // --------------------------------------
  1156.                 case 'string': {
  1157.                     return '"' + item + '"';
  1158.                 }
  1159.                 // --------------------------------------
  1160.                 case 'number': {
  1161.                     item = parseInt(item, 10);
  1162.                     if ( isNaN(item) ) { // no ternary operator, for clarity
  1163.                         return 'NaN';
  1164.                     } else {
  1165.                         return item.toString();
  1166.                     }
  1167.                 }
  1168.                 // --------------------------------------
  1169.                 case 'regexp': {
  1170.                     if (item.toString().length <= 20) {
  1171.                         item.toString();
  1172.                     } else {
  1173.                         return '[object RegExp]';
  1174.                     }
  1175.                 }
  1176.                 // --------------------------------------
  1177.                 case 'function': case 'boolean': {
  1178.                     return item.toString();
  1179.                 }
  1180.                 // --------------------------------------
  1181.                 case 'null': {
  1182.                     return 'null';
  1183.                 }
  1184.                 // --------------------------------------
  1185.                 case 'undefined': {
  1186.                     return 'undefined';
  1187.                 }
  1188.                 // --------------------------------------
  1189.                 default: {
  1190.                     return core.toString.call(item);
  1191.                 }
  1192.             }
  1193.         },
  1194.  
  1195.         // typeOf by Douglas Crockford. modified by JoeSimmons
  1196.         typeOf : function typeOf(value) {
  1197.             var s = typeof value,
  1198.                 ostr = core.toString.call(value);
  1199.  
  1200.             if (s === 'object' || s === 'function') {
  1201.                 if (value) {
  1202.                     if (ostr === '[object Array]') {
  1203.                         s = 'array';
  1204.                     } else if ( ostr === '[object Text]' || ostr.match(rElementObject) ) {
  1205.                         s = 'element';
  1206.                     } else if (ostr === '[object HTMLCollection]') {
  1207.                         s = 'collection';
  1208.                     } else if (ostr === '[object NodeList]') {
  1209.                         s = 'nodelist';
  1210.                     } else if (ostr === '[object Arguments]') {
  1211.                         s = 'arguments';
  1212.                     } else if (ostr === '[object RegExp]') {
  1213.                         s = 'regexp';
  1214.                     }
  1215.                 } else {
  1216.                     s = 'null';
  1217.                 }
  1218.             }
  1219.             return s;
  1220.         },
  1221.  
  1222.         waitFor : function waitFor(info) {
  1223.             var verifier = function () { return true; },
  1224.                 done = info ? info.done : null,
  1225.                 i, selector, context, waitForInterval;
  1226.  
  1227.             if (info == null || typeof done !== 'function') { return; }
  1228.  
  1229.             switch ( JSL.typeOf(info.selector) ) {
  1230.                 case 'string': case 'element': case 'array': {
  1231.                     selector = info.selector;
  1232.                     break;
  1233.                 }
  1234.                 default: {
  1235.                     return error('Invalid selector passed to JSL.waitFor()');
  1236.                 }
  1237.             }
  1238.  
  1239.             switch ( JSL.typeOf(info.context) ) {
  1240.                 case 'string': case 'element': case 'array': {
  1241.                     context = info.context;
  1242.                 }
  1243.             }
  1244.  
  1245.             if (typeof info.verifier === 'function' && info.verifier.toString().indexOf('return ') !== -1) {
  1246.                 verifier = info.verifier;
  1247.             }
  1248.  
  1249.             function clear() {
  1250.                 JSL.clearInterval(waitForInterval);
  1251.             }
  1252.  
  1253.             function check() {
  1254.                 var elem = JSL(selector, context);
  1255.  
  1256.                 if (elem.exists && verifier(elem) === true) {
  1257.                     done(elem);
  1258.                     return clear();
  1259.                 }
  1260.  
  1261.                 if (i >= 150) { // check for 30 seconds max
  1262.                     return clear();
  1263.                 }
  1264.  
  1265.                 i += 1;
  1266.             }
  1267.  
  1268.             waitForInterval = JSL.setInterval(check, 200);
  1269.         },
  1270.  
  1271.         xpath : function xpath(obj) {
  1272.             var type = obj.type || 7,
  1273.                 types = {
  1274.                     '1' : 'numberValue',
  1275.                     '2' : 'stringValue',
  1276.                     '3' : 'booleanValue',
  1277.                     '8' : 'singleNodeValue',
  1278.                     '9' : 'singleNodeValue'
  1279.                 },
  1280.                 expression = obj.expression,
  1281.                 context = obj.context || document,
  1282.                 doc = document, xp;
  1283.  
  1284.                 if (typeof context.evaluate === 'function') {
  1285.                     doc = context;
  1286.                 } else if (typeof context.ownerDocument.evaluate === 'function') {
  1287.                     doc = context.ownerDocument;
  1288.                 }
  1289.  
  1290.                 xp = doc.evaluate(expression, context, null, type, null);
  1291.  
  1292.             if (!expression) {
  1293.                 error('An expression must be supplied for JSL.xpath()');
  1294.                 return null;
  1295.             }
  1296.  
  1297.             if ( types[type] ) {
  1298.                 return xp[ types[ type ] ];
  1299.             } else {
  1300.                 return JSL.toArray(xp);
  1301.             }
  1302.         }
  1303.     });
  1304.  
  1305.     // assign JSL to the window object
  1306.     window.JSL = window._J = JSL;
  1307.  
  1308.     // just for testing purposes
  1309.     //unsafeWindow.JSL = unsafeWindow._J = JSL;
  1310.  
  1311. }(window));
  1312.  
  1313.  
  1314. /*
  1315. // JSL test button
  1316. // use it to test code on user click (non-automatic)
  1317. (function () {
  1318.     var mo = new MutationObserver(function (mutations) {
  1319.         mutations.forEach(function (mutation) {
  1320.             var target = mutation.target;
  1321.  
  1322.             if (mutation.attributeName === 'value' && target.value !== 'Run JSL test') {
  1323.                 target.value = 'Run JSL test';
  1324.             }
  1325.         });
  1326.     });
  1327.  
  1328.     JSL(document.body).append(
  1329.         'input',
  1330.         {
  1331.             id : 'jsl_user_test',
  1332.             type : 'button',
  1333.             value : 'Run JSL test',
  1334.             style : 'display: block; position: fixed; top: 4px; right: 4px; z-index: 999999; padding: 2px 14px; font-size: 11pt; font-family: Arial, Verdana;',
  1335.             onclick : function () {
  1336.  
  1337.             // ---- ENTER ONCLICK CODE HERE ----
  1338.                 window.setTimeout(function () {
  1339.                     JSL(document.body).append('<div id="waitForTest">I\'m a JSL.waitFor() test DIV!</div>');
  1340.                 }, 1500);
  1341.  
  1342.                 JSL.waitFor({
  1343.                     selector : '#waitForTest',
  1344.                     done : function (elem) {
  1345.                         alert('#waitForTest is loaded!');
  1346.                     }
  1347.                 });
  1348.             // ---------------------------------
  1349.             }
  1350.         }
  1351.     );
  1352.  
  1353.     mo.observe( JSL('#jsl_user_test')[0], { attributes : true } );
  1354. }());
  1355. */