loada 0.1.3

data/lib/loada.min.js

@@ -0,0 +1 @@
+!function(){var a,b=function(a,b){return function(){return a.apply(b,arguments)}},c=[].slice;a=document.getElementsByTagName("head")[0],this.Loada=function(){function d(a,c){var d,e;if(this.set=a,this._loadGroup=b(this._loadGroup,this),this.options={prefix:"loada",localStorage:!0},this.requires={input:[],set:{},length:0},this.set||(this.set="*"),c)for(d in c)e=c[d],this.options[d]=e;this.key=""+this.options.prefix+"."+this.set,this.setup()}return d.prototype.Progress=function(){function a(a,b){this.count=a,this.progressCallback=b,this.data={}}return a.prototype.set=function(a,b){return this.data[a]=Math.min(b,100),"function"==typeof this.progressCallback?this.progressCallback(this.total()):void 0},a.prototype.total=function(){var a,b,c,d;c=0,d=this.data;for(a in d)b=d[a],c+=Math.round(100*(b/this.count))/100;return c},a}(),d.set=function(){return function(a,b,c){c.prototype=a.prototype;var d=new c,e=a.apply(d,b);return Object(e)===e?e:d}(this,arguments,function(){})},d.prototype.setup=function(){return this.options.localStorage&&(this.storage=localStorage[this.key]||{},"string"==typeof this.storage)?this.storage=JSON.parse(localStorage[this.key]):void 0},d.prototype.save=function(){return localStorage[this.key]=JSON.stringify(this.storage)},d.prototype.clear=function(){return delete localStorage[this.key]},d.prototype.get=function(a){var b;return null!=(b=this.storage[a])?b.source:void 0},d.prototype.expire=function(){var a,b,c,d,e,f,g,h,i=this;f=new Date,a=function(a){return a.expirationDate&&new Date(a.expirationDate)<=f},b=function(){return!i.requires.set[d]},c=function(a){return i.requires.set[d].revision!==a.revision},g=this.storage,h=[];for(d in g)e=g[d],a(e)||b(e)||c(e)?h.push(delete this.storage[d]):h.push(void 0);return h},d.prototype.require=function(){var a,b,d,e,f,g;for(a=1<=arguments.length?c.call(arguments,0):[],e=0,f=a.length;f>e;e++)b=a[e],b.key||(b.key=b.url),b.type||(b.type=null!=(g=b.url)?g.split(".").pop():void 0),null==b.localStorage&&(b.localStorage=!0),null==b.require&&(b.require=!0),b.expires&&(d=new Date,b.expirationDate=d.setTime(d.getTime()+1e3*60*60*b.expires)),"js"===b.type||"css"===b.type||"text"===b.type?this.requires.set[b.key]=b:console.error("Unknown asset type for "+b.url+" – skipped");return this.requires.length+=a.length,this.requires.input.push(a)},d.prototype.load=function(a){var b,c,d=this;return a||(a={}),this.options.localStorage&&this.expire(),c=new this.Progress(this.requires.length,a.progress),b=0,this._ensureSizes(null!=a.progress,function(){var e,f,g,h,i;for(h=d.requires.input,i=[],f=0,g=h.length;g>f;f++)e=h[f],b++,i.push(d._loadGroup(e.slice(0),c,function(){return b--,0===b?(d.save(),"function"==typeof a.success?a.success():void 0):void 0}));return i})},d.prototype._ensureSizes=function(a,b){var c,d,e,f,g,h,i=this;if(!a){f=this.requires.set;for(c in f)d=f[c],d.size=0;return b()}e=0,g=this.requires.set,h=[];for(c in g)d=g[c],h.push(function(a){return null==a.size?(e++,i._ajax("HEAD",a.url,function(c){var d;return e--,d=c.getResponseHeader("Content-Length"),d&&(d=parseInt(d)),a.size=d||0,0===e?b():void 0})):void 0}(d));return h},d.prototype._loadGroup=function(a,b,c){var d,e,f=this;return d=a.shift(),d?this.options.localStorage&&this.storage[d.key]&&d.localStorage?(null!=b&&b.set(d.key,100),this.storage[d.key].require&&this._inject(this.storage[d.key]),this._loadGroup(a,b,c)):(e=this.options.localStorage?"_loadAJAX":"_loadInline",this[e](d,b,function(){return f.options.localStorage&&(f.storage[d.key]=d),d.require&&f._inject(d),f._loadGroup(a,b,c)})):c()},d.prototype._loadAJAX=function(a,b,c){var d,e;return e=this._ajax("GET",a.url,function(e){return a.source=e.responseText,clearInterval(d),null!=b&&b.set(a.key,100),c()}),a.size>0?d=setInterval(function(){var c;return c=Math.round(100*100*(e.responseText.length/a.size))/100,null!=b?b.set(a.key,c):void 0},100):void 0},d.prototype._loadInline=function(b,c,d){var e,f,g;return"js"!==b.type?(console.error("Attempt to load something other than JS without localStorage."),console.error(""+b.url+" is not loaded!"),null!=c&&c.set(b.key,100),d()):(g=document.createElement("script"),e=!1,f=function(){return e||null!=this.readyState&&"loaded"!==this.readyState&&"complete"!==this.readyState?void 0:(e=!0,null!=c&&c.set(b.key,100),"function"==typeof d&&d(),g.onload=g.onreadystatechange=null)},g.onload=g.onreadystatechange=f,g.src=b.url,a.appendChild(g))},d.prototype._inject=function(b){var c,d;return"js"===b.type?(c=document.createElement("script"),c.defer=!0,c.text=b.source,a.appendChild(c)):"css"===b.type?(d=document.createElement("style"),d.innerHTML=b.source,a.appendChild(d)):void 0},d.prototype._ajax=function(a,b,c){var d;return d=window.XMLHttpRequest?new XMLHttpRequest:new ActiveXObject("Microsoft.XMLHTTP"),d.open(a,b,1),d.onreadystatechange=function(){return d.readyState>3?"function"==typeof c?c(d):void 0:void 0},d.send(),d},d}()}.call(this);

