var jQuery = function (selector, context) {
   return new jQuery.prototype.init(selector, context);
};

jQuery.prototype = {
   constructor: jQuery
};

jQuery.fn = jQuery.prototype = {
   constructor: jQuery
};

var init = jQuery.prototype.init = function (selector, context) {
   /** Для начала создаём массив, в который будем скидывать нужные элементы */
   var array = [];
   /** Сначала мы проработаем вариан,
    * когда кодер указал селектор 
    * или HTML код в первом аргументе
    */
   if (typeof selector === 'string') {
   /** Далее проверяем, не является ли первый аргумент DOM элементом */
   } else if (selector.nodeType) {
   /** 
    * Следующая проверка будет на ситуацию
    * если первый аргумент является массивом
   */
   } else if ({}.toString.call(selector) === '[object Array]') {
   /**
    * Следующей проверкой будет вариант,
    * когда первый аргумент является объектом
    */
   } else if ({}.toString.call(selector) === '[object Object]') {
   /** Теперь проверяем, может это живой массив элементов? */
   } else if ({}.toString.call(selector) === '[object HTMLCollection]' || {}.toString.call(selector) === '[object NodeList]') {
   /** Если первый аргумент — это функция */
   } else if ({}.toString.call(selector) === '[object Function]') {
   /** Если же ни однин тип не подошёл, то выводим пустой массив */
   } else {
      return array;
   }
};

/** Проверяем, не является ли селектор HTML кодом */
if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
/** Если это не HTML, то обычный селектор */
} else {        
};

