☰

JoeSimmons' Library

A JavaScript library used for bypass copy paste

当前为 2017-01-18 提交的版本，查看 最新版本。

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