data/lib/loada.rb

@@ -0,0 +1,14 @@
+require 'json'
+
+module Loada
+  PACKAGE = File.expand_path("../../package.json", __FILE__)
+
+  # Converting semver to the notation compatible with rubygems
+  VERSION = JSON.parse(File.read(PACKAGE))['version'].gsub '-', '.'
+
+  def self.assets_paths
+    [
+      File.expand_path('../../src', __FILE__)
+    ]
+  end
+end

data/loada.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path("../lib/loada.rb", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "loada"
+  s.version     = Loada::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "The Loada"
+  s.email       = "boris@staal.io"
+  s.homepage    = "http://github.com/inossidabile/loada"
+  s.description = "A gem wrapper to include Loada via the asset pipeline"
+  s.authors     = ['Boris Staal']
+
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'sprockets'
+end

data/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "loada",
+  "version": "0.1.3",
+  "description": "Browser assets preloader with the support of localStorage-based caching and progress tracking",
+  "repository": "",
+  "keywords": [
+    "browser",
+    "preloader",
+    "assets"
+  ],
+  "author": "Boris Staal",
+  "license": "MIT",
+  "devDependencies": {
+    "grunt": "~0.4.1",
+    "grunt-contrib-coffee": "~0.7.0",
+    "grunt-contrib-jasmine": "~0.5.1",
+    "grunt-contrib-connect": "~0.3.0",
+    "grunt-release": "~0.3.5",
+    "grunt-coffeelint": "0.0.6",
+    "grunt-contrib-watch": "~0.4.4",
+    "bower": "~0.9.2",
+    "grunt-contrib-uglify": "~0.2.2"
+  }
+}

data/spec/helpers/spec_helper.coffee

@@ -0,0 +1,2 @@
+afterEach ->
+  localStorage.clear()

data/spec/loada_spec.coffee