1. С помощью специальных функций, парсится HTML код и живой массив, который вернула функция парсинга, объединяется с основным массивом.
   
   
   Реализация и аналог функции парсинга HTML кода — jQuery.parseHTML()

   К сожалению, я не расскажу про то, как реализована эта функция, т.к. у неё слишком много ответвлений, про которые можно писать отдельную статью. Но вы не расстраивайтесь, про то, как работает эта функция, уже написали. Вы можете прочитать эту статью перейдя по следующей ссылке: habrahabr.ru/post/164533
   
   Я же расскажу вам про альтернативные функции, с помощью которых можно реализовать данный функционал.
   
   

   1. Первая альтернатива — создадим элемент, в который с помощью innerHTML внесём нашу строку с кодом и заберём уже готовые DOM элементы.
      
      

      var parseHTML = function (HTML) {
         /**
          * Хоть мы и пишем простую альтернативу,
          * но проверить тип аргумента и
          * проверить это код или нет — нужно.
          * Код это или нет узнаём тем же образом
          * что и в условии основной функции
          */
         if (typeof HTML === 'string' && HTML[0] === "<" && HTML[HTML.length - 1] === ">" && HTML.length >= 3) {
            /** Создаём элемент */
            var E = document.createElement('div');
            /** Вставляем в элемент наш HTML код */
            E.innerHTML = HTML;
            /** Далее выводим готовый живой массив */
            return E.childNodes;
         } else {
            /** Если тип — не строка, то вернём пустой массив */
            return [];
         };
      };

      
      
   2. Вторая альтернатива — распарсить с помощью функции DOMParser(); и её дополнительной функции parseFromString();.
      
      

      var parseHTML = function (HTML) {
         /**
          * Хоть мы и пишем простую альтернативу,
          * но проверить тип аргумента и
          * проверить это код или нет — нужно.
          * Код это или нет узнаём тем же образом
          * что и в условии основной функции
          */
         if (typeof HTML === 'string' && HTML[0] === "<" && HTML[HTML.length - 1] === ">" && HTML.length >= 3) {
            /** Создаём новый HTML документ с кодом из аргумента  */
            var DOM = new DOMParser().parseFromString(HTML, 'text/html');
            /** Получаем наше пропарсенное содержимое  */
            var DOMList = DOM.body.childNodes;
            /** Далее выводим готовый живой массив  */
            return DOMList;
         } else {
            /** Если тип — не строка, то вернём пустой массив  */
            return [];
         };
      };

      
      
   3. Третья альтернатива — распарсить с помощью функции document.implementation.createHTMLDocument();.
      
      

      var parseHTML = function (HTML) {
         /**
          * Хоть мы и пишем простую альтернативу,
          * но проверить тип аргумента и
          * проверить это код или нет — нужно.
          * Код это или нет узнаём тем же образом
          * что и в условии основной функции
          */
         if (typeof HTML === 'string' && HTML[0] === "<" && HTML[HTML.length - 1] === ">" && HTML.length >= 3) {
            /** Создадим новый HTML документ */
            var DOM = document.implementation.createHTMLDocument();
            /** Внесём в него HTML строку */
            DOM.body.innerHTML = HTML;
            /** Получаем уже живой массив */
            var DOMList = DOM.body.childNodes;
            /** Далее выводим его */
            return DOMList;
         } else {
            /** Если тип — не строка, то вернём пустой массив */
            return [];
         };
      };

      
      

   
   Но нам нужна функция, которая повторит весь функционал jQuery функции. Поэтому мы создадим одну функцию, которая включит в себя все три вышеперечисленные варианта:
   
   

   var parseHTML = function (data, context, keepScripts) {
      /** Если к нам отправили не строку, то вернуть пустой массив */
      if (typeof data !== 'string') {
         return [];
      }
      /**
       * Мы принимаем свойство context
       * как keepScripts, если в нём
       * указан true/false
       */
      if (typeof context === 'boolean') {
         keepScripts = context;
         context = false;
      };
     
      var DOM, DOMList;
   
      if (!context || context === document) {
         /** Создаём HTML страницу */
         DOM = document.implementation.createHTMLDocument() || new DOMParser().parseFromString('', 'text/html');
         /** Внесём в него HTML строку */
         DOM.body.innerHTML = data;
         /** Получаем наше пропарсенное содержимое */
         DOMList = DOM.body.childNodes;
       } else if (context.nodeType) {
         /** Создаём новый элемент, через который будем парсить код */
         DOM = document.createElement('div');
         /** Добавляем этот элемент в целевой элемент */
         context.appendChild(DOM);
         /** Добавляем содержимое в элемент */
         DOM.innerHTML = data;
         /** Получаем список элементов */
         DOMList = DOM.childNodes;
         /** Удаляем DOM */
         DOM.parentNode.removeChild(DOM);
      };
     
        /** Если нужно запустить скрипт, указанный в коде */
        if (keepScripts === true) {
         /** Получаем список скриптов */
         var scripts = DOM.scripts || DOM.querySelectorAll('script');
   
         /** Проверяем наличие файлов скрипта */
         if (scripts.length) {
            /** Перебираем все скрипты */
            for (var i = 0; i < scripts.length; i++) {
               /** Создаём новый элемент скрипта */
               var script = document.createElement('script');
               /** Передаём новосозданному элементу скрипта все параметры */
               script.innerHTML = scripts[i].innerHTML;
               if (scripts[i].attributes) script.attributes = scripts[i].attributes;
               /** Добавляем скрипт в HEAD для запуска */
               document.head.appendChild(script);
               /** Удаляем скрипт из HEAD */
               script.parentNode.removeChild(script);
            };
         };
      };
   
      /** Перебираем значения в обычный массив и выводим */
      return (function () {
         var array = [];
   
         for (var i = 0; i < DOMList.length; i++) {
            array[array.length] = DOMList[i];
         };
   
         return array;
      })();
   };

   
   
   
   
   Реализация и аналог функции объединения массивов — jQuery.merge()

   Если мы заглянем в исходники jQuery, то увидим, что у них данная функция реализуется следующим образом:
   
   

   var merge = function( first, second ) {
      var len = +second.length, /** Я не знаю зачем они преобразуют second.length в число, если по идее, это и так число (если кто-то знает, пишите в комментариях) */
         j = 0,
         i = first.length;
   
      /** Перебираем значения второго массива */
      for ( ; j < len; j++ ) {
         /**
          * Добавляем новое значение в первый массив
          * и за одно плюсует счётчик количества
          * элементов в первом массиве
          */
         first[ i++ ] = second[ j ];
      }
   
      /** Записываем новое количество элементов в массиве */
      first.length = i;
   
      /** Выводим готовый массив */
      return first;
   };

   
   Альтернатив у функции jQuery.merge() есть несколько:
   
   

   1. Первой альтернативой является функция Array.concat();, которая объединяет массивы.
      
      

      [0, 1, 2].concat([3, 4, 5]); // [0, 1, 2, 3, 4, 5]

      
      Но данная функция не подойдёт, если вы хотите присоединить к массиву HTML коллекцию или список Node, так как у вас выведется массив в массиве, вместо объединения.
      
      Но это довольно легко исправить: нужно преобраовать живой массив в обычный. Это можно сделать с помощью функции [].slice.call().
      
      

      [0, 1, 2].concat( [].slice.call(document.querySelectorAll(selector)) ); // [0, 1, 2, element, element]

      
      Или же это можно сделать перебрав все элементы живого массива и переместив их в обычный массив.
      
      

      var elements = document.querySelectorAll(selector);
      var array = [];
      for (var i = 0; i < elements.length; i++) {
         array[array.length] = elements[i];
      };
      [0, 1, 2].concat(array); // [0, 1, 2, element, element]

      
      
   2. Вторая альтернатива — перебрать элементы второго массива и перенести их в первый. Эту же технологию можно наблюдать в стандартной функции jQuery.
      
      

      var merge = function (array0, array1) {
         for (var i = 0; i < array1.length; i++) {
            array0[array0.length] = array1[i];
            /**
             * Или array0.push(array1[i]);
             * если первый массив не живой
             */
         };
      
         return array0;
      };
      merge([0, 1, 2], [3, 4, 5]); // [0, 1, 3, 4, 5, 6]

      
      

   
   
   
   
2. Проверяем, является ли аргумент context объектом с параметрами. Если да, то записываем все параметры аргументами в DOM элементы.
   
   

   if ({}.toString.call(context) === '[object Object]') {
      for (var i = 0; i < array.length; i++) {
         for (var argument in context) {
            array.setAttribute(argument, context[argument]);
         };
      };
   };

   
   
3. Выводим готовый массив с элементами
   

Sizzle( String selector );

/** 
 * Проверяем, является ли аргумент context элементом или 
 * селектором элементов, в которых нужно искать элементы 
 * по селектору из аргумента selector
 */
/** Если аргумент context является элементом */
if (context && context.nodeType) {
   /** Получаем список элементов из родительского */
   var Elements = context.querySelectorAll(selector);
   /** Переносим список элементов в массив и выводим */
   return jQuery.merge(array, Elements);
 /** Если аргумент context является живым массив */
} else if ({}.toString.call(context) === '[object HTMLCollection]' || {}.toString.call(context) === '[object NodeList]') {
   /** 
    * Перебираем всех родителей и нужные
    * дочерние элементы переносим в массив
    */
   for (var i = 0; i < context.length; i++) {
      /** Получаем список элементов из родительского */
      var Elements = context[i].querySelectorAll(selector);
      /** Переносим список элементов в массив */
      jQuery.merge(array, Elements);
   };
   /** Выводим массив */
   return array;
/** Если аргумент context является селектором */
} else if (typeof context === 'string') {
   /** Получаем все родительские элементы
    * по селектору
    */
   var Parents = document.querySelectorAll(context);
   /** 
    * Перебираем всех родителей и нужные
    * дочерние элементы переносим в массив
    */
   for (var i = 0; i < Parents.length; i++) {
      /** Получаем список элементов из родительского */
      var Elements = Parents[i].querySelectorAll(selector);
      /** Переносим список элементов в массив */
      jQuery.merge(array, Elements);
   };
   /** Выводим массив */
   return array;
/** 
 * Если ни одни из вариантов не подходит, 
 * то осуществляем обычный поисх элементов
 */
} else {
   /** Получаем список элементов по селектору */
   var Elements = document.querySelectorAll(selector);
   /** Выводим массив */
   return jQuery.merge(array, Elements);
};