@@ -0,0 +1,318 @@
+describe "Loada", ->
+
+  it "initializes properly", ->
+    set = Loada.set(undefined, localStorage: false)
+    expect(set.set).toEqual '*'
+    expect(set.options.localStorage).toBeFalsy()
+    expect(set.storage).toBeUndefined()
+
+    localStorage['loada.foo'] = JSON.stringify('foo': 'bar')
+
+    set = Loada.set 'foo'
+    expect(set.set).toEqual 'foo'
+    expect(set.options.localStorage).toBeTruthy()
+    expect(set.storage).toEqual {'foo': 'bar'}
+
+  describe "expiration", ->
+    it "cuts by date", ->
+      expired   = new Date
+      unexpired = new Date
+      unexpired.setTime(unexpired.getTime() + 60*1000)
+
+      libraries = 
+        'foo.js': {expirationDate: expired}
+        'bar.js': {expirationDate: unexpired}
+      localStorage['loada.*'] = JSON.stringify libraries
+
+      set = Loada.set()
+      set.require url: 'foo.js'
+      set.require url: 'bar.js'
+
+      expect(set.storage['foo.js']).toBeDefined()
+      expect(set.storage['bar.js']).toBeDefined()
+
+      set.expire()
+      expect(set.storage['foo.js']).toBeUndefined()
+      expect(set.storage['bar.js']).toBeDefined()
+
+    it "cuts by existance", ->
+      localStorage['loada.*'] = JSON.stringify { 'foo.js': {}, 'bar.js': {} }
+
+      set = Loada.set()
+      set.require url: 'bar.js'
+
+      expect(set.storage['foo.js']).toBeDefined()
+      expect(set.storage['bar.js']).toBeDefined()
+
+      set.expire()
+      expect(set.storage['foo.js']).toBeUndefined()
+      expect(set.storage['bar.js']).toBeDefined()
+
+    it "cuts by revision", ->
+      localStorage['loada.*'] = JSON.stringify 
+        'foo.js': {revision: 1}
+        'bar.js': {}
+        'baz.js': {}
+
+      set = Loada.set()
+      set.require url: 'foo.js', revision: 1
+      set.require url: 'bar.js', revision: 1
+      set.require url: 'baz.js'
+
+      expect(set.storage['foo.js']).toBeDefined()
+      expect(set.storage['bar.js']).toBeDefined()
+      expect(set.storage['baz.js']).toBeDefined()
+
+      set.expire()
+      expect(set.storage['foo.js']).toBeDefined()
+      expect(set.storage['bar.js']).toBeUndefined()
+      expect(set.storage['baz.js']).toBeDefined()
+
+  describe "size ensurer", ->
+    beforeEach ->
+      @set = Loada.set()
+      @set.require url: 'foo.js', size: 100
+      @set.require url: 'bar.js'
+      @set.require url: 'baz.js'
+
+    it "zerofills with no progress tracking", ->
+      callback = sinon.spy()
+      @set._ensureSizes false, callback
+      expect(callback.callCount).toEqual 1
+      expect(@set.requires.set['foo.js'].size).toEqual 0
+
+    it "gets sizes with progress tracking", ->
+      callback = sinon.spy()
+      server   = sinon.fakeServer.create()
+      @set._ensureSizes true, callback
+
+      waits 0
+
+      runs ->
+        expect(server.requests[0].url).toEqual 'bar.js'
+        expect(server.requests[1].url).toEqual 'baz.js'
+
+        server.requests[0].respond 200, {'Content-Length': '100'}, ''
+        server.requests[1].respond 200, {}, ''
+        server.restore()
+
+      waits 0
+
+      runs ->
+        expect(callback.callCount).toEqual 1
+        expect(@set.requires.set['foo.js'].size).toEqual 100
+        expect(@set.requires.set['bar.js'].size).toEqual 100
+        expect(@set.requires.set['baz.js'].size).toEqual(0)
+
+  describe "loader", ->
+    beforeEach ->
+      @server = sinon.fakeServer.create()
+      @set = Loada.set()
+      sinon.stub @set, '_inject'
+
+    afterEach ->
+      @set._inject.restore()
+      @server.restore()
+
+    it "gets single from cache", ->
+      localStorage['loada.*'] = JSON.stringify 
+        'foo.js': {require: true}
+
+      @set.setup()
+      callback = sinon.spy()
+      @set.require url: 'foo.js'
+
+      @set._loadGroup @set.requires.input[0], null, callback
+
+      waits 0
+
+      runs ->
+        expect(@server.requests.length).toEqual 0
+        expect(callback.callCount).toEqual 1
+        expect(@set._inject.callCount).toEqual 1
+        expect(@set._inject.args[0][0]).toEqual {require: true}
+
+    it "gets single from net", ->
+      callback = sinon.spy()
+      @set.require url: 'foo.js'
+
+      @set._loadGroup @set.requires.input[0], null, callback
+
+      waits 0
+
+      runs ->
+        @server.requests[0].respond 200, {}, 'foobar'
+
+      waits 0
+
+      runs ->
+        library =
+          url: 'foo.js'
+          key: 'foo.js'
+          type: 'js'
+          source: 'foobar'
+          localStorage: true
+          require: true
+
+        expect(@server.requests.length).toEqual 1
+        expect(@set.storage['foo.js']).toEqual library
+        expect(callback.callCount).toEqual 1
+        expect(@set._inject.callCount).toEqual 1
+        expect(@set._inject.args[0][0]).toEqual library
+
+    it "orders properly", ->
+      @set.require(
+        { url: 'foo.js' },
+        { url: 'bar.js' }
+      )
+      @set.require url: 'baz.js'
+
+      @set._loadGroup @set.requires.input[0], null, ->
+      @set._loadGroup @set.requires.input[1], null, ->
+
+      waits 0
+
+      runs ->
+        @server.requests[0].respond 200, {}, 'foobar'
+        @server.requests[1].respond 200, {}, 'foobar'
+        @server.requests[2].respond 200, {}, 'foobar'
+
+      waits 0
+
+      runs ->
+        expect(@server.requests[0].url).toEqual 'foo.js'
+        expect(@server.requests[1].url).toEqual 'baz.js'
+        expect(@server.requests[2].url).toEqual 'bar.js'
+
+    describe "progress", ->
+      it "tracks with cache", ->
+        progress = {set: sinon.spy()}
+
+        localStorage['loada.*'] = JSON.stringify 
+          'foo.js': {}
+          'bar.js': {}
+
+        @set.setup()
+        @set.require(
+          { url: 'foo.js' },
+          { url: 'bar.js' }
+        )
+
+        @set._loadGroup @set.requires.input[0], progress, ->
+
+        expect(progress.set.callCount).toEqual 2
+        expect(progress.set.args[0]).toEqual ['foo.js', 100]
+        expect(progress.set.args[1]).toEqual ['bar.js', 100]
+
+      it "tracks with net", ->
+        progress = {set: sinon.spy()}
+
+        @set.require(
+          { url: 'foo.js' },
+          { url: 'bar.js' }
+        )
+
+        @set._loadGroup @set.requires.input[0], progress, ->
+
+        waits 0
+
+        runs ->
+          @server.requests[0].respond 200, {}, 'foobar'
+          @server.requests[1].respond 200, {}, 'foobar'
+
+        waits 0
+
+        runs ->
+          expect(progress.set.callCount).toEqual 2
+          expect(progress.set.args[0]).toEqual ['foo.js', 100]
+          expect(progress.set.args[1]).toEqual ['bar.js', 100]
+
+  it "loads through inlining", ->
+    window.TEST = 0
+
+    set = Loada.set()
+    server = sinon.fakeServer.create()
+    callback = sinon.spy()
+
+    set._loadInline {url: 'spec/support/test.js', key: 'test.js', type: 'js'}, null, callback
+
+    waits 100
+
+    runs ->
+      expect(callback.callCount).toEqual 1
+      expect(window.TEST).toEqual 1
+      delete window.TEST
+
+  it "injects", ->
+    window.TEST = 0
+
+    set = Loada.set()
+    set._inject source: 'window.TEST = 1', type: 'js'
+
+    expect(window.TEST).toEqual 1
+    delete window.TEST
+
+  it "caches", ->
+    set = Loada.set()
+    server = sinon.fakeServer.create()
+    sinon.stub set, '_inject'
+    set.require url: 'foo.js'
+    set.require url: 'bar.js'
+
+    set.load()
+
+    waits 0
+
+    runs ->
+      expect(server.requests.length).toEqual 2
+      server.requests[0].respond 200, {}, 'foobar'
+      server.requests[1].respond 200, {}, 'foobar'
+
+    waits 0
+
+    runs ->
+      set.load()
+
+    runs ->
+      expect(server.requests.length).toEqual 2
+
+    runs ->
+      server.restore()
+      set._inject.restore()
+
+  it "loads", ->
+    window.TEST = 0
+
+    progress = sinon.spy()
+    success = sinon.spy()
+
+    set = Loada.set()
+    set.require url: 'spec/support/test.js'
+    set.load
+      progress: progress
+      success: success
+
+    waits 100
+
+    runs ->
+      expect(progress.callCount).toEqual 1
+      expect(progress.args[0][0]).toEqual 100
+      expect(success.callCount).toEqual 1
+      expect(window.TEST).toEqual 1
+
+      delete window.TEST
+
+  it "loads text", ->
+    set = Loada.set()
+    server = sinon.fakeServer.create()
+    set.require url: 'foo', type: 'text'
+
+    set.load()
+
+    waits 0
+
+    runs ->
+      expect(server.requests.length).toEqual 1
+      server.requests[0].respond 200, {}, 'foobar'
+
+      expect(set.get 'foo').toEqual 'foobar'