var init = jQuery.prototype.init = function (selector, context) {
   /** Для начала создаём массив, в который будем скидывать нужные элементы */
   var array = [];
   /** Сначала мы проработаем вариан,
    * когда кодер указал селектор 
    * или HTML код в первом аргументе
    */
   if (typeof selector === 'string') {
      /** Проверяем, не является ли селектор HTML кодом */
      if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
         /** Парсим HTML код и объединям с основным массивом */
         jQuery.merge(array, jQuery.parseHTML(selector, context && context.nodeType ? context.ownerDocument || context : document, true));
         /** Проверяем, является ли аргумент context объектом 
          * с параметрами. Если да, то записываем все параметры 
          * аргументами в DOM элементы. 
          */
         if ({}.toString.call(context) === '[object Object]') {
            for (var i = 0; i < array.length; i++) {
               for (var argument in context) {
                  array.setAttribute(argument, context[argument]);
               };
            };
         };
         /** Выводим массив */
         return array;
      /** Если это не HTML, то обычный селектор */
      } else {
         /** 
          * Проверяем, является ли аргумент context элементом или 
          * селектором элементов, в которых нужно искать элементы 
          * по селектору из аргумента selector
          */
         /** Если аргумент context является элементом */
         if (context && context.nodeType) {
            /** Получаем список элементов из родительского */
            var Elements = context.querySelectorAll(selector);
            /** Переносим список элементов в массив и выводим */
            return jQuery.merge(array, Elements);
         /** Если аргумент context является живым массив */
         } else if ({}.toString.call(context) === '[object HTMLCollection]' || {}.toString.call(context) === '[object NodeList]') {
            /** 
             * Перебираем всех родителей и нужные
             * дочерние элементы переносим в массив
             */
            for (var i = 0; i < context.length; i++) {
               /** Получаем список элементов из родительского */
               var Elements = context[i].querySelectorAll(selector);
               /** Переносим список элементов в массив */
               jQuery.merge(array, Elements);
            };
            /** Выводим массив */
            return array;
         /** Если аргумент context является селектором */
         } else if (typeof context === 'string') {
            /** Получаем все родительские элементы
             * по селектору
             */
            var Parents = document.querySelectorAll(context);
            /** 
             * Перебираем всех родителей и нужные
             * дочерние элементы переносим в массив
             */
            for (var i = 0; i < Parents.length; i++) {
               /** Получаем список элементов из родительского */
               var Elements = Parents[i].querySelectorAll(selector);
               /** Переносим список элементов в массив */
               jQuery.merge(array, Elements);
            };
            /** Выводим массив */
            return array;
         /** 
          * Если ни одни из вариантов не подходит, 
          * то осуществляем обычный поисх элементов
          */
         } else {
            /** Получаем список элементов по селектору */
            var Elements = document.querySelectorAll(selector);
            /** Выводим массив */
            return jQuery.merge(array, Elements);
         }
      };
   /** Далее проверяем, не является ли первый аргумент DOM элементом */
   } else if (selector.nodeType) {
   /** 
    * Следующая проверка будет на ситуацию
    * если первый аргумент является массивом
   */
   } else if ({}.toString.call(selector) === '[object Array]') {
   /**
    * Следующей проверкой будет вариант,
    * когда первый аргумент является объектом
    */
   } else if ({}.toString.call(selector) === '[object Object]') {
   /** Теперь проверяем, может это живой массив элементов? */
   } else if ({}.toString.call(selector) === '[object HTMLCollection]' || {}.toString.call(selector) === '[object NodeList]') {
   /** Если первый аргумент — это функция */
   } else if ({}.toString.call(selector) === '[object Function]') {
   /** Если же ни однин тип не подошёл, то выводим пустой массив */
   } else {
      return array;
   }
};

/** Вставляем элемент в массив */
array[0] = selector;
/** Выводим основной массив */
return array;

/** Объединям массивы */
jQuery.merge(array, selector);
/** Выводим основной массив */
return array;

/** Вставляем объект в массив */
array[0] = selector;
/** Выводим основной массив */
return array;

/** Переносим элемент из живого массива в основной массив */
jQuery.merge(array, selector);
/** Выводим основной массив */
return array;

var ready = (function() {
  var readyList,
      DOMContentLoaded,
      class2type = {};
      class2type["[object Boolean]"] = "boolean";
      class2type["[object Number]"] = "number";
      class2type["[object String]"] = "string";
      class2type["[object Function]"] = "function";
      class2type["[object Array]"] = "array";
      class2type["[object Date]"] = "date";
      class2type["[object RegExp]"] = "regexp";
      class2type["[object Object]"] = "object";

  var ReadyObj = {
      // Является ли DOM готовым к использованию? Устанавливаем значение true, как только оно произойдет.
      isReady: false,
      // Счетчик, чтобы отслеживать количество элементов, ожидающих до начала события.
      readyWait: 1,
      // Удерживаем (или отпускаем) готовое событие
      holdReady: function(hold) {
        if (hold) {
          ReadyObj.readyWait++;
        } else {
          ReadyObj.ready(true);
        }
      },
      // Запускаем, когда DOM готов
      ready: function(wait) {
        // Либо трюк не работает, либо события DOMready/load и еще не готовы
        if ((wait === true && !--ReadyObj.readyWait) || (wait !== true && !ReadyObj.isReady)) {
          // Проверяем, что body существует, в случае, если IE наложает.
          if (!document.body) {
            return setTimeout(ReadyObj.ready, 1);
          }

          // Запоминаем что DOM готов
          ReadyObj.isReady = true;
          // Если обычное событие DOM Ready запускается, уменьшается и ожидает, если потребуется,
          if (wait !== true && --ReadyObj.readyWait > 0) {
            return;
          }
          // Если функции связаны, выполнить
          readyList.resolveWith(document, [ReadyObj]);

          // Запуск любых связанных событий
          //if ( ReadyObj.fn.trigger ) {
          //    ReadyObj( document ).trigger( "ready" ).unbind( "ready" );
          //}
        }
      },
      bindReady: function() {
        if (readyList) {
          return;
        }
        readyList = ReadyObj._Deferred();

        // Поймать случаи, когда $(document).ready() вызывается после
        // события браузера, которое уже произошло.
        if (document.readyState === "complete") {
          // Обращаемся к нему асинхронно, чтобы позволить скриптам возможность задержать готовность
          return setTimeout(ReadyObj.ready, 1);
        }

        // Mozilla, Opera и webkit nightlies в настоящее время поддерживают это событие
        if (document.addEventListener) {
          // Используем удобный callback события
          document.addEventListener("DOMContentLoaded", DOMContentLoaded, false);
          // Откат к window.onload, который всегда будет работать
          window.addEventListener("load", ReadyObj.ready, false);

          // Если используется тип событий IE
        } else if (document.attachEvent) {
          // Обеспечить запуск перед загрузкой,
          // Возможно, поздно, но безопасно также для iframes
          document.attachEvent("onreadystatechange", DOMContentLoaded);

          // Откат к window.onload, который всегда будет работать
          window.attachEvent("onload", ReadyObj.ready);

          // Если IE, а не frame
          // Постоянно проверяем, готов ли документ
          var toplevel = false;

          try {
            toplevel = window.frameElement == null;
          } catch (e) {}

          if (document.documentElement.doScroll && toplevel) {
            doScrollCheck();
          }
        }
      },
      _Deferred: function() {
        var // список callback
          callbacks = [],
          // stored [ context , args ]
          fired,
          // Чтобы избежать запуска, когда это уже сделано
          firing,
          // Чтобы узнать, отменена ли отсрочка
          cancelled,
          // Отложенный
          deferred = {
            // done( f1, f2, ...)
            done: function() {
              if (!cancelled) {
                var args = arguments,
                  i,
                  length,
                  elem,
                  type,
                  _fired;
                if (fired) {
                  _fired = fired;
                  fired = 0;
                }
                for (i = 0, length = args.length; i < length; i++) {
                  elem = args[i];
                  type = ReadyObj.type(elem);
                  if (type === "array") {
                    deferred.done.apply(deferred, elem);
                  } else if (type === "function") {
                    callbacks.push(elem);
                  }
                }
                if (_fired) {
                  deferred.resolveWith(_fired[0], _fired[1]);
                }
              }
              return this;
            },

            // Разрешить с заданным контекстом и аргументами
            resolveWith: function(context, args) {
              if (!cancelled && !fired && !firing) {
                // Проверяем, что имеются аргументы
                args = args || [];
                firing = 1;
                try {
                  while (callbacks[0]) {
                    callbacks.shift().apply(context, args); //shifts a callback, and applies it to document
                  }
                } finally {
                  fired = [context, args];
                  firing = 0;
                }
              }
              return this;
            },

            // Решить с этим в качестве контекста и приведенных аргументов
            resolve: function() {
              deferred.resolveWith(this, arguments);
              return this;
            },

            // Отложено ли это решение?
            isResolved: function() {
              return !!(firing || fired);
            },

            // Отмена
            cancel: function() {
              cancelled = 1;
              callbacks = [];
              return this;
            }
          };

        return deferred;
      },
      type: function(obj) {
        return obj == null ?
          String(obj) :
          class2type[Object.prototype.toString.call(obj)] || "object";
      }
    }
    // Проверка готовности DOM для Internet Explorer
  function doScrollCheck() {
    if (ReadyObj.isReady) {
      return;
    }

    try {
      // Если используется IE, то используйте трюк Диего Перини
      // http://javascript.nwbox.com/IEContentLoaded/
      document.documentElement.doScroll("left");
    } catch (e) {
      setTimeout(doScrollCheck, 1);
      return;
    }

    // И выполнить функцию ожидания
    ReadyObj.ready();
  }
  // Функция очистки для document ready
  if (document.addEventListener) {
    DOMContentLoaded = function() {
      document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
      ReadyObj.ready();
    };

  } else if (document.attachEvent) {
    DOMContentLoaded = function() {
      // Проверяем, что body существует, в случае, если IE наложает (ticket #5443).
      if (document.readyState === "complete") {
        document.detachEvent("onreadystatechange", DOMContentLoaded);
        ReadyObj.ready();
      }
    };
  }

  function ready(fn) {
    // Прикрепляем "слушателя"
    ReadyObj.bindReady();

    var type = ReadyObj.type(fn);

    // Добавляем callback'а
    readyList.done(fn); // ReadyList является результатом _Deferred()
  }
  return ready;
})();