data/spec/support/test.js

@@ -0,0 +1 @@
+window.TEST = 1

data/src/loada.coffee

@@ -0,0 +1,294 @@
+$head = document.getElementsByTagName("head")[0]
+
+#
+# Loada is the kickass in-browser assets (JS/CSS) loader supporting localStorage
+# and progress tracking.
+#
+# @see https://github.com/inossidabile/loada/
+#
+class @Loada
+  Progress: class
+    constructor: (@count, @progressCallback) ->
+      @data = {}
+
+    set: (key, percent) ->
+      @data[key] = Math.min(percent, 100.0)
+      @progressCallback? @total()
+
+    total: ->
+      total = 0
+      total += Math.round(percent/@count*100)/100 for key, percent of @data
+      total
+
+  #
+  # Alias for the #{constructor}
+  #
+  @set: ->
+    new @ arguments...
+
+  #
+  # @param [String]   Name of the libraries set
+  # @param [Object]
+  #
+  constructor: (@set, options) ->
+    @options =
+      prefix: 'loada'
+      localStorage: true
+
+    @requires =
+      input: []
+      set: {}
+      length: 0
+
+    @set ||= '*'
+    @options[k] = v for k,v of options if options
+    @key = "#{@options.prefix}.#{@set}"
+
+    @setup()
+
+  #
+  # Loads current available cache for the current set into the instance
+  #
+  setup: ->
+    if @options.localStorage
+      @storage = localStorage[@key] || {}
+
+      if typeof(@storage) == 'string'
+        @storage = JSON.parse(localStorage[@key])
+
+  #
+  # Saves current set state to localStorage
+  #
+  save: ->
+    localStorage[@key] = JSON.stringify @storage
+
+  #
+  # Removes localStorage entry bound to current set
+  #
+  clear: -> delete localStorage[@key]
+
+  #
+  # Gets raw source of an asset
+  #
+  # @param key [String]       Key of the asset
+  #
+  get: (key) ->
+    @storage[key]?.source
+
+  #
+  # Cleans up current state
+  #
+  # Removes entries that are:
+  #   * expired by date (`expires` option)
+  #   * got new revision (`revision` option)
+  #   * not found in the current requires list
+  #
+  expire: ->
+    now = new Date
+
+    byDate = (library) =>
+      library.expirationDate && new Date(library.expirationDate) <= now
+
+    byExistance = (library) =>
+      !@requires.set[key]
+
+    byRevision = (library) =>
+      @requires.set[key].revision != library.revision
+
+    for key, library of @storage
+
+      if byDate(library) || byExistance(library) || byRevision(library)
+        delete @storage[key]
+
+  #
+  # Adds library that should be loaded
+  #
+  # All the libraries passed within one call will be loaded
+  # successive. Separate {#require} calls are loading in parallel.
+  #
+  # Library object consists of the following options:
+  #   * **url**: location of the asset to load
+  #   * **key**: storage key (default to url)
+  #   * **type**: js/css (defaults to url extension parsing)
+  #   * **revision**: manual revision number – triggers cache bust whenever it changes
+  #   * **expires**: amount of hours to keep entry for (defaults to unlimited cache)
+  #   * **cache**: whether localStorage should be used for particular asset
+  #   * **size**: asset download size (defaults to additional HEAD request result)
+  #
+  # @param libraries [Object]     Library object
+  #
+  require: (libraries...) ->
+    for library in libraries
+      library.key  ||= library.url
+      library.type ||= library.url?.split('.').pop()
+      library.localStorage = true unless library.localStorage?
+      library.require = true unless library.require?
+
+      if library.expires
+        now = new Date
+        library.expirationDate = now.setTime(now.getTime() + library.expires*60*60*1000)
+
+      if library.type == 'js' || library.type == 'css' || library.type == 'text'
+        @requires.set[library.key] = library
+      else
+        console.error "Unknown asset type for #{library.url} – skipped"
+
+    @requires.length += libraries.length
+    @requires.input.push libraries
+
+  #
+  # Starts the inclusion of required libraries
+  #
+  # Accepts following options:
+  #   * **success**: gets called as soon as all the assets are loaded
+  #   * **progress(percent)**: ticks from time to time passing you curent download progress
+  #
+  # @param [Object] callbacks       List of callbacks
+  #
+  load: (callbacks) ->
+    callbacks ||= {}
+    @expire() if @options.localStorage
+
+    progress = new @Progress(@requires.length, callbacks.progress)
+    loaders  = 0
+
+    @_ensureSizes callbacks.progress?, =>
+      for group in @requires.input
+        loaders++
+
+        @_loadGroup group.slice(0), progress, =>
+          loaders--
+          if loaders == 0
+            @save()
+            callbacks.success?()
+
+  #
+  # Ensures every asset has 'size' option
+  #
+  # Runs HEAD request trying to parse Content-Length header for
+  # those that don't have.
+  #
+  # @private
+  #
+  _ensureSizes: (perform, callback) ->
+    unless perform
+      library.size = 0 for key, library of @requires.set
+      return callback()
+
+    requests = 0
+
+    for key, library of @requires.set
+      do (library) =>
+        unless library.size?
+          requests++
+
+          @_ajax 'HEAD', library.url, (xhr) ->
+            requests--
+            size = xhr.getResponseHeader('Content-Length')
+            size = parseInt(size) if size
+            library.size = size || 0
+            callback() if requests == 0
+
+  #
+  # Loads one require group successively
+  #
+  # @private
+  #
+  _loadGroup: (group, progress, callback) =>
+    library = group.shift()
+
+    return callback() unless library
+
+    if @options.localStorage && @storage[library.key] && library.localStorage
+      progress?.set library.key, 100
+      @_inject @storage[library.key] if @storage[library.key].require
+      @_loadGroup group, progress, callback
+    else
+      method = if @options.localStorage
+        "_loadAJAX"
+      else
+        "_loadInline"
+
+      @[method] library, progress, =>
+        @storage[library.key] = library if @options.localStorage
+        @_inject library if library.require
+        @_loadGroup group, progress, callback
+
+  #
+  # Loads one asset by AJAX query and stores it into instance
+  #
+  # @private
+  #
+  _loadAJAX: (library, progress, callback) ->
+    xhr = @_ajax 'GET', library.url, (xhr) =>
+      library.source = xhr.responseText
+      clearInterval poller
+      progress?.set library.key, 100
+      callback()
+
+    if library.size > 0
+      poller = setInterval (->
+        percent = Math.round(xhr.responseText.length / library.size * 100 * 100) / 100
+        progress?.set library.key, percent
+      ),
+      100
+
+  #
+  # Loads one asset by inlining it into DOM
+  #
+  # @private
+  #
+  _loadInline: (library, progress, callback) ->
+    if library.type != 'js'
+      console.error "Attempt to load something other than JS without localStorage."
+      console.error "#{library.url} is not loaded!"
+      progress?.set library.key, 100
+      return callback()
+
+    script = document.createElement "script"
+    done   = false
+
+    proceed = ->
+      if !done && (!@readyState? || @readyState == "loaded" || @readyState == "complete")
+        done = true
+        progress?.set library.key, 100
+        callback?()
+        script.onload = script.onreadystatechange = null
+
+    script.onload = script.onreadystatechange = proceed
+
+    script.src = library.url
+    $head.appendChild script
+
+  #
+  # Activates downloaded asset
+  #
+  # @private
+  #
+  _inject: (library) ->
+    if library.type == 'js'
+      script = document.createElement "script"
+      script.defer = true
+      script.text = library.source
+      $head.appendChild script
+    else if library.type == 'css'
+      style = document.createElement "style"
+      style.innerHTML = library.source
+      $head.appendChild style
+
+  #
+  # Starring custom XHR wrapper!
+  #
+  # @private
+  #
+  _ajax: (method, url, callback) ->
+    if window.XMLHttpRequest
+      xhr = new XMLHttpRequest
+    else
+      xhr = new ActiveXObject 'Microsoft.XMLHTTP'
+
+    xhr.open method, url, 1
+    xhr.onreadystatechange = -> callback?(xhr) if xhr.readyState > 3
+    xhr.send()
+
+    xhr