/** Запускаем функции после загрузки DOM дерева */
document.onreadystatechange = function(){
   if(document.readyState === 'complete'){
      selector();
   };
};
/** Вернём эту же функцию */
return selector;

if (array.__proto__) {
   array.__proto__ = jQuery.prototype;
} else {
   for (var param in jQuery.prototype) {
      array[param] = jQuery.prototype[param];
   };
};

/** Создаём функцию — обложку */
var jQuery = function (selector, context) {
   return new jQuery.prototype.init(selector, context);
};

/** Создаём для функции прототип */
jQuery.prototype = {
   constructor: jQuery
};

/** Создаём основную функцию */
var init = jQuery.prototype.init = function (selector, context) {
   /** Для начала создаём массив, в который будем скидывать нужные элементы */
   var array = [];
   /** 
    * К его proto массива присваиваем
    * прототип главной функции,
    * чтобы потом можно было 
    * создавать дополнительный
    * функционал для jQuery объектов
   */
   /** Объект __proto__ достаточно новый
    * Начинает работать начиная с IE11+
    * Поэтому мы создадим некий полифилл
    */
   if (array.__proto__) {
      array.__proto__ = jQuery.prototype;
   } else {
      for (var param in jQuery.prototype) {
         array[param] = jQuery.prototype[param];
      };
   };
   /** Сначала мы проработаем вариан,
    * когда кодер указал селектор 
    * или HTML код в первом аргументе
    */
   if (typeof selector === 'string') {
      /** Проверяем, не является ли селектор HTML кодом */
      if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
         /** Парсим HTML код и объединям с основным массивом */
         jQuery.merge(array, jQuery.parseHTML(selector, context && context.nodeType ? context.ownerDocument || context : document, true));
         /** Проверяем, является ли аргумент context объектом 
          * с параметрами. Если да, то записываем все параметры 
          * аргументами в DOM элементы. 
          */
         if ({}.toString.call(context) === '[object Object]') {
            for (var i = 0; i < array.length; i++) {
               for (var argument in context) {
                  array.setAttribute(argument, context[argument]);
               };
            };
         };
         /** Выводим массив */
         return array;
         /** Если это не HTML, то обычный селектор */
      } else {
         /** 
          * Проверяем, является ли аргумент context элементом или 
          * селектором элементов, в которых нужно искать элементы 
          * по селектору из аргумента selector
          */
         /** Если аргумент context является элементом */
         if (context && context.nodeType) {
            /** Получаем список элементов из родительского */
            var Elements = context.querySelectorAll(selector);
            /** Переносим список элементов в массив и выводим */
            return jQuery.merge(array, Elements);
            /** Если аргумент context является живым массив */
         } else if ({}.toString.call(context) === '[object HTMLCollection]' || {}.toString.call(context) === '[object NodeList]') {
            /** 
             * Перебираем всех родителей и нужные
             * дочерние элементы переносим в массив
             */
            for (var i = 0; i < context.length; i++) {
               /** Получаем список элементов из родительского */
               var Elements = context[i].querySelectorAll(selector);
               /** Переносим список элементов в массив */
               jQuery.merge(array, Elements);
            };
            /** Выводим массив */
            return array;
            /** Если аргумент context является селектором */
         } else if (typeof context === 'string') {
            /** Получаем все родительские элементы
             * по селектору
             */
            var Parents = document.querySelectorAll(context);
            /** 
             * Перебираем всех родителей и нужные
             * дочерние элементы переносим в массив
             */
            for (var i = 0; i < Parents.length; i++) {
               /** Получаем список элементов из родительского */
               var Elements = Parents[i].querySelectorAll(selector);
               /** Переносим список элементов в массив */
               jQuery.merge(array, Elements);
            };
            /** Выводим массив */
            return array;
            /** 
             * Если ни одни из вариантов не подходит, 
             * то осуществляем обычный поисх элементов
             */
         } else {
            /** Получаем список элементов по селектору */
            var Elements = document.querySelectorAll(selector);
            /** Выводим массив */
            return jQuery.merge(array, Elements);
         }
      };
      /** Далее проверяем, не является ли первый аргумент DOM элементом */
   } else if (selector.nodeType) {
      /** Вставляем элемент в массив */
      array[0] = selector;
      /** Выводим основной массив */
      return array;
      /** 
       * Следующая проверка будет на ситуацию
       * если первый аргумент является массивом
      */
   } else if ({}.toString.call(selector) === '[object Array]') {
      /** Объединям массивы */
      jQuery.merge(array, selector);
      /** Выводим основной массив */
      return array;
      /**
       * Следующей проверкой будет вариант,
       * когда первый аргумент является объектом
       */
   } else if ({}.toString.call(selector) === '[object Object]') {
      /** Вставляем объект в массив */
      array[0] = selector;
      /** Выводим основной массив */
      return array;
      /** Теперь проверяем, может это живой массив элементов? */
   } else if ({}.toString.call(selector) === '[object HTMLCollection]' || {}.toString.call(selector) === '[object NodeList]') {
      /** Переносим элемент из живого массива в основной массив */
      jQuery.merge(array, selector);
      /** Выводим основной массив */
      return array;
      /** Если первый аргумент — это функция */
   } else if ({}.toString.call(selector) === '[object Function]') {
      /** Запускаем функции после загрузки DOM дерева */
      document.onreadystatechange = function(){
         if(document.readyState === 'complete'){
            selector();
         };
      };
      /** Вернём эту же функцию */
      return selector;
      /** Если же ни однин тип не подошёл, то выводим пустой массив */
   } else {
      return array;
   }
};

jQuery.merge = function (first, second) {
   var len = +second.length, /** Я не знаю зачем они преобразуют second.length в число, если по идее, это и так число */
      j = 0,
      i = first.length;

   /** Перебираем значения второго массива */
   for (; j < len; j++) {
      /**
       * Добавляем новое значение в первый массив
       * и за одно плюсует счётчик количества
       * элементов в первом массиве
       */
      first[i++] = second[j];
   }

   /** Записываем новое количество элементов в массиве */
   first.length = i;

   /** Выводим готовый массив */
   return first;
};

jQuery.parseHTML = function (data, context, keepScripts) {
   /** Если к нам отправили не строку, то вернуть пустой массив */
   if (typeof data !== 'string') {
      return [];
   }
   /**
    * Мы принимаем свойство context
    * как keepScripts, если в нём
    * указан true/false
    */
   if (typeof context === 'boolean') {
      keepScripts = context;
      context = false;
   };

   var DOM, DOMList;

   if (!context || context === document) {
      /** Создаём HTML страницу */
      DOM = document.implementation.createHTMLDocument() || new DOMParser().parseFromString('', 'text/html');
      /** Внесём в него HTML строку */
      DOM.body.innerHTML = data;
      /** Получаем наше пропарсенное содержимое */
      DOMList = DOM.body.childNodes;
   } else if (context.nodeType) {
      /** Создаём новый элемент, через который будем парсить код */
      DOM = document.createElement('div');
      /** Добавляем этот элемент в целевой элемент */
      context.appendChild(DOM);
      /** Добавляем содержимое в элемент */
      DOM.innerHTML = data;
      /** Получаем список элементов */
      DOMList = DOM.childNodes;
      /** Удаляем DOM */
      DOM.parentNode.removeChild(DOM);
   };

   /** Если нужно запустить скрипт, указанный в коде */
   if (keepScripts === true) {
      /** Получаем список скриптов */
      var scripts = DOM.scripts || DOM.querySelectorAll('script');

      /** Проверяем наличие файлов скрипта */
      if (scripts.length > 0) {
         /** Перебираем все скрипты */
         for (var i = 0; i < scripts.length; i++) {
            /** Создаём новый элемент скрипта */
            var script = document.createElement('script');
            /** Передаём новосозданному элементу скрипта все параметры */
            script.innerHTML = scripts[i].innerHTML;
            if (scripts[i].attributes) script.attributes = scripts[i].attributes;
            /** Добавляем скрипт в HEAD для запуска */
            document.head.appendChild(script);
            /** Удаляем скрипт из HEAD */
            script.parentNode.removeChild(script);
         };
      };
   };

   /** Перебираем значения в обычный массив и выводим */
   return (function () {
      var array = [];

      for (var i = 0; i < DOMList.length; i++) {
         array[array.length] = DOMList[i];
      };

      return array;
   })();
};

jQuery.prototype.myFunction = function () {...};