diff --git a/assets/faces.jpg b/assets/faces.jpg
new file mode 100644
index 0000000..bc64955
Binary files /dev/null and b/assets/faces.jpg differ
diff --git a/build/bundle.js b/build/bundle.js
index 443075d..a6ee2d9 100644
--- a/build/bundle.js
+++ b/build/bundle.js
@@ -4773,6 +4773,2453 @@ return /******/ (function(modules) { // webpackBootstrap
 });
 ;
 },{}],23:[function(require,module,exports){
+/**
+ * tracking - A modern approach for Computer Vision on the web.
+ * @author Eduardo Lundgren <edu@rdo.io>
+ * @version v1.1.2
+ * @link http://trackingjs.com
+ * @license BSD
+ */
+(function(window, undefined) {
+  window.tracking = window.tracking || {};
+
+  /**
+   * Inherit the prototype methods from one constructor into another.
+   *
+   * Usage:
+   * <pre>
+   * function ParentClass(a, b) { }
+   * ParentClass.prototype.foo = function(a) { }
+   *
+   * function ChildClass(a, b, c) {
+   *   tracking.base(this, a, b);
+   * }
+   * tracking.inherits(ChildClass, ParentClass);
+   *
+   * var child = new ChildClass('a', 'b', 'c');
+   * child.foo();
+   * </pre>
+   *
+   * @param {Function} childCtor Child class.
+   * @param {Function} parentCtor Parent class.
+   */
+  tracking.inherits = function(childCtor, parentCtor) {
+    function TempCtor() {
+    }
+    TempCtor.prototype = parentCtor.prototype;
+    childCtor.superClass_ = parentCtor.prototype;
+    childCtor.prototype = new TempCtor();
+    childCtor.prototype.constructor = childCtor;
+
+    /**
+     * Calls superclass constructor/method.
+     *
+     * This function is only available if you use tracking.inherits to express
+     * inheritance relationships between classes.
+     *
+     * @param {!object} me Should always be "this".
+     * @param {string} methodName The method name to call. Calling superclass
+     *     constructor can be done with the special string 'constructor'.
+     * @param {...*} var_args The arguments to pass to superclass
+     *     method/constructor.
+     * @return {*} The return value of the superclass method/constructor.
+     */
+    childCtor.base = function(me, methodName) {
+      var args = Array.prototype.slice.call(arguments, 2);
+      return parentCtor.prototype[methodName].apply(me, args);
+    };
+  };
+
+  /**
+   * Captures the user camera when tracking a video element and set its source
+   * to the camera stream.
+   * @param {HTMLVideoElement} element Canvas element to track.
+   * @param {object} opt_options Optional configuration to the tracker.
+   */
+  tracking.initUserMedia_ = function(element, opt_options) {
+    window.navigator.getUserMedia({
+      video: true,
+      audio: !!(opt_options && opt_options.audio)
+    }, function(stream) {
+        try {
+          element.src = window.URL.createObjectURL(stream);
+        } catch (err) {
+          element.src = stream;
+        }
+      }, function() {
+        throw Error('Cannot capture user camera.');
+      }
+    );
+  };
+
+  /**
+   * Tests whether the object is a dom node.
+   * @param {object} o Object to be tested.
+   * @return {boolean} True if the object is a dom node.
+   */
+  tracking.isNode = function(o) {
+    return o.nodeType || this.isWindow(o);
+  };
+
+  /**
+   * Tests whether the object is the `window` object.
+   * @param {object} o Object to be tested.
+   * @return {boolean} True if the object is the `window` object.
+   */
+  tracking.isWindow = function(o) {
+    return !!(o && o.alert && o.document);
+  };
+
+  /**
+   * Selects a dom node from a CSS3 selector using `document.querySelector`.
+   * @param {string} selector
+   * @param {object} opt_element The root element for the query. When not
+   *     specified `document` is used as root element.
+   * @return {HTMLElement} The first dom element that matches to the selector.
+   *     If not found, returns `null`.
+   */
+  tracking.one = function(selector, opt_element) {
+    if (this.isNode(selector)) {
+      return selector;
+    }
+    return (opt_element || document).querySelector(selector);
+  };
+
+  /**
+   * Tracks a canvas, image or video element based on the specified `tracker`
+   * instance. This method extract the pixel information of the input element
+   * to pass to the `tracker` instance. When tracking a video, the
+   * `tracker.track(pixels, width, height)` will be in a
+   * `requestAnimationFrame` loop in order to track all video frames.
+   *
+   * Example:
+   * var tracker = new tracking.ColorTracker();
+   *
+   * tracking.track('#video', tracker);
+   * or
+   * tracking.track('#video', tracker, { camera: true });
+   *
+   * tracker.on('track', function(event) {
+   *   // console.log(event.data[0].x, event.data[0].y)
+   * });
+   *
+   * @param {HTMLElement} element The element to track, canvas, image or
+   *     video.
+   * @param {tracking.Tracker} tracker The tracker instance used to track the
+   *     element.
+   * @param {object} opt_options Optional configuration to the tracker.
+   */
+  tracking.track = function(element, tracker, opt_options) {
+    element = tracking.one(element);
+    if (!element) {
+      throw new Error('Element not found, try a different element or selector.');
+    }
+    if (!tracker) {
+      throw new Error('Tracker not specified, try `tracking.track(element, new tracking.FaceTracker())`.');
+    }
+
+    switch (element.nodeName.toLowerCase()) {
+      case 'canvas':
+        return this.trackCanvas_(element, tracker, opt_options);
+      case 'img':
+        return this.trackImg_(element, tracker, opt_options);
+      case 'video':
+        if (opt_options) {
+          if (opt_options.camera) {
+            this.initUserMedia_(element, opt_options);
+          }
+        }
+        return this.trackVideo_(element, tracker, opt_options);
+      default:
+        throw new Error('Element not supported, try in a canvas, img, or video.');
+    }
+  };
+
+  /**
+   * Tracks a canvas element based on the specified `tracker` instance and
+   * returns a `TrackerTask` for this track.
+   * @param {HTMLCanvasElement} element Canvas element to track.
+   * @param {tracking.Tracker} tracker The tracker instance used to track the
+   *     element.
+   * @param {object} opt_options Optional configuration to the tracker.
+   * @return {tracking.TrackerTask}
+   * @private
+   */
+  tracking.trackCanvas_ = function(element, tracker) {
+    var self = this;
+    var task = new tracking.TrackerTask(tracker);
+    task.on('run', function() {
+      self.trackCanvasInternal_(element, tracker);
+    });
+    return task.run();
+  };
+
+  /**
+   * Tracks a canvas element based on the specified `tracker` instance. This
+   * method extract the pixel information of the input element to pass to the
+   * `tracker` instance.
+   * @param {HTMLCanvasElement} element Canvas element to track.
+   * @param {tracking.Tracker} tracker The tracker instance used to track the
+   *     element.
+   * @param {object} opt_options Optional configuration to the tracker.
+   * @private
+   */
+  tracking.trackCanvasInternal_ = function(element, tracker) {
+    var width = element.width;
+    var height = element.height;
+    var context = element.getContext('2d');
+    var imageData = context.getImageData(0, 0, width, height);
+    tracker.track(imageData.data, width, height);
+  };
+
+  /**
+   * Tracks a image element based on the specified `tracker` instance. This
+   * method extract the pixel information of the input element to pass to the
+   * `tracker` instance.
+   * @param {HTMLImageElement} element Canvas element to track.
+   * @param {tracking.Tracker} tracker The tracker instance used to track the
+   *     element.
+   * @param {object} opt_options Optional configuration to the tracker.
+   * @private
+   */
+  tracking.trackImg_ = function(element, tracker) {
+    var width = element.width;
+    var height = element.height;
+    var canvas = document.createElement('canvas');
+
+    canvas.width = width;
+    canvas.height = height;
+
+    var task = new tracking.TrackerTask(tracker);
+    task.on('run', function() {
+      tracking.Canvas.loadImage(canvas, element.src, 0, 0, width, height, function() {
+        tracking.trackCanvasInternal_(canvas, tracker);
+      });
+    });
+    return task.run();
+  };
+
+  /**
+   * Tracks a video element based on the specified `tracker` instance. This
+   * method extract the pixel information of the input element to pass to the
+   * `tracker` instance. The `tracker.track(pixels, width, height)` will be in
+   * a `requestAnimationFrame` loop in order to track all video frames.
+   * @param {HTMLVideoElement} element Canvas element to track.
+   * @param {tracking.Tracker} tracker The tracker instance used to track the
+   *     element.
+   * @param {object} opt_options Optional configuration to the tracker.
+   * @private
+   */
+  tracking.trackVideo_ = function(element, tracker) {
+    var canvas = document.createElement('canvas');
+    var context = canvas.getContext('2d');
+    var width;
+    var height;
+
+    var resizeCanvas_ = function() {
+      width = element.offsetWidth;
+      height = element.offsetHeight;
+      canvas.width = width;
+      canvas.height = height;
+    };
+    resizeCanvas_();
+    element.addEventListener('resize', resizeCanvas_);
+
+    var requestId;
+    var requestAnimationFrame_ = function() {
+      requestId = window.requestAnimationFrame(function() {
+        if (element.readyState === element.HAVE_ENOUGH_DATA) {
+          try {
+            // Firefox v~30.0 gets confused with the video readyState firing an
+            // erroneous HAVE_ENOUGH_DATA just before HAVE_CURRENT_DATA state,
+            // hence keep trying to read it until resolved.
+            context.drawImage(element, 0, 0, width, height);
+          } catch (err) {}
+          tracking.trackCanvasInternal_(canvas, tracker);
+        }
+        requestAnimationFrame_();
+      });
+    };
+
+    var task = new tracking.TrackerTask(tracker);
+    task.on('stop', function() {
+      window.cancelAnimationFrame(requestId);
+    });
+    task.on('run', function() {
+      requestAnimationFrame_();
+    });
+    return task.run();
+  };
+
+  // Browser polyfills
+  //===================
+
+  if (!window.URL) {
+    window.URL = window.URL || window.webkitURL || window.msURL || window.oURL;
+  }
+
+  if (!navigator.getUserMedia) {
+    navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia ||
+    navigator.mozGetUserMedia || navigator.msGetUserMedia;
+  }
+}(window));
+
+(function() {
+  /**
+   * EventEmitter utility.
+   * @constructor
+   */
+  tracking.EventEmitter = function() {};
+
+  /**
+   * Holds event listeners scoped by event type.
+   * @type {object}
+   * @private
+   */
+  tracking.EventEmitter.prototype.events_ = null;
+
+  /**
+   * Adds a listener to the end of the listeners array for the specified event.
+   * @param {string} event
+   * @param {function} listener
+   * @return {object} Returns emitter, so calls can be chained.
+   */
+  tracking.EventEmitter.prototype.addListener = function(event, listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('Listener must be a function');
+    }
+    if (!this.events_) {
+      this.events_ = {};
+    }
+
+    this.emit('newListener', event, listener);
+
+    if (!this.events_[event]) {
+      this.events_[event] = [];
+    }
+
+    this.events_[event].push(listener);
+
+    return this;
+  };
+
+  /**
+   * Returns an array of listeners for the specified event.
+   * @param {string} event
+   * @return {array} Array of listeners.
+   */
+  tracking.EventEmitter.prototype.listeners = function(event) {
+    return this.events_ && this.events_[event];
+  };
+
+  /**
+   * Execute each of the listeners in order with the supplied arguments.
+   * @param {string} event
+   * @param {*} opt_args [arg1], [arg2], [...]
+   * @return {boolean} Returns true if event had listeners, false otherwise.
+   */
+  tracking.EventEmitter.prototype.emit = function(event) {
+    var listeners = this.listeners(event);
+    if (listeners) {
+      var args = Array.prototype.slice.call(arguments, 1);
+      for (var i = 0; i < listeners.length; i++) {
+        if (listeners[i]) {
+          listeners[i].apply(this, args);
+        }
+      }
+      return true;
+    }
+    return false;
+  };
+
+  /**
+   * Adds a listener to the end of the listeners array for the specified event.
+   * @param {string} event
+   * @param {function} listener
+   * @return {object} Returns emitter, so calls can be chained.
+   */
+  tracking.EventEmitter.prototype.on = tracking.EventEmitter.prototype.addListener;
+
+  /**
+   * Adds a one time listener for the event. This listener is invoked only the
+   * next time the event is fired, after which it is removed.
+   * @param {string} event
+   * @param {function} listener
+   * @return {object} Returns emitter, so calls can be chained.
+   */
+  tracking.EventEmitter.prototype.once = function(event, listener) {
+    var self = this;
+    self.on(event, function handlerInternal() {
+      self.removeListener(event, handlerInternal);
+      listener.apply(this, arguments);
+    });
+  };
+
+  /**
+   * Removes all listeners, or those of the specified event. It's not a good
+   * idea to remove listeners that were added elsewhere in the code,
+   * especially when it's on an emitter that you didn't create.
+   * @param {string} event
+   * @return {object} Returns emitter, so calls can be chained.
+   */
+  tracking.EventEmitter.prototype.removeAllListeners = function(opt_event) {
+    if (!this.events_) {
+      return this;
+    }
+    if (opt_event) {
+      delete this.events_[opt_event];
+    } else {
+      delete this.events_;
+    }
+    return this;
+  };
+
+  /**
+   * Remove a listener from the listener array for the specified event.
+   * Caution: changes array indices in the listener array behind the listener.
+   * @param {string} event
+   * @param {function} listener
+   * @return {object} Returns emitter, so calls can be chained.
+   */
+  tracking.EventEmitter.prototype.removeListener = function(event, listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('Listener must be a function');
+    }
+    if (!this.events_) {
+      return this;
+    }
+
+    var listeners = this.listeners(event);
+    if (Array.isArray(listeners)) {
+      var i = listeners.indexOf(listener);
+      if (i < 0) {
+        return this;
+      }
+      listeners.splice(i, 1);
+    }
+
+    return this;
+  };
+
+  /**
+   * By default EventEmitters will print a warning if more than 10 listeners
+   * are added for a particular event. This is a useful default which helps
+   * finding memory leaks. Obviously not all Emitters should be limited to 10.
+   * This function allows that to be increased. Set to zero for unlimited.
+   * @param {number} n The maximum number of listeners.
+   */
+  tracking.EventEmitter.prototype.setMaxListeners = function() {
+    throw new Error('Not implemented');
+  };
+
+}());
+
+(function() {
+  /**
+   * Canvas utility.
+   * @static
+   * @constructor
+   */
+  tracking.Canvas = {};
+
+  /**
+   * Loads an image source into the canvas.
+   * @param {HTMLCanvasElement} canvas The canvas dom element.
+   * @param {string} src The image source.
+   * @param {number} x The canvas horizontal coordinate to load the image.
+   * @param {number} y The canvas vertical coordinate to load the image.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {function} opt_callback Callback that fires when the image is loaded
+   *     into the canvas.
+   * @static
+   */
+  tracking.Canvas.loadImage = function(canvas, src, x, y, width, height, opt_callback) {
+    var instance = this;
+    var img = new window.Image();
+    img.crossOrigin = '*';
+    img.onload = function() {
+      var context = canvas.getContext('2d');
+      canvas.width = width;
+      canvas.height = height;
+      context.drawImage(img, x, y, width, height);
+      if (opt_callback) {
+        opt_callback.call(instance);
+      }
+      img = null;
+    };
+    img.src = src;
+  };
+}());
+
+(function() {
+  /**
+   * DisjointSet utility with path compression. Some applications involve
+   * grouping n distinct objects into a collection of disjoint sets. Two
+   * important operations are then finding which set a given object belongs to
+   * and uniting the two sets. A disjoint set data structure maintains a
+   * collection S={ S1 , S2 ,..., Sk } of disjoint dynamic sets. Each set is
+   * identified by a representative, which usually is a member in the set.
+   * @static
+   * @constructor
+   */
+  tracking.DisjointSet = function(length) {
+    if (length === undefined) {
+      throw new Error('DisjointSet length not specified.');
+    }
+    this.length = length;
+    this.parent = new Uint32Array(length);
+    for (var i = 0; i < length; i++) {
+      this.parent[i] = i;
+    }
+  };
+
+  /**
+   * Holds the length of the internal set.
+   * @type {number}
+   */
+  tracking.DisjointSet.prototype.length = null;
+
+  /**
+   * Holds the set containing the representative values.
+   * @type {Array.<number>}
+   */
+  tracking.DisjointSet.prototype.parent = null;
+
+  /**
+   * Finds a pointer to the representative of the set containing i.
+   * @param {number} i
+   * @return {number} The representative set of i.
+   */
+  tracking.DisjointSet.prototype.find = function(i) {
+    if (this.parent[i] === i) {
+      return i;
+    } else {
+      return (this.parent[i] = this.find(this.parent[i]));
+    }
+  };
+
+  /**
+   * Unites two dynamic sets containing objects i and j, say Si and Sj, into
+   * a new set that Si ∪ Sj, assuming that Si ∩ Sj = ∅;
+   * @param {number} i
+   * @param {number} j
+   */
+  tracking.DisjointSet.prototype.union = function(i, j) {
+    var iRepresentative = this.find(i);
+    var jRepresentative = this.find(j);
+    this.parent[iRepresentative] = jRepresentative;
+  };
+
+}());
+
+(function() {
+  /**
+   * Image utility.
+   * @static
+   * @constructor
+   */
+  tracking.Image = {};
+
+  /**
+   * Computes gaussian blur. Adapted from
+   * https://github.com/kig/canvasfilters.
+   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {number} diameter Gaussian blur diameter, must be greater than 1.
+   * @return {array} The edge pixels in a linear [r,g,b,a,...] array.
+   */
+  tracking.Image.blur = function(pixels, width, height, diameter) {
+    diameter = Math.abs(diameter);
+    if (diameter <= 1) {
+      throw new Error('Diameter should be greater than 1.');
+    }
+    var radius = diameter / 2;
+    var len = Math.ceil(diameter) + (1 - (Math.ceil(diameter) % 2));
+    var weights = new Float32Array(len);
+    var rho = (radius + 0.5) / 3;
+    var rhoSq = rho * rho;
+    var gaussianFactor = 1 / Math.sqrt(2 * Math.PI * rhoSq);
+    var rhoFactor = -1 / (2 * rho * rho);
+    var wsum = 0;
+    var middle = Math.floor(len / 2);
+    for (var i = 0; i < len; i++) {
+      var x = i - middle;
+      var gx = gaussianFactor * Math.exp(x * x * rhoFactor);
+      weights[i] = gx;
+      wsum += gx;
+    }
+    for (var j = 0; j < weights.length; j++) {
+      weights[j] /= wsum;
+    }
+    return this.separableConvolve(pixels, width, height, weights, weights, false);
+  };
+
+  /**
+   * Computes the integral image for summed, squared, rotated and sobel pixels.
+   * @param {array} pixels The pixels in a linear [r,g,b,a,...] array to loop
+   *     through.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {array} opt_integralImage Empty array of size `width * height` to
+   *     be filled with the integral image values. If not specified compute sum
+   *     values will be skipped.
+   * @param {array} opt_integralImageSquare Empty array of size `width *
+   *     height` to be filled with the integral image squared values. If not
+   *     specified compute squared values will be skipped.
+   * @param {array} opt_tiltedIntegralImage Empty array of size `width *
+   *     height` to be filled with the rotated integral image values. If not
+   *     specified compute sum values will be skipped.
+   * @param {array} opt_integralImageSobel Empty array of size `width *
+   *     height` to be filled with the integral image of sobel values. If not
+   *     specified compute sobel filtering will be skipped.
+   * @static
+   */
+  tracking.Image.computeIntegralImage = function(pixels, width, height, opt_integralImage, opt_integralImageSquare, opt_tiltedIntegralImage, opt_integralImageSobel) {
+    if (arguments.length < 4) {
+      throw new Error('You should specify at least one output array in the order: sum, square, tilted, sobel.');
+    }
+    var pixelsSobel;
+    if (opt_integralImageSobel) {
+      pixelsSobel = tracking.Image.sobel(pixels, width, height);
+    }
+    for (var i = 0; i < height; i++) {
+      for (var j = 0; j < width; j++) {
+        var w = i * width * 4 + j * 4;
+        var pixel = ~~(pixels[w] * 0.299 + pixels[w + 1] * 0.587 + pixels[w + 2] * 0.114);
+        if (opt_integralImage) {
+          this.computePixelValueSAT_(opt_integralImage, width, i, j, pixel);
+        }
+        if (opt_integralImageSquare) {
+          this.computePixelValueSAT_(opt_integralImageSquare, width, i, j, pixel * pixel);
+        }
+        if (opt_tiltedIntegralImage) {
+          var w1 = w - width * 4;
+          var pixelAbove = ~~(pixels[w1] * 0.299 + pixels[w1 + 1] * 0.587 + pixels[w1 + 2] * 0.114);
+          this.computePixelValueRSAT_(opt_tiltedIntegralImage, width, i, j, pixel, pixelAbove || 0);
+        }
+        if (opt_integralImageSobel) {
+          this.computePixelValueSAT_(opt_integralImageSobel, width, i, j, pixelsSobel[w]);
+        }
+      }
+    }
+  };
+
+  /**
+   * Helper method to compute the rotated summed area table (RSAT) by the
+   * formula:
+   *
+   * RSAT(x, y) = RSAT(x-1, y-1) + RSAT(x+1, y-1) - RSAT(x, y-2) + I(x, y) + I(x, y-1)
+   *
+   * @param {number} width The image width.
+   * @param {array} RSAT Empty array of size `width * height` to be filled with
+   *     the integral image values. If not specified compute sum values will be
+   *     skipped.
+   * @param {number} i Vertical position of the pixel to be evaluated.
+   * @param {number} j Horizontal position of the pixel to be evaluated.
+   * @param {number} pixel Pixel value to be added to the integral image.
+   * @static
+   * @private
+   */
+  tracking.Image.computePixelValueRSAT_ = function(RSAT, width, i, j, pixel, pixelAbove) {
+    var w = i * width + j;
+    RSAT[w] = (RSAT[w - width - 1] || 0) + (RSAT[w - width + 1] || 0) - (RSAT[w - width - width] || 0) + pixel + pixelAbove;
+  };
+
+  /**
+   * Helper method to compute the summed area table (SAT) by the formula:
+   *
+   * SAT(x, y) = SAT(x, y-1) + SAT(x-1, y) + I(x, y) - SAT(x-1, y-1)
+   *
+   * @param {number} width The image width.
+   * @param {array} SAT Empty array of size `width * height` to be filled with
+   *     the integral image values. If not specified compute sum values will be
+   *     skipped.
+   * @param {number} i Vertical position of the pixel to be evaluated.
+   * @param {number} j Horizontal position of the pixel to be evaluated.
+   * @param {number} pixel Pixel value to be added to the integral image.
+   * @static
+   * @private
+   */
+  tracking.Image.computePixelValueSAT_ = function(SAT, width, i, j, pixel) {
+    var w = i * width + j;
+    SAT[w] = (SAT[w - width] || 0) + (SAT[w - 1] || 0) + pixel - (SAT[w - width - 1] || 0);
+  };
+
+  /**
+   * Converts a color from a colorspace based on an RGB color model to a
+   * grayscale representation of its luminance. The coefficients represent the
+   * measured intensity perception of typical trichromat humans, in
+   * particular, human vision is most sensitive to green and least sensitive
+   * to blue.
+   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {boolean} fillRGBA If the result should fill all RGBA values with the gray scale
+   *  values, instead of returning a single value per pixel.
+   * @param {Uint8ClampedArray} The grayscale pixels in a linear array ([p,p,p,a,...] if fillRGBA
+   *  is true and [p1, p2, p3, ...] if fillRGBA is false).
+   * @static
+   */
+  tracking.Image.grayscale = function(pixels, width, height, fillRGBA) {
+    var gray = new Uint8ClampedArray(fillRGBA ? pixels.length : pixels.length >> 2);
+    var p = 0;
+    var w = 0;
+    for (var i = 0; i < height; i++) {
+      for (var j = 0; j < width; j++) {
+        var value = pixels[w] * 0.299 + pixels[w + 1] * 0.587 + pixels[w + 2] * 0.114;
+        gray[p++] = value;
+
+        if (fillRGBA) {
+          gray[p++] = value;
+          gray[p++] = value;
+          gray[p++] = pixels[w + 3];
+        }
+
+        w += 4;
+      }
+    }
+    return gray;
+  };
+
+  /**
+   * Fast horizontal separable convolution. A point spread function (PSF) is
+   * said to be separable if it can be broken into two one-dimensional
+   * signals: a vertical and a horizontal projection. The convolution is
+   * performed by sliding the kernel over the image, generally starting at the
+   * top left corner, so as to move the kernel through all the positions where
+   * the kernel fits entirely within the boundaries of the image. Adapted from
+   * https://github.com/kig/canvasfilters.
+   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {array} weightsVector The weighting vector, e.g [-1,0,1].
+   * @param {number} opaque
+   * @return {array} The convoluted pixels in a linear [r,g,b,a,...] array.
+   */
+  tracking.Image.horizontalConvolve = function(pixels, width, height, weightsVector, opaque) {
+    var side = weightsVector.length;
+    var halfSide = Math.floor(side / 2);
+    var output = new Float32Array(width * height * 4);
+    var alphaFac = opaque ? 1 : 0;
+
+    for (var y = 0; y < height; y++) {
+      for (var x = 0; x < width; x++) {
+        var sy = y;
+        var sx = x;
+        var offset = (y * width + x) * 4;
+        var r = 0;
+        var g = 0;
+        var b = 0;
+        var a = 0;
+        for (var cx = 0; cx < side; cx++) {
+          var scy = sy;
+          var scx = Math.min(width - 1, Math.max(0, sx + cx - halfSide));
+          var poffset = (scy * width + scx) * 4;
+          var wt = weightsVector[cx];
+          r += pixels[poffset] * wt;
+          g += pixels[poffset + 1] * wt;
+          b += pixels[poffset + 2] * wt;
+          a += pixels[poffset + 3] * wt;
+        }
+        output[offset] = r;
+        output[offset + 1] = g;
+        output[offset + 2] = b;
+        output[offset + 3] = a + alphaFac * (255 - a);
+      }
+    }
+    return output;
+  };
+
+  /**
+   * Fast vertical separable convolution. A point spread function (PSF) is
+   * said to be separable if it can be broken into two one-dimensional
+   * signals: a vertical and a horizontal projection. The convolution is
+   * performed by sliding the kernel over the image, generally starting at the
+   * top left corner, so as to move the kernel through all the positions where
+   * the kernel fits entirely within the boundaries of the image. Adapted from
+   * https://github.com/kig/canvasfilters.
+   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {array} weightsVector The weighting vector, e.g [-1,0,1].
+   * @param {number} opaque
+   * @return {array} The convoluted pixels in a linear [r,g,b,a,...] array.
+   */
+  tracking.Image.verticalConvolve = function(pixels, width, height, weightsVector, opaque) {
+    var side = weightsVector.length;
+    var halfSide = Math.floor(side / 2);
+    var output = new Float32Array(width * height * 4);
+    var alphaFac = opaque ? 1 : 0;
+
+    for (var y = 0; y < height; y++) {
+      for (var x = 0; x < width; x++) {
+        var sy = y;
+        var sx = x;
+        var offset = (y * width + x) * 4;
+        var r = 0;
+        var g = 0;
+        var b = 0;
+        var a = 0;
+        for (var cy = 0; cy < side; cy++) {
+          var scy = Math.min(height - 1, Math.max(0, sy + cy - halfSide));
+          var scx = sx;
+          var poffset = (scy * width + scx) * 4;
+          var wt = weightsVector[cy];
+          r += pixels[poffset] * wt;
+          g += pixels[poffset + 1] * wt;
+          b += pixels[poffset + 2] * wt;
+          a += pixels[poffset + 3] * wt;
+        }
+        output[offset] = r;
+        output[offset + 1] = g;
+        output[offset + 2] = b;
+        output[offset + 3] = a + alphaFac * (255 - a);
+      }
+    }
+    return output;
+  };
+
+  /**
+   * Fast separable convolution. A point spread function (PSF) is said to be
+   * separable if it can be broken into two one-dimensional signals: a
+   * vertical and a horizontal projection. The convolution is performed by
+   * sliding the kernel over the image, generally starting at the top left
+   * corner, so as to move the kernel through all the positions where the
+   * kernel fits entirely within the boundaries of the image. Adapted from
+   * https://github.com/kig/canvasfilters.
+   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {array} horizWeights The horizontal weighting vector, e.g [-1,0,1].
+   * @param {array} vertWeights The vertical vector, e.g [-1,0,1].
+   * @param {number} opaque
+   * @return {array} The convoluted pixels in a linear [r,g,b,a,...] array.
+   */
+  tracking.Image.separableConvolve = function(pixels, width, height, horizWeights, vertWeights, opaque) {
+    var vertical = this.verticalConvolve(pixels, width, height, vertWeights, opaque);
+    return this.horizontalConvolve(vertical, width, height, horizWeights, opaque);
+  };
+
+  /**
+   * Compute image edges using Sobel operator. Computes the vertical and
+   * horizontal gradients of the image and combines the computed images to
+   * find edges in the image. The way we implement the Sobel filter here is by
+   * first grayscaling the image, then taking the horizontal and vertical
+   * gradients and finally combining the gradient images to make up the final
+   * image. Adapted from https://github.com/kig/canvasfilters.
+   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @return {array} The edge pixels in a linear [r,g,b,a,...] array.
+   */
+  tracking.Image.sobel = function(pixels, width, height) {
+    pixels = this.grayscale(pixels, width, height, true);
+    var output = new Float32Array(width * height * 4);
+    var sobelSignVector = new Float32Array([-1, 0, 1]);
+    var sobelScaleVector = new Float32Array([1, 2, 1]);
+    var vertical = this.separableConvolve(pixels, width, height, sobelSignVector, sobelScaleVector);
+    var horizontal = this.separableConvolve(pixels, width, height, sobelScaleVector, sobelSignVector);
+
+    for (var i = 0; i < output.length; i += 4) {
+      var v = vertical[i];
+      var h = horizontal[i];
+      var p = Math.sqrt(h * h + v * v);
+      output[i] = p;
+      output[i + 1] = p;
+      output[i + 2] = p;
+      output[i + 3] = 255;
+    }
+
+    return output;
+  };
+
+}());
+
+(function() {
+  /**
+   * ViolaJones utility.
+   * @static
+   * @constructor
+   */
+  tracking.ViolaJones = {};
+
+  /**
+   * Holds the minimum area of intersection that defines when a rectangle is
+   * from the same group. Often when a face is matched multiple rectangles are
+   * classified as possible rectangles to represent the face, when they
+   * intersects they are grouped as one face.
+   * @type {number}
+   * @default 0.5
+   * @static
+   */
+  tracking.ViolaJones.REGIONS_OVERLAP = 0.5;
+
+  /**
+   * Holds the HAAR cascade classifiers converted from OpenCV training.
+   * @type {array}
+   * @static
+   */
+  tracking.ViolaJones.classifiers = {};
+
+  /**
+   * Detects through the HAAR cascade data rectangles matches.
+   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {number} initialScale The initial scale to start the block
+   *     scaling.
+   * @param {number} scaleFactor The scale factor to scale the feature block.
+   * @param {number} stepSize The block step size.
+   * @param {number} edgesDensity Percentage density edges inside the
+   *     classifier block. Value from [0.0, 1.0], defaults to 0.2. If specified
+   *     edge detection will be applied to the image to prune dead areas of the
+   *     image, this can improve significantly performance.
+   * @param {number} data The HAAR cascade data.
+   * @return {array} Found rectangles.
+   * @static
+   */
+  tracking.ViolaJones.detect = function(pixels, width, height, initialScale, scaleFactor, stepSize, edgesDensity, data) {
+    var total = 0;
+    var rects = [];
+    var integralImage = new Int32Array(width * height);
+    var integralImageSquare = new Int32Array(width * height);
+    var tiltedIntegralImage = new Int32Array(width * height);
+
+    var integralImageSobel;
+    if (edgesDensity > 0) {
+      integralImageSobel = new Int32Array(width * height);
+    }
+
+    tracking.Image.computeIntegralImage(pixels, width, height, integralImage, integralImageSquare, tiltedIntegralImage, integralImageSobel);
+
+    var minWidth = data[0];
+    var minHeight = data[1];
+    var scale = initialScale * scaleFactor;
+    var blockWidth = (scale * minWidth) | 0;
+    var blockHeight = (scale * minHeight) | 0;
+
+    while (blockWidth < width && blockHeight < height) {
+      var step = (scale * stepSize + 0.5) | 0;
+      for (var i = 0; i < (height - blockHeight); i += step) {
+        for (var j = 0; j < (width - blockWidth); j += step) {
+
+          if (edgesDensity > 0) {
+            if (this.isTriviallyExcluded(edgesDensity, integralImageSobel, i, j, width, blockWidth, blockHeight)) {
+              continue;
+            }
+          }
+
+          if (this.evalStages_(data, integralImage, integralImageSquare, tiltedIntegralImage, i, j, width, blockWidth, blockHeight, scale)) {
+            rects[total++] = {
+              width: blockWidth,
+              height: blockHeight,
+              x: j,
+              y: i
+            };
+          }
+        }
+      }
+
+      scale *= scaleFactor;
+      blockWidth = (scale * minWidth) | 0;
+      blockHeight = (scale * minHeight) | 0;
+    }
+    return this.mergeRectangles_(rects);
+  };
+
+  /**
+   * Fast check to test whether the edges density inside the block is greater
+   * than a threshold, if true it tests the stages. This can improve
+   * significantly performance.
+   * @param {number} edgesDensity Percentage density edges inside the
+   *     classifier block.
+   * @param {array} integralImageSobel The integral image of a sobel image.
+   * @param {number} i Vertical position of the pixel to be evaluated.
+   * @param {number} j Horizontal position of the pixel to be evaluated.
+   * @param {number} width The image width.
+   * @return {boolean} True whether the block at position i,j can be skipped,
+   *     false otherwise.
+   * @static
+   * @protected
+   */
+  tracking.ViolaJones.isTriviallyExcluded = function(edgesDensity, integralImageSobel, i, j, width, blockWidth, blockHeight) {
+    var wbA = i * width + j;
+    var wbB = wbA + blockWidth;
+    var wbD = wbA + blockHeight * width;
+    var wbC = wbD + blockWidth;
+    var blockEdgesDensity = (integralImageSobel[wbA] - integralImageSobel[wbB] - integralImageSobel[wbD] + integralImageSobel[wbC]) / (blockWidth * blockHeight * 255);
+    if (blockEdgesDensity < edgesDensity) {
+      return true;
+    }
+    return false;
+  };
+
+  /**
+   * Evaluates if the block size on i,j position is a valid HAAR cascade
+   * stage.
+   * @param {number} data The HAAR cascade data.
+   * @param {number} i Vertical position of the pixel to be evaluated.
+   * @param {number} j Horizontal position of the pixel to be evaluated.
+   * @param {number} width The image width.
+   * @param {number} blockSize The block size.
+   * @param {number} scale The scale factor of the block size and its original
+   *     size.
+   * @param {number} inverseArea The inverse area of the block size.
+   * @return {boolean} Whether the region passes all the stage tests.
+   * @private
+   * @static
+   */
+  tracking.ViolaJones.evalStages_ = function(data, integralImage, integralImageSquare, tiltedIntegralImage, i, j, width, blockWidth, blockHeight, scale) {
+    var inverseArea = 1.0 / (blockWidth * blockHeight);
+    var wbA = i * width + j;
+    var wbB = wbA + blockWidth;
+    var wbD = wbA + blockHeight * width;
+    var wbC = wbD + blockWidth;
+    var mean = (integralImage[wbA] - integralImage[wbB] - integralImage[wbD] + integralImage[wbC]) * inverseArea;
+    var variance = (integralImageSquare[wbA] - integralImageSquare[wbB] - integralImageSquare[wbD] + integralImageSquare[wbC]) * inverseArea - mean * mean;
+
+    var standardDeviation = 1;
+    if (variance > 0) {
+      standardDeviation = Math.sqrt(variance);
+    }
+
+    var length = data.length;
+
+    for (var w = 2; w < length; ) {
+      var stageSum = 0;
+      var stageThreshold = data[w++];
+      var nodeLength = data[w++];
+
+      while (nodeLength--) {
+        var rectsSum = 0;
+        var tilted = data[w++];
+        var rectsLength = data[w++];
+
+        for (var r = 0; r < rectsLength; r++) {
+          var rectLeft = (j + data[w++] * scale + 0.5) | 0;
+          var rectTop = (i + data[w++] * scale + 0.5) | 0;
+          var rectWidth = (data[w++] * scale + 0.5) | 0;
+          var rectHeight = (data[w++] * scale + 0.5) | 0;
+          var rectWeight = data[w++];
+
+          var w1;
+          var w2;
+          var w3;
+          var w4;
+          if (tilted) {
+            // RectSum(r) = RSAT(x-h+w, y+w+h-1) + RSAT(x, y-1) - RSAT(x-h, y+h-1) - RSAT(x+w, y+w-1)
+            w1 = (rectLeft - rectHeight + rectWidth) + (rectTop + rectWidth + rectHeight - 1) * width;
+            w2 = rectLeft + (rectTop - 1) * width;
+            w3 = (rectLeft - rectHeight) + (rectTop + rectHeight - 1) * width;
+            w4 = (rectLeft + rectWidth) + (rectTop + rectWidth - 1) * width;
+            rectsSum += (tiltedIntegralImage[w1] + tiltedIntegralImage[w2] - tiltedIntegralImage[w3] - tiltedIntegralImage[w4]) * rectWeight;
+          } else {
+            // RectSum(r) = SAT(x-1, y-1) + SAT(x+w-1, y+h-1) - SAT(x-1, y+h-1) - SAT(x+w-1, y-1)
+            w1 = rectTop * width + rectLeft;
+            w2 = w1 + rectWidth;
+            w3 = w1 + rectHeight * width;
+            w4 = w3 + rectWidth;
+            rectsSum += (integralImage[w1] - integralImage[w2] - integralImage[w3] + integralImage[w4]) * rectWeight;
+            // TODO: Review the code below to analyze performance when using it instead.
+            // w1 = (rectLeft - 1) + (rectTop - 1) * width;
+            // w2 = (rectLeft + rectWidth - 1) + (rectTop + rectHeight - 1) * width;
+            // w3 = (rectLeft - 1) + (rectTop + rectHeight - 1) * width;
+            // w4 = (rectLeft + rectWidth - 1) + (rectTop - 1) * width;
+            // rectsSum += (integralImage[w1] + integralImage[w2] - integralImage[w3] - integralImage[w4]) * rectWeight;
+          }
+        }
+
+        var nodeThreshold = data[w++];
+        var nodeLeft = data[w++];
+        var nodeRight = data[w++];
+
+        if (rectsSum * inverseArea < nodeThreshold * standardDeviation) {
+          stageSum += nodeLeft;
+        } else {
+          stageSum += nodeRight;
+        }
+      }
+
+      if (stageSum < stageThreshold) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  /**
+   * Postprocess the detected sub-windows in order to combine overlapping
+   * detections into a single detection.
+   * @param {array} rects
+   * @return {array}
+   * @private
+   * @static
+   */
+  tracking.ViolaJones.mergeRectangles_ = function(rects) {
+    var disjointSet = new tracking.DisjointSet(rects.length);
+
+    for (var i = 0; i < rects.length; i++) {
+      var r1 = rects[i];
+      for (var j = 0; j < rects.length; j++) {
+        var r2 = rects[j];
+        if (tracking.Math.intersectRect(r1.x, r1.y, r1.x + r1.width, r1.y + r1.height, r2.x, r2.y, r2.x + r2.width, r2.y + r2.height)) {
+          var x1 = Math.max(r1.x, r2.x);
+          var y1 = Math.max(r1.y, r2.y);
+          var x2 = Math.min(r1.x + r1.width, r2.x + r2.width);
+          var y2 = Math.min(r1.y + r1.height, r2.y + r2.height);
+          var overlap = (x1 - x2) * (y1 - y2);
+          var area1 = (r1.width * r1.height);
+          var area2 = (r2.width * r2.height);
+
+          if ((overlap / (area1 * (area1 / area2)) >= this.REGIONS_OVERLAP) &&
+            (overlap / (area2 * (area1 / area2)) >= this.REGIONS_OVERLAP)) {
+            disjointSet.union(i, j);
+          }
+        }
+      }
+    }
+
+    var map = {};
+    for (var k = 0; k < disjointSet.length; k++) {
+      var rep = disjointSet.find(k);
+      if (!map[rep]) {
+        map[rep] = {
+          total: 1,
+          width: rects[k].width,
+          height: rects[k].height,
+          x: rects[k].x,
+          y: rects[k].y
+        };
+        continue;
+      }
+      map[rep].total++;
+      map[rep].width += rects[k].width;
+      map[rep].height += rects[k].height;
+      map[rep].x += rects[k].x;
+      map[rep].y += rects[k].y;
+    }
+
+    var result = [];
+    Object.keys(map).forEach(function(key) {
+      var rect = map[key];
+      result.push({
+        total: rect.total,
+        width: (rect.width / rect.total + 0.5) | 0,
+        height: (rect.height / rect.total + 0.5) | 0,
+        x: (rect.x / rect.total + 0.5) | 0,
+        y: (rect.y / rect.total + 0.5) | 0
+      });
+    });
+
+    return result;
+  };
+
+}());
+
+(function() {
+  /**
+   * Brief intends for "Binary Robust Independent Elementary Features".This
+   * method generates a binary string for each keypoint found by an extractor
+   * method.
+   * @static
+   * @constructor
+   */
+  tracking.Brief = {};
+
+  /**
+   * The set of binary tests is defined by the nd (x,y)-location pairs
+   * uniquely chosen during the initialization. Values could vary between N =
+   * 128,256,512. N=128 yield good compromises between speed, storage
+   * efficiency, and recognition rate.
+   * @type {number}
+   */
+  tracking.Brief.N = 512;
+
+  /**
+   * Caches coordinates values of (x,y)-location pairs uniquely chosen during
+   * the initialization.
+   * @type {Object.<number, Int32Array>}
+   * @private
+   * @static
+   */
+  tracking.Brief.randomImageOffsets_ = {};
+
+  /**
+   * Caches delta values of (x,y)-location pairs uniquely chosen during
+   * the initialization.
+   * @type {Int32Array}
+   * @private
+   * @static
+   */
+  tracking.Brief.randomWindowOffsets_ = null;
+
+  /**
+   * Generates a binary string for each found keypoints extracted using an
+   * extractor method.
+   * @param {array} The grayscale pixels in a linear [p1,p2,...] array.
+   * @param {number} width The image width.
+   * @param {array} keypoints
+   * @return {Int32Array} Returns an array where for each four sequence int
+   *     values represent the descriptor binary string (128 bits) necessary
+   *     to describe the corner, e.g. [0,0,0,0, 0,0,0,0, ...].
+   * @static
+   */
+  tracking.Brief.getDescriptors = function(pixels, width, keypoints) {
+    // Optimizing divide by 32 operation using binary shift
+    // (this.N >> 5) === this.N/32.
+    var descriptors = new Int32Array((keypoints.length >> 1) * (this.N >> 5));
+    var descriptorWord = 0;
+    var offsets = this.getRandomOffsets_(width);
+    var position = 0;
+
+    for (var i = 0; i < keypoints.length; i += 2) {
+      var w = width * keypoints[i + 1] + keypoints[i];
+
+      var offsetsPosition = 0;
+      for (var j = 0, n = this.N; j < n; j++) {
+        if (pixels[offsets[offsetsPosition++] + w] < pixels[offsets[offsetsPosition++] + w]) {
+          // The bit in the position `j % 32` of descriptorWord should be set to 1. We do
+          // this by making an OR operation with a binary number that only has the bit
+          // in that position set to 1. That binary number is obtained by shifting 1 left by
+          // `j % 32` (which is the same as `j & 31` left) positions.
+          descriptorWord |= 1 << (j & 31);
+        }
+
+        // If the next j is a multiple of 32, we will need to use a new descriptor word to hold
+        // the next results.
+        if (!((j + 1) & 31)) {
+          descriptors[position++] = descriptorWord;
+          descriptorWord = 0;
+        }
+      }
+    }
+
+    return descriptors;
+  };
+
+  /**
+   * Matches sets of features {mi} and {m′j} extracted from two images taken
+   * from similar, and often successive, viewpoints. A classical procedure
+   * runs as follows. For each point {mi} in the first image, search in a
+   * region of the second image around location {mi} for point {m′j}. The
+   * search is based on the similarity of the local image windows, also known
+   * as kernel windows, centered on the points, which strongly characterizes
+   * the points when the images are sufficiently close. Once each keypoint is
+   * described with its binary string, they need to be compared with the
+   * closest matching point. Distance metric is critical to the performance of
+   * in- trusion detection systems. Thus using binary strings reduces the size
+   * of the descriptor and provides an interesting data structure that is fast
+   * to operate whose similarity can be measured by the Hamming distance.
+   * @param {array} keypoints1
+   * @param {array} descriptors1
+   * @param {array} keypoints2
+   * @param {array} descriptors2
+   * @return {Int32Array} Returns an array where the index is the corner1
+   *     index coordinate, and the value is the corresponding match index of
+   *     corner2, e.g. keypoints1=[x0,y0,x1,y1,...] and
+   *     keypoints2=[x'0,y'0,x'1,y'1,...], if x0 matches x'1 and x1 matches x'0,
+   *     the return array would be [3,0].
+   * @static
+   */
+  tracking.Brief.match = function(keypoints1, descriptors1, keypoints2, descriptors2) {
+    var len1 = keypoints1.length >> 1;
+    var len2 = keypoints2.length >> 1;
+    var matches = new Array(len1);
+
+    for (var i = 0; i < len1; i++) {
+      var min = Infinity;
+      var minj = 0;
+      for (var j = 0; j < len2; j++) {
+        var dist = 0;
+        // Optimizing divide by 32 operation using binary shift
+        // (this.N >> 5) === this.N/32.
+        for (var k = 0, n = this.N >> 5; k < n; k++) {
+          dist += tracking.Math.hammingWeight(descriptors1[i * n + k] ^ descriptors2[j * n + k]);
+        }
+        if (dist < min) {
+          min = dist;
+          minj = j;
+        }
+      }
+      matches[i] = {
+        index1: i,
+        index2: minj,
+        keypoint1: [keypoints1[2 * i], keypoints1[2 * i + 1]],
+        keypoint2: [keypoints2[2 * minj], keypoints2[2 * minj + 1]],
+        confidence: 1 - min / this.N
+      };
+    }
+
+    return matches;
+  };
+
+  /**
+   * Removes matches outliers by testing matches on both directions.
+   * @param {array} keypoints1
+   * @param {array} descriptors1
+   * @param {array} keypoints2
+   * @param {array} descriptors2
+   * @return {Int32Array} Returns an array where the index is the corner1
+   *     index coordinate, and the value is the corresponding match index of
+   *     corner2, e.g. keypoints1=[x0,y0,x1,y1,...] and
+   *     keypoints2=[x'0,y'0,x'1,y'1,...], if x0 matches x'1 and x1 matches x'0,
+   *     the return array would be [3,0].
+   * @static
+   */
+  tracking.Brief.reciprocalMatch = function(keypoints1, descriptors1, keypoints2, descriptors2) {
+    var matches = [];
+    if (keypoints1.length === 0 || keypoints2.length === 0) {
+      return matches;
+    }
+
+    var matches1 = tracking.Brief.match(keypoints1, descriptors1, keypoints2, descriptors2);
+    var matches2 = tracking.Brief.match(keypoints2, descriptors2, keypoints1, descriptors1);
+    for (var i = 0; i < matches1.length; i++) {
+      if (matches2[matches1[i].index2].index2 === i) {
+        matches.push(matches1[i]);
+      }
+    }
+    return matches;
+  };
+
+  /**
+   * Gets the coordinates values of (x,y)-location pairs uniquely chosen
+   * during the initialization.
+   * @return {array} Array with the random offset values.
+   * @private
+   */
+  tracking.Brief.getRandomOffsets_ = function(width) {
+    if (!this.randomWindowOffsets_) {
+      var windowPosition = 0;
+      var windowOffsets = new Int32Array(4 * this.N);
+      for (var i = 0; i < this.N; i++) {
+        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));
+        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));
+        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));
+        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));
+      }
+      this.randomWindowOffsets_ = windowOffsets;
+    }
+
+    if (!this.randomImageOffsets_[width]) {
+      var imagePosition = 0;
+      var imageOffsets = new Int32Array(2 * this.N);
+      for (var j = 0; j < this.N; j++) {
+        imageOffsets[imagePosition++] = this.randomWindowOffsets_[4 * j] * width + this.randomWindowOffsets_[4 * j + 1];
+        imageOffsets[imagePosition++] = this.randomWindowOffsets_[4 * j + 2] * width + this.randomWindowOffsets_[4 * j + 3];
+      }
+      this.randomImageOffsets_[width] = imageOffsets;
+    }
+
+    return this.randomImageOffsets_[width];
+  };
+}());
+
+(function() {
+  /**
+   * FAST intends for "Features from Accelerated Segment Test". This method
+   * performs a point segment test corner detection. The segment test
+   * criterion operates by considering a circle of sixteen pixels around the
+   * corner candidate p. The detector classifies p as a corner if there exists
+   * a set of n contiguous pixelsin the circle which are all brighter than the
+   * intensity of the candidate pixel Ip plus a threshold t, or all darker
+   * than Ip − t.
+   *
+   *       15 00 01
+   *    14          02
+   * 13                03
+   * 12       []       04
+   * 11                05
+   *    10          06
+   *       09 08 07
+   *
+   * For more reference:
+   * http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.60.3991&rep=rep1&type=pdf
+   * @static
+   * @constructor
+   */
+  tracking.Fast = {};
+
+  /**
+   * Holds the threshold to determine whether the tested pixel is brighter or
+   * darker than the corner candidate p.
+   * @type {number}
+   * @default 40
+   * @static
+   */
+  tracking.Fast.THRESHOLD = 40;
+
+  /**
+   * Caches coordinates values of the circle surrounding the pixel candidate p.
+   * @type {Object.<number, Int32Array>}
+   * @private
+   * @static
+   */
+  tracking.Fast.circles_ = {};
+
+  /**
+   * Finds corners coordinates on the graysacaled image.
+   * @param {array} The grayscale pixels in a linear [p1,p2,...] array.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {number} threshold to determine whether the tested pixel is brighter or
+   *     darker than the corner candidate p. Default value is 40.
+   * @return {array} Array containing the coordinates of all found corners,
+   *     e.g. [x0,y0,x1,y1,...], where P(x0,y0) represents a corner coordinate.
+   * @static
+   */
+  tracking.Fast.findCorners = function(pixels, width, height, opt_threshold) {
+    var circleOffsets = this.getCircleOffsets_(width);
+    var circlePixels = new Int32Array(16);
+    var corners = [];
+
+    if (opt_threshold === undefined) {
+      opt_threshold = this.THRESHOLD;
+    }
+
+    // When looping through the image pixels, skips the first three lines from
+    // the image boundaries to constrain the surrounding circle inside the image
+    // area.
+    for (var i = 3; i < height - 3; i++) {
+      for (var j = 3; j < width - 3; j++) {
+        var w = i * width + j;
+        var p = pixels[w];
+
+        // Loops the circle offsets to read the pixel value for the sixteen
+        // surrounding pixels.
+        for (var k = 0; k < 16; k++) {
+          circlePixels[k] = pixels[w + circleOffsets[k]];
+        }
+
+        if (this.isCorner(p, circlePixels, opt_threshold)) {
+          // The pixel p is classified as a corner, as optimization increment j
+          // by the circle radius 3 to skip the neighbor pixels inside the
+          // surrounding circle. This can be removed without compromising the
+          // result.
+          corners.push(j, i);
+          j += 3;
+        }
+      }
+    }
+
+    return corners;
+  };
+
+  /**
+   * Checks if the circle pixel is brighter than the candidate pixel p by
+   * a threshold.
+   * @param {number} circlePixel The circle pixel value.
+   * @param {number} p The value of the candidate pixel p.
+   * @param {number} threshold
+   * @return {Boolean}
+   * @static
+   */
+  tracking.Fast.isBrighter = function(circlePixel, p, threshold) {
+    return circlePixel - p > threshold;
+  };
+
+  /**
+   * Checks if the circle pixel is within the corner of the candidate pixel p
+   * by a threshold.
+   * @param {number} p The value of the candidate pixel p.
+   * @param {number} circlePixel The circle pixel value.
+   * @param {number} threshold
+   * @return {Boolean}
+   * @static
+   */
+  tracking.Fast.isCorner = function(p, circlePixels, threshold) {
+    if (this.isTriviallyExcluded(circlePixels, p, threshold)) {
+      return false;
+    }
+
+    for (var x = 0; x < 16; x++) {
+      var darker = true;
+      var brighter = true;
+
+      for (var y = 0; y < 9; y++) {
+        var circlePixel = circlePixels[(x + y) & 15];
+
+        if (!this.isBrighter(p, circlePixel, threshold)) {
+          brighter = false;
+          if (darker === false) {
+            break;
+          }
+        }
+
+        if (!this.isDarker(p, circlePixel, threshold)) {
+          darker = false;
+          if (brighter === false) {
+            break;
+          }
+        }
+      }
+
+      if (brighter || darker) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  /**
+   * Checks if the circle pixel is darker than the candidate pixel p by
+   * a threshold.
+   * @param {number} circlePixel The circle pixel value.
+   * @param {number} p The value of the candidate pixel p.
+   * @param {number} threshold
+   * @return {Boolean}
+   * @static
+   */
+  tracking.Fast.isDarker = function(circlePixel, p, threshold) {
+    return p - circlePixel > threshold;
+  };
+
+  /**
+   * Fast check to test if the candidate pixel is a trivially excluded value.
+   * In order to be a corner, the candidate pixel value should be darker or
+   * brighter than 9-12 surrounding pixels, when at least three of the top,
+   * bottom, left and right pixels are brighter or darker it can be
+   * automatically excluded improving the performance.
+   * @param {number} circlePixel The circle pixel value.
+   * @param {number} p The value of the candidate pixel p.
+   * @param {number} threshold
+   * @return {Boolean}
+   * @static
+   * @protected
+   */
+  tracking.Fast.isTriviallyExcluded = function(circlePixels, p, threshold) {
+    var count = 0;
+    var circleBottom = circlePixels[8];
+    var circleLeft = circlePixels[12];
+    var circleRight = circlePixels[4];
+    var circleTop = circlePixels[0];
+
+    if (this.isBrighter(circleTop, p, threshold)) {
+      count++;
+    }
+    if (this.isBrighter(circleRight, p, threshold)) {
+      count++;
+    }
+    if (this.isBrighter(circleBottom, p, threshold)) {
+      count++;
+    }
+    if (this.isBrighter(circleLeft, p, threshold)) {
+      count++;
+    }
+
+    if (count < 3) {
+      count = 0;
+      if (this.isDarker(circleTop, p, threshold)) {
+        count++;
+      }
+      if (this.isDarker(circleRight, p, threshold)) {
+        count++;
+      }
+      if (this.isDarker(circleBottom, p, threshold)) {
+        count++;
+      }
+      if (this.isDarker(circleLeft, p, threshold)) {
+        count++;
+      }
+      if (count < 3) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  /**
+   * Gets the sixteen offset values of the circle surrounding pixel.
+   * @param {number} width The image width.
+   * @return {array} Array with the sixteen offset values of the circle
+   *     surrounding pixel.
+   * @private
+   */
+  tracking.Fast.getCircleOffsets_ = function(width) {
+    if (this.circles_[width]) {
+      return this.circles_[width];
+    }
+
+    var circle = new Int32Array(16);
+
+    circle[0] = -width - width - width;
+    circle[1] = circle[0] + 1;
+    circle[2] = circle[1] + width + 1;
+    circle[3] = circle[2] + width + 1;
+    circle[4] = circle[3] + width;
+    circle[5] = circle[4] + width;
+    circle[6] = circle[5] + width - 1;
+    circle[7] = circle[6] + width - 1;
+    circle[8] = circle[7] - 1;
+    circle[9] = circle[8] - 1;
+    circle[10] = circle[9] - width - 1;
+    circle[11] = circle[10] - width - 1;
+    circle[12] = circle[11] - width;
+    circle[13] = circle[12] - width;
+    circle[14] = circle[13] - width + 1;
+    circle[15] = circle[14] - width + 1;
+
+    this.circles_[width] = circle;
+    return circle;
+  };
+}());
+
+(function() {
+  /**
+   * Math utility.
+   * @static
+   * @constructor
+   */
+  tracking.Math = {};
+
+  /**
+   * Euclidean distance between two points P(x0, y0) and P(x1, y1).
+   * @param {number} x0 Horizontal coordinate of P0.
+   * @param {number} y0 Vertical coordinate of P0.
+   * @param {number} x1 Horizontal coordinate of P1.
+   * @param {number} y1 Vertical coordinate of P1.
+   * @return {number} The euclidean distance.
+   */
+  tracking.Math.distance = function(x0, y0, x1, y1) {
+    var dx = x1 - x0;
+    var dy = y1 - y0;
+
+    return Math.sqrt(dx * dx + dy * dy);
+  };
+
+  /**
+   * Calculates the Hamming weight of a string, which is the number of symbols that are
+   * different from the zero-symbol of the alphabet used. It is thus
+   * equivalent to the Hamming distance from the all-zero string of the same
+   * length. For the most typical case, a string of bits, this is the number
+   * of 1's in the string.
+   *
+   * Example:
+   *
+   * <pre>
+   *  Binary string     Hamming weight
+   *   11101                 4
+   *   11101010              5
+   * </pre>
+   *
+   * @param {number} i Number that holds the binary string to extract the hamming weight.
+   * @return {number} The hamming weight.
+   */
+  tracking.Math.hammingWeight = function(i) {
+    i = i - ((i >> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
+
+    return ((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
+  };
+
+  /**
+   * Generates a random number between [a, b] interval.
+   * @param {number} a
+   * @param {number} b
+   * @return {number}
+   */
+  tracking.Math.uniformRandom = function(a, b) {
+    return a + Math.random() * (b - a);
+  };
+
+  /**
+   * Tests if a rectangle intersects with another.
+   *
+   *  <pre>
+   *  x0y0 --------       x2y2 --------
+   *      |       |           |       |
+   *      -------- x1y1       -------- x3y3
+   * </pre>
+   *
+   * @param {number} x0 Horizontal coordinate of P0.
+   * @param {number} y0 Vertical coordinate of P0.
+   * @param {number} x1 Horizontal coordinate of P1.
+   * @param {number} y1 Vertical coordinate of P1.
+   * @param {number} x2 Horizontal coordinate of P2.
+   * @param {number} y2 Vertical coordinate of P2.
+   * @param {number} x3 Horizontal coordinate of P3.
+   * @param {number} y3 Vertical coordinate of P3.
+   * @return {boolean}
+   */
+  tracking.Math.intersectRect = function(x0, y0, x1, y1, x2, y2, x3, y3) {
+    return !(x2 > x1 || x3 < x0 || y2 > y1 || y3 < y0);
+  };
+
+}());
+
+(function() {
+  /**
+   * Matrix utility.
+   * @static
+   * @constructor
+   */
+  tracking.Matrix = {};
+
+  /**
+   * Loops the array organized as major-row order and executes `fn` callback
+   * for each iteration. The `fn` callback receives the following parameters:
+   * `(r,g,b,a,index,i,j)`, where `r,g,b,a` represents the pixel color with
+   * alpha channel, `index` represents the position in the major-row order
+   * array and `i,j` the respective indexes positions in two dimensions.
+   * @param {array} pixels The pixels in a linear [r,g,b,a,...] array to loop
+   *     through.
+   * @param {number} width The image width.
+   * @param {number} height The image height.
+   * @param {function} fn The callback function for each pixel.
+   * @param {number} opt_jump Optional jump for the iteration, by default it
+   *     is 1, hence loops all the pixels of the array.
+   * @static
+   */
+  tracking.Matrix.forEach = function(pixels, width, height, fn, opt_jump) {
+    opt_jump = opt_jump || 1;
+    for (var i = 0; i < height; i += opt_jump) {
+      for (var j = 0; j < width; j += opt_jump) {
+        var w = i * width * 4 + j * 4;
+        fn.call(this, pixels[w], pixels[w + 1], pixels[w + 2], pixels[w + 3], w, i, j);
+      }
+    }
+  };
+
+}());
+
+(function() {
+  /**
+   * EPnp utility.
+   * @static
+   * @constructor
+   */
+  tracking.EPnP = {};
+
+  tracking.EPnP.solve = function(objectPoints, imagePoints, cameraMatrix) {};
+}());
+
+(function() {
+  /**
+   * Tracker utility.
+   * @constructor
+   * @extends {tracking.EventEmitter}
+   */
+  tracking.Tracker = function() {
+    tracking.Tracker.base(this, 'constructor');
+  };
+
+  tracking.inherits(tracking.Tracker, tracking.EventEmitter);
+
+  /**
+   * Tracks the pixels on the array. This method is called for each video
+   * frame in order to emit `track` event.
+   * @param {Uint8ClampedArray} pixels The pixels data to track.
+   * @param {number} width The pixels canvas width.
+   * @param {number} height The pixels canvas height.
+   */
+  tracking.Tracker.prototype.track = function() {};
+}());
+
+(function() {
+  /**
+   * TrackerTask utility.
+   * @constructor
+   * @extends {tracking.EventEmitter}
+   */
+  tracking.TrackerTask = function(tracker) {
+    tracking.TrackerTask.base(this, 'constructor');
+
+    if (!tracker) {
+      throw new Error('Tracker instance not specified.');
+    }
+
+    this.setTracker(tracker);
+  };
+
+  tracking.inherits(tracking.TrackerTask, tracking.EventEmitter);
+
+  /**
+   * Holds the tracker instance managed by this task.
+   * @type {tracking.Tracker}
+   * @private
+   */
+  tracking.TrackerTask.prototype.tracker_ = null;
+
+  /**
+   * Holds if the tracker task is in running.
+   * @type {boolean}
+   * @private
+   */
+  tracking.TrackerTask.prototype.running_ = false;
+
+  /**
+   * Gets the tracker instance managed by this task.
+   * @return {tracking.Tracker}
+   */
+  tracking.TrackerTask.prototype.getTracker = function() {
+    return this.tracker_;
+  };
+
+  /**
+   * Returns true if the tracker task is in running, false otherwise.
+   * @return {boolean}
+   * @private
+   */
+  tracking.TrackerTask.prototype.inRunning = function() {
+    return this.running_;
+  };
+
+  /**
+   * Sets if the tracker task is in running.
+   * @param {boolean} running
+   * @private
+   */
+  tracking.TrackerTask.prototype.setRunning = function(running) {
+    this.running_ = running;
+  };
+
+  /**
+   * Sets the tracker instance managed by this task.
+   * @return {tracking.Tracker}
+   */
+  tracking.TrackerTask.prototype.setTracker = function(tracker) {
+    this.tracker_ = tracker;
+  };
+
+  /**
+   * Emits a `run` event on the tracker task for the implementers to run any
+   * child action, e.g. `requestAnimationFrame`.
+   * @return {object} Returns itself, so calls can be chained.
+   */
+  tracking.TrackerTask.prototype.run = function() {
+    var self = this;
+
+    if (this.inRunning()) {
+      return;
+    }
+
+    this.setRunning(true);
+    this.reemitTrackEvent_ = function(event) {
+      self.emit('track', event);
+    };
+    this.tracker_.on('track', this.reemitTrackEvent_);
+    this.emit('run');
+    return this;
+  };
+
+  /**
+   * Emits a `stop` event on the tracker task for the implementers to stop any
+   * child action being done, e.g. `requestAnimationFrame`.
+   * @return {object} Returns itself, so calls can be chained.
+   */
+  tracking.TrackerTask.prototype.stop = function() {
+    if (!this.inRunning()) {
+      return;
+    }
+
+    this.setRunning(false);
+    this.emit('stop');
+    this.tracker_.removeListener('track', this.reemitTrackEvent_);
+    return this;
+  };
+}());
+
+(function() {
+  /**
+   * ColorTracker utility to track colored blobs in a frame using color
+   * difference evaluation.
+   * @constructor
+   * @param {string|Array.<string>} opt_colors Optional colors to track.
+   * @extends {tracking.Tracker}
+   */
+  tracking.ColorTracker = function(opt_colors) {
+    tracking.ColorTracker.base(this, 'constructor');
+
+    if (typeof opt_colors === 'string') {
+      opt_colors = [opt_colors];
+    }
+
+    if (opt_colors) {
+      opt_colors.forEach(function(color) {
+        if (!tracking.ColorTracker.getColor(color)) {
+          throw new Error('Color not valid, try `new tracking.ColorTracker("magenta")`.');
+        }
+      });
+      this.setColors(opt_colors);
+    }
+  };
+
+  tracking.inherits(tracking.ColorTracker, tracking.Tracker);
+
+  /**
+   * Holds the known colors.
+   * @type {Object.<string, function>}
+   * @private
+   * @static
+   */
+  tracking.ColorTracker.knownColors_ = {};
+
+  /**
+   * Caches coordinates values of the neighbours surrounding a pixel.
+   * @type {Object.<number, Int32Array>}
+   * @private
+   * @static
+   */
+  tracking.ColorTracker.neighbours_ = {};
+
+  /**
+   * Registers a color as known color.
+   * @param {string} name The color name.
+   * @param {function} fn The color function to test if the passed (r,g,b) is
+   *     the desired color.
+   * @static
+   */
+  tracking.ColorTracker.registerColor = function(name, fn) {
+    tracking.ColorTracker.knownColors_[name] = fn;
+  };
+
+  /**
+   * Gets the known color function that is able to test whether an (r,g,b) is
+   * the desired color.
+   * @param {string} name The color name.
+   * @return {function} The known color test function.
+   * @static
+   */
+  tracking.ColorTracker.getColor = function(name) {
+    return tracking.ColorTracker.knownColors_[name];
+  };
+
+  /**
+   * Holds the colors to be tracked by the `ColorTracker` instance.
+   * @default ['magenta']
+   * @type {Array.<string>}
+   */
+  tracking.ColorTracker.prototype.colors = ['magenta'];
+
+  /**
+   * Holds the minimum dimension to classify a rectangle.
+   * @default 20
+   * @type {number}
+   */
+  tracking.ColorTracker.prototype.minDimension = 20;
+
+  /**
+   * Holds the maximum dimension to classify a rectangle.
+   * @default Infinity
+   * @type {number}
+   */
+  tracking.ColorTracker.prototype.maxDimension = Infinity;
+
+
+  /**
+   * Holds the minimum group size to be classified as a rectangle.
+   * @default 30
+   * @type {number}
+   */
+  tracking.ColorTracker.prototype.minGroupSize = 30;
+
+  /**
+   * Calculates the central coordinate from the cloud points. The cloud points
+   * are all points that matches the desired color.
+   * @param {Array.<number>} cloud Major row order array containing all the
+   *     points from the desired color, e.g. [x1, y1, c2, y2, ...].
+   * @param {number} total Total numbers of pixels of the desired color.
+   * @return {object} Object containing the x, y and estimated z coordinate of
+   *     the blog extracted from the cloud points.
+   * @private
+   */
+  tracking.ColorTracker.prototype.calculateDimensions_ = function(cloud, total) {
+    var maxx = -1;
+    var maxy = -1;
+    var minx = Infinity;
+    var miny = Infinity;
+
+    for (var c = 0; c < total; c += 2) {
+      var x = cloud[c];
+      var y = cloud[c + 1];
+
+      if (x < minx) {
+        minx = x;
+      }
+      if (x > maxx) {
+        maxx = x;
+      }
+      if (y < miny) {
+        miny = y;
+      }
+      if (y > maxy) {
+        maxy = y;
+      }
+    }
+
+    return {
+      width: maxx - minx,
+      height: maxy - miny,
+      x: minx,
+      y: miny
+    };
+  };
+
+  /**
+   * Gets the colors being tracked by the `ColorTracker` instance.
+   * @return {Array.<string>}
+   */
+  tracking.ColorTracker.prototype.getColors = function() {
+    return this.colors;
+  };
+
+  /**
+   * Gets the minimum dimension to classify a rectangle.
+   * @return {number}
+   */
+  tracking.ColorTracker.prototype.getMinDimension = function() {
+    return this.minDimension;
+  };
+
+  /**
+   * Gets the maximum dimension to classify a rectangle.
+   * @return {number}
+   */
+  tracking.ColorTracker.prototype.getMaxDimension = function() {
+    return this.maxDimension;
+  };
+
+  /**
+   * Gets the minimum group size to be classified as a rectangle.
+   * @return {number}
+   */
+  tracking.ColorTracker.prototype.getMinGroupSize = function() {
+    return this.minGroupSize;
+  };
+
+  /**
+   * Gets the eight offset values of the neighbours surrounding a pixel.
+   * @param {number} width The image width.
+   * @return {array} Array with the eight offset values of the neighbours
+   *     surrounding a pixel.
+   * @private
+   */
+  tracking.ColorTracker.prototype.getNeighboursForWidth_ = function(width) {
+    if (tracking.ColorTracker.neighbours_[width]) {
+      return tracking.ColorTracker.neighbours_[width];
+    }
+
+    var neighbours = new Int32Array(8);
+
+    neighbours[0] = -width * 4;
+    neighbours[1] = -width * 4 + 4;
+    neighbours[2] = 4;
+    neighbours[3] = width * 4 + 4;
+    neighbours[4] = width * 4;
+    neighbours[5] = width * 4 - 4;
+    neighbours[6] = -4;
+    neighbours[7] = -width * 4 - 4;
+
+    tracking.ColorTracker.neighbours_[width] = neighbours;
+
+    return neighbours;
+  };
+
+  /**
+   * Unites groups whose bounding box intersect with each other.
+   * @param {Array.<Object>} rects
+   * @private
+   */
+  tracking.ColorTracker.prototype.mergeRectangles_ = function(rects) {
+    var intersects;
+    var results = [];
+    var minDimension = this.getMinDimension();
+    var maxDimension = this.getMaxDimension();
+
+    for (var r = 0; r < rects.length; r++) {
+      var r1 = rects[r];
+      intersects = true;
+      for (var s = r + 1; s < rects.length; s++) {
+        var r2 = rects[s];
+        if (tracking.Math.intersectRect(r1.x, r1.y, r1.x + r1.width, r1.y + r1.height, r2.x, r2.y, r2.x + r2.width, r2.y + r2.height)) {
+          intersects = false;
+          var x1 = Math.min(r1.x, r2.x);
+          var y1 = Math.min(r1.y, r2.y);
+          var x2 = Math.max(r1.x + r1.width, r2.x + r2.width);
+          var y2 = Math.max(r1.y + r1.height, r2.y + r2.height);
+          r2.height = y2 - y1;
+          r2.width = x2 - x1;
+          r2.x = x1;
+          r2.y = y1;
+          break;
+        }
+      }
+
+      if (intersects) {
+        if (r1.width >= minDimension && r1.height >= minDimension) {
+          if (r1.width <= maxDimension && r1.height <= maxDimension) {
+            results.push(r1);
+          }
+        }
+      }
+    }
+
+    return results;
+  };
+
+  /**
+   * Sets the colors to be tracked by the `ColorTracker` instance.
+   * @param {Array.<string>} colors
+   */
+  tracking.ColorTracker.prototype.setColors = function(colors) {
+    this.colors = colors;
+  };
+
+  /**
+   * Sets the minimum dimension to classify a rectangle.
+   * @param {number} minDimension
+   */
+  tracking.ColorTracker.prototype.setMinDimension = function(minDimension) {
+    this.minDimension = minDimension;
+  };
+
+  /**
+   * Sets the maximum dimension to classify a rectangle.
+   * @param {number} maxDimension
+   */
+  tracking.ColorTracker.prototype.setMaxDimension = function(maxDimension) {
+    this.maxDimension = maxDimension;
+  };
+
+  /**
+   * Sets the minimum group size to be classified as a rectangle.
+   * @param {number} minGroupSize
+   */
+  tracking.ColorTracker.prototype.setMinGroupSize = function(minGroupSize) {
+    this.minGroupSize = minGroupSize;
+  };
+
+  /**
+   * Tracks the `Video` frames. This method is called for each video frame in
+   * order to emit `track` event.
+   * @param {Uint8ClampedArray} pixels The pixels data to track.
+   * @param {number} width The pixels canvas width.
+   * @param {number} height The pixels canvas height.
+   */
+  tracking.ColorTracker.prototype.track = function(pixels, width, height) {
+    var self = this;
+    var colors = this.getColors();
+
+    if (!colors) {
+      throw new Error('Colors not specified, try `new tracking.ColorTracker("magenta")`.');
+    }
+
+    var results = [];
+
+    colors.forEach(function(color) {
+      results = results.concat(self.trackColor_(pixels, width, height, color));
+    });
+
+    this.emit('track', {
+      data: results
+    });
+  };
+
+  /**
+   * Find the given color in the given matrix of pixels using Flood fill
+   * algorithm to determines the area connected to a given node in a
+   * multi-dimensional array.
+   * @param {Uint8ClampedArray} pixels The pixels data to track.
+   * @param {number} width The pixels canvas width.
+   * @param {number} height The pixels canvas height.
+   * @param {string} color The color to be found
+   * @private
+   */
+  tracking.ColorTracker.prototype.trackColor_ = function(pixels, width, height, color) {
+    var colorFn = tracking.ColorTracker.knownColors_[color];
+    var currGroup = new Int32Array(pixels.length >> 2);
+    var currGroupSize;
+    var currI;
+    var currJ;
+    var currW;
+    var marked = new Int8Array(pixels.length);
+    var minGroupSize = this.getMinGroupSize();
+    var neighboursW = this.getNeighboursForWidth_(width);
+    var queue = new Int32Array(pixels.length);
+    var queuePosition;
+    var results = [];
+    var w = -4;
+
+    if (!colorFn) {
+      return results;
+    }
+
+    for (var i = 0; i < height; i++) {
+      for (var j = 0; j < width; j++) {
+        w += 4;
+
+        if (marked[w]) {
+          continue;
+        }
+
+        currGroupSize = 0;
+
+        queuePosition = -1;
+        queue[++queuePosition] = w;
+        queue[++queuePosition] = i;
+        queue[++queuePosition] = j;
+
+        marked[w] = 1;
+
+        while (queuePosition >= 0) {
+          currJ = queue[queuePosition--];
+          currI = queue[queuePosition--];
+          currW = queue[queuePosition--];
+
+          if (colorFn(pixels[currW], pixels[currW + 1], pixels[currW + 2], pixels[currW + 3], currW, currI, currJ)) {
+            currGroup[currGroupSize++] = currJ;
+            currGroup[currGroupSize++] = currI;
+
+            for (var k = 0; k < neighboursW.length; k++) {
+              var otherW = currW + neighboursW[k];
+              var otherI = currI + neighboursI[k];
+              var otherJ = currJ + neighboursJ[k];
+              if (!marked[otherW] && otherI >= 0 && otherI < height && otherJ >= 0 && otherJ < width) {
+                queue[++queuePosition] = otherW;
+                queue[++queuePosition] = otherI;
+                queue[++queuePosition] = otherJ;
+
+                marked[otherW] = 1;
+              }
+            }
+          }
+        }
+
+        if (currGroupSize >= minGroupSize) {
+          var data = this.calculateDimensions_(currGroup, currGroupSize);
+          if (data) {
+            data.color = color;
+            results.push(data);
+          }
+        }
+      }
+    }
+
+    return this.mergeRectangles_(results);
+  };
+
+  // Default colors
+  //===================
+
+  tracking.ColorTracker.registerColor('cyan', function(r, g, b) {
+    var thresholdGreen = 50,
+      thresholdBlue = 70,
+      dx = r - 0,
+      dy = g - 255,
+      dz = b - 255;
+
+    if ((g - r) >= thresholdGreen && (b - r) >= thresholdBlue) {
+      return true;
+    }
+    return dx * dx + dy * dy + dz * dz < 6400;
+  });
+
+  tracking.ColorTracker.registerColor('magenta', function(r, g, b) {
+    var threshold = 50,
+      dx = r - 255,
+      dy = g - 0,
+      dz = b - 255;
+
+    if ((r - g) >= threshold && (b - g) >= threshold) {
+      return true;
+    }
+    return dx * dx + dy * dy + dz * dz < 19600;
+  });
+
+  tracking.ColorTracker.registerColor('yellow', function(r, g, b) {
+    var threshold = 50,
+      dx = r - 255,
+      dy = g - 255,
+      dz = b - 0;
+
+    if ((r - b) >= threshold && (g - b) >= threshold) {
+      return true;
+    }
+    return dx * dx + dy * dy + dz * dz < 10000;
+  });
+
+
+  // Caching neighbour i/j offset values.
+  //=====================================
+  var neighboursI = new Int32Array([-1, -1, 0, 1, 1, 1, 0, -1]);
+  var neighboursJ = new Int32Array([0, 1, 1, 1, 0, -1, -1, -1]);
+}());
+
+(function() {
+  /**
+   * ObjectTracker utility.
+   * @constructor
+   * @param {string|Array.<string|Array.<number>>} opt_classifiers Optional
+   *     object classifiers to track.
+   * @extends {tracking.Tracker}
+   */
+  tracking.ObjectTracker = function(opt_classifiers) {
+    tracking.ObjectTracker.base(this, 'constructor');
+
+    if (opt_classifiers) {
+      if (!Array.isArray(opt_classifiers)) {
+        opt_classifiers = [opt_classifiers];
+      }
+
+      if (Array.isArray(opt_classifiers)) {
+        opt_classifiers.forEach(function(classifier, i) {
+          if (typeof classifier === 'string') {
+            opt_classifiers[i] = tracking.ViolaJones.classifiers[classifier];
+          }
+          if (!opt_classifiers[i]) {
+            throw new Error('Object classifier not valid, try `new tracking.ObjectTracker("face")`.');
+          }
+        });
+      }
+    }
+
+    this.setClassifiers(opt_classifiers);
+  };
+
+  tracking.inherits(tracking.ObjectTracker, tracking.Tracker);
+
+  /**
+   * Specifies the edges density of a block in order to decide whether to skip
+   * it or not.
+   * @default 0.2
+   * @type {number}
+   */
+  tracking.ObjectTracker.prototype.edgesDensity = 0.2;
+
+  /**
+   * Specifies the initial scale to start the feature block scaling.
+   * @default 1.0
+   * @type {number}
+   */
+  tracking.ObjectTracker.prototype.initialScale = 1.0;
+
+  /**
+   * Specifies the scale factor to scale the feature block.
+   * @default 1.25
+   * @type {number}
+   */
+  tracking.ObjectTracker.prototype.scaleFactor = 1.25;
+
+  /**
+   * Specifies the block step size.
+   * @default 1.5
+   * @type {number}
+   */
+  tracking.ObjectTracker.prototype.stepSize = 1.5;
+
+  /**
+   * Gets the tracker HAAR classifiers.
+   * @return {TypedArray.<number>}
+   */
+  tracking.ObjectTracker.prototype.getClassifiers = function() {
+    return this.classifiers;
+  };
+
+  /**
+   * Gets the edges density value.
+   * @return {number}
+   */
+  tracking.ObjectTracker.prototype.getEdgesDensity = function() {
+    return this.edgesDensity;
+  };
+
+  /**
+   * Gets the initial scale to start the feature block scaling.
+   * @return {number}
+   */
+  tracking.ObjectTracker.prototype.getInitialScale = function() {
+    return this.initialScale;
+  };
+
+  /**
+   * Gets the scale factor to scale the feature block.
+   * @return {number}
+   */
+  tracking.ObjectTracker.prototype.getScaleFactor = function() {
+    return this.scaleFactor;
+  };
+
+  /**
+   * Gets the block step size.
+   * @return {number}
+   */
+  tracking.ObjectTracker.prototype.getStepSize = function() {
+    return this.stepSize;
+  };
+
+  /**
+   * Tracks the `Video` frames. This method is called for each video frame in
+   * order to emit `track` event.
+   * @param {Uint8ClampedArray} pixels The pixels data to track.
+   * @param {number} width The pixels canvas width.
+   * @param {number} height The pixels canvas height.
+   */
+  tracking.ObjectTracker.prototype.track = function(pixels, width, height) {
+    var self = this;
+    var classifiers = this.getClassifiers();
+
+    if (!classifiers) {
+      throw new Error('Object classifier not specified, try `new tracking.ObjectTracker("face")`.');
+    }
+
+    var results = [];
+
+    classifiers.forEach(function(classifier) {
+      results = results.concat(tracking.ViolaJones.detect(pixels, width, height, self.getInitialScale(), self.getScaleFactor(), self.getStepSize(), self.getEdgesDensity(), classifier));
+    });
+
+    this.emit('track', {
+      data: results
+    });
+  };
+
+  /**
+   * Sets the tracker HAAR classifiers.
+   * @param {TypedArray.<number>} classifiers
+   */
+  tracking.ObjectTracker.prototype.setClassifiers = function(classifiers) {
+    this.classifiers = classifiers;
+  };
+
+  /**
+   * Sets the edges density.
+   * @param {number} edgesDensity
+   */
+  tracking.ObjectTracker.prototype.setEdgesDensity = function(edgesDensity) {
+    this.edgesDensity = edgesDensity;
+  };
+
+  /**
+   * Sets the initial scale to start the block scaling.
+   * @param {number} initialScale
+   */
+  tracking.ObjectTracker.prototype.setInitialScale = function(initialScale) {
+    this.initialScale = initialScale;
+  };
+
+  /**
+   * Sets the scale factor to scale the feature block.
+   * @param {number} scaleFactor
+   */
+  tracking.ObjectTracker.prototype.setScaleFactor = function(scaleFactor) {
+    this.scaleFactor = scaleFactor;
+  };
+
+  /**
+   * Sets the block step size.
+   * @param {number} stepSize
+   */
+  tracking.ObjectTracker.prototype.setStepSize = function(stepSize) {
+    this.stepSize = stepSize;
+  };
+
+}());
+
+},{}],24:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -4787,7 +7234,68 @@ exports.default = {
   APP_VERSION: APP_VERSION
 };
 
-},{}],24:[function(require,module,exports){
+},{}],25:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _tracking = require('tracking');
+
+var _tracking2 = _interopRequireDefault(_tracking);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 在chrome下截屏可以渲染出图片，但是在微信里面不行
+ */
+var Face = function () {
+  function Face() {
+    (0, _classCallCheck3.default)(this, Face);
+
+    this.registEvent();
+  }
+
+  (0, _createClass3.default)(Face, [{
+    key: 'registEvent',
+    value: function registEvent() {
+      document.getElementById('J_FaceDetech').addEventListener('click', function (e) {
+        var img = document.getElementById('J_ImgFace');
+        var tracker = new _tracking2.default.ObjectTracker(['face', 'eye', 'mouth']);
+        tracker.setStepSize(1.7);
+        _tracking2.default.track('#J_FaceDetech', tracker);
+        tracker.on('track', function (event) {
+          event.data.forEach(function (rect) {
+            window.plot(rect.x, rect.y, rect.width, rect.height);
+          });
+        });
+        window.plot = function (x, y, w, h) {
+          var rect = document.createElement('div');
+          document.querySelector('.face-wrapper').appendChild(rect);
+          rect.classList.add('rect');
+          rect.style.width = w + 'px';
+          rect.style.height = h + 'px';
+          rect.style.left = img.offsetLeft + x + 'px';
+          rect.style.top = img.offsetTop + y + 'px';
+        };
+      });
+    }
+  }]);
+  return Face;
+}();
+
+exports.default = Face;
+
+},{"babel-runtime/helpers/classCallCheck":2,"babel-runtime/helpers/createClass":3,"tracking":23}],26:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -4845,7 +7353,7 @@ var Html2canvas = function () {
 
 exports.default = Html2canvas;
 
-},{"babel-runtime/helpers/classCallCheck":2,"babel-runtime/helpers/createClass":3,"html2canvas":21}],25:[function(require,module,exports){
+},{"babel-runtime/helpers/classCallCheck":2,"babel-runtime/helpers/createClass":3,"html2canvas":21}],27:[function(require,module,exports){
 'use strict';
 
 var _config = require('./config');
@@ -4860,18 +7368,23 @@ var _html2canvas = require('./html2canvas');
 
 var _html2canvas2 = _interopRequireDefault(_html2canvas);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _face = require('./face');
 
-new _qrcode2.default(); /*
-                        * The Entry
-                        */
+var _face2 = _interopRequireDefault(_face);
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+* The Entry
+*/
+new _qrcode2.default();
 new _html2canvas2.default();
+new _face2.default();
 
 var title = 'Hello ' + _config2.default.APP_NAME + '!';
 document.getElementById('title').innerHTML = title;
 
-},{"./config":23,"./html2canvas":24,"./qrcode":26}],26:[function(require,module,exports){
+},{"./config":24,"./face":25,"./html2canvas":26,"./qrcode":28}],28:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -4945,6 +7458,6 @@ var QRCode = function () {
 
 exports.default = QRCode;
 
-},{"babel-runtime/helpers/classCallCheck":2,"babel-runtime/helpers/createClass":3,"qrcode2":22}]},{},[25]);
+},{"babel-runtime/helpers/classCallCheck":2,"babel-runtime/helpers/createClass":3,"qrcode2":22}]},{},[27]);
 
 //# sourceMappingURL=bundle.js.map
diff --git a/build/bundle.js.map b/build/bundle.js.map
index fa6f7bc..542a6ae 100644
--- a/build/bundle.js.map
+++ b/build/bundle.js.map
@@ -1 +1 @@
-{"version":3,"names":[],"mappings":"","sources":["bundle.js"],"sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){\nmodule.exports = { \"default\": require(\"core-js/library/fn/object/define-property\"), __esModule: true };\n},{\"core-js/library/fn/object/define-property\":4}],2:[function(require,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n},{}],3:[function(require,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n},{\"../core-js/object/define-property\":1}],4:[function(require,module,exports){\nrequire('../../modules/es6.object.define-property');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function defineProperty(it, key, desc){\n  return $Object.defineProperty(it, key, desc);\n};\n},{\"../../modules/_core\":7,\"../../modules/es6.object.define-property\":20}],5:[function(require,module,exports){\nmodule.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};\n},{}],6:[function(require,module,exports){\nvar isObject = require('./_is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n},{\"./_is-object\":16}],7:[function(require,module,exports){\nvar core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n},{}],8:[function(require,module,exports){\n// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n},{\"./_a-function\":5}],9:[function(require,module,exports){\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n},{\"./_fails\":12}],10:[function(require,module,exports){\nvar isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n},{\"./_global\":13,\"./_is-object\":16}],11:[function(require,module,exports){\nvar global    = require('./_global')\n  , core      = require('./_core')\n  , ctx       = require('./_ctx')\n  , hide      = require('./_hide')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n},{\"./_core\":7,\"./_ctx\":8,\"./_global\":13,\"./_hide\":14}],12:[function(require,module,exports){\nmodule.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n},{}],13:[function(require,module,exports){\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n},{}],14:[function(require,module,exports){\nvar dP         = require('./_object-dp')\n  , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};\n},{\"./_descriptors\":9,\"./_object-dp\":17,\"./_property-desc\":18}],15:[function(require,module,exports){\nmodule.exports = !require('./_descriptors') && !require('./_fails')(function(){\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n},{\"./_descriptors\":9,\"./_dom-create\":10,\"./_fails\":12}],16:[function(require,module,exports){\nmodule.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n},{}],17:[function(require,module,exports){\nvar anObject       = require('./_an-object')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , toPrimitive    = require('./_to-primitive')\n  , dP             = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};\n},{\"./_an-object\":6,\"./_descriptors\":9,\"./_ie8-dom-define\":15,\"./_to-primitive\":19}],18:[function(require,module,exports){\nmodule.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n},{}],19:[function(require,module,exports){\n// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n},{\"./_is-object\":16}],20:[function(require,module,exports){\nvar $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', {defineProperty: require('./_object-dp').f});\n},{\"./_descriptors\":9,\"./_export\":11,\"./_object-dp\":17}],21:[function(require,module,exports){\n(function (global){\n/*\n  html2canvas 0.5.0-beta4 <http://html2canvas.hertzen.com>\n  Copyright (c) 2016 Niklas von Hertzen\n\n  Released under  License\n*/\n\n(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.html2canvas = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){\n(function (global){\n/*! https://mths.be/punycode v1.4.0 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.3.2',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n},{}],2:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\n\nfunction restoreOwnerScroll(ownerDocument, x, y) {\n    if (ownerDocument.defaultView && (x !== ownerDocument.defaultView.pageXOffset || y !== ownerDocument.defaultView.pageYOffset)) {\n        ownerDocument.defaultView.scrollTo(x, y);\n    }\n}\n\nfunction cloneCanvasContents(canvas, clonedCanvas) {\n    try {\n        if (clonedCanvas) {\n            clonedCanvas.width = canvas.width;\n            clonedCanvas.height = canvas.height;\n            clonedCanvas.getContext(\"2d\").putImageData(canvas.getContext(\"2d\").getImageData(0, 0, canvas.width, canvas.height), 0, 0);\n        }\n    } catch(e) {\n        log(\"Unable to copy canvas content from\", canvas, e);\n    }\n}\n\nfunction cloneNode(node, javascriptEnabled) {\n    var clone = node.nodeType === 3 ? document.createTextNode(node.nodeValue) : node.cloneNode(false);\n\n    var child = node.firstChild;\n    while(child) {\n        if (javascriptEnabled === true || child.nodeType !== 1 || child.nodeName !== 'SCRIPT') {\n            clone.appendChild(cloneNode(child, javascriptEnabled));\n        }\n        child = child.nextSibling;\n    }\n\n    if (node.nodeType === 1) {\n        clone._scrollTop = node.scrollTop;\n        clone._scrollLeft = node.scrollLeft;\n        if (node.nodeName === \"CANVAS\") {\n            cloneCanvasContents(node, clone);\n        } else if (node.nodeName === \"TEXTAREA\" || node.nodeName === \"SELECT\") {\n            clone.value = node.value;\n        }\n    }\n\n    return clone;\n}\n\nfunction initNode(node) {\n    if (node.nodeType === 1) {\n        node.scrollTop = node._scrollTop;\n        node.scrollLeft = node._scrollLeft;\n\n        var child = node.firstChild;\n        while(child) {\n            initNode(child);\n            child = child.nextSibling;\n        }\n    }\n}\n\nmodule.exports = function(ownerDocument, containerDocument, width, height, options, x ,y) {\n    var documentElement = cloneNode(ownerDocument.documentElement, options.javascriptEnabled);\n    var container = containerDocument.createElement(\"iframe\");\n\n    container.className = \"html2canvas-container\";\n    container.style.visibility = \"hidden\";\n    container.style.position = \"fixed\";\n    container.style.left = \"-10000px\";\n    container.style.top = \"0px\";\n    container.style.border = \"0\";\n    container.width = width;\n    container.height = height;\n    container.scrolling = \"no\"; // ios won't scroll without it\n    containerDocument.body.appendChild(container);\n\n    return new Promise(function(resolve) {\n        var documentClone = container.contentWindow.document;\n\n        /* Chrome doesn't detect relative background-images assigned in inline <style> sheets when fetched through getComputedStyle\n         if window url is about:blank, we can assign the url to current by writing onto the document\n         */\n        container.contentWindow.onload = container.onload = function() {\n            var interval = setInterval(function() {\n                if (documentClone.body.childNodes.length > 0) {\n                    initNode(documentClone.documentElement);\n                    clearInterval(interval);\n                    if (options.type === \"view\") {\n                        container.contentWindow.scrollTo(x, y);\n                        if ((/(iPad|iPhone|iPod)/g).test(navigator.userAgent) && (container.contentWindow.scrollY !== y || container.contentWindow.scrollX !== x)) {\n                            documentClone.documentElement.style.top = (-y) + \"px\";\n                            documentClone.documentElement.style.left = (-x) + \"px\";\n                            documentClone.documentElement.style.position = 'absolute';\n                        }\n                    }\n                    resolve(container);\n                }\n            }, 50);\n        };\n\n        documentClone.open();\n        documentClone.write(\"<!DOCTYPE html><html></html>\");\n        // Chrome scrolls the parent document for some reason after the write to the cloned window???\n        restoreOwnerScroll(ownerDocument, x, y);\n        documentClone.replaceChild(documentClone.adoptNode(documentElement), documentClone.documentElement);\n        documentClone.close();\n    });\n};\n\n},{\"./log\":13}],3:[function(_dereq_,module,exports){\n// http://dev.w3.org/csswg/css-color/\n\nfunction Color(value) {\n    this.r = 0;\n    this.g = 0;\n    this.b = 0;\n    this.a = null;\n    var result = this.fromArray(value) ||\n        this.namedColor(value) ||\n        this.rgb(value) ||\n        this.rgba(value) ||\n        this.hex6(value) ||\n        this.hex3(value);\n}\n\nColor.prototype.darken = function(amount) {\n    var a = 1 - amount;\n    return  new Color([\n        Math.round(this.r * a),\n        Math.round(this.g * a),\n        Math.round(this.b * a),\n        this.a\n    ]);\n};\n\nColor.prototype.isTransparent = function() {\n    return this.a === 0;\n};\n\nColor.prototype.isBlack = function() {\n    return this.r === 0 && this.g === 0 && this.b === 0;\n};\n\nColor.prototype.fromArray = function(array) {\n    if (Array.isArray(array)) {\n        this.r = Math.min(array[0], 255);\n        this.g = Math.min(array[1], 255);\n        this.b = Math.min(array[2], 255);\n        if (array.length > 3) {\n            this.a = array[3];\n        }\n    }\n\n    return (Array.isArray(array));\n};\n\nvar _hex3 = /^#([a-f0-9]{3})$/i;\n\nColor.prototype.hex3 = function(value) {\n    var match = null;\n    if ((match = value.match(_hex3)) !== null) {\n        this.r = parseInt(match[1][0] + match[1][0], 16);\n        this.g = parseInt(match[1][1] + match[1][1], 16);\n        this.b = parseInt(match[1][2] + match[1][2], 16);\n    }\n    return match !== null;\n};\n\nvar _hex6 = /^#([a-f0-9]{6})$/i;\n\nColor.prototype.hex6 = function(value) {\n    var match = null;\n    if ((match = value.match(_hex6)) !== null) {\n        this.r = parseInt(match[1].substring(0, 2), 16);\n        this.g = parseInt(match[1].substring(2, 4), 16);\n        this.b = parseInt(match[1].substring(4, 6), 16);\n    }\n    return match !== null;\n};\n\n\nvar _rgb = /^rgb\\(\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*\\)$/;\n\nColor.prototype.rgb = function(value) {\n    var match = null;\n    if ((match = value.match(_rgb)) !== null) {\n        this.r = Number(match[1]);\n        this.g = Number(match[2]);\n        this.b = Number(match[3]);\n    }\n    return match !== null;\n};\n\nvar _rgba = /^rgba\\(\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d?\\.?\\d+)\\s*\\)$/;\n\nColor.prototype.rgba = function(value) {\n    var match = null;\n    if ((match = value.match(_rgba)) !== null) {\n        this.r = Number(match[1]);\n        this.g = Number(match[2]);\n        this.b = Number(match[3]);\n        this.a = Number(match[4]);\n    }\n    return match !== null;\n};\n\nColor.prototype.toString = function() {\n    return this.a !== null && this.a !== 1 ?\n    \"rgba(\" + [this.r, this.g, this.b, this.a].join(\",\") + \")\" :\n    \"rgb(\" + [this.r, this.g, this.b].join(\",\") + \")\";\n};\n\nColor.prototype.namedColor = function(value) {\n    value = value.toLowerCase();\n    var color = colors[value];\n    if (color) {\n        this.r = color[0];\n        this.g = color[1];\n        this.b = color[2];\n    } else if (value === \"transparent\") {\n        this.r = this.g = this.b = this.a = 0;\n        return true;\n    }\n\n    return !!color;\n};\n\nColor.prototype.isColor = true;\n\n// JSON.stringify([].slice.call($$('.named-color-table tr'), 1).map(function(row) { return [row.childNodes[3].textContent, row.childNodes[5].textContent.trim().split(\",\").map(Number)] }).reduce(function(data, row) {data[row[0]] = row[1]; return data}, {}))\nvar colors = {\n    \"aliceblue\": [240, 248, 255],\n    \"antiquewhite\": [250, 235, 215],\n    \"aqua\": [0, 255, 255],\n    \"aquamarine\": [127, 255, 212],\n    \"azure\": [240, 255, 255],\n    \"beige\": [245, 245, 220],\n    \"bisque\": [255, 228, 196],\n    \"black\": [0, 0, 0],\n    \"blanchedalmond\": [255, 235, 205],\n    \"blue\": [0, 0, 255],\n    \"blueviolet\": [138, 43, 226],\n    \"brown\": [165, 42, 42],\n    \"burlywood\": [222, 184, 135],\n    \"cadetblue\": [95, 158, 160],\n    \"chartreuse\": [127, 255, 0],\n    \"chocolate\": [210, 105, 30],\n    \"coral\": [255, 127, 80],\n    \"cornflowerblue\": [100, 149, 237],\n    \"cornsilk\": [255, 248, 220],\n    \"crimson\": [220, 20, 60],\n    \"cyan\": [0, 255, 255],\n    \"darkblue\": [0, 0, 139],\n    \"darkcyan\": [0, 139, 139],\n    \"darkgoldenrod\": [184, 134, 11],\n    \"darkgray\": [169, 169, 169],\n    \"darkgreen\": [0, 100, 0],\n    \"darkgrey\": [169, 169, 169],\n    \"darkkhaki\": [189, 183, 107],\n    \"darkmagenta\": [139, 0, 139],\n    \"darkolivegreen\": [85, 107, 47],\n    \"darkorange\": [255, 140, 0],\n    \"darkorchid\": [153, 50, 204],\n    \"darkred\": [139, 0, 0],\n    \"darksalmon\": [233, 150, 122],\n    \"darkseagreen\": [143, 188, 143],\n    \"darkslateblue\": [72, 61, 139],\n    \"darkslategray\": [47, 79, 79],\n    \"darkslategrey\": [47, 79, 79],\n    \"darkturquoise\": [0, 206, 209],\n    \"darkviolet\": [148, 0, 211],\n    \"deeppink\": [255, 20, 147],\n    \"deepskyblue\": [0, 191, 255],\n    \"dimgray\": [105, 105, 105],\n    \"dimgrey\": [105, 105, 105],\n    \"dodgerblue\": [30, 144, 255],\n    \"firebrick\": [178, 34, 34],\n    \"floralwhite\": [255, 250, 240],\n    \"forestgreen\": [34, 139, 34],\n    \"fuchsia\": [255, 0, 255],\n    \"gainsboro\": [220, 220, 220],\n    \"ghostwhite\": [248, 248, 255],\n    \"gold\": [255, 215, 0],\n    \"goldenrod\": [218, 165, 32],\n    \"gray\": [128, 128, 128],\n    \"green\": [0, 128, 0],\n    \"greenyellow\": [173, 255, 47],\n    \"grey\": [128, 128, 128],\n    \"honeydew\": [240, 255, 240],\n    \"hotpink\": [255, 105, 180],\n    \"indianred\": [205, 92, 92],\n    \"indigo\": [75, 0, 130],\n    \"ivory\": [255, 255, 240],\n    \"khaki\": [240, 230, 140],\n    \"lavender\": [230, 230, 250],\n    \"lavenderblush\": [255, 240, 245],\n    \"lawngreen\": [124, 252, 0],\n    \"lemonchiffon\": [255, 250, 205],\n    \"lightblue\": [173, 216, 230],\n    \"lightcoral\": [240, 128, 128],\n    \"lightcyan\": [224, 255, 255],\n    \"lightgoldenrodyellow\": [250, 250, 210],\n    \"lightgray\": [211, 211, 211],\n    \"lightgreen\": [144, 238, 144],\n    \"lightgrey\": [211, 211, 211],\n    \"lightpink\": [255, 182, 193],\n    \"lightsalmon\": [255, 160, 122],\n    \"lightseagreen\": [32, 178, 170],\n    \"lightskyblue\": [135, 206, 250],\n    \"lightslategray\": [119, 136, 153],\n    \"lightslategrey\": [119, 136, 153],\n    \"lightsteelblue\": [176, 196, 222],\n    \"lightyellow\": [255, 255, 224],\n    \"lime\": [0, 255, 0],\n    \"limegreen\": [50, 205, 50],\n    \"linen\": [250, 240, 230],\n    \"magenta\": [255, 0, 255],\n    \"maroon\": [128, 0, 0],\n    \"mediumaquamarine\": [102, 205, 170],\n    \"mediumblue\": [0, 0, 205],\n    \"mediumorchid\": [186, 85, 211],\n    \"mediumpurple\": [147, 112, 219],\n    \"mediumseagreen\": [60, 179, 113],\n    \"mediumslateblue\": [123, 104, 238],\n    \"mediumspringgreen\": [0, 250, 154],\n    \"mediumturquoise\": [72, 209, 204],\n    \"mediumvioletred\": [199, 21, 133],\n    \"midnightblue\": [25, 25, 112],\n    \"mintcream\": [245, 255, 250],\n    \"mistyrose\": [255, 228, 225],\n    \"moccasin\": [255, 228, 181],\n    \"navajowhite\": [255, 222, 173],\n    \"navy\": [0, 0, 128],\n    \"oldlace\": [253, 245, 230],\n    \"olive\": [128, 128, 0],\n    \"olivedrab\": [107, 142, 35],\n    \"orange\": [255, 165, 0],\n    \"orangered\": [255, 69, 0],\n    \"orchid\": [218, 112, 214],\n    \"palegoldenrod\": [238, 232, 170],\n    \"palegreen\": [152, 251, 152],\n    \"paleturquoise\": [175, 238, 238],\n    \"palevioletred\": [219, 112, 147],\n    \"papayawhip\": [255, 239, 213],\n    \"peachpuff\": [255, 218, 185],\n    \"peru\": [205, 133, 63],\n    \"pink\": [255, 192, 203],\n    \"plum\": [221, 160, 221],\n    \"powderblue\": [176, 224, 230],\n    \"purple\": [128, 0, 128],\n    \"rebeccapurple\": [102, 51, 153],\n    \"red\": [255, 0, 0],\n    \"rosybrown\": [188, 143, 143],\n    \"royalblue\": [65, 105, 225],\n    \"saddlebrown\": [139, 69, 19],\n    \"salmon\": [250, 128, 114],\n    \"sandybrown\": [244, 164, 96],\n    \"seagreen\": [46, 139, 87],\n    \"seashell\": [255, 245, 238],\n    \"sienna\": [160, 82, 45],\n    \"silver\": [192, 192, 192],\n    \"skyblue\": [135, 206, 235],\n    \"slateblue\": [106, 90, 205],\n    \"slategray\": [112, 128, 144],\n    \"slategrey\": [112, 128, 144],\n    \"snow\": [255, 250, 250],\n    \"springgreen\": [0, 255, 127],\n    \"steelblue\": [70, 130, 180],\n    \"tan\": [210, 180, 140],\n    \"teal\": [0, 128, 128],\n    \"thistle\": [216, 191, 216],\n    \"tomato\": [255, 99, 71],\n    \"turquoise\": [64, 224, 208],\n    \"violet\": [238, 130, 238],\n    \"wheat\": [245, 222, 179],\n    \"white\": [255, 255, 255],\n    \"whitesmoke\": [245, 245, 245],\n    \"yellow\": [255, 255, 0],\n    \"yellowgreen\": [154, 205, 50]\n};\n\nmodule.exports = Color;\n\n},{}],4:[function(_dereq_,module,exports){\nvar Support = _dereq_('./support');\nvar CanvasRenderer = _dereq_('./renderers/canvas');\nvar ImageLoader = _dereq_('./imageloader');\nvar NodeParser = _dereq_('./nodeparser');\nvar NodeContainer = _dereq_('./nodecontainer');\nvar log = _dereq_('./log');\nvar utils = _dereq_('./utils');\nvar createWindowClone = _dereq_('./clone');\nvar loadUrlDocument = _dereq_('./proxy').loadUrlDocument;\nvar getBounds = utils.getBounds;\n\nvar html2canvasNodeAttribute = \"data-html2canvas-node\";\nvar html2canvasCloneIndex = 0;\n\nfunction html2canvas(nodeList, options) {\n    var index = html2canvasCloneIndex++;\n    options = options || {};\n    if (options.logging) {\n        log.options.logging = true;\n        log.options.start = Date.now();\n    }\n\n    options.async = typeof(options.async) === \"undefined\" ? true : options.async;\n    options.allowTaint = typeof(options.allowTaint) === \"undefined\" ? false : options.allowTaint;\n    options.removeContainer = typeof(options.removeContainer) === \"undefined\" ? true : options.removeContainer;\n    options.javascriptEnabled = typeof(options.javascriptEnabled) === \"undefined\" ? false : options.javascriptEnabled;\n    options.imageTimeout = typeof(options.imageTimeout) === \"undefined\" ? 10000 : options.imageTimeout;\n    options.renderer = typeof(options.renderer) === \"function\" ? options.renderer : CanvasRenderer;\n    options.strict = !!options.strict;\n\n    if (typeof(nodeList) === \"string\") {\n        if (typeof(options.proxy) !== \"string\") {\n            return Promise.reject(\"Proxy must be used when rendering url\");\n        }\n        var width = options.width != null ? options.width : window.innerWidth;\n        var height = options.height != null ? options.height : window.innerHeight;\n        return loadUrlDocument(absoluteUrl(nodeList), options.proxy, document, width, height, options).then(function(container) {\n            return renderWindow(container.contentWindow.document.documentElement, container, options, width, height);\n        });\n    }\n\n    var node = ((nodeList === undefined) ? [document.documentElement] : ((nodeList.length) ? nodeList : [nodeList]))[0];\n    node.setAttribute(html2canvasNodeAttribute + index, index);\n    return renderDocument(node.ownerDocument, options, node.ownerDocument.defaultView.innerWidth, node.ownerDocument.defaultView.innerHeight, index).then(function(canvas) {\n        if (typeof(options.onrendered) === \"function\") {\n            log(\"options.onrendered is deprecated, html2canvas returns a Promise containing the canvas\");\n            options.onrendered(canvas);\n        }\n        return canvas;\n    });\n}\n\nhtml2canvas.CanvasRenderer = CanvasRenderer;\nhtml2canvas.NodeContainer = NodeContainer;\nhtml2canvas.log = log;\nhtml2canvas.utils = utils;\n\nvar html2canvasExport = (typeof(document) === \"undefined\" || typeof(Object.create) !== \"function\" || typeof(document.createElement(\"canvas\").getContext) !== \"function\") ? function() {\n    return Promise.reject(\"No canvas support\");\n} : html2canvas;\n\nmodule.exports = html2canvasExport;\n\nif (typeof(define) === 'function' && define.amd) {\n    define('html2canvas', [], function() {\n        return html2canvasExport;\n    });\n}\n\nfunction renderDocument(document, options, windowWidth, windowHeight, html2canvasIndex) {\n    return createWindowClone(document, document, windowWidth, windowHeight, options, document.defaultView.pageXOffset, document.defaultView.pageYOffset).then(function(container) {\n        log(\"Document cloned\");\n        var attributeName = html2canvasNodeAttribute + html2canvasIndex;\n        var selector = \"[\" + attributeName + \"='\" + html2canvasIndex + \"']\";\n        document.querySelector(selector).removeAttribute(attributeName);\n        var clonedWindow = container.contentWindow;\n        var node = clonedWindow.document.querySelector(selector);\n        var oncloneHandler = (typeof(options.onclone) === \"function\") ? Promise.resolve(options.onclone(clonedWindow.document)) : Promise.resolve(true);\n        return oncloneHandler.then(function() {\n            return renderWindow(node, container, options, windowWidth, windowHeight);\n        });\n    });\n}\n\nfunction renderWindow(node, container, options, windowWidth, windowHeight) {\n    var clonedWindow = container.contentWindow;\n    var support = new Support(clonedWindow.document);\n    var imageLoader = new ImageLoader(options, support);\n    var bounds = getBounds(node);\n    var width = options.type === \"view\" ? windowWidth : documentWidth(clonedWindow.document);\n    var height = options.type === \"view\" ? windowHeight : documentHeight(clonedWindow.document);\n    var renderer = new options.renderer(width, height, imageLoader, options, document);\n    var parser = new NodeParser(node, renderer, support, imageLoader, options);\n    return parser.ready.then(function() {\n        log(\"Finished rendering\");\n        var canvas;\n\n        if (options.type === \"view\") {\n            canvas = crop(renderer.canvas, {width: renderer.canvas.width, height: renderer.canvas.height, top: 0, left: 0, x: 0, y: 0});\n        } else if (node === clonedWindow.document.body || node === clonedWindow.document.documentElement || options.canvas != null) {\n            canvas = renderer.canvas;\n        } else {\n            canvas = crop(renderer.canvas, {width:  options.width != null ? options.width : bounds.width, height: options.height != null ? options.height : bounds.height, top: bounds.top, left: bounds.left, x: 0, y: 0});\n        }\n\n        cleanupContainer(container, options);\n        return canvas;\n    });\n}\n\nfunction cleanupContainer(container, options) {\n    if (options.removeContainer) {\n        container.parentNode.removeChild(container);\n        log(\"Cleaned up container\");\n    }\n}\n\nfunction crop(canvas, bounds) {\n    var croppedCanvas = document.createElement(\"canvas\");\n    var x1 = Math.min(canvas.width - 1, Math.max(0, bounds.left));\n    var x2 = Math.min(canvas.width, Math.max(1, bounds.left + bounds.width));\n    var y1 = Math.min(canvas.height - 1, Math.max(0, bounds.top));\n    var y2 = Math.min(canvas.height, Math.max(1, bounds.top + bounds.height));\n    croppedCanvas.width = bounds.width;\n    croppedCanvas.height =  bounds.height;\n    var width = x2-x1;\n    var height = y2-y1;\n    log(\"Cropping canvas at:\", \"left:\", bounds.left, \"top:\", bounds.top, \"width:\", width, \"height:\", height);\n    log(\"Resulting crop with width\", bounds.width, \"and height\", bounds.height, \"with x\", x1, \"and y\", y1);\n    croppedCanvas.getContext(\"2d\").drawImage(canvas, x1, y1, width, height, bounds.x, bounds.y, width, height);\n    return croppedCanvas;\n}\n\nfunction documentWidth (doc) {\n    return Math.max(\n        Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth),\n        Math.max(doc.body.offsetWidth, doc.documentElement.offsetWidth),\n        Math.max(doc.body.clientWidth, doc.documentElement.clientWidth)\n    );\n}\n\nfunction documentHeight (doc) {\n    return Math.max(\n        Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight),\n        Math.max(doc.body.offsetHeight, doc.documentElement.offsetHeight),\n        Math.max(doc.body.clientHeight, doc.documentElement.clientHeight)\n    );\n}\n\nfunction absoluteUrl(url) {\n    var link = document.createElement(\"a\");\n    link.href = url;\n    link.href = link.href;\n    return link;\n}\n\n},{\"./clone\":2,\"./imageloader\":11,\"./log\":13,\"./nodecontainer\":14,\"./nodeparser\":15,\"./proxy\":16,\"./renderers/canvas\":20,\"./support\":22,\"./utils\":26}],5:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\nvar smallImage = _dereq_('./utils').smallImage;\n\nfunction DummyImageContainer(src) {\n    this.src = src;\n    log(\"DummyImageContainer for\", src);\n    if (!this.promise || !this.image) {\n        log(\"Initiating DummyImageContainer\");\n        DummyImageContainer.prototype.image = new Image();\n        var image = this.image;\n        DummyImageContainer.prototype.promise = new Promise(function(resolve, reject) {\n            image.onload = resolve;\n            image.onerror = reject;\n            image.src = smallImage();\n            if (image.complete === true) {\n                resolve(image);\n            }\n        });\n    }\n}\n\nmodule.exports = DummyImageContainer;\n\n},{\"./log\":13,\"./utils\":26}],6:[function(_dereq_,module,exports){\nvar smallImage = _dereq_('./utils').smallImage;\n\nfunction Font(family, size) {\n    var container = document.createElement('div'),\n        img = document.createElement('img'),\n        span = document.createElement('span'),\n        sampleText = 'Hidden Text',\n        baseline,\n        middle;\n\n    container.style.visibility = \"hidden\";\n    container.style.fontFamily = family;\n    container.style.fontSize = size;\n    container.style.margin = 0;\n    container.style.padding = 0;\n\n    document.body.appendChild(container);\n\n    img.src = smallImage();\n    img.width = 1;\n    img.height = 1;\n\n    img.style.margin = 0;\n    img.style.padding = 0;\n    img.style.verticalAlign = \"baseline\";\n\n    span.style.fontFamily = family;\n    span.style.fontSize = size;\n    span.style.margin = 0;\n    span.style.padding = 0;\n\n    span.appendChild(document.createTextNode(sampleText));\n    container.appendChild(span);\n    container.appendChild(img);\n    baseline = (img.offsetTop - span.offsetTop) + 1;\n\n    container.removeChild(span);\n    container.appendChild(document.createTextNode(sampleText));\n\n    container.style.lineHeight = \"normal\";\n    img.style.verticalAlign = \"super\";\n\n    middle = (img.offsetTop-container.offsetTop) + 1;\n\n    document.body.removeChild(container);\n\n    this.baseline = baseline;\n    this.lineWidth = 1;\n    this.middle = middle;\n}\n\nmodule.exports = Font;\n\n},{\"./utils\":26}],7:[function(_dereq_,module,exports){\nvar Font = _dereq_('./font');\n\nfunction FontMetrics() {\n    this.data = {};\n}\n\nFontMetrics.prototype.getMetrics = function(family, size) {\n    if (this.data[family + \"-\" + size] === undefined) {\n        this.data[family + \"-\" + size] = new Font(family, size);\n    }\n    return this.data[family + \"-\" + size];\n};\n\nmodule.exports = FontMetrics;\n\n},{\"./font\":6}],8:[function(_dereq_,module,exports){\nvar utils = _dereq_('./utils');\nvar getBounds = utils.getBounds;\nvar loadUrlDocument = _dereq_('./proxy').loadUrlDocument;\n\nfunction FrameContainer(container, sameOrigin, options) {\n    this.image = null;\n    this.src = container;\n    var self = this;\n    var bounds = getBounds(container);\n    this.promise = (!sameOrigin ? this.proxyLoad(options.proxy, bounds, options) : new Promise(function(resolve) {\n        if (container.contentWindow.document.URL === \"about:blank\" || container.contentWindow.document.documentElement == null) {\n            container.contentWindow.onload = container.onload = function() {\n                resolve(container);\n            };\n        } else {\n            resolve(container);\n        }\n    })).then(function(container) {\n        var html2canvas = _dereq_('./core');\n        return html2canvas(container.contentWindow.document.documentElement, {type: 'view', width: container.width, height: container.height, proxy: options.proxy, javascriptEnabled: options.javascriptEnabled, removeContainer: options.removeContainer, allowTaint: options.allowTaint, imageTimeout: options.imageTimeout / 2});\n    }).then(function(canvas) {\n        return self.image = canvas;\n    });\n}\n\nFrameContainer.prototype.proxyLoad = function(proxy, bounds, options) {\n    var container = this.src;\n    return loadUrlDocument(container.src, proxy, container.ownerDocument, bounds.width, bounds.height, options);\n};\n\nmodule.exports = FrameContainer;\n\n},{\"./core\":4,\"./proxy\":16,\"./utils\":26}],9:[function(_dereq_,module,exports){\nfunction GradientContainer(imageData) {\n    this.src = imageData.value;\n    this.colorStops = [];\n    this.type = null;\n    this.x0 = 0.5;\n    this.y0 = 0.5;\n    this.x1 = 0.5;\n    this.y1 = 0.5;\n    this.promise = Promise.resolve(true);\n}\n\nGradientContainer.TYPES = {\n    LINEAR: 1,\n    RADIAL: 2\n};\n\n// TODO: support hsl[a], negative %/length values\n// TODO: support <angle> (e.g. -?\\d{1,3}(?:\\.\\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )\nGradientContainer.REGEXP_COLORSTOP = /^\\s*(rgba?\\(\\s*\\d{1,3},\\s*\\d{1,3},\\s*\\d{1,3}(?:,\\s*[0-9\\.]+)?\\s*\\)|[a-z]{3,20}|#[a-f0-9]{3,6})(?:\\s+(\\d{1,3}(?:\\.\\d+)?)(%|px)?)?(?:\\s|$)/i;\n\nmodule.exports = GradientContainer;\n\n},{}],10:[function(_dereq_,module,exports){\nfunction ImageContainer(src, cors) {\n    this.src = src;\n    this.image = new Image();\n    var self = this;\n    this.tainted = null;\n    this.promise = new Promise(function(resolve, reject) {\n        self.image.onload = resolve;\n        self.image.onerror = reject;\n        if (cors) {\n            self.image.crossOrigin = \"anonymous\";\n        }\n        self.image.src = src;\n        if (self.image.complete === true) {\n            resolve(self.image);\n        }\n    });\n}\n\nmodule.exports = ImageContainer;\n\n},{}],11:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\nvar ImageContainer = _dereq_('./imagecontainer');\nvar DummyImageContainer = _dereq_('./dummyimagecontainer');\nvar ProxyImageContainer = _dereq_('./proxyimagecontainer');\nvar FrameContainer = _dereq_('./framecontainer');\nvar SVGContainer = _dereq_('./svgcontainer');\nvar SVGNodeContainer = _dereq_('./svgnodecontainer');\nvar LinearGradientContainer = _dereq_('./lineargradientcontainer');\nvar WebkitGradientContainer = _dereq_('./webkitgradientcontainer');\nvar bind = _dereq_('./utils').bind;\n\nfunction ImageLoader(options, support) {\n    this.link = null;\n    this.options = options;\n    this.support = support;\n    this.origin = this.getOrigin(window.location.href);\n}\n\nImageLoader.prototype.findImages = function(nodes) {\n    var images = [];\n    nodes.reduce(function(imageNodes, container) {\n        switch(container.node.nodeName) {\n        case \"IMG\":\n            return imageNodes.concat([{\n                args: [container.node.src],\n                method: \"url\"\n            }]);\n        case \"svg\":\n        case \"IFRAME\":\n            return imageNodes.concat([{\n                args: [container.node],\n                method: container.node.nodeName\n            }]);\n        }\n        return imageNodes;\n    }, []).forEach(this.addImage(images, this.loadImage), this);\n    return images;\n};\n\nImageLoader.prototype.findBackgroundImage = function(images, container) {\n    container.parseBackgroundImages().filter(this.hasImageBackground).forEach(this.addImage(images, this.loadImage), this);\n    return images;\n};\n\nImageLoader.prototype.addImage = function(images, callback) {\n    return function(newImage) {\n        newImage.args.forEach(function(image) {\n            if (!this.imageExists(images, image)) {\n                images.splice(0, 0, callback.call(this, newImage));\n                log('Added image #' + (images.length), typeof(image) === \"string\" ? image.substring(0, 100) : image);\n            }\n        }, this);\n    };\n};\n\nImageLoader.prototype.hasImageBackground = function(imageData) {\n    return imageData.method !== \"none\";\n};\n\nImageLoader.prototype.loadImage = function(imageData) {\n    if (imageData.method === \"url\") {\n        var src = imageData.args[0];\n        if (this.isSVG(src) && !this.support.svg && !this.options.allowTaint) {\n            return new SVGContainer(src);\n        } else if (src.match(/data:image\\/.*;base64,/i)) {\n            return new ImageContainer(src.replace(/url\\(['\"]{0,}|['\"]{0,}\\)$/ig, ''), false);\n        } else if (this.isSameOrigin(src) || this.options.allowTaint === true || this.isSVG(src)) {\n            return new ImageContainer(src, false);\n        } else if (this.support.cors && !this.options.allowTaint && this.options.useCORS) {\n            return new ImageContainer(src, true);\n        } else if (this.options.proxy) {\n            return new ProxyImageContainer(src, this.options.proxy);\n        } else {\n            return new DummyImageContainer(src);\n        }\n    } else if (imageData.method === \"linear-gradient\") {\n        return new LinearGradientContainer(imageData);\n    } else if (imageData.method === \"gradient\") {\n        return new WebkitGradientContainer(imageData);\n    } else if (imageData.method === \"svg\") {\n        return new SVGNodeContainer(imageData.args[0], this.support.svg);\n    } else if (imageData.method === \"IFRAME\") {\n        return new FrameContainer(imageData.args[0], this.isSameOrigin(imageData.args[0].src), this.options);\n    } else {\n        return new DummyImageContainer(imageData);\n    }\n};\n\nImageLoader.prototype.isSVG = function(src) {\n    return src.substring(src.length - 3).toLowerCase() === \"svg\" || SVGContainer.prototype.isInline(src);\n};\n\nImageLoader.prototype.imageExists = function(images, src) {\n    return images.some(function(image) {\n        return image.src === src;\n    });\n};\n\nImageLoader.prototype.isSameOrigin = function(url) {\n    return (this.getOrigin(url) === this.origin);\n};\n\nImageLoader.prototype.getOrigin = function(url) {\n    var link = this.link || (this.link = document.createElement(\"a\"));\n    link.href = url;\n    link.href = link.href; // IE9, LOL! - http://jsfiddle.net/niklasvh/2e48b/\n    return link.protocol + link.hostname + link.port;\n};\n\nImageLoader.prototype.getPromise = function(container) {\n    return this.timeout(container, this.options.imageTimeout)['catch'](function() {\n        var dummy = new DummyImageContainer(container.src);\n        return dummy.promise.then(function(image) {\n            container.image = image;\n        });\n    });\n};\n\nImageLoader.prototype.get = function(src) {\n    var found = null;\n    return this.images.some(function(img) {\n        return (found = img).src === src;\n    }) ? found : null;\n};\n\nImageLoader.prototype.fetch = function(nodes) {\n    this.images = nodes.reduce(bind(this.findBackgroundImage, this), this.findImages(nodes));\n    this.images.forEach(function(image, index) {\n        image.promise.then(function() {\n            log(\"Succesfully loaded image #\"+ (index+1), image);\n        }, function(e) {\n            log(\"Failed loading image #\"+ (index+1), image, e);\n        });\n    });\n    this.ready = Promise.all(this.images.map(this.getPromise, this));\n    log(\"Finished searching images\");\n    return this;\n};\n\nImageLoader.prototype.timeout = function(container, timeout) {\n    var timer;\n    var promise = Promise.race([container.promise, new Promise(function(res, reject) {\n        timer = setTimeout(function() {\n            log(\"Timed out loading image\", container);\n            reject(container);\n        }, timeout);\n    })]).then(function(container) {\n        clearTimeout(timer);\n        return container;\n    });\n    promise['catch'](function() {\n        clearTimeout(timer);\n    });\n    return promise;\n};\n\nmodule.exports = ImageLoader;\n\n},{\"./dummyimagecontainer\":5,\"./framecontainer\":8,\"./imagecontainer\":10,\"./lineargradientcontainer\":12,\"./log\":13,\"./proxyimagecontainer\":17,\"./svgcontainer\":23,\"./svgnodecontainer\":24,\"./utils\":26,\"./webkitgradientcontainer\":27}],12:[function(_dereq_,module,exports){\nvar GradientContainer = _dereq_('./gradientcontainer');\nvar Color = _dereq_('./color');\n\nfunction LinearGradientContainer(imageData) {\n    GradientContainer.apply(this, arguments);\n    this.type = GradientContainer.TYPES.LINEAR;\n\n    var hasDirection = LinearGradientContainer.REGEXP_DIRECTION.test( imageData.args[0] ) ||\n        !GradientContainer.REGEXP_COLORSTOP.test( imageData.args[0] );\n\n    if (hasDirection) {\n        imageData.args[0].split(/\\s+/).reverse().forEach(function(position, index) {\n            switch(position) {\n            case \"left\":\n                this.x0 = 0;\n                this.x1 = 1;\n                break;\n            case \"top\":\n                this.y0 = 0;\n                this.y1 = 1;\n                break;\n            case \"right\":\n                this.x0 = 1;\n                this.x1 = 0;\n                break;\n            case \"bottom\":\n                this.y0 = 1;\n                this.y1 = 0;\n                break;\n            case \"to\":\n                var y0 = this.y0;\n                var x0 = this.x0;\n                this.y0 = this.y1;\n                this.x0 = this.x1;\n                this.x1 = x0;\n                this.y1 = y0;\n                break;\n            case \"center\":\n                break; // centered by default\n            // Firefox internally converts position keywords to percentages:\n            // http://www.w3.org/TR/2010/WD-CSS2-20101207/colors.html#propdef-background-position\n            default: // percentage or absolute length\n                // TODO: support absolute start point positions (e.g., use bounds to convert px to a ratio)\n                var ratio = parseFloat(position, 10) * 1e-2;\n                if (isNaN(ratio)) { // invalid or unhandled value\n                    break;\n                }\n                if (index === 0) {\n                    this.y0 = ratio;\n                    this.y1 = 1 - this.y0;\n                } else {\n                    this.x0 = ratio;\n                    this.x1 = 1 - this.x0;\n                }\n                break;\n            }\n        }, this);\n    } else {\n        this.y0 = 0;\n        this.y1 = 1;\n    }\n\n    this.colorStops = imageData.args.slice(hasDirection ? 1 : 0).map(function(colorStop) {\n        var colorStopMatch = colorStop.match(GradientContainer.REGEXP_COLORSTOP);\n        var value = +colorStopMatch[2];\n        var unit = value === 0 ? \"%\" : colorStopMatch[3]; // treat \"0\" as \"0%\"\n        return {\n            color: new Color(colorStopMatch[1]),\n            // TODO: support absolute stop positions (e.g., compute gradient line length & convert px to ratio)\n            stop: unit === \"%\" ? value / 100 : null\n        };\n    });\n\n    if (this.colorStops[0].stop === null) {\n        this.colorStops[0].stop = 0;\n    }\n\n    if (this.colorStops[this.colorStops.length - 1].stop === null) {\n        this.colorStops[this.colorStops.length - 1].stop = 1;\n    }\n\n    // calculates and fills-in explicit stop positions when omitted from rule\n    this.colorStops.forEach(function(colorStop, index) {\n        if (colorStop.stop === null) {\n            this.colorStops.slice(index).some(function(find, count) {\n                if (find.stop !== null) {\n                    colorStop.stop = ((find.stop - this.colorStops[index - 1].stop) / (count + 1)) + this.colorStops[index - 1].stop;\n                    return true;\n                } else {\n                    return false;\n                }\n            }, this);\n        }\n    }, this);\n}\n\nLinearGradientContainer.prototype = Object.create(GradientContainer.prototype);\n\n// TODO: support <angle> (e.g. -?\\d{1,3}(?:\\.\\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )\nLinearGradientContainer.REGEXP_DIRECTION = /^\\s*(?:to|left|right|top|bottom|center|\\d{1,3}(?:\\.\\d+)?%?)(?:\\s|$)/i;\n\nmodule.exports = LinearGradientContainer;\n\n},{\"./color\":3,\"./gradientcontainer\":9}],13:[function(_dereq_,module,exports){\nvar logger = function() {\n    if (logger.options.logging && window.console && window.console.log) {\n        Function.prototype.bind.call(window.console.log, (window.console)).apply(window.console, [(Date.now() - logger.options.start) + \"ms\", \"html2canvas:\"].concat([].slice.call(arguments, 0)));\n    }\n};\n\nlogger.options = {logging: false};\nmodule.exports = logger;\n\n},{}],14:[function(_dereq_,module,exports){\nvar Color = _dereq_('./color');\nvar utils = _dereq_('./utils');\nvar getBounds = utils.getBounds;\nvar parseBackgrounds = utils.parseBackgrounds;\nvar offsetBounds = utils.offsetBounds;\n\nfunction NodeContainer(node, parent) {\n    this.node = node;\n    this.parent = parent;\n    this.stack = null;\n    this.bounds = null;\n    this.borders = null;\n    this.clip = [];\n    this.backgroundClip = [];\n    this.offsetBounds = null;\n    this.visible = null;\n    this.computedStyles = null;\n    this.colors = {};\n    this.styles = {};\n    this.backgroundImages = null;\n    this.transformData = null;\n    this.transformMatrix = null;\n    this.isPseudoElement = false;\n    this.opacity = null;\n}\n\nNodeContainer.prototype.cloneTo = function(stack) {\n    stack.visible = this.visible;\n    stack.borders = this.borders;\n    stack.bounds = this.bounds;\n    stack.clip = this.clip;\n    stack.backgroundClip = this.backgroundClip;\n    stack.computedStyles = this.computedStyles;\n    stack.styles = this.styles;\n    stack.backgroundImages = this.backgroundImages;\n    stack.opacity = this.opacity;\n};\n\nNodeContainer.prototype.getOpacity = function() {\n    return this.opacity === null ? (this.opacity = this.cssFloat('opacity')) : this.opacity;\n};\n\nNodeContainer.prototype.assignStack = function(stack) {\n    this.stack = stack;\n    stack.children.push(this);\n};\n\nNodeContainer.prototype.isElementVisible = function() {\n    return this.node.nodeType === Node.TEXT_NODE ? this.parent.visible : (\n        this.css('display') !== \"none\" &&\n        this.css('visibility') !== \"hidden\" &&\n        !this.node.hasAttribute(\"data-html2canvas-ignore\") &&\n        (this.node.nodeName !== \"INPUT\" || this.node.getAttribute(\"type\") !== \"hidden\")\n    );\n};\n\nNodeContainer.prototype.css = function(attribute) {\n    if (!this.computedStyles) {\n        this.computedStyles = this.isPseudoElement ? this.parent.computedStyle(this.before ? \":before\" : \":after\") : this.computedStyle(null);\n    }\n\n    return this.styles[attribute] || (this.styles[attribute] = this.computedStyles[attribute]);\n};\n\nNodeContainer.prototype.prefixedCss = function(attribute) {\n    var prefixes = [\"webkit\", \"moz\", \"ms\", \"o\"];\n    var value = this.css(attribute);\n    if (value === undefined) {\n        prefixes.some(function(prefix) {\n            value = this.css(prefix + attribute.substr(0, 1).toUpperCase() + attribute.substr(1));\n            return value !== undefined;\n        }, this);\n    }\n    return value === undefined ? null : value;\n};\n\nNodeContainer.prototype.computedStyle = function(type) {\n    return this.node.ownerDocument.defaultView.getComputedStyle(this.node, type);\n};\n\nNodeContainer.prototype.cssInt = function(attribute) {\n    var value = parseInt(this.css(attribute), 10);\n    return (isNaN(value)) ? 0 : value; // borders in old IE are throwing 'medium' for demo.html\n};\n\nNodeContainer.prototype.color = function(attribute) {\n    return this.colors[attribute] || (this.colors[attribute] = new Color(this.css(attribute)));\n};\n\nNodeContainer.prototype.cssFloat = function(attribute) {\n    var value = parseFloat(this.css(attribute));\n    return (isNaN(value)) ? 0 : value;\n};\n\nNodeContainer.prototype.fontWeight = function() {\n    var weight = this.css(\"fontWeight\");\n    switch(parseInt(weight, 10)){\n    case 401:\n        weight = \"bold\";\n        break;\n    case 400:\n        weight = \"normal\";\n        break;\n    }\n    return weight;\n};\n\nNodeContainer.prototype.parseClip = function() {\n    var matches = this.css('clip').match(this.CLIP);\n    if (matches) {\n        return {\n            top: parseInt(matches[1], 10),\n            right: parseInt(matches[2], 10),\n            bottom: parseInt(matches[3], 10),\n            left: parseInt(matches[4], 10)\n        };\n    }\n    return null;\n};\n\nNodeContainer.prototype.parseBackgroundImages = function() {\n    return this.backgroundImages || (this.backgroundImages = parseBackgrounds(this.css(\"backgroundImage\")));\n};\n\nNodeContainer.prototype.cssList = function(property, index) {\n    var value = (this.css(property) || '').split(',');\n    value = value[index || 0] || value[0] || 'auto';\n    value = value.trim().split(' ');\n    if (value.length === 1) {\n        value = [value[0], isPercentage(value[0]) ? 'auto' : value[0]];\n    }\n    return value;\n};\n\nNodeContainer.prototype.parseBackgroundSize = function(bounds, image, index) {\n    var size = this.cssList(\"backgroundSize\", index);\n    var width, height;\n\n    if (isPercentage(size[0])) {\n        width = bounds.width * parseFloat(size[0]) / 100;\n    } else if (/contain|cover/.test(size[0])) {\n        var targetRatio = bounds.width / bounds.height, currentRatio = image.width / image.height;\n        return (targetRatio < currentRatio ^ size[0] === 'contain') ?  {width: bounds.height * currentRatio, height: bounds.height} : {width: bounds.width, height: bounds.width / currentRatio};\n    } else {\n        width = parseInt(size[0], 10);\n    }\n\n    if (size[0] === 'auto' && size[1] === 'auto') {\n        height = image.height;\n    } else if (size[1] === 'auto') {\n        height = width / image.width * image.height;\n    } else if (isPercentage(size[1])) {\n        height =  bounds.height * parseFloat(size[1]) / 100;\n    } else {\n        height = parseInt(size[1], 10);\n    }\n\n    if (size[0] === 'auto') {\n        width = height / image.height * image.width;\n    }\n\n    return {width: width, height: height};\n};\n\nNodeContainer.prototype.parseBackgroundPosition = function(bounds, image, index, backgroundSize) {\n    var position = this.cssList('backgroundPosition', index);\n    var left, top;\n\n    if (isPercentage(position[0])){\n        left = (bounds.width - (backgroundSize || image).width) * (parseFloat(position[0]) / 100);\n    } else {\n        left = parseInt(position[0], 10);\n    }\n\n    if (position[1] === 'auto') {\n        top = left / image.width * image.height;\n    } else if (isPercentage(position[1])){\n        top =  (bounds.height - (backgroundSize || image).height) * parseFloat(position[1]) / 100;\n    } else {\n        top = parseInt(position[1], 10);\n    }\n\n    if (position[0] === 'auto') {\n        left = top / image.height * image.width;\n    }\n\n    return {left: left, top: top};\n};\n\nNodeContainer.prototype.parseBackgroundRepeat = function(index) {\n    return this.cssList(\"backgroundRepeat\", index)[0];\n};\n\nNodeContainer.prototype.parseTextShadows = function() {\n    var textShadow = this.css(\"textShadow\");\n    var results = [];\n\n    if (textShadow && textShadow !== 'none') {\n        var shadows = textShadow.match(this.TEXT_SHADOW_PROPERTY);\n        for (var i = 0; shadows && (i < shadows.length); i++) {\n            var s = shadows[i].match(this.TEXT_SHADOW_VALUES);\n            results.push({\n                color: new Color(s[0]),\n                offsetX: s[1] ? parseFloat(s[1].replace('px', '')) : 0,\n                offsetY: s[2] ? parseFloat(s[2].replace('px', '')) : 0,\n                blur: s[3] ? s[3].replace('px', '') : 0\n            });\n        }\n    }\n    return results;\n};\n\nNodeContainer.prototype.parseTransform = function() {\n    if (!this.transformData) {\n        if (this.hasTransform()) {\n            var offset = this.parseBounds();\n            var origin = this.prefixedCss(\"transformOrigin\").split(\" \").map(removePx).map(asFloat);\n            origin[0] += offset.left;\n            origin[1] += offset.top;\n            this.transformData = {\n                origin: origin,\n                matrix: this.parseTransformMatrix()\n            };\n        } else {\n            this.transformData = {\n                origin: [0, 0],\n                matrix: [1, 0, 0, 1, 0, 0]\n            };\n        }\n    }\n    return this.transformData;\n};\n\nNodeContainer.prototype.parseTransformMatrix = function() {\n    if (!this.transformMatrix) {\n        var transform = this.prefixedCss(\"transform\");\n        var matrix = transform ? parseMatrix(transform.match(this.MATRIX_PROPERTY)) : null;\n        this.transformMatrix = matrix ? matrix : [1, 0, 0, 1, 0, 0];\n    }\n    return this.transformMatrix;\n};\n\nNodeContainer.prototype.parseBounds = function() {\n    return this.bounds || (this.bounds = this.hasTransform() ? offsetBounds(this.node) : getBounds(this.node));\n};\n\nNodeContainer.prototype.hasTransform = function() {\n    return this.parseTransformMatrix().join(\",\") !== \"1,0,0,1,0,0\" || (this.parent && this.parent.hasTransform());\n};\n\nNodeContainer.prototype.getValue = function() {\n    var value = this.node.value || \"\";\n    if (this.node.tagName === \"SELECT\") {\n        value = selectionValue(this.node);\n    } else if (this.node.type === \"password\") {\n        value = Array(value.length + 1).join('\\u2022'); // jshint ignore:line\n    }\n    return value.length === 0 ? (this.node.placeholder || \"\") : value;\n};\n\nNodeContainer.prototype.MATRIX_PROPERTY = /(matrix|matrix3d)\\((.+)\\)/;\nNodeContainer.prototype.TEXT_SHADOW_PROPERTY = /((rgba|rgb)\\([^\\)]+\\)(\\s-?\\d+px){0,})/g;\nNodeContainer.prototype.TEXT_SHADOW_VALUES = /(-?\\d+px)|(#.+)|(rgb\\(.+\\))|(rgba\\(.+\\))/g;\nNodeContainer.prototype.CLIP = /^rect\\((\\d+)px,? (\\d+)px,? (\\d+)px,? (\\d+)px\\)$/;\n\nfunction selectionValue(node) {\n    var option = node.options[node.selectedIndex || 0];\n    return option ? (option.text || \"\") : \"\";\n}\n\nfunction parseMatrix(match) {\n    if (match && match[1] === \"matrix\") {\n        return match[2].split(\",\").map(function(s) {\n            return parseFloat(s.trim());\n        });\n    } else if (match && match[1] === \"matrix3d\") {\n        var matrix3d = match[2].split(\",\").map(function(s) {\n          return parseFloat(s.trim());\n        });\n        return [matrix3d[0], matrix3d[1], matrix3d[4], matrix3d[5], matrix3d[12], matrix3d[13]];\n    }\n}\n\nfunction isPercentage(value) {\n    return value.toString().indexOf(\"%\") !== -1;\n}\n\nfunction removePx(str) {\n    return str.replace(\"px\", \"\");\n}\n\nfunction asFloat(str) {\n    return parseFloat(str);\n}\n\nmodule.exports = NodeContainer;\n\n},{\"./color\":3,\"./utils\":26}],15:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\nvar punycode = _dereq_('punycode');\nvar NodeContainer = _dereq_('./nodecontainer');\nvar TextContainer = _dereq_('./textcontainer');\nvar PseudoElementContainer = _dereq_('./pseudoelementcontainer');\nvar FontMetrics = _dereq_('./fontmetrics');\nvar Color = _dereq_('./color');\nvar StackingContext = _dereq_('./stackingcontext');\nvar utils = _dereq_('./utils');\nvar bind = utils.bind;\nvar getBounds = utils.getBounds;\nvar parseBackgrounds = utils.parseBackgrounds;\nvar offsetBounds = utils.offsetBounds;\n\nfunction NodeParser(element, renderer, support, imageLoader, options) {\n    log(\"Starting NodeParser\");\n    this.renderer = renderer;\n    this.options = options;\n    this.range = null;\n    this.support = support;\n    this.renderQueue = [];\n    this.stack = new StackingContext(true, 1, element.ownerDocument, null);\n    var parent = new NodeContainer(element, null);\n    if (options.background) {\n        renderer.rectangle(0, 0, renderer.width, renderer.height, new Color(options.background));\n    }\n    if (element === element.ownerDocument.documentElement) {\n        // http://www.w3.org/TR/css3-background/#special-backgrounds\n        var canvasBackground = new NodeContainer(parent.color('backgroundColor').isTransparent() ? element.ownerDocument.body : element.ownerDocument.documentElement, null);\n        renderer.rectangle(0, 0, renderer.width, renderer.height, canvasBackground.color('backgroundColor'));\n    }\n    parent.visibile = parent.isElementVisible();\n    this.createPseudoHideStyles(element.ownerDocument);\n    this.disableAnimations(element.ownerDocument);\n    this.nodes = flatten([parent].concat(this.getChildren(parent)).filter(function(container) {\n        return container.visible = container.isElementVisible();\n    }).map(this.getPseudoElements, this));\n    this.fontMetrics = new FontMetrics();\n    log(\"Fetched nodes, total:\", this.nodes.length);\n    log(\"Calculate overflow clips\");\n    this.calculateOverflowClips();\n    log(\"Start fetching images\");\n    this.images = imageLoader.fetch(this.nodes.filter(isElement));\n    this.ready = this.images.ready.then(bind(function() {\n        log(\"Images loaded, starting parsing\");\n        log(\"Creating stacking contexts\");\n        this.createStackingContexts();\n        log(\"Sorting stacking contexts\");\n        this.sortStackingContexts(this.stack);\n        this.parse(this.stack);\n        log(\"Render queue created with \" + this.renderQueue.length + \" items\");\n        return new Promise(bind(function(resolve) {\n            if (!options.async) {\n                this.renderQueue.forEach(this.paint, this);\n                resolve();\n            } else if (typeof(options.async) === \"function\") {\n                options.async.call(this, this.renderQueue, resolve);\n            } else if (this.renderQueue.length > 0){\n                this.renderIndex = 0;\n                this.asyncRenderer(this.renderQueue, resolve);\n            } else {\n                resolve();\n            }\n        }, this));\n    }, this));\n}\n\nNodeParser.prototype.calculateOverflowClips = function() {\n    this.nodes.forEach(function(container) {\n        if (isElement(container)) {\n            if (isPseudoElement(container)) {\n                container.appendToDOM();\n            }\n            container.borders = this.parseBorders(container);\n            var clip = (container.css('overflow') === \"hidden\") ? [container.borders.clip] : [];\n            var cssClip = container.parseClip();\n            if (cssClip && [\"absolute\", \"fixed\"].indexOf(container.css('position')) !== -1) {\n                clip.push([[\"rect\",\n                        container.bounds.left + cssClip.left,\n                        container.bounds.top + cssClip.top,\n                        cssClip.right - cssClip.left,\n                        cssClip.bottom - cssClip.top\n                ]]);\n            }\n            container.clip = hasParentClip(container) ? container.parent.clip.concat(clip) : clip;\n            container.backgroundClip = (container.css('overflow') !== \"hidden\") ? container.clip.concat([container.borders.clip]) : container.clip;\n            if (isPseudoElement(container)) {\n                container.cleanDOM();\n            }\n        } else if (isTextNode(container)) {\n            container.clip = hasParentClip(container) ? container.parent.clip : [];\n        }\n        if (!isPseudoElement(container)) {\n            container.bounds = null;\n        }\n    }, this);\n};\n\nfunction hasParentClip(container) {\n    return container.parent && container.parent.clip.length;\n}\n\nNodeParser.prototype.asyncRenderer = function(queue, resolve, asyncTimer) {\n    asyncTimer = asyncTimer || Date.now();\n    this.paint(queue[this.renderIndex++]);\n    if (queue.length === this.renderIndex) {\n        resolve();\n    } else if (asyncTimer + 20 > Date.now()) {\n        this.asyncRenderer(queue, resolve, asyncTimer);\n    } else {\n        setTimeout(bind(function() {\n            this.asyncRenderer(queue, resolve);\n        }, this), 0);\n    }\n};\n\nNodeParser.prototype.createPseudoHideStyles = function(document) {\n    this.createStyles(document, '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + ':before { content: \"\" !important; display: none !important; }' +\n        '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER + ':after { content: \"\" !important; display: none !important; }');\n};\n\nNodeParser.prototype.disableAnimations = function(document) {\n    this.createStyles(document, '* { -webkit-animation: none !important; -moz-animation: none !important; -o-animation: none !important; animation: none !important; ' +\n        '-webkit-transition: none !important; -moz-transition: none !important; -o-transition: none !important; transition: none !important;}');\n};\n\nNodeParser.prototype.createStyles = function(document, styles) {\n    var hidePseudoElements = document.createElement('style');\n    hidePseudoElements.innerHTML = styles;\n    document.body.appendChild(hidePseudoElements);\n};\n\nNodeParser.prototype.getPseudoElements = function(container) {\n    var nodes = [[container]];\n    if (container.node.nodeType === Node.ELEMENT_NODE) {\n        var before = this.getPseudoElement(container, \":before\");\n        var after = this.getPseudoElement(container, \":after\");\n\n        if (before) {\n            nodes.push(before);\n        }\n\n        if (after) {\n            nodes.push(after);\n        }\n    }\n    return flatten(nodes);\n};\n\nfunction toCamelCase(str) {\n    return str.replace(/(\\-[a-z])/g, function(match){\n        return match.toUpperCase().replace('-','');\n    });\n}\n\nNodeParser.prototype.getPseudoElement = function(container, type) {\n    var style = container.computedStyle(type);\n    if(!style || !style.content || style.content === \"none\" || style.content === \"-moz-alt-content\" || style.display === \"none\") {\n        return null;\n    }\n\n    var content = stripQuotes(style.content);\n    var isImage = content.substr(0, 3) === 'url';\n    var pseudoNode = document.createElement(isImage ? 'img' : 'html2canvaspseudoelement');\n    var pseudoContainer = new PseudoElementContainer(pseudoNode, container, type);\n\n    for (var i = style.length-1; i >= 0; i--) {\n        var property = toCamelCase(style.item(i));\n        pseudoNode.style[property] = style[property];\n    }\n\n    pseudoNode.className = PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + \" \" + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER;\n\n    if (isImage) {\n        pseudoNode.src = parseBackgrounds(content)[0].args[0];\n        return [pseudoContainer];\n    } else {\n        var text = document.createTextNode(content);\n        pseudoNode.appendChild(text);\n        return [pseudoContainer, new TextContainer(text, pseudoContainer)];\n    }\n};\n\n\nNodeParser.prototype.getChildren = function(parentContainer) {\n    return flatten([].filter.call(parentContainer.node.childNodes, renderableNode).map(function(node) {\n        var container = [node.nodeType === Node.TEXT_NODE ? new TextContainer(node, parentContainer) : new NodeContainer(node, parentContainer)].filter(nonIgnoredElement);\n        return node.nodeType === Node.ELEMENT_NODE && container.length && node.tagName !== \"TEXTAREA\" ? (container[0].isElementVisible() ? container.concat(this.getChildren(container[0])) : []) : container;\n    }, this));\n};\n\nNodeParser.prototype.newStackingContext = function(container, hasOwnStacking) {\n    var stack = new StackingContext(hasOwnStacking, container.getOpacity(), container.node, container.parent);\n    container.cloneTo(stack);\n    var parentStack = hasOwnStacking ? stack.getParentStack(this) : stack.parent.stack;\n    parentStack.contexts.push(stack);\n    container.stack = stack;\n};\n\nNodeParser.prototype.createStackingContexts = function() {\n    this.nodes.forEach(function(container) {\n        if (isElement(container) && (this.isRootElement(container) || hasOpacity(container) || isPositionedForStacking(container) || this.isBodyWithTransparentRoot(container) || container.hasTransform())) {\n            this.newStackingContext(container, true);\n        } else if (isElement(container) && ((isPositioned(container) && zIndex0(container)) || isInlineBlock(container) || isFloating(container))) {\n            this.newStackingContext(container, false);\n        } else {\n            container.assignStack(container.parent.stack);\n        }\n    }, this);\n};\n\nNodeParser.prototype.isBodyWithTransparentRoot = function(container) {\n    return container.node.nodeName === \"BODY\" && container.parent.color('backgroundColor').isTransparent();\n};\n\nNodeParser.prototype.isRootElement = function(container) {\n    return container.parent === null;\n};\n\nNodeParser.prototype.sortStackingContexts = function(stack) {\n    stack.contexts.sort(zIndexSort(stack.contexts.slice(0)));\n    stack.contexts.forEach(this.sortStackingContexts, this);\n};\n\nNodeParser.prototype.parseTextBounds = function(container) {\n    return function(text, index, textList) {\n        if (container.parent.css(\"textDecoration\").substr(0, 4) !== \"none\" || text.trim().length !== 0) {\n            if (this.support.rangeBounds && !container.parent.hasTransform()) {\n                var offset = textList.slice(0, index).join(\"\").length;\n                return this.getRangeBounds(container.node, offset, text.length);\n            } else if (container.node && typeof(container.node.data) === \"string\") {\n                var replacementNode = container.node.splitText(text.length);\n                var bounds = this.getWrapperBounds(container.node, container.parent.hasTransform());\n                container.node = replacementNode;\n                return bounds;\n            }\n        } else if(!this.support.rangeBounds || container.parent.hasTransform()){\n            container.node = container.node.splitText(text.length);\n        }\n        return {};\n    };\n};\n\nNodeParser.prototype.getWrapperBounds = function(node, transform) {\n    var wrapper = node.ownerDocument.createElement('html2canvaswrapper');\n    var parent = node.parentNode,\n        backupText = node.cloneNode(true);\n\n    wrapper.appendChild(node.cloneNode(true));\n    parent.replaceChild(wrapper, node);\n    var bounds = transform ? offsetBounds(wrapper) : getBounds(wrapper);\n    parent.replaceChild(backupText, wrapper);\n    return bounds;\n};\n\nNodeParser.prototype.getRangeBounds = function(node, offset, length) {\n    var range = this.range || (this.range = node.ownerDocument.createRange());\n    range.setStart(node, offset);\n    range.setEnd(node, offset + length);\n    return range.getBoundingClientRect();\n};\n\nfunction ClearTransform() {}\n\nNodeParser.prototype.parse = function(stack) {\n    // http://www.w3.org/TR/CSS21/visuren.html#z-index\n    var negativeZindex = stack.contexts.filter(negativeZIndex); // 2. the child stacking contexts with negative stack levels (most negative first).\n    var descendantElements = stack.children.filter(isElement);\n    var descendantNonFloats = descendantElements.filter(not(isFloating));\n    var nonInlineNonPositionedDescendants = descendantNonFloats.filter(not(isPositioned)).filter(not(inlineLevel)); // 3 the in-flow, non-inline-level, non-positioned descendants.\n    var nonPositionedFloats = descendantElements.filter(not(isPositioned)).filter(isFloating); // 4. the non-positioned floats.\n    var inFlow = descendantNonFloats.filter(not(isPositioned)).filter(inlineLevel); // 5. the in-flow, inline-level, non-positioned descendants, including inline tables and inline blocks.\n    var stackLevel0 = stack.contexts.concat(descendantNonFloats.filter(isPositioned)).filter(zIndex0); // 6. the child stacking contexts with stack level 0 and the positioned descendants with stack level 0.\n    var text = stack.children.filter(isTextNode).filter(hasText);\n    var positiveZindex = stack.contexts.filter(positiveZIndex); // 7. the child stacking contexts with positive stack levels (least positive first).\n    negativeZindex.concat(nonInlineNonPositionedDescendants).concat(nonPositionedFloats)\n        .concat(inFlow).concat(stackLevel0).concat(text).concat(positiveZindex).forEach(function(container) {\n            this.renderQueue.push(container);\n            if (isStackingContext(container)) {\n                this.parse(container);\n                this.renderQueue.push(new ClearTransform());\n            }\n        }, this);\n};\n\nNodeParser.prototype.paint = function(container) {\n    try {\n        if (container instanceof ClearTransform) {\n            this.renderer.ctx.restore();\n        } else if (isTextNode(container)) {\n            if (isPseudoElement(container.parent)) {\n                container.parent.appendToDOM();\n            }\n            this.paintText(container);\n            if (isPseudoElement(container.parent)) {\n                container.parent.cleanDOM();\n            }\n        } else {\n            this.paintNode(container);\n        }\n    } catch(e) {\n        log(e);\n        if (this.options.strict) {\n            throw e;\n        }\n    }\n};\n\nNodeParser.prototype.paintNode = function(container) {\n    if (isStackingContext(container)) {\n        this.renderer.setOpacity(container.opacity);\n        this.renderer.ctx.save();\n        if (container.hasTransform()) {\n            this.renderer.setTransform(container.parseTransform());\n        }\n    }\n\n    if (container.node.nodeName === \"INPUT\" && container.node.type === \"checkbox\") {\n        this.paintCheckbox(container);\n    } else if (container.node.nodeName === \"INPUT\" && container.node.type === \"radio\") {\n        this.paintRadio(container);\n    } else {\n        this.paintElement(container);\n    }\n};\n\nNodeParser.prototype.paintElement = function(container) {\n    var bounds = container.parseBounds();\n    this.renderer.clip(container.backgroundClip, function() {\n        this.renderer.renderBackground(container, bounds, container.borders.borders.map(getWidth));\n    }, this);\n\n    this.renderer.clip(container.clip, function() {\n        this.renderer.renderBorders(container.borders.borders);\n    }, this);\n\n    this.renderer.clip(container.backgroundClip, function() {\n        switch (container.node.nodeName) {\n        case \"svg\":\n        case \"IFRAME\":\n            var imgContainer = this.images.get(container.node);\n            if (imgContainer) {\n                this.renderer.renderImage(container, bounds, container.borders, imgContainer);\n            } else {\n                log(\"Error loading <\" + container.node.nodeName + \">\", container.node);\n            }\n            break;\n        case \"IMG\":\n            var imageContainer = this.images.get(container.node.src);\n            if (imageContainer) {\n                this.renderer.renderImage(container, bounds, container.borders, imageContainer);\n            } else {\n                log(\"Error loading <img>\", container.node.src);\n            }\n            break;\n        case \"CANVAS\":\n            this.renderer.renderImage(container, bounds, container.borders, {image: container.node});\n            break;\n        case \"SELECT\":\n        case \"INPUT\":\n        case \"TEXTAREA\":\n            this.paintFormValue(container);\n            break;\n        }\n    }, this);\n};\n\nNodeParser.prototype.paintCheckbox = function(container) {\n    var b = container.parseBounds();\n\n    var size = Math.min(b.width, b.height);\n    var bounds = {width: size - 1, height: size - 1, top: b.top, left: b.left};\n    var r = [3, 3];\n    var radius = [r, r, r, r];\n    var borders = [1,1,1,1].map(function(w) {\n        return {color: new Color('#A5A5A5'), width: w};\n    });\n\n    var borderPoints = calculateCurvePoints(bounds, radius, borders);\n\n    this.renderer.clip(container.backgroundClip, function() {\n        this.renderer.rectangle(bounds.left + 1, bounds.top + 1, bounds.width - 2, bounds.height - 2, new Color(\"#DEDEDE\"));\n        this.renderer.renderBorders(calculateBorders(borders, bounds, borderPoints, radius));\n        if (container.node.checked) {\n            this.renderer.font(new Color('#424242'), 'normal', 'normal', 'bold', (size - 3) + \"px\", 'arial');\n            this.renderer.text(\"\\u2714\", bounds.left + size / 6, bounds.top + size - 1);\n        }\n    }, this);\n};\n\nNodeParser.prototype.paintRadio = function(container) {\n    var bounds = container.parseBounds();\n\n    var size = Math.min(bounds.width, bounds.height) - 2;\n\n    this.renderer.clip(container.backgroundClip, function() {\n        this.renderer.circleStroke(bounds.left + 1, bounds.top + 1, size, new Color('#DEDEDE'), 1, new Color('#A5A5A5'));\n        if (container.node.checked) {\n            this.renderer.circle(Math.ceil(bounds.left + size / 4) + 1, Math.ceil(bounds.top + size / 4) + 1, Math.floor(size / 2), new Color('#424242'));\n        }\n    }, this);\n};\n\nNodeParser.prototype.paintFormValue = function(container) {\n    var value = container.getValue();\n    if (value.length > 0) {\n        var document = container.node.ownerDocument;\n        var wrapper = document.createElement('html2canvaswrapper');\n        var properties = ['lineHeight', 'textAlign', 'fontFamily', 'fontWeight', 'fontSize', 'color',\n            'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom',\n            'width', 'height', 'borderLeftStyle', 'borderTopStyle', 'borderLeftWidth', 'borderTopWidth',\n            'boxSizing', 'whiteSpace', 'wordWrap'];\n\n        properties.forEach(function(property) {\n            try {\n                wrapper.style[property] = container.css(property);\n            } catch(e) {\n                // Older IE has issues with \"border\"\n                log(\"html2canvas: Parse: Exception caught in renderFormValue: \" + e.message);\n            }\n        });\n        var bounds = container.parseBounds();\n        wrapper.style.position = \"fixed\";\n        wrapper.style.left = bounds.left + \"px\";\n        wrapper.style.top = bounds.top + \"px\";\n        wrapper.textContent = value;\n        document.body.appendChild(wrapper);\n        this.paintText(new TextContainer(wrapper.firstChild, container));\n        document.body.removeChild(wrapper);\n    }\n};\n\nNodeParser.prototype.paintText = function(container) {\n    container.applyTextTransform();\n    var characters = punycode.ucs2.decode(container.node.data);\n    var textList = (!this.options.letterRendering || noLetterSpacing(container)) && !hasUnicode(container.node.data) ? getWords(characters) : characters.map(function(character) {\n        return punycode.ucs2.encode([character]);\n    });\n\n    var weight = container.parent.fontWeight();\n    var size = container.parent.css('fontSize');\n    var family = container.parent.css('fontFamily');\n    var shadows = container.parent.parseTextShadows();\n\n    this.renderer.font(container.parent.color('color'), container.parent.css('fontStyle'), container.parent.css('fontVariant'), weight, size, family);\n    if (shadows.length) {\n        // TODO: support multiple text shadows\n        this.renderer.fontShadow(shadows[0].color, shadows[0].offsetX, shadows[0].offsetY, shadows[0].blur);\n    } else {\n        this.renderer.clearShadow();\n    }\n\n    this.renderer.clip(container.parent.clip, function() {\n        textList.map(this.parseTextBounds(container), this).forEach(function(bounds, index) {\n            if (bounds) {\n                this.renderer.text(textList[index], bounds.left, bounds.bottom);\n                this.renderTextDecoration(container.parent, bounds, this.fontMetrics.getMetrics(family, size));\n            }\n        }, this);\n    }, this);\n};\n\nNodeParser.prototype.renderTextDecoration = function(container, bounds, metrics) {\n    switch(container.css(\"textDecoration\").split(\" \")[0]) {\n    case \"underline\":\n        // Draws a line at the baseline of the font\n        // TODO As some browsers display the line as more than 1px if the font-size is big, need to take that into account both in position and size\n        this.renderer.rectangle(bounds.left, Math.round(bounds.top + metrics.baseline + metrics.lineWidth), bounds.width, 1, container.color(\"color\"));\n        break;\n    case \"overline\":\n        this.renderer.rectangle(bounds.left, Math.round(bounds.top), bounds.width, 1, container.color(\"color\"));\n        break;\n    case \"line-through\":\n        // TODO try and find exact position for line-through\n        this.renderer.rectangle(bounds.left, Math.ceil(bounds.top + metrics.middle + metrics.lineWidth), bounds.width, 1, container.color(\"color\"));\n        break;\n    }\n};\n\nvar borderColorTransforms = {\n    inset: [\n        [\"darken\", 0.60],\n        [\"darken\", 0.10],\n        [\"darken\", 0.10],\n        [\"darken\", 0.60]\n    ]\n};\n\nNodeParser.prototype.parseBorders = function(container) {\n    var nodeBounds = container.parseBounds();\n    var radius = getBorderRadiusData(container);\n    var borders = [\"Top\", \"Right\", \"Bottom\", \"Left\"].map(function(side, index) {\n        var style = container.css('border' + side + 'Style');\n        var color = container.color('border' + side + 'Color');\n        if (style === \"inset\" && color.isBlack()) {\n            color = new Color([255, 255, 255, color.a]); // this is wrong, but\n        }\n        var colorTransform = borderColorTransforms[style] ? borderColorTransforms[style][index] : null;\n        return {\n            width: container.cssInt('border' + side + 'Width'),\n            color: colorTransform ? color[colorTransform[0]](colorTransform[1]) : color,\n            args: null\n        };\n    });\n    var borderPoints = calculateCurvePoints(nodeBounds, radius, borders);\n\n    return {\n        clip: this.parseBackgroundClip(container, borderPoints, borders, radius, nodeBounds),\n        borders: calculateBorders(borders, nodeBounds, borderPoints, radius)\n    };\n};\n\nfunction calculateBorders(borders, nodeBounds, borderPoints, radius) {\n    return borders.map(function(border, borderSide) {\n        if (border.width > 0) {\n            var bx = nodeBounds.left;\n            var by = nodeBounds.top;\n            var bw = nodeBounds.width;\n            var bh = nodeBounds.height - (borders[2].width);\n\n            switch(borderSide) {\n            case 0:\n                // top border\n                bh = borders[0].width;\n                border.args = drawSide({\n                        c1: [bx, by],\n                        c2: [bx + bw, by],\n                        c3: [bx + bw - borders[1].width, by + bh],\n                        c4: [bx + borders[3].width, by + bh]\n                    }, radius[0], radius[1],\n                    borderPoints.topLeftOuter, borderPoints.topLeftInner, borderPoints.topRightOuter, borderPoints.topRightInner);\n                break;\n            case 1:\n                // right border\n                bx = nodeBounds.left + nodeBounds.width - (borders[1].width);\n                bw = borders[1].width;\n\n                border.args = drawSide({\n                        c1: [bx + bw, by],\n                        c2: [bx + bw, by + bh + borders[2].width],\n                        c3: [bx, by + bh],\n                        c4: [bx, by + borders[0].width]\n                    }, radius[1], radius[2],\n                    borderPoints.topRightOuter, borderPoints.topRightInner, borderPoints.bottomRightOuter, borderPoints.bottomRightInner);\n                break;\n            case 2:\n                // bottom border\n                by = (by + nodeBounds.height) - (borders[2].width);\n                bh = borders[2].width;\n                border.args = drawSide({\n                        c1: [bx + bw, by + bh],\n                        c2: [bx, by + bh],\n                        c3: [bx + borders[3].width, by],\n                        c4: [bx + bw - borders[3].width, by]\n                    }, radius[2], radius[3],\n                    borderPoints.bottomRightOuter, borderPoints.bottomRightInner, borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner);\n                break;\n            case 3:\n                // left border\n                bw = borders[3].width;\n                border.args = drawSide({\n                        c1: [bx, by + bh + borders[2].width],\n                        c2: [bx, by],\n                        c3: [bx + bw, by + borders[0].width],\n                        c4: [bx + bw, by + bh]\n                    }, radius[3], radius[0],\n                    borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner, borderPoints.topLeftOuter, borderPoints.topLeftInner);\n                break;\n            }\n        }\n        return border;\n    });\n}\n\nNodeParser.prototype.parseBackgroundClip = function(container, borderPoints, borders, radius, bounds) {\n    var backgroundClip = container.css('backgroundClip'),\n        borderArgs = [];\n\n    switch(backgroundClip) {\n    case \"content-box\":\n    case \"padding-box\":\n        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftInner, borderPoints.topRightInner, bounds.left + borders[3].width, bounds.top + borders[0].width);\n        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightInner, borderPoints.bottomRightInner, bounds.left + bounds.width - borders[1].width, bounds.top + borders[0].width);\n        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightInner, borderPoints.bottomLeftInner, bounds.left + bounds.width - borders[1].width, bounds.top + bounds.height - borders[2].width);\n        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftInner, borderPoints.topLeftInner, bounds.left + borders[3].width, bounds.top + bounds.height - borders[2].width);\n        break;\n\n    default:\n        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftOuter, borderPoints.topRightOuter, bounds.left, bounds.top);\n        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightOuter, borderPoints.bottomRightOuter, bounds.left + bounds.width, bounds.top);\n        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightOuter, borderPoints.bottomLeftOuter, bounds.left + bounds.width, bounds.top + bounds.height);\n        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftOuter, borderPoints.topLeftOuter, bounds.left, bounds.top + bounds.height);\n        break;\n    }\n\n    return borderArgs;\n};\n\nfunction getCurvePoints(x, y, r1, r2) {\n    var kappa = 4 * ((Math.sqrt(2) - 1) / 3);\n    var ox = (r1) * kappa, // control point offset horizontal\n        oy = (r2) * kappa, // control point offset vertical\n        xm = x + r1, // x-middle\n        ym = y + r2; // y-middle\n    return {\n        topLeft: bezierCurve({x: x, y: ym}, {x: x, y: ym - oy}, {x: xm - ox, y: y}, {x: xm, y: y}),\n        topRight: bezierCurve({x: x, y: y}, {x: x + ox,y: y}, {x: xm, y: ym - oy}, {x: xm, y: ym}),\n        bottomRight: bezierCurve({x: xm, y: y}, {x: xm, y: y + oy}, {x: x + ox, y: ym}, {x: x, y: ym}),\n        bottomLeft: bezierCurve({x: xm, y: ym}, {x: xm - ox, y: ym}, {x: x, y: y + oy}, {x: x, y:y})\n    };\n}\n\nfunction calculateCurvePoints(bounds, borderRadius, borders) {\n    var x = bounds.left,\n        y = bounds.top,\n        width = bounds.width,\n        height = bounds.height,\n\n        tlh = borderRadius[0][0] < width / 2 ? borderRadius[0][0] : width / 2,\n        tlv = borderRadius[0][1] < height / 2 ? borderRadius[0][1] : height / 2,\n        trh = borderRadius[1][0] < width / 2 ? borderRadius[1][0] : width / 2,\n        trv = borderRadius[1][1] < height / 2 ? borderRadius[1][1] : height / 2,\n        brh = borderRadius[2][0] < width / 2 ? borderRadius[2][0] : width / 2,\n        brv = borderRadius[2][1] < height / 2 ? borderRadius[2][1] : height / 2,\n        blh = borderRadius[3][0] < width / 2 ? borderRadius[3][0] : width / 2,\n        blv = borderRadius[3][1] < height / 2 ? borderRadius[3][1] : height / 2;\n\n    var topWidth = width - trh,\n        rightHeight = height - brv,\n        bottomWidth = width - brh,\n        leftHeight = height - blv;\n\n    return {\n        topLeftOuter: getCurvePoints(x, y, tlh, tlv).topLeft.subdivide(0.5),\n        topLeftInner: getCurvePoints(x + borders[3].width, y + borders[0].width, Math.max(0, tlh - borders[3].width), Math.max(0, tlv - borders[0].width)).topLeft.subdivide(0.5),\n        topRightOuter: getCurvePoints(x + topWidth, y, trh, trv).topRight.subdivide(0.5),\n        topRightInner: getCurvePoints(x + Math.min(topWidth, width + borders[3].width), y + borders[0].width, (topWidth > width + borders[3].width) ? 0 :trh - borders[3].width, trv - borders[0].width).topRight.subdivide(0.5),\n        bottomRightOuter: getCurvePoints(x + bottomWidth, y + rightHeight, brh, brv).bottomRight.subdivide(0.5),\n        bottomRightInner: getCurvePoints(x + Math.min(bottomWidth, width - borders[3].width), y + Math.min(rightHeight, height + borders[0].width), Math.max(0, brh - borders[1].width),  brv - borders[2].width).bottomRight.subdivide(0.5),\n        bottomLeftOuter: getCurvePoints(x, y + leftHeight, blh, blv).bottomLeft.subdivide(0.5),\n        bottomLeftInner: getCurvePoints(x + borders[3].width, y + leftHeight, Math.max(0, blh - borders[3].width), blv - borders[2].width).bottomLeft.subdivide(0.5)\n    };\n}\n\nfunction bezierCurve(start, startControl, endControl, end) {\n    var lerp = function (a, b, t) {\n        return {\n            x: a.x + (b.x - a.x) * t,\n            y: a.y + (b.y - a.y) * t\n        };\n    };\n\n    return {\n        start: start,\n        startControl: startControl,\n        endControl: endControl,\n        end: end,\n        subdivide: function(t) {\n            var ab = lerp(start, startControl, t),\n                bc = lerp(startControl, endControl, t),\n                cd = lerp(endControl, end, t),\n                abbc = lerp(ab, bc, t),\n                bccd = lerp(bc, cd, t),\n                dest = lerp(abbc, bccd, t);\n            return [bezierCurve(start, ab, abbc, dest), bezierCurve(dest, bccd, cd, end)];\n        },\n        curveTo: function(borderArgs) {\n            borderArgs.push([\"bezierCurve\", startControl.x, startControl.y, endControl.x, endControl.y, end.x, end.y]);\n        },\n        curveToReversed: function(borderArgs) {\n            borderArgs.push([\"bezierCurve\", endControl.x, endControl.y, startControl.x, startControl.y, start.x, start.y]);\n        }\n    };\n}\n\nfunction drawSide(borderData, radius1, radius2, outer1, inner1, outer2, inner2) {\n    var borderArgs = [];\n\n    if (radius1[0] > 0 || radius1[1] > 0) {\n        borderArgs.push([\"line\", outer1[1].start.x, outer1[1].start.y]);\n        outer1[1].curveTo(borderArgs);\n    } else {\n        borderArgs.push([ \"line\", borderData.c1[0], borderData.c1[1]]);\n    }\n\n    if (radius2[0] > 0 || radius2[1] > 0) {\n        borderArgs.push([\"line\", outer2[0].start.x, outer2[0].start.y]);\n        outer2[0].curveTo(borderArgs);\n        borderArgs.push([\"line\", inner2[0].end.x, inner2[0].end.y]);\n        inner2[0].curveToReversed(borderArgs);\n    } else {\n        borderArgs.push([\"line\", borderData.c2[0], borderData.c2[1]]);\n        borderArgs.push([\"line\", borderData.c3[0], borderData.c3[1]]);\n    }\n\n    if (radius1[0] > 0 || radius1[1] > 0) {\n        borderArgs.push([\"line\", inner1[1].end.x, inner1[1].end.y]);\n        inner1[1].curveToReversed(borderArgs);\n    } else {\n        borderArgs.push([\"line\", borderData.c4[0], borderData.c4[1]]);\n    }\n\n    return borderArgs;\n}\n\nfunction parseCorner(borderArgs, radius1, radius2, corner1, corner2, x, y) {\n    if (radius1[0] > 0 || radius1[1] > 0) {\n        borderArgs.push([\"line\", corner1[0].start.x, corner1[0].start.y]);\n        corner1[0].curveTo(borderArgs);\n        corner1[1].curveTo(borderArgs);\n    } else {\n        borderArgs.push([\"line\", x, y]);\n    }\n\n    if (radius2[0] > 0 || radius2[1] > 0) {\n        borderArgs.push([\"line\", corner2[0].start.x, corner2[0].start.y]);\n    }\n}\n\nfunction negativeZIndex(container) {\n    return container.cssInt(\"zIndex\") < 0;\n}\n\nfunction positiveZIndex(container) {\n    return container.cssInt(\"zIndex\") > 0;\n}\n\nfunction zIndex0(container) {\n    return container.cssInt(\"zIndex\") === 0;\n}\n\nfunction inlineLevel(container) {\n    return [\"inline\", \"inline-block\", \"inline-table\"].indexOf(container.css(\"display\")) !== -1;\n}\n\nfunction isStackingContext(container) {\n    return (container instanceof StackingContext);\n}\n\nfunction hasText(container) {\n    return container.node.data.trim().length > 0;\n}\n\nfunction noLetterSpacing(container) {\n    return (/^(normal|none|0px)$/.test(container.parent.css(\"letterSpacing\")));\n}\n\nfunction getBorderRadiusData(container) {\n    return [\"TopLeft\", \"TopRight\", \"BottomRight\", \"BottomLeft\"].map(function(side) {\n        var value = container.css('border' + side + 'Radius');\n        var arr = value.split(\" \");\n        if (arr.length <= 1) {\n            arr[1] = arr[0];\n        }\n        return arr.map(asInt);\n    });\n}\n\nfunction renderableNode(node) {\n    return (node.nodeType === Node.TEXT_NODE || node.nodeType === Node.ELEMENT_NODE);\n}\n\nfunction isPositionedForStacking(container) {\n    var position = container.css(\"position\");\n    var zIndex = ([\"absolute\", \"relative\", \"fixed\"].indexOf(position) !== -1) ? container.css(\"zIndex\") : \"auto\";\n    return zIndex !== \"auto\";\n}\n\nfunction isPositioned(container) {\n    return container.css(\"position\") !== \"static\";\n}\n\nfunction isFloating(container) {\n    return container.css(\"float\") !== \"none\";\n}\n\nfunction isInlineBlock(container) {\n    return [\"inline-block\", \"inline-table\"].indexOf(container.css(\"display\")) !== -1;\n}\n\nfunction not(callback) {\n    var context = this;\n    return function() {\n        return !callback.apply(context, arguments);\n    };\n}\n\nfunction isElement(container) {\n    return container.node.nodeType === Node.ELEMENT_NODE;\n}\n\nfunction isPseudoElement(container) {\n    return container.isPseudoElement === true;\n}\n\nfunction isTextNode(container) {\n    return container.node.nodeType === Node.TEXT_NODE;\n}\n\nfunction zIndexSort(contexts) {\n    return function(a, b) {\n        return (a.cssInt(\"zIndex\") + (contexts.indexOf(a) / contexts.length)) - (b.cssInt(\"zIndex\") + (contexts.indexOf(b) / contexts.length));\n    };\n}\n\nfunction hasOpacity(container) {\n    return container.getOpacity() < 1;\n}\n\nfunction asInt(value) {\n    return parseInt(value, 10);\n}\n\nfunction getWidth(border) {\n    return border.width;\n}\n\nfunction nonIgnoredElement(nodeContainer) {\n    return (nodeContainer.node.nodeType !== Node.ELEMENT_NODE || [\"SCRIPT\", \"HEAD\", \"TITLE\", \"OBJECT\", \"BR\", \"OPTION\"].indexOf(nodeContainer.node.nodeName) === -1);\n}\n\nfunction flatten(arrays) {\n    return [].concat.apply([], arrays);\n}\n\nfunction stripQuotes(content) {\n    var first = content.substr(0, 1);\n    return (first === content.substr(content.length - 1) && first.match(/'|\"/)) ? content.substr(1, content.length - 2) : content;\n}\n\nfunction getWords(characters) {\n    var words = [], i = 0, onWordBoundary = false, word;\n    while(characters.length) {\n        if (isWordBoundary(characters[i]) === onWordBoundary) {\n            word = characters.splice(0, i);\n            if (word.length) {\n                words.push(punycode.ucs2.encode(word));\n            }\n            onWordBoundary =! onWordBoundary;\n            i = 0;\n        } else {\n            i++;\n        }\n\n        if (i >= characters.length) {\n            word = characters.splice(0, i);\n            if (word.length) {\n                words.push(punycode.ucs2.encode(word));\n            }\n        }\n    }\n    return words;\n}\n\nfunction isWordBoundary(characterCode) {\n    return [\n        32, // <space>\n        13, // \\r\n        10, // \\n\n        9, // \\t\n        45 // -\n    ].indexOf(characterCode) !== -1;\n}\n\nfunction hasUnicode(string) {\n    return (/[^\\u0000-\\u00ff]/).test(string);\n}\n\nmodule.exports = NodeParser;\n\n},{\"./color\":3,\"./fontmetrics\":7,\"./log\":13,\"./nodecontainer\":14,\"./pseudoelementcontainer\":18,\"./stackingcontext\":21,\"./textcontainer\":25,\"./utils\":26,\"punycode\":1}],16:[function(_dereq_,module,exports){\nvar XHR = _dereq_('./xhr');\nvar utils = _dereq_('./utils');\nvar log = _dereq_('./log');\nvar createWindowClone = _dereq_('./clone');\nvar decode64 = utils.decode64;\n\nfunction Proxy(src, proxyUrl, document) {\n    var supportsCORS = ('withCredentials' in new XMLHttpRequest());\n    if (!proxyUrl) {\n        return Promise.reject(\"No proxy configured\");\n    }\n    var callback = createCallback(supportsCORS);\n    var url = createProxyUrl(proxyUrl, src, callback);\n\n    return supportsCORS ? XHR(url) : (jsonp(document, url, callback).then(function(response) {\n        return decode64(response.content);\n    }));\n}\nvar proxyCount = 0;\n\nfunction ProxyURL(src, proxyUrl, document) {\n    var supportsCORSImage = ('crossOrigin' in new Image());\n    var callback = createCallback(supportsCORSImage);\n    var url = createProxyUrl(proxyUrl, src, callback);\n    return (supportsCORSImage ? Promise.resolve(url) : jsonp(document, url, callback).then(function(response) {\n        return \"data:\" + response.type + \";base64,\" + response.content;\n    }));\n}\n\nfunction jsonp(document, url, callback) {\n    return new Promise(function(resolve, reject) {\n        var s = document.createElement(\"script\");\n        var cleanup = function() {\n            delete window.html2canvas.proxy[callback];\n            document.body.removeChild(s);\n        };\n        window.html2canvas.proxy[callback] = function(response) {\n            cleanup();\n            resolve(response);\n        };\n        s.src = url;\n        s.onerror = function(e) {\n            cleanup();\n            reject(e);\n        };\n        document.body.appendChild(s);\n    });\n}\n\nfunction createCallback(useCORS) {\n    return !useCORS ? \"html2canvas_\" + Date.now() + \"_\" + (++proxyCount) + \"_\" + Math.round(Math.random() * 100000) : \"\";\n}\n\nfunction createProxyUrl(proxyUrl, src, callback) {\n    return proxyUrl + \"?url=\" + encodeURIComponent(src) + (callback.length ? \"&callback=html2canvas.proxy.\" + callback : \"\");\n}\n\nfunction documentFromHTML(src) {\n    return function(html) {\n        var parser = new DOMParser(), doc;\n        try {\n            doc = parser.parseFromString(html, \"text/html\");\n        } catch(e) {\n            log(\"DOMParser not supported, falling back to createHTMLDocument\");\n            doc = document.implementation.createHTMLDocument(\"\");\n            try {\n                doc.open();\n                doc.write(html);\n                doc.close();\n            } catch(ee) {\n                log(\"createHTMLDocument write not supported, falling back to document.body.innerHTML\");\n                doc.body.innerHTML = html; // ie9 doesnt support writing to documentElement\n            }\n        }\n\n        var b = doc.querySelector(\"base\");\n        if (!b || !b.href.host) {\n            var base = doc.createElement(\"base\");\n            base.href = src;\n            doc.head.insertBefore(base, doc.head.firstChild);\n        }\n\n        return doc;\n    };\n}\n\nfunction loadUrlDocument(src, proxy, document, width, height, options) {\n    return new Proxy(src, proxy, window.document).then(documentFromHTML(src)).then(function(doc) {\n        return createWindowClone(doc, document, width, height, options, 0, 0);\n    });\n}\n\nexports.Proxy = Proxy;\nexports.ProxyURL = ProxyURL;\nexports.loadUrlDocument = loadUrlDocument;\n\n},{\"./clone\":2,\"./log\":13,\"./utils\":26,\"./xhr\":28}],17:[function(_dereq_,module,exports){\nvar ProxyURL = _dereq_('./proxy').ProxyURL;\n\nfunction ProxyImageContainer(src, proxy) {\n    var link = document.createElement(\"a\");\n    link.href = src;\n    src = link.href;\n    this.src = src;\n    this.image = new Image();\n    var self = this;\n    this.promise = new Promise(function(resolve, reject) {\n        self.image.crossOrigin = \"Anonymous\";\n        self.image.onload = resolve;\n        self.image.onerror = reject;\n\n        new ProxyURL(src, proxy, document).then(function(url) {\n            self.image.src = url;\n        })['catch'](reject);\n    });\n}\n\nmodule.exports = ProxyImageContainer;\n\n},{\"./proxy\":16}],18:[function(_dereq_,module,exports){\nvar NodeContainer = _dereq_('./nodecontainer');\n\nfunction PseudoElementContainer(node, parent, type) {\n    NodeContainer.call(this, node, parent);\n    this.isPseudoElement = true;\n    this.before = type === \":before\";\n}\n\nPseudoElementContainer.prototype.cloneTo = function(stack) {\n    PseudoElementContainer.prototype.cloneTo.call(this, stack);\n    stack.isPseudoElement = true;\n    stack.before = this.before;\n};\n\nPseudoElementContainer.prototype = Object.create(NodeContainer.prototype);\n\nPseudoElementContainer.prototype.appendToDOM = function() {\n    if (this.before) {\n        this.parent.node.insertBefore(this.node, this.parent.node.firstChild);\n    } else {\n        this.parent.node.appendChild(this.node);\n    }\n    this.parent.node.className += \" \" + this.getHideClass();\n};\n\nPseudoElementContainer.prototype.cleanDOM = function() {\n    this.node.parentNode.removeChild(this.node);\n    this.parent.node.className = this.parent.node.className.replace(this.getHideClass(), \"\");\n};\n\nPseudoElementContainer.prototype.getHideClass = function() {\n    return this[\"PSEUDO_HIDE_ELEMENT_CLASS_\" + (this.before ? \"BEFORE\" : \"AFTER\")];\n};\n\nPseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE = \"___html2canvas___pseudoelement_before\";\nPseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER = \"___html2canvas___pseudoelement_after\";\n\nmodule.exports = PseudoElementContainer;\n\n},{\"./nodecontainer\":14}],19:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\n\nfunction Renderer(width, height, images, options, document) {\n    this.width = width;\n    this.height = height;\n    this.images = images;\n    this.options = options;\n    this.document = document;\n}\n\nRenderer.prototype.renderImage = function(container, bounds, borderData, imageContainer) {\n    var paddingLeft = container.cssInt('paddingLeft'),\n        paddingTop = container.cssInt('paddingTop'),\n        paddingRight = container.cssInt('paddingRight'),\n        paddingBottom = container.cssInt('paddingBottom'),\n        borders = borderData.borders;\n\n    var width = bounds.width - (borders[1].width + borders[3].width + paddingLeft + paddingRight);\n    var height = bounds.height - (borders[0].width + borders[2].width + paddingTop + paddingBottom);\n    this.drawImage(\n        imageContainer,\n        0,\n        0,\n        imageContainer.image.width || width,\n        imageContainer.image.height || height,\n        bounds.left + paddingLeft + borders[3].width,\n        bounds.top + paddingTop + borders[0].width,\n        width,\n        height\n    );\n};\n\nRenderer.prototype.renderBackground = function(container, bounds, borderData) {\n    if (bounds.height > 0 && bounds.width > 0) {\n        this.renderBackgroundColor(container, bounds);\n        this.renderBackgroundImage(container, bounds, borderData);\n    }\n};\n\nRenderer.prototype.renderBackgroundColor = function(container, bounds) {\n    var color = container.color(\"backgroundColor\");\n    if (!color.isTransparent()) {\n        this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, color);\n    }\n};\n\nRenderer.prototype.renderBorders = function(borders) {\n    borders.forEach(this.renderBorder, this);\n};\n\nRenderer.prototype.renderBorder = function(data) {\n    if (!data.color.isTransparent() && data.args !== null) {\n        this.drawShape(data.args, data.color);\n    }\n};\n\nRenderer.prototype.renderBackgroundImage = function(container, bounds, borderData) {\n    var backgroundImages = container.parseBackgroundImages();\n    backgroundImages.reverse().forEach(function(backgroundImage, index, arr) {\n        switch(backgroundImage.method) {\n        case \"url\":\n            var image = this.images.get(backgroundImage.args[0]);\n            if (image) {\n                this.renderBackgroundRepeating(container, bounds, image, arr.length - (index+1), borderData);\n            } else {\n                log(\"Error loading background-image\", backgroundImage.args[0]);\n            }\n            break;\n        case \"linear-gradient\":\n        case \"gradient\":\n            var gradientImage = this.images.get(backgroundImage.value);\n            if (gradientImage) {\n                this.renderBackgroundGradient(gradientImage, bounds, borderData);\n            } else {\n                log(\"Error loading background-image\", backgroundImage.args[0]);\n            }\n            break;\n        case \"none\":\n            break;\n        default:\n            log(\"Unknown background-image type\", backgroundImage.args[0]);\n        }\n    }, this);\n};\n\nRenderer.prototype.renderBackgroundRepeating = function(container, bounds, imageContainer, index, borderData) {\n    var size = container.parseBackgroundSize(bounds, imageContainer.image, index);\n    var position = container.parseBackgroundPosition(bounds, imageContainer.image, index, size);\n    var repeat = container.parseBackgroundRepeat(index);\n    switch (repeat) {\n    case \"repeat-x\":\n    case \"repeat no-repeat\":\n        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + borderData[3], bounds.top + position.top + borderData[0], 99999, size.height, borderData);\n        break;\n    case \"repeat-y\":\n    case \"no-repeat repeat\":\n        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + borderData[0], size.width, 99999, borderData);\n        break;\n    case \"no-repeat\":\n        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + position.top + borderData[0], size.width, size.height, borderData);\n        break;\n    default:\n        this.renderBackgroundRepeat(imageContainer, position, size, {top: bounds.top, left: bounds.left}, borderData[3], borderData[0]);\n        break;\n    }\n};\n\nmodule.exports = Renderer;\n\n},{\"./log\":13}],20:[function(_dereq_,module,exports){\nvar Renderer = _dereq_('../renderer');\nvar LinearGradientContainer = _dereq_('../lineargradientcontainer');\nvar log = _dereq_('../log');\n\nfunction CanvasRenderer(width, height) {\n    Renderer.apply(this, arguments);\n    this.canvas = this.options.canvas || this.document.createElement(\"canvas\");\n    if (!this.options.canvas) {\n        this.canvas.width = width;\n        this.canvas.height = height;\n    }\n    this.ctx = this.canvas.getContext(\"2d\");\n    this.taintCtx = this.document.createElement(\"canvas\").getContext(\"2d\");\n    this.ctx.textBaseline = \"bottom\";\n    this.variables = {};\n    log(\"Initialized CanvasRenderer with size\", width, \"x\", height);\n}\n\nCanvasRenderer.prototype = Object.create(Renderer.prototype);\n\nCanvasRenderer.prototype.setFillStyle = function(fillStyle) {\n    this.ctx.fillStyle = typeof(fillStyle) === \"object\" && !!fillStyle.isColor ? fillStyle.toString() : fillStyle;\n    return this.ctx;\n};\n\nCanvasRenderer.prototype.rectangle = function(left, top, width, height, color) {\n    this.setFillStyle(color).fillRect(left, top, width, height);\n};\n\nCanvasRenderer.prototype.circle = function(left, top, size, color) {\n    this.setFillStyle(color);\n    this.ctx.beginPath();\n    this.ctx.arc(left + size / 2, top + size / 2, size / 2, 0, Math.PI*2, true);\n    this.ctx.closePath();\n    this.ctx.fill();\n};\n\nCanvasRenderer.prototype.circleStroke = function(left, top, size, color, stroke, strokeColor) {\n    this.circle(left, top, size, color);\n    this.ctx.strokeStyle = strokeColor.toString();\n    this.ctx.stroke();\n};\n\nCanvasRenderer.prototype.drawShape = function(shape, color) {\n    this.shape(shape);\n    this.setFillStyle(color).fill();\n};\n\nCanvasRenderer.prototype.taints = function(imageContainer) {\n    if (imageContainer.tainted === null) {\n        this.taintCtx.drawImage(imageContainer.image, 0, 0);\n        try {\n            this.taintCtx.getImageData(0, 0, 1, 1);\n            imageContainer.tainted = false;\n        } catch(e) {\n            this.taintCtx = document.createElement(\"canvas\").getContext(\"2d\");\n            imageContainer.tainted = true;\n        }\n    }\n\n    return imageContainer.tainted;\n};\n\nCanvasRenderer.prototype.drawImage = function(imageContainer, sx, sy, sw, sh, dx, dy, dw, dh) {\n    if (!this.taints(imageContainer) || this.options.allowTaint) {\n        this.ctx.drawImage(imageContainer.image, sx, sy, sw, sh, dx, dy, dw, dh);\n    }\n};\n\nCanvasRenderer.prototype.clip = function(shapes, callback, context) {\n    this.ctx.save();\n    shapes.filter(hasEntries).forEach(function(shape) {\n        this.shape(shape).clip();\n    }, this);\n    callback.call(context);\n    this.ctx.restore();\n};\n\nCanvasRenderer.prototype.shape = function(shape) {\n    this.ctx.beginPath();\n    shape.forEach(function(point, index) {\n        if (point[0] === \"rect\") {\n            this.ctx.rect.apply(this.ctx, point.slice(1));\n        } else {\n            this.ctx[(index === 0) ? \"moveTo\" : point[0] + \"To\" ].apply(this.ctx, point.slice(1));\n        }\n    }, this);\n    this.ctx.closePath();\n    return this.ctx;\n};\n\nCanvasRenderer.prototype.font = function(color, style, variant, weight, size, family) {\n    this.setFillStyle(color).font = [style, variant, weight, size, family].join(\" \").split(\",\")[0];\n};\n\nCanvasRenderer.prototype.fontShadow = function(color, offsetX, offsetY, blur) {\n    this.setVariable(\"shadowColor\", color.toString())\n        .setVariable(\"shadowOffsetY\", offsetX)\n        .setVariable(\"shadowOffsetX\", offsetY)\n        .setVariable(\"shadowBlur\", blur);\n};\n\nCanvasRenderer.prototype.clearShadow = function() {\n    this.setVariable(\"shadowColor\", \"rgba(0,0,0,0)\");\n};\n\nCanvasRenderer.prototype.setOpacity = function(opacity) {\n    this.ctx.globalAlpha = opacity;\n};\n\nCanvasRenderer.prototype.setTransform = function(transform) {\n    this.ctx.translate(transform.origin[0], transform.origin[1]);\n    this.ctx.transform.apply(this.ctx, transform.matrix);\n    this.ctx.translate(-transform.origin[0], -transform.origin[1]);\n};\n\nCanvasRenderer.prototype.setVariable = function(property, value) {\n    if (this.variables[property] !== value) {\n        this.variables[property] = this.ctx[property] = value;\n    }\n\n    return this;\n};\n\nCanvasRenderer.prototype.text = function(text, left, bottom) {\n    this.ctx.fillText(text, left, bottom);\n};\n\nCanvasRenderer.prototype.backgroundRepeatShape = function(imageContainer, backgroundPosition, size, bounds, left, top, width, height, borderData) {\n    var shape = [\n        [\"line\", Math.round(left), Math.round(top)],\n        [\"line\", Math.round(left + width), Math.round(top)],\n        [\"line\", Math.round(left + width), Math.round(height + top)],\n        [\"line\", Math.round(left), Math.round(height + top)]\n    ];\n    this.clip([shape], function() {\n        this.renderBackgroundRepeat(imageContainer, backgroundPosition, size, bounds, borderData[3], borderData[0]);\n    }, this);\n};\n\nCanvasRenderer.prototype.renderBackgroundRepeat = function(imageContainer, backgroundPosition, size, bounds, borderLeft, borderTop) {\n    var offsetX = Math.round(bounds.left + backgroundPosition.left + borderLeft), offsetY = Math.round(bounds.top + backgroundPosition.top + borderTop);\n    this.setFillStyle(this.ctx.createPattern(this.resizeImage(imageContainer, size), \"repeat\"));\n    this.ctx.translate(offsetX, offsetY);\n    this.ctx.fill();\n    this.ctx.translate(-offsetX, -offsetY);\n};\n\nCanvasRenderer.prototype.renderBackgroundGradient = function(gradientImage, bounds) {\n    if (gradientImage instanceof LinearGradientContainer) {\n        var gradient = this.ctx.createLinearGradient(\n            bounds.left + bounds.width * gradientImage.x0,\n            bounds.top + bounds.height * gradientImage.y0,\n            bounds.left +  bounds.width * gradientImage.x1,\n            bounds.top +  bounds.height * gradientImage.y1);\n        gradientImage.colorStops.forEach(function(colorStop) {\n            gradient.addColorStop(colorStop.stop, colorStop.color.toString());\n        });\n        this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, gradient);\n    }\n};\n\nCanvasRenderer.prototype.resizeImage = function(imageContainer, size) {\n    var image = imageContainer.image;\n    if(image.width === size.width && image.height === size.height) {\n        return image;\n    }\n\n    var ctx, canvas = document.createElement('canvas');\n    canvas.width = size.width;\n    canvas.height = size.height;\n    ctx = canvas.getContext(\"2d\");\n    ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, size.width, size.height );\n    return canvas;\n};\n\nfunction hasEntries(array) {\n    return array.length > 0;\n}\n\nmodule.exports = CanvasRenderer;\n\n},{\"../lineargradientcontainer\":12,\"../log\":13,\"../renderer\":19}],21:[function(_dereq_,module,exports){\nvar NodeContainer = _dereq_('./nodecontainer');\n\nfunction StackingContext(hasOwnStacking, opacity, element, parent) {\n    NodeContainer.call(this, element, parent);\n    this.ownStacking = hasOwnStacking;\n    this.contexts = [];\n    this.children = [];\n    this.opacity = (this.parent ? this.parent.stack.opacity : 1) * opacity;\n}\n\nStackingContext.prototype = Object.create(NodeContainer.prototype);\n\nStackingContext.prototype.getParentStack = function(context) {\n    var parentStack = (this.parent) ? this.parent.stack : null;\n    return parentStack ? (parentStack.ownStacking ? parentStack : parentStack.getParentStack(context)) : context.stack;\n};\n\nmodule.exports = StackingContext;\n\n},{\"./nodecontainer\":14}],22:[function(_dereq_,module,exports){\nfunction Support(document) {\n    this.rangeBounds = this.testRangeBounds(document);\n    this.cors = this.testCORS();\n    this.svg = this.testSVG();\n}\n\nSupport.prototype.testRangeBounds = function(document) {\n    var range, testElement, rangeBounds, rangeHeight, support = false;\n\n    if (document.createRange) {\n        range = document.createRange();\n        if (range.getBoundingClientRect) {\n            testElement = document.createElement('boundtest');\n            testElement.style.height = \"123px\";\n            testElement.style.display = \"block\";\n            document.body.appendChild(testElement);\n\n            range.selectNode(testElement);\n            rangeBounds = range.getBoundingClientRect();\n            rangeHeight = rangeBounds.height;\n\n            if (rangeHeight === 123) {\n                support = true;\n            }\n            document.body.removeChild(testElement);\n        }\n    }\n\n    return support;\n};\n\nSupport.prototype.testCORS = function() {\n    return typeof((new Image()).crossOrigin) !== \"undefined\";\n};\n\nSupport.prototype.testSVG = function() {\n    var img = new Image();\n    var canvas = document.createElement(\"canvas\");\n    var ctx =  canvas.getContext(\"2d\");\n    img.src = \"data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>\";\n\n    try {\n        ctx.drawImage(img, 0, 0);\n        canvas.toDataURL();\n    } catch(e) {\n        return false;\n    }\n    return true;\n};\n\nmodule.exports = Support;\n\n},{}],23:[function(_dereq_,module,exports){\nvar XHR = _dereq_('./xhr');\nvar decode64 = _dereq_('./utils').decode64;\n\nfunction SVGContainer(src) {\n    this.src = src;\n    this.image = null;\n    var self = this;\n\n    this.promise = this.hasFabric().then(function() {\n        return (self.isInline(src) ? Promise.resolve(self.inlineFormatting(src)) : XHR(src));\n    }).then(function(svg) {\n        return new Promise(function(resolve) {\n            window.html2canvas.svg.fabric.loadSVGFromString(svg, self.createCanvas.call(self, resolve));\n        });\n    });\n}\n\nSVGContainer.prototype.hasFabric = function() {\n    return !window.html2canvas.svg || !window.html2canvas.svg.fabric ? Promise.reject(new Error(\"html2canvas.svg.js is not loaded, cannot render svg\")) : Promise.resolve();\n};\n\nSVGContainer.prototype.inlineFormatting = function(src) {\n    return (/^data:image\\/svg\\+xml;base64,/.test(src)) ? this.decode64(this.removeContentType(src)) : this.removeContentType(src);\n};\n\nSVGContainer.prototype.removeContentType = function(src) {\n    return src.replace(/^data:image\\/svg\\+xml(;base64)?,/,'');\n};\n\nSVGContainer.prototype.isInline = function(src) {\n    return (/^data:image\\/svg\\+xml/i.test(src));\n};\n\nSVGContainer.prototype.createCanvas = function(resolve) {\n    var self = this;\n    return function (objects, options) {\n        var canvas = new window.html2canvas.svg.fabric.StaticCanvas('c');\n        self.image = canvas.lowerCanvasEl;\n        canvas\n            .setWidth(options.width)\n            .setHeight(options.height)\n            .add(window.html2canvas.svg.fabric.util.groupSVGElements(objects, options))\n            .renderAll();\n        resolve(canvas.lowerCanvasEl);\n    };\n};\n\nSVGContainer.prototype.decode64 = function(str) {\n    return (typeof(window.atob) === \"function\") ? window.atob(str) : decode64(str);\n};\n\nmodule.exports = SVGContainer;\n\n},{\"./utils\":26,\"./xhr\":28}],24:[function(_dereq_,module,exports){\nvar SVGContainer = _dereq_('./svgcontainer');\n\nfunction SVGNodeContainer(node, _native) {\n    this.src = node;\n    this.image = null;\n    var self = this;\n\n    this.promise = _native ? new Promise(function(resolve, reject) {\n        self.image = new Image();\n        self.image.onload = resolve;\n        self.image.onerror = reject;\n        self.image.src = \"data:image/svg+xml,\" + (new XMLSerializer()).serializeToString(node);\n        if (self.image.complete === true) {\n            resolve(self.image);\n        }\n    }) : this.hasFabric().then(function() {\n        return new Promise(function(resolve) {\n            window.html2canvas.svg.fabric.parseSVGDocument(node, self.createCanvas.call(self, resolve));\n        });\n    });\n}\n\nSVGNodeContainer.prototype = Object.create(SVGContainer.prototype);\n\nmodule.exports = SVGNodeContainer;\n\n},{\"./svgcontainer\":23}],25:[function(_dereq_,module,exports){\nvar NodeContainer = _dereq_('./nodecontainer');\n\nfunction TextContainer(node, parent) {\n    NodeContainer.call(this, node, parent);\n}\n\nTextContainer.prototype = Object.create(NodeContainer.prototype);\n\nTextContainer.prototype.applyTextTransform = function() {\n    this.node.data = this.transform(this.parent.css(\"textTransform\"));\n};\n\nTextContainer.prototype.transform = function(transform) {\n    var text = this.node.data;\n    switch(transform){\n        case \"lowercase\":\n            return text.toLowerCase();\n        case \"capitalize\":\n            return text.replace(/(^|\\s|:|-|\\(|\\))([a-z])/g, capitalize);\n        case \"uppercase\":\n            return text.toUpperCase();\n        default:\n            return text;\n    }\n};\n\nfunction capitalize(m, p1, p2) {\n    if (m.length > 0) {\n        return p1 + p2.toUpperCase();\n    }\n}\n\nmodule.exports = TextContainer;\n\n},{\"./nodecontainer\":14}],26:[function(_dereq_,module,exports){\nexports.smallImage = function smallImage() {\n    return \"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7\";\n};\n\nexports.bind = function(callback, context) {\n    return function() {\n        return callback.apply(context, arguments);\n    };\n};\n\n/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n\nexports.decode64 = function(base64) {\n    var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    var len = base64.length, i, encoded1, encoded2, encoded3, encoded4, byte1, byte2, byte3;\n\n    var output = \"\";\n\n    for (i = 0; i < len; i+=4) {\n        encoded1 = chars.indexOf(base64[i]);\n        encoded2 = chars.indexOf(base64[i+1]);\n        encoded3 = chars.indexOf(base64[i+2]);\n        encoded4 = chars.indexOf(base64[i+3]);\n\n        byte1 = (encoded1 << 2) | (encoded2 >> 4);\n        byte2 = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n        byte3 = ((encoded3 & 3) << 6) | encoded4;\n        if (encoded3 === 64) {\n            output += String.fromCharCode(byte1);\n        } else if (encoded4 === 64 || encoded4 === -1) {\n            output += String.fromCharCode(byte1, byte2);\n        } else{\n            output += String.fromCharCode(byte1, byte2, byte3);\n        }\n    }\n\n    return output;\n};\n\nexports.getBounds = function(node) {\n    if (node.getBoundingClientRect) {\n        var clientRect = node.getBoundingClientRect();\n        var width = node.offsetWidth == null ? clientRect.width : node.offsetWidth;\n        return {\n            top: clientRect.top,\n            bottom: clientRect.bottom || (clientRect.top + clientRect.height),\n            right: clientRect.left + width,\n            left: clientRect.left,\n            width:  width,\n            height: node.offsetHeight == null ? clientRect.height : node.offsetHeight\n        };\n    }\n    return {};\n};\n\nexports.offsetBounds = function(node) {\n    var parent = node.offsetParent ? exports.offsetBounds(node.offsetParent) : {top: 0, left: 0};\n\n    return {\n        top: node.offsetTop + parent.top,\n        bottom: node.offsetTop + node.offsetHeight + parent.top,\n        right: node.offsetLeft + parent.left + node.offsetWidth,\n        left: node.offsetLeft + parent.left,\n        width: node.offsetWidth,\n        height: node.offsetHeight\n    };\n};\n\nexports.parseBackgrounds = function(backgroundImage) {\n    var whitespace = ' \\r\\n\\t',\n        method, definition, prefix, prefix_i, block, results = [],\n        mode = 0, numParen = 0, quote, args;\n    var appendResult = function() {\n        if(method) {\n            if (definition.substr(0, 1) === '\"') {\n                definition = definition.substr(1, definition.length - 2);\n            }\n            if (definition) {\n                args.push(definition);\n            }\n            if (method.substr(0, 1) === '-' && (prefix_i = method.indexOf('-', 1 ) + 1) > 0) {\n                prefix = method.substr(0, prefix_i);\n                method = method.substr(prefix_i);\n            }\n            results.push({\n                prefix: prefix,\n                method: method.toLowerCase(),\n                value: block,\n                args: args,\n                image: null\n            });\n        }\n        args = [];\n        method = prefix = definition = block = '';\n    };\n    args = [];\n    method = prefix = definition = block = '';\n    backgroundImage.split(\"\").forEach(function(c) {\n        if (mode === 0 && whitespace.indexOf(c) > -1) {\n            return;\n        }\n        switch(c) {\n        case '\"':\n            if(!quote) {\n                quote = c;\n            } else if(quote === c) {\n                quote = null;\n            }\n            break;\n        case '(':\n            if(quote) {\n                break;\n            } else if(mode === 0) {\n                mode = 1;\n                block += c;\n                return;\n            } else {\n                numParen++;\n            }\n            break;\n        case ')':\n            if (quote) {\n                break;\n            } else if(mode === 1) {\n                if(numParen === 0) {\n                    mode = 0;\n                    block += c;\n                    appendResult();\n                    return;\n                } else {\n                    numParen--;\n                }\n            }\n            break;\n\n        case ',':\n            if (quote) {\n                break;\n            } else if(mode === 0) {\n                appendResult();\n                return;\n            } else if (mode === 1) {\n                if (numParen === 0 && !method.match(/^url$/i)) {\n                    args.push(definition);\n                    definition = '';\n                    block += c;\n                    return;\n                }\n            }\n            break;\n        }\n\n        block += c;\n        if (mode === 0) {\n            method += c;\n        } else {\n            definition += c;\n        }\n    });\n\n    appendResult();\n    return results;\n};\n\n},{}],27:[function(_dereq_,module,exports){\nvar GradientContainer = _dereq_('./gradientcontainer');\n\nfunction WebkitGradientContainer(imageData) {\n    GradientContainer.apply(this, arguments);\n    this.type = imageData.args[0] === \"linear\" ? GradientContainer.TYPES.LINEAR : GradientContainer.TYPES.RADIAL;\n}\n\nWebkitGradientContainer.prototype = Object.create(GradientContainer.prototype);\n\nmodule.exports = WebkitGradientContainer;\n\n},{\"./gradientcontainer\":9}],28:[function(_dereq_,module,exports){\nfunction XHR(url) {\n    return new Promise(function(resolve, reject) {\n        var xhr = new XMLHttpRequest();\n        xhr.open('GET', url);\n\n        xhr.onload = function() {\n            if (xhr.status === 200) {\n                resolve(xhr.responseText);\n            } else {\n                reject(new Error(xhr.statusText));\n            }\n        };\n\n        xhr.onerror = function() {\n            reject(new Error(\"Network Error\"));\n        };\n\n        xhr.send();\n    });\n}\n\nmodule.exports = XHR;\n\n},{}]},{},[4])(4)\n});\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n},{}],22:[function(require,module,exports){\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"QRCode2\"] = factory();\n\telse\n\t\troot[\"QRCode2\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\n\tObject.defineProperty(exports, \"__esModule\", {\n\t\tvalue: true\n\t});\n\t/**\n\t * @fileoverview\n\t * - Using the 'QRCode for Javascript library'\n\t * - Fixed dataset of 'QRCode for Javascript library' for support full-spec.\n\t * - this library has no dependencies.\n\t * \n\t * @author davidshimjs\n\t * @see <a href=\"http://www.d-project.com/\" target=\"_blank\">http://www.d-project.com/</a>\n\t * @see <a href=\"http://jeromeetienne.github.com/jquery-qrcode/\" target=\"_blank\">http://jeromeetienne.github.com/jquery-qrcode/</a>\n\t */\n\tvar QRCode;\n\n\t(function (global) {\n\t\t//---------------------------------------------------------------------\n\t\t// QRCode for JavaScript\n\t\t//\n\t\t// Copyright (c) 2009 Kazuhiko Arase\n\t\t//\n\t\t// URL: http://www.d-project.com/\n\t\t//\n\t\t// Licensed under the MIT license:\n\t\t//   http://www.opensource.org/licenses/mit-license.php\n\t\t//\n\t\t// The word \"QR Code\" is registered trademark of\n\t\t// DENSO WAVE INCORPORATED\n\t\t//   http://www.denso-wave.com/qrcode/faqpatent-e.html\n\t\t//\n\t\t//---------------------------------------------------------------------\n\t\tfunction QR8bitByte(data) {\n\t\t\tthis.mode = QRMode.MODE_8BIT_BYTE;\n\t\t\tthis.data = data;\n\t\t\tthis.parsedData = [];\n\n\t\t\t// Added to support UTF-8 Characters\n\t\t\tfor (var i = 0, l = this.data.length; i < l; i++) {\n\t\t\t\tvar byteArray = [];\n\t\t\t\tvar code = this.data.charCodeAt(i);\n\n\t\t\t\tif (code > 0x10000) {\n\t\t\t\t\tbyteArray[0] = 0xF0 | (code & 0x1C0000) >>> 18;\n\t\t\t\t\tbyteArray[1] = 0x80 | (code & 0x3F000) >>> 12;\n\t\t\t\t\tbyteArray[2] = 0x80 | (code & 0xFC0) >>> 6;\n\t\t\t\t\tbyteArray[3] = 0x80 | code & 0x3F;\n\t\t\t\t} else if (code > 0x800) {\n\t\t\t\t\tbyteArray[0] = 0xE0 | (code & 0xF000) >>> 12;\n\t\t\t\t\tbyteArray[1] = 0x80 | (code & 0xFC0) >>> 6;\n\t\t\t\t\tbyteArray[2] = 0x80 | code & 0x3F;\n\t\t\t\t} else if (code > 0x80) {\n\t\t\t\t\tbyteArray[0] = 0xC0 | (code & 0x7C0) >>> 6;\n\t\t\t\t\tbyteArray[1] = 0x80 | code & 0x3F;\n\t\t\t\t} else {\n\t\t\t\t\tbyteArray[0] = code;\n\t\t\t\t}\n\n\t\t\t\tthis.parsedData.push(byteArray);\n\t\t\t}\n\n\t\t\tthis.parsedData = Array.prototype.concat.apply([], this.parsedData);\n\n\t\t\tif (this.parsedData.length != this.data.length) {\n\t\t\t\tthis.parsedData.unshift(191);\n\t\t\t\tthis.parsedData.unshift(187);\n\t\t\t\tthis.parsedData.unshift(239);\n\t\t\t}\n\t\t}\n\n\t\tQR8bitByte.prototype = {\n\t\t\tgetLength: function getLength(buffer) {\n\t\t\t\treturn this.parsedData.length;\n\t\t\t},\n\t\t\twrite: function write(buffer) {\n\t\t\t\tfor (var i = 0, l = this.parsedData.length; i < l; i++) {\n\t\t\t\t\tbuffer.put(this.parsedData[i], 8);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tfunction QRCodeModel(typeNumber, errorCorrectLevel) {\n\t\t\tthis.typeNumber = typeNumber;\n\t\t\tthis.errorCorrectLevel = errorCorrectLevel;\n\t\t\tthis.modules = null;\n\t\t\tthis.moduleCount = 0;\n\t\t\tthis.dataCache = null;\n\t\t\tthis.dataList = [];\n\t\t}\n\n\t\tQRCodeModel.prototype = { addData: function addData(data) {\n\t\t\t\tvar newData = new QR8bitByte(data);this.dataList.push(newData);this.dataCache = null;\n\t\t\t}, isDark: function isDark(row, col) {\n\t\t\t\tif (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {\n\t\t\t\t\tthrow new Error(row + \",\" + col);\n\t\t\t\t}\n\t\t\t\treturn this.modules[row][col];\n\t\t\t}, getModuleCount: function getModuleCount() {\n\t\t\t\treturn this.moduleCount;\n\t\t\t}, make: function make() {\n\t\t\t\tthis.makeImpl(false, this.getBestMaskPattern());\n\t\t\t}, makeImpl: function makeImpl(test, maskPattern) {\n\t\t\t\tthis.moduleCount = this.typeNumber * 4 + 17;this.modules = new Array(this.moduleCount);for (var row = 0; row < this.moduleCount; row++) {\n\t\t\t\t\tthis.modules[row] = new Array(this.moduleCount);for (var col = 0; col < this.moduleCount; col++) {\n\t\t\t\t\t\tthis.modules[row][col] = null;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tthis.setupPositionProbePattern(0, 0);this.setupPositionProbePattern(this.moduleCount - 7, 0);this.setupPositionProbePattern(0, this.moduleCount - 7);this.setupPositionAdjustPattern();this.setupTimingPattern();this.setupTypeInfo(test, maskPattern);if (this.typeNumber >= 7) {\n\t\t\t\t\tthis.setupTypeNumber(test);\n\t\t\t\t}\n\t\t\t\tif (this.dataCache == null) {\n\t\t\t\t\tthis.dataCache = QRCodeModel.createData(this.typeNumber, this.errorCorrectLevel, this.dataList);\n\t\t\t\t}\n\t\t\t\tthis.mapData(this.dataCache, maskPattern);\n\t\t\t}, setupPositionProbePattern: function setupPositionProbePattern(row, col) {\n\t\t\t\tfor (var r = -1; r <= 7; r++) {\n\t\t\t\t\tif (row + r <= -1 || this.moduleCount <= row + r) continue;for (var c = -1; c <= 7; c++) {\n\t\t\t\t\t\tif (col + c <= -1 || this.moduleCount <= col + c) continue;if (0 <= r && r <= 6 && (c == 0 || c == 6) || 0 <= c && c <= 6 && (r == 0 || r == 6) || 2 <= r && r <= 4 && 2 <= c && c <= 4) {\n\t\t\t\t\t\t\tthis.modules[row + r][col + c] = true;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.modules[row + r][col + c] = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}, getBestMaskPattern: function getBestMaskPattern() {\n\t\t\t\tvar minLostPoint = 0;var pattern = 0;for (var i = 0; i < 8; i++) {\n\t\t\t\t\tthis.makeImpl(true, i);var lostPoint = QRUtil.getLostPoint(this);if (i == 0 || minLostPoint > lostPoint) {\n\t\t\t\t\t\tminLostPoint = lostPoint;pattern = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn pattern;\n\t\t\t}, createMovieClip: function createMovieClip(target_mc, instance_name, depth) {\n\t\t\t\tvar qr_mc = target_mc.createEmptyMovieClip(instance_name, depth);var cs = 1;this.make();for (var row = 0; row < this.modules.length; row++) {\n\t\t\t\t\tvar y = row * cs;for (var col = 0; col < this.modules[row].length; col++) {\n\t\t\t\t\t\tvar x = col * cs;var dark = this.modules[row][col];if (dark) {\n\t\t\t\t\t\t\tqr_mc.beginFill(0, 100);qr_mc.moveTo(x, y);qr_mc.lineTo(x + cs, y);qr_mc.lineTo(x + cs, y + cs);qr_mc.lineTo(x, y + cs);qr_mc.endFill();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn qr_mc;\n\t\t\t}, setupTimingPattern: function setupTimingPattern() {\n\t\t\t\tfor (var r = 8; r < this.moduleCount - 8; r++) {\n\t\t\t\t\tif (this.modules[r][6] != null) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tthis.modules[r][6] = r % 2 == 0;\n\t\t\t\t}\n\t\t\t\tfor (var c = 8; c < this.moduleCount - 8; c++) {\n\t\t\t\t\tif (this.modules[6][c] != null) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tthis.modules[6][c] = c % 2 == 0;\n\t\t\t\t}\n\t\t\t}, setupPositionAdjustPattern: function setupPositionAdjustPattern() {\n\t\t\t\tvar pos = QRUtil.getPatternPosition(this.typeNumber);for (var i = 0; i < pos.length; i++) {\n\t\t\t\t\tfor (var j = 0; j < pos.length; j++) {\n\t\t\t\t\t\tvar row = pos[i];var col = pos[j];if (this.modules[row][col] != null) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tfor (var r = -2; r <= 2; r++) {\n\t\t\t\t\t\t\tfor (var c = -2; c <= 2; c++) {\n\t\t\t\t\t\t\t\tif (r == -2 || r == 2 || c == -2 || c == 2 || r == 0 && c == 0) {\n\t\t\t\t\t\t\t\t\tthis.modules[row + r][col + c] = true;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tthis.modules[row + r][col + c] = false;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}, setupTypeNumber: function setupTypeNumber(test) {\n\t\t\t\tvar bits = QRUtil.getBCHTypeNumber(this.typeNumber);for (var i = 0; i < 18; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;\n\t\t\t\t}\n\t\t\t\tfor (var i = 0; i < 18; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;this.modules[i % 3 + this.moduleCount - 8 - 3][Math.floor(i / 3)] = mod;\n\t\t\t\t}\n\t\t\t}, setupTypeInfo: function setupTypeInfo(test, maskPattern) {\n\t\t\t\tvar data = this.errorCorrectLevel << 3 | maskPattern;var bits = QRUtil.getBCHTypeInfo(data);for (var i = 0; i < 15; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;if (i < 6) {\n\t\t\t\t\t\tthis.modules[i][8] = mod;\n\t\t\t\t\t} else if (i < 8) {\n\t\t\t\t\t\tthis.modules[i + 1][8] = mod;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.modules[this.moduleCount - 15 + i][8] = mod;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var i = 0; i < 15; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;if (i < 8) {\n\t\t\t\t\t\tthis.modules[8][this.moduleCount - i - 1] = mod;\n\t\t\t\t\t} else if (i < 9) {\n\t\t\t\t\t\tthis.modules[8][15 - i - 1 + 1] = mod;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.modules[8][15 - i - 1] = mod;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tthis.modules[this.moduleCount - 8][8] = !test;\n\t\t\t}, mapData: function mapData(data, maskPattern) {\n\t\t\t\tvar inc = -1;var row = this.moduleCount - 1;var bitIndex = 7;var byteIndex = 0;for (var col = this.moduleCount - 1; col > 0; col -= 2) {\n\t\t\t\t\tif (col == 6) col--;while (true) {\n\t\t\t\t\t\tfor (var c = 0; c < 2; c++) {\n\t\t\t\t\t\t\tif (this.modules[row][col - c] == null) {\n\t\t\t\t\t\t\t\tvar dark = false;if (byteIndex < data.length) {\n\t\t\t\t\t\t\t\t\tdark = (data[byteIndex] >>> bitIndex & 1) == 1;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tvar mask = QRUtil.getMask(maskPattern, row, col - c);if (mask) {\n\t\t\t\t\t\t\t\t\tdark = !dark;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tthis.modules[row][col - c] = dark;bitIndex--;if (bitIndex == -1) {\n\t\t\t\t\t\t\t\t\tbyteIndex++;bitIndex = 7;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\trow += inc;if (row < 0 || this.moduleCount <= row) {\n\t\t\t\t\t\t\trow -= inc;inc = -inc;break;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} };QRCodeModel.PAD0 = 0xEC;QRCodeModel.PAD1 = 0x11;QRCodeModel.createData = function (typeNumber, errorCorrectLevel, dataList) {\n\t\t\tvar rsBlocks = QRRSBlock.getRSBlocks(typeNumber, errorCorrectLevel);var buffer = new QRBitBuffer();for (var i = 0; i < dataList.length; i++) {\n\t\t\t\tvar data = dataList[i];buffer.put(data.mode, 4);buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber));data.write(buffer);\n\t\t\t}\n\t\t\tvar totalDataCount = 0;for (var i = 0; i < rsBlocks.length; i++) {\n\t\t\t\ttotalDataCount += rsBlocks[i].dataCount;\n\t\t\t}\n\t\t\tif (buffer.getLengthInBits() > totalDataCount * 8) {\n\t\t\t\tthrow new Error(\"code length overflow. (\" + buffer.getLengthInBits() + \">\" + totalDataCount * 8 + \")\");\n\t\t\t}\n\t\t\tif (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {\n\t\t\t\tbuffer.put(0, 4);\n\t\t\t}\n\t\t\twhile (buffer.getLengthInBits() % 8 != 0) {\n\t\t\t\tbuffer.putBit(false);\n\t\t\t}\n\t\t\twhile (true) {\n\t\t\t\tif (buffer.getLengthInBits() >= totalDataCount * 8) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tbuffer.put(QRCodeModel.PAD0, 8);if (buffer.getLengthInBits() >= totalDataCount * 8) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tbuffer.put(QRCodeModel.PAD1, 8);\n\t\t\t}\n\t\t\treturn QRCodeModel.createBytes(buffer, rsBlocks);\n\t\t};QRCodeModel.createBytes = function (buffer, rsBlocks) {\n\t\t\tvar offset = 0;var maxDcCount = 0;var maxEcCount = 0;var dcdata = new Array(rsBlocks.length);var ecdata = new Array(rsBlocks.length);for (var r = 0; r < rsBlocks.length; r++) {\n\t\t\t\tvar dcCount = rsBlocks[r].dataCount;var ecCount = rsBlocks[r].totalCount - dcCount;maxDcCount = Math.max(maxDcCount, dcCount);maxEcCount = Math.max(maxEcCount, ecCount);dcdata[r] = new Array(dcCount);for (var i = 0; i < dcdata[r].length; i++) {\n\t\t\t\t\tdcdata[r][i] = 0xff & buffer.buffer[i + offset];\n\t\t\t\t}\n\t\t\t\toffset += dcCount;var rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount);var rawPoly = new QRPolynomial(dcdata[r], rsPoly.getLength() - 1);var modPoly = rawPoly.mod(rsPoly);ecdata[r] = new Array(rsPoly.getLength() - 1);for (var i = 0; i < ecdata[r].length; i++) {\n\t\t\t\t\tvar modIndex = i + modPoly.getLength() - ecdata[r].length;ecdata[r][i] = modIndex >= 0 ? modPoly.get(modIndex) : 0;\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar totalCodeCount = 0;for (var i = 0; i < rsBlocks.length; i++) {\n\t\t\t\ttotalCodeCount += rsBlocks[i].totalCount;\n\t\t\t}\n\t\t\tvar data = new Array(totalCodeCount);var index = 0;for (var i = 0; i < maxDcCount; i++) {\n\t\t\t\tfor (var r = 0; r < rsBlocks.length; r++) {\n\t\t\t\t\tif (i < dcdata[r].length) {\n\t\t\t\t\t\tdata[index++] = dcdata[r][i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i = 0; i < maxEcCount; i++) {\n\t\t\t\tfor (var r = 0; r < rsBlocks.length; r++) {\n\t\t\t\t\tif (i < ecdata[r].length) {\n\t\t\t\t\t\tdata[index++] = ecdata[r][i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn data;\n\t\t};var QRMode = { MODE_NUMBER: 1 << 0, MODE_ALPHA_NUM: 1 << 1, MODE_8BIT_BYTE: 1 << 2, MODE_KANJI: 1 << 3 };var QRErrorCorrectLevel = { L: 1, M: 0, Q: 3, H: 2 };var QRMaskPattern = { PATTERN000: 0, PATTERN001: 1, PATTERN010: 2, PATTERN011: 3, PATTERN100: 4, PATTERN101: 5, PATTERN110: 6, PATTERN111: 7 };var QRUtil = { PATTERN_POSITION_TABLE: [[], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34], [6, 22, 38], [6, 24, 42], [6, 26, 46], [6, 28, 50], [6, 30, 54], [6, 32, 58], [6, 34, 62], [6, 26, 46, 66], [6, 26, 48, 70], [6, 26, 50, 74], [6, 30, 54, 78], [6, 30, 56, 82], [6, 30, 58, 86], [6, 34, 62, 90], [6, 28, 50, 72, 94], [6, 26, 50, 74, 98], [6, 30, 54, 78, 102], [6, 28, 54, 80, 106], [6, 32, 58, 84, 110], [6, 30, 58, 86, 114], [6, 34, 62, 90, 118], [6, 26, 50, 74, 98, 122], [6, 30, 54, 78, 102, 126], [6, 26, 52, 78, 104, 130], [6, 30, 56, 82, 108, 134], [6, 34, 60, 86, 112, 138], [6, 30, 58, 86, 114, 142], [6, 34, 62, 90, 118, 146], [6, 30, 54, 78, 102, 126, 150], [6, 24, 50, 76, 102, 128, 154], [6, 28, 54, 80, 106, 132, 158], [6, 32, 58, 84, 110, 136, 162], [6, 26, 54, 82, 110, 138, 166], [6, 30, 58, 86, 114, 142, 170]], G15: 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0, G18: 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0, G15_MASK: 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1, getBCHTypeInfo: function getBCHTypeInfo(data) {\n\t\t\t\tvar d = data << 10;while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) >= 0) {\n\t\t\t\t\td ^= QRUtil.G15 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15);\n\t\t\t\t}\n\t\t\t\treturn (data << 10 | d) ^ QRUtil.G15_MASK;\n\t\t\t}, getBCHTypeNumber: function getBCHTypeNumber(data) {\n\t\t\t\tvar d = data << 12;while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) >= 0) {\n\t\t\t\t\td ^= QRUtil.G18 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18);\n\t\t\t\t}\n\t\t\t\treturn data << 12 | d;\n\t\t\t}, getBCHDigit: function getBCHDigit(data) {\n\t\t\t\tvar digit = 0;while (data != 0) {\n\t\t\t\t\tdigit++;data >>>= 1;\n\t\t\t\t}\n\t\t\t\treturn digit;\n\t\t\t}, getPatternPosition: function getPatternPosition(typeNumber) {\n\t\t\t\treturn QRUtil.PATTERN_POSITION_TABLE[typeNumber - 1];\n\t\t\t}, getMask: function getMask(maskPattern, i, j) {\n\t\t\t\tswitch (maskPattern) {case QRMaskPattern.PATTERN000:\n\t\t\t\t\t\treturn (i + j) % 2 == 0;case QRMaskPattern.PATTERN001:\n\t\t\t\t\t\treturn i % 2 == 0;case QRMaskPattern.PATTERN010:\n\t\t\t\t\t\treturn j % 3 == 0;case QRMaskPattern.PATTERN011:\n\t\t\t\t\t\treturn (i + j) % 3 == 0;case QRMaskPattern.PATTERN100:\n\t\t\t\t\t\treturn (Math.floor(i / 2) + Math.floor(j / 3)) % 2 == 0;case QRMaskPattern.PATTERN101:\n\t\t\t\t\t\treturn i * j % 2 + i * j % 3 == 0;case QRMaskPattern.PATTERN110:\n\t\t\t\t\t\treturn (i * j % 2 + i * j % 3) % 2 == 0;case QRMaskPattern.PATTERN111:\n\t\t\t\t\t\treturn (i * j % 3 + (i + j) % 2) % 2 == 0;default:\n\t\t\t\t\t\tthrow new Error(\"bad maskPattern:\" + maskPattern);}\n\t\t\t}, getErrorCorrectPolynomial: function getErrorCorrectPolynomial(errorCorrectLength) {\n\t\t\t\tvar a = new QRPolynomial([1], 0);for (var i = 0; i < errorCorrectLength; i++) {\n\t\t\t\t\ta = a.multiply(new QRPolynomial([1, QRMath.gexp(i)], 0));\n\t\t\t\t}\n\t\t\t\treturn a;\n\t\t\t}, getLengthInBits: function getLengthInBits(mode, type) {\n\t\t\t\tif (1 <= type && type < 10) {\n\t\t\t\t\tswitch (mode) {case QRMode.MODE_NUMBER:\n\t\t\t\t\t\t\treturn 10;case QRMode.MODE_ALPHA_NUM:\n\t\t\t\t\t\t\treturn 9;case QRMode.MODE_8BIT_BYTE:\n\t\t\t\t\t\t\treturn 8;case QRMode.MODE_KANJI:\n\t\t\t\t\t\t\treturn 8;default:\n\t\t\t\t\t\t\tthrow new Error(\"mode:\" + mode);}\n\t\t\t\t} else if (type < 27) {\n\t\t\t\t\tswitch (mode) {case QRMode.MODE_NUMBER:\n\t\t\t\t\t\t\treturn 12;case QRMode.MODE_ALPHA_NUM:\n\t\t\t\t\t\t\treturn 11;case QRMode.MODE_8BIT_BYTE:\n\t\t\t\t\t\t\treturn 16;case QRMode.MODE_KANJI:\n\t\t\t\t\t\t\treturn 10;default:\n\t\t\t\t\t\t\tthrow new Error(\"mode:\" + mode);}\n\t\t\t\t} else if (type < 41) {\n\t\t\t\t\tswitch (mode) {case QRMode.MODE_NUMBER:\n\t\t\t\t\t\t\treturn 14;case QRMode.MODE_ALPHA_NUM:\n\t\t\t\t\t\t\treturn 13;case QRMode.MODE_8BIT_BYTE:\n\t\t\t\t\t\t\treturn 16;case QRMode.MODE_KANJI:\n\t\t\t\t\t\t\treturn 12;default:\n\t\t\t\t\t\t\tthrow new Error(\"mode:\" + mode);}\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error(\"type:\" + type);\n\t\t\t\t}\n\t\t\t}, getLostPoint: function getLostPoint(qrCode) {\n\t\t\t\tvar moduleCount = qrCode.getModuleCount();var lostPoint = 0;for (var row = 0; row < moduleCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < moduleCount; col++) {\n\t\t\t\t\t\tvar sameCount = 0;var dark = qrCode.isDark(row, col);for (var r = -1; r <= 1; r++) {\n\t\t\t\t\t\t\tif (row + r < 0 || moduleCount <= row + r) {\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tfor (var c = -1; c <= 1; c++) {\n\t\t\t\t\t\t\t\tif (col + c < 0 || moduleCount <= col + c) {\n\t\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif (r == 0 && c == 0) {\n\t\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif (dark == qrCode.isDark(row + r, col + c)) {\n\t\t\t\t\t\t\t\t\tsameCount++;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (sameCount > 5) {\n\t\t\t\t\t\t\tlostPoint += 3 + sameCount - 5;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var row = 0; row < moduleCount - 1; row++) {\n\t\t\t\t\tfor (var col = 0; col < moduleCount - 1; col++) {\n\t\t\t\t\t\tvar count = 0;if (qrCode.isDark(row, col)) count++;if (qrCode.isDark(row + 1, col)) count++;if (qrCode.isDark(row, col + 1)) count++;if (qrCode.isDark(row + 1, col + 1)) count++;if (count == 0 || count == 4) {\n\t\t\t\t\t\t\tlostPoint += 3;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var row = 0; row < moduleCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < moduleCount - 6; col++) {\n\t\t\t\t\t\tif (qrCode.isDark(row, col) && !qrCode.isDark(row, col + 1) && qrCode.isDark(row, col + 2) && qrCode.isDark(row, col + 3) && qrCode.isDark(row, col + 4) && !qrCode.isDark(row, col + 5) && qrCode.isDark(row, col + 6)) {\n\t\t\t\t\t\t\tlostPoint += 40;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var col = 0; col < moduleCount; col++) {\n\t\t\t\t\tfor (var row = 0; row < moduleCount - 6; row++) {\n\t\t\t\t\t\tif (qrCode.isDark(row, col) && !qrCode.isDark(row + 1, col) && qrCode.isDark(row + 2, col) && qrCode.isDark(row + 3, col) && qrCode.isDark(row + 4, col) && !qrCode.isDark(row + 5, col) && qrCode.isDark(row + 6, col)) {\n\t\t\t\t\t\t\tlostPoint += 40;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tvar darkCount = 0;for (var col = 0; col < moduleCount; col++) {\n\t\t\t\t\tfor (var row = 0; row < moduleCount; row++) {\n\t\t\t\t\t\tif (qrCode.isDark(row, col)) {\n\t\t\t\t\t\t\tdarkCount++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tvar ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;lostPoint += ratio * 10;return lostPoint;\n\t\t\t} };var QRMath = { glog: function glog(n) {\n\t\t\t\tif (n < 1) {\n\t\t\t\t\tthrow new Error(\"glog(\" + n + \")\");\n\t\t\t\t}\n\t\t\t\treturn QRMath.LOG_TABLE[n];\n\t\t\t}, gexp: function gexp(n) {\n\t\t\t\twhile (n < 0) {\n\t\t\t\t\tn += 255;\n\t\t\t\t}\n\t\t\t\twhile (n >= 256) {\n\t\t\t\t\tn -= 255;\n\t\t\t\t}\n\t\t\t\treturn QRMath.EXP_TABLE[n];\n\t\t\t}, EXP_TABLE: new Array(256), LOG_TABLE: new Array(256) };for (var i = 0; i < 8; i++) {\n\t\t\tQRMath.EXP_TABLE[i] = 1 << i;\n\t\t}\n\t\tfor (var i = 8; i < 256; i++) {\n\t\t\tQRMath.EXP_TABLE[i] = QRMath.EXP_TABLE[i - 4] ^ QRMath.EXP_TABLE[i - 5] ^ QRMath.EXP_TABLE[i - 6] ^ QRMath.EXP_TABLE[i - 8];\n\t\t}\n\t\tfor (var i = 0; i < 255; i++) {\n\t\t\tQRMath.LOG_TABLE[QRMath.EXP_TABLE[i]] = i;\n\t\t}\n\t\tfunction QRPolynomial(num, shift) {\n\t\t\tif (num.length == undefined) {\n\t\t\t\tthrow new Error(num.length + \"/\" + shift);\n\t\t\t}\n\t\t\tvar offset = 0;while (offset < num.length && num[offset] == 0) {\n\t\t\t\toffset++;\n\t\t\t}\n\t\t\tthis.num = new Array(num.length - offset + shift);for (var i = 0; i < num.length - offset; i++) {\n\t\t\t\tthis.num[i] = num[i + offset];\n\t\t\t}\n\t\t}\n\t\tQRPolynomial.prototype = { get: function get(index) {\n\t\t\t\treturn this.num[index];\n\t\t\t}, getLength: function getLength() {\n\t\t\t\treturn this.num.length;\n\t\t\t}, multiply: function multiply(e) {\n\t\t\t\tvar num = new Array(this.getLength() + e.getLength() - 1);for (var i = 0; i < this.getLength(); i++) {\n\t\t\t\t\tfor (var j = 0; j < e.getLength(); j++) {\n\t\t\t\t\t\tnum[i + j] ^= QRMath.gexp(QRMath.glog(this.get(i)) + QRMath.glog(e.get(j)));\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn new QRPolynomial(num, 0);\n\t\t\t}, mod: function mod(e) {\n\t\t\t\tif (this.getLength() - e.getLength() < 0) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tvar ratio = QRMath.glog(this.get(0)) - QRMath.glog(e.get(0));var num = new Array(this.getLength());for (var i = 0; i < this.getLength(); i++) {\n\t\t\t\t\tnum[i] = this.get(i);\n\t\t\t\t}\n\t\t\t\tfor (var i = 0; i < e.getLength(); i++) {\n\t\t\t\t\tnum[i] ^= QRMath.gexp(QRMath.glog(e.get(i)) + ratio);\n\t\t\t\t}\n\t\t\t\treturn new QRPolynomial(num, 0).mod(e);\n\t\t\t} };function QRRSBlock(totalCount, dataCount) {\n\t\t\tthis.totalCount = totalCount;this.dataCount = dataCount;\n\t\t}\n\t\tQRRSBlock.RS_BLOCK_TABLE = [[1, 26, 19], [1, 26, 16], [1, 26, 13], [1, 26, 9], [1, 44, 34], [1, 44, 28], [1, 44, 22], [1, 44, 16], [1, 70, 55], [1, 70, 44], [2, 35, 17], [2, 35, 13], [1, 100, 80], [2, 50, 32], [2, 50, 24], [4, 25, 9], [1, 134, 108], [2, 67, 43], [2, 33, 15, 2, 34, 16], [2, 33, 11, 2, 34, 12], [2, 86, 68], [4, 43, 27], [4, 43, 19], [4, 43, 15], [2, 98, 78], [4, 49, 31], [2, 32, 14, 4, 33, 15], [4, 39, 13, 1, 40, 14], [2, 121, 97], [2, 60, 38, 2, 61, 39], [4, 40, 18, 2, 41, 19], [4, 40, 14, 2, 41, 15], [2, 146, 116], [3, 58, 36, 2, 59, 37], [4, 36, 16, 4, 37, 17], [4, 36, 12, 4, 37, 13], [2, 86, 68, 2, 87, 69], [4, 69, 43, 1, 70, 44], [6, 43, 19, 2, 44, 20], [6, 43, 15, 2, 44, 16], [4, 101, 81], [1, 80, 50, 4, 81, 51], [4, 50, 22, 4, 51, 23], [3, 36, 12, 8, 37, 13], [2, 116, 92, 2, 117, 93], [6, 58, 36, 2, 59, 37], [4, 46, 20, 6, 47, 21], [7, 42, 14, 4, 43, 15], [4, 133, 107], [8, 59, 37, 1, 60, 38], [8, 44, 20, 4, 45, 21], [12, 33, 11, 4, 34, 12], [3, 145, 115, 1, 146, 116], [4, 64, 40, 5, 65, 41], [11, 36, 16, 5, 37, 17], [11, 36, 12, 5, 37, 13], [5, 109, 87, 1, 110, 88], [5, 65, 41, 5, 66, 42], [5, 54, 24, 7, 55, 25], [11, 36, 12], [5, 122, 98, 1, 123, 99], [7, 73, 45, 3, 74, 46], [15, 43, 19, 2, 44, 20], [3, 45, 15, 13, 46, 16], [1, 135, 107, 5, 136, 108], [10, 74, 46, 1, 75, 47], [1, 50, 22, 15, 51, 23], [2, 42, 14, 17, 43, 15], [5, 150, 120, 1, 151, 121], [9, 69, 43, 4, 70, 44], [17, 50, 22, 1, 51, 23], [2, 42, 14, 19, 43, 15], [3, 141, 113, 4, 142, 114], [3, 70, 44, 11, 71, 45], [17, 47, 21, 4, 48, 22], [9, 39, 13, 16, 40, 14], [3, 135, 107, 5, 136, 108], [3, 67, 41, 13, 68, 42], [15, 54, 24, 5, 55, 25], [15, 43, 15, 10, 44, 16], [4, 144, 116, 4, 145, 117], [17, 68, 42], [17, 50, 22, 6, 51, 23], [19, 46, 16, 6, 47, 17], [2, 139, 111, 7, 140, 112], [17, 74, 46], [7, 54, 24, 16, 55, 25], [34, 37, 13], [4, 151, 121, 5, 152, 122], [4, 75, 47, 14, 76, 48], [11, 54, 24, 14, 55, 25], [16, 45, 15, 14, 46, 16], [6, 147, 117, 4, 148, 118], [6, 73, 45, 14, 74, 46], [11, 54, 24, 16, 55, 25], [30, 46, 16, 2, 47, 17], [8, 132, 106, 4, 133, 107], [8, 75, 47, 13, 76, 48], [7, 54, 24, 22, 55, 25], [22, 45, 15, 13, 46, 16], [10, 142, 114, 2, 143, 115], [19, 74, 46, 4, 75, 47], [28, 50, 22, 6, 51, 23], [33, 46, 16, 4, 47, 17], [8, 152, 122, 4, 153, 123], [22, 73, 45, 3, 74, 46], [8, 53, 23, 26, 54, 24], [12, 45, 15, 28, 46, 16], [3, 147, 117, 10, 148, 118], [3, 73, 45, 23, 74, 46], [4, 54, 24, 31, 55, 25], [11, 45, 15, 31, 46, 16], [7, 146, 116, 7, 147, 117], [21, 73, 45, 7, 74, 46], [1, 53, 23, 37, 54, 24], [19, 45, 15, 26, 46, 16], [5, 145, 115, 10, 146, 116], [19, 75, 47, 10, 76, 48], [15, 54, 24, 25, 55, 25], [23, 45, 15, 25, 46, 16], [13, 145, 115, 3, 146, 116], [2, 74, 46, 29, 75, 47], [42, 54, 24, 1, 55, 25], [23, 45, 15, 28, 46, 16], [17, 145, 115], [10, 74, 46, 23, 75, 47], [10, 54, 24, 35, 55, 25], [19, 45, 15, 35, 46, 16], [17, 145, 115, 1, 146, 116], [14, 74, 46, 21, 75, 47], [29, 54, 24, 19, 55, 25], [11, 45, 15, 46, 46, 16], [13, 145, 115, 6, 146, 116], [14, 74, 46, 23, 75, 47], [44, 54, 24, 7, 55, 25], [59, 46, 16, 1, 47, 17], [12, 151, 121, 7, 152, 122], [12, 75, 47, 26, 76, 48], [39, 54, 24, 14, 55, 25], [22, 45, 15, 41, 46, 16], [6, 151, 121, 14, 152, 122], [6, 75, 47, 34, 76, 48], [46, 54, 24, 10, 55, 25], [2, 45, 15, 64, 46, 16], [17, 152, 122, 4, 153, 123], [29, 74, 46, 14, 75, 47], [49, 54, 24, 10, 55, 25], [24, 45, 15, 46, 46, 16], [4, 152, 122, 18, 153, 123], [13, 74, 46, 32, 75, 47], [48, 54, 24, 14, 55, 25], [42, 45, 15, 32, 46, 16], [20, 147, 117, 4, 148, 118], [40, 75, 47, 7, 76, 48], [43, 54, 24, 22, 55, 25], [10, 45, 15, 67, 46, 16], [19, 148, 118, 6, 149, 119], [18, 75, 47, 31, 76, 48], [34, 54, 24, 34, 55, 25], [20, 45, 15, 61, 46, 16]];QRRSBlock.getRSBlocks = function (typeNumber, errorCorrectLevel) {\n\t\t\tvar rsBlock = QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);if (rsBlock == undefined) {\n\t\t\t\tthrow new Error(\"bad rs block @ typeNumber:\" + typeNumber + \"/errorCorrectLevel:\" + errorCorrectLevel);\n\t\t\t}\n\t\t\tvar length = rsBlock.length / 3;var list = [];for (var i = 0; i < length; i++) {\n\t\t\t\tvar count = rsBlock[i * 3 + 0];var totalCount = rsBlock[i * 3 + 1];var dataCount = rsBlock[i * 3 + 2];for (var j = 0; j < count; j++) {\n\t\t\t\t\tlist.push(new QRRSBlock(totalCount, dataCount));\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn list;\n\t\t};QRRSBlock.getRsBlockTable = function (typeNumber, errorCorrectLevel) {\n\t\t\tswitch (errorCorrectLevel) {case QRErrorCorrectLevel.L:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];case QRErrorCorrectLevel.M:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];case QRErrorCorrectLevel.Q:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];case QRErrorCorrectLevel.H:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];default:\n\t\t\t\t\treturn undefined;}\n\t\t};function QRBitBuffer() {\n\t\t\tthis.buffer = [];this.length = 0;\n\t\t}\n\t\tQRBitBuffer.prototype = { get: function get(index) {\n\t\t\t\tvar bufIndex = Math.floor(index / 8);return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;\n\t\t\t}, put: function put(num, length) {\n\t\t\t\tfor (var i = 0; i < length; i++) {\n\t\t\t\t\tthis.putBit((num >>> length - i - 1 & 1) == 1);\n\t\t\t\t}\n\t\t\t}, getLengthInBits: function getLengthInBits() {\n\t\t\t\treturn this.length;\n\t\t\t}, putBit: function putBit(bit) {\n\t\t\t\tvar bufIndex = Math.floor(this.length / 8);if (this.buffer.length <= bufIndex) {\n\t\t\t\t\tthis.buffer.push(0);\n\t\t\t\t}\n\t\t\t\tif (bit) {\n\t\t\t\t\tthis.buffer[bufIndex] |= 0x80 >>> this.length % 8;\n\t\t\t\t}\n\t\t\t\tthis.length++;\n\t\t\t} };var QRCodeLimitLength = [[17, 14, 11, 7], [32, 26, 20, 14], [53, 42, 32, 24], [78, 62, 46, 34], [106, 84, 60, 44], [134, 106, 74, 58], [154, 122, 86, 64], [192, 152, 108, 84], [230, 180, 130, 98], [271, 213, 151, 119], [321, 251, 177, 137], [367, 287, 203, 155], [425, 331, 241, 177], [458, 362, 258, 194], [520, 412, 292, 220], [586, 450, 322, 250], [644, 504, 364, 280], [718, 560, 394, 310], [792, 624, 442, 338], [858, 666, 482, 382], [929, 711, 509, 403], [1003, 779, 565, 439], [1091, 857, 611, 461], [1171, 911, 661, 511], [1273, 997, 715, 535], [1367, 1059, 751, 593], [1465, 1125, 805, 625], [1528, 1190, 868, 658], [1628, 1264, 908, 698], [1732, 1370, 982, 742], [1840, 1452, 1030, 790], [1952, 1538, 1112, 842], [2068, 1628, 1168, 898], [2188, 1722, 1228, 958], [2303, 1809, 1283, 983], [2431, 1911, 1351, 1051], [2563, 1989, 1423, 1093], [2699, 2099, 1499, 1139], [2809, 2213, 1579, 1219], [2953, 2331, 1663, 1273]];\n\n\t\tfunction _isSupportCanvas() {\n\t\t\treturn typeof CanvasRenderingContext2D != \"undefined\";\n\t\t}\n\n\t\t// android 2.x doesn't support Data-URI spec\n\t\tfunction _getAndroid() {\n\t\t\tvar android = false;\n\t\t\tvar sAgent = navigator.userAgent;\n\n\t\t\tif (/android/i.test(sAgent)) {\n\t\t\t\t// android\n\t\t\t\tandroid = true;\n\t\t\t\tvar aMat = sAgent.toString().match(/android ([0-9]\\.[0-9])/i);\n\n\t\t\t\tif (aMat && aMat[1]) {\n\t\t\t\t\tandroid = parseFloat(aMat[1]);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn android;\n\t\t}\n\n\t\tvar svgDrawer = function () {\n\n\t\t\tvar Drawing = function Drawing(el, htOption) {\n\t\t\t\tthis._el = el;\n\t\t\t\tthis._htOption = htOption;\n\t\t\t};\n\n\t\t\tDrawing.prototype.draw = function (oQRCode) {\n\t\t\t\tvar _htOption = this._htOption;\n\t\t\t\tvar _el = this._el;\n\t\t\t\tvar nCount = oQRCode.getModuleCount();\n\t\t\t\tvar nWidth = Math.floor(_htOption.width / nCount);\n\t\t\t\tvar nHeight = Math.floor(_htOption.height / nCount);\n\n\t\t\t\tthis.clear();\n\n\t\t\t\tfunction makeSVG(tag, attrs) {\n\t\t\t\t\tvar el = document.createElementNS('http://www.w3.org/2000/svg', tag);\n\t\t\t\t\tfor (var k in attrs) {\n\t\t\t\t\t\tif (attrs.hasOwnProperty(k)) el.setAttribute(k, attrs[k]);\n\t\t\t\t\t}return el;\n\t\t\t\t}\n\n\t\t\t\tvar svg = makeSVG(\"svg\", { 'viewBox': '0 0 ' + String(nCount) + \" \" + String(nCount), 'width': '100%', 'height': '100%', 'fill': _htOption.colorLight });\n\t\t\t\tsvg.setAttributeNS(\"http://www.w3.org/2000/xmlns/\", \"xmlns:xlink\", \"http://www.w3.org/1999/xlink\");\n\t\t\t\t_el.appendChild(svg);\n\n\t\t\t\tsvg.appendChild(makeSVG(\"rect\", { \"fill\": _htOption.colorLight, \"width\": \"100%\", \"height\": \"100%\" }));\n\t\t\t\tsvg.appendChild(makeSVG(\"rect\", { \"fill\": _htOption.colorDark, \"width\": \"1\", \"height\": \"1\", \"id\": \"template\" }));\n\n\t\t\t\tfor (var row = 0; row < nCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < nCount; col++) {\n\t\t\t\t\t\tif (oQRCode.isDark(row, col)) {\n\t\t\t\t\t\t\tvar child = makeSVG(\"use\", { \"x\": String(col), \"y\": String(row) });\n\t\t\t\t\t\t\tchild.setAttributeNS(\"http://www.w3.org/1999/xlink\", \"href\", \"#template\");\n\t\t\t\t\t\t\tsvg.appendChild(child);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tDrawing.prototype.clear = function () {\n\t\t\t\twhile (this._el.hasChildNodes()) {\n\t\t\t\t\tthis._el.removeChild(this._el.lastChild);\n\t\t\t\t}\n\t\t\t};\n\t\t\treturn Drawing;\n\t\t}();\n\n\t\tvar useSVG = document.documentElement.tagName.toLowerCase() === \"svg\";\n\n\t\t// Drawing in DOM by using Table tag\n\t\tvar Drawing = useSVG ? svgDrawer : !_isSupportCanvas() ? function () {\n\t\t\tvar Drawing = function Drawing(el, htOption) {\n\t\t\t\tthis._el = el;\n\t\t\t\tthis._htOption = htOption;\n\t\t\t};\n\n\t\t\t/**\n\t   * Draw the QRCode\n\t   *\n\t   * @param {QRCode} oQRCode\n\t   */\n\t\t\tDrawing.prototype.draw = function (oQRCode) {\n\t\t\t\tvar _htOption = this._htOption;\n\t\t\t\tvar _el = this._el;\n\t\t\t\tvar nCount = oQRCode.getModuleCount();\n\t\t\t\tvar nWidth = Math.floor(_htOption.width / nCount);\n\t\t\t\tvar nHeight = Math.floor(_htOption.height / nCount);\n\t\t\t\tvar aHTML = ['<table style=\"border:0;border-collapse:collapse;\">'];\n\n\t\t\t\tfor (var row = 0; row < nCount; row++) {\n\t\t\t\t\taHTML.push('<tr>');\n\n\t\t\t\t\tfor (var col = 0; col < nCount; col++) {\n\t\t\t\t\t\taHTML.push('<td style=\"border:0;border-collapse:collapse;padding:0;margin:0;width:' + nWidth + 'px;height:' + nHeight + 'px;background-color:' + (oQRCode.isDark(row, col) ? _htOption.colorDark : _htOption.colorLight) + ';\"></td>');\n\t\t\t\t\t}\n\n\t\t\t\t\taHTML.push('</tr>');\n\t\t\t\t}\n\n\t\t\t\taHTML.push('</table>');\n\t\t\t\t_el.innerHTML = aHTML.join('');\n\n\t\t\t\t// Fix the margin values as real size.\n\t\t\t\tvar elTable = _el.childNodes[0];\n\t\t\t\tvar nLeftMarginTable = (_htOption.width - elTable.offsetWidth) / 2;\n\t\t\t\tvar nTopMarginTable = (_htOption.height - elTable.offsetHeight) / 2;\n\n\t\t\t\tif (nLeftMarginTable > 0 && nTopMarginTable > 0) {\n\t\t\t\t\telTable.style.margin = nTopMarginTable + \"px \" + nLeftMarginTable + \"px\";\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t   * Clear the QRCode\n\t   */\n\t\t\tDrawing.prototype.clear = function () {\n\t\t\t\tthis._el.innerHTML = '';\n\t\t\t};\n\n\t\t\treturn Drawing;\n\t\t}() : function () {\n\t\t\t// Drawing in Canvas\n\t\t\tfunction _onMakeImage() {\n\t\t\t\tthis._elImage.src = this._elCanvas.toDataURL(\"image/png\");\n\t\t\t\tthis._elImage.style.display = \"block\";\n\t\t\t\tthis._elCanvas.style.display = \"none\";\n\t\t\t}\n\n\t\t\t// Android 2.1 bug workaround\n\t\t\t// http://code.google.com/p/android/issues/detail?id=5141\n\t\t\tif (global._android && global._android <= 2.1) {\n\t\t\t\tvar factor = 1 / window.devicePixelRatio;\n\t\t\t\tvar drawImage = CanvasRenderingContext2D.prototype.drawImage;\n\t\t\t\tCanvasRenderingContext2D.prototype.drawImage = function (image, sx, sy, sw, sh, dx, dy, dw, dh) {\n\t\t\t\t\tif (\"nodeName\" in image && /img/i.test(image.nodeName)) {\n\t\t\t\t\t\tfor (var i = arguments.length - 1; i >= 1; i--) {\n\t\t\t\t\t\t\targuments[i] = arguments[i] * factor;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (typeof dw == \"undefined\") {\n\t\t\t\t\t\targuments[1] *= factor;\n\t\t\t\t\t\targuments[2] *= factor;\n\t\t\t\t\t\targuments[3] *= factor;\n\t\t\t\t\t\targuments[4] *= factor;\n\t\t\t\t\t}\n\n\t\t\t\t\tdrawImage.apply(this, arguments);\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t/**\n\t   * Check whether the user's browser supports Data URI or not\n\t   *\n\t   * @private\n\t   * @param {Function} fSuccess Occurs if it supports Data URI\n\t   * @param {Function} fFail Occurs if it doesn't support Data URI\n\t   */\n\t\t\tfunction _safeSetDataURI(fSuccess, fFail) {\n\t\t\t\tvar self = this;\n\t\t\t\tself._fFail = fFail;\n\t\t\t\tself._fSuccess = fSuccess;\n\n\t\t\t\t// Check it just once\n\t\t\t\tif (self._bSupportDataURI === null) {\n\t\t\t\t\tvar el = document.createElement(\"img\");\n\t\t\t\t\tvar fOnError = function fOnError() {\n\t\t\t\t\t\tself._bSupportDataURI = false;\n\n\t\t\t\t\t\tif (self._fFail) {\n\t\t\t\t\t\t\tself._fFail.call(self);\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\tvar fOnSuccess = function fOnSuccess() {\n\t\t\t\t\t\tself._bSupportDataURI = true;\n\n\t\t\t\t\t\tif (self._fSuccess) {\n\t\t\t\t\t\t\tself._fSuccess.call(self);\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\n\t\t\t\t\tel.onabort = fOnError;\n\t\t\t\t\tel.onerror = fOnError;\n\t\t\t\t\tel.onload = fOnSuccess;\n\t\t\t\t\tel.src = \"data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==\"; // the Image contains 1px data.\n\t\t\t\t\treturn;\n\t\t\t\t} else if (self._bSupportDataURI === true && self._fSuccess) {\n\t\t\t\t\tself._fSuccess.call(self);\n\t\t\t\t} else if (self._bSupportDataURI === false && self._fFail) {\n\t\t\t\t\tself._fFail.call(self);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t   * Drawing QRCode by using canvas\n\t   *\n\t   * @constructor\n\t   * @param {HTMLElement} el\n\t   * @param {Object} htOption QRCode Options\n\t   */\n\t\t\tvar Drawing = function Drawing(el, htOption) {\n\t\t\t\tthis._bIsPainted = false;\n\t\t\t\tthis._android = _getAndroid();\n\n\t\t\t\tthis._htOption = htOption;\n\t\t\t\tthis._elCanvas = document.createElement(\"canvas\");\n\t\t\t\tthis._elCanvas.width = htOption.width;\n\t\t\t\tthis._elCanvas.height = htOption.height;\n\t\t\t\tel.appendChild(this._elCanvas);\n\t\t\t\tthis._el = el;\n\t\t\t\tthis._oContext = this._elCanvas.getContext(\"2d\");\n\t\t\t\tthis._bIsPainted = false;\n\t\t\t\tthis._elImage = document.createElement(\"img\");\n\t\t\t\tthis._elImage.alt = \"Scan me!\";\n\t\t\t\tthis._elImage.style.display = \"none\";\n\t\t\t\tthis._el.appendChild(this._elImage);\n\t\t\t\tthis._bSupportDataURI = null;\n\t\t\t};\n\n\t\t\t/**\n\t   * Draw the QRCode\n\t   *\n\t   * @param {QRCode} oQRCode\n\t   */\n\t\t\tDrawing.prototype.draw = function (oQRCode) {\n\t\t\t\tvar _elImage = this._elImage;\n\t\t\t\tvar _oContext = this._oContext;\n\t\t\t\tvar _htOption = this._htOption;\n\n\t\t\t\tvar nCount = oQRCode.getModuleCount();\n\t\t\t\tvar nWidth = _htOption.width / nCount;\n\t\t\t\tvar nHeight = _htOption.height / nCount;\n\t\t\t\tvar nRoundedWidth = Math.round(nWidth);\n\t\t\t\tvar nRoundedHeight = Math.round(nHeight);\n\n\t\t\t\t_elImage.style.display = \"none\";\n\t\t\t\tthis.clear();\n\n\t\t\t\tfor (var row = 0; row < nCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < nCount; col++) {\n\t\t\t\t\t\tvar bIsDark = oQRCode.isDark(row, col);\n\t\t\t\t\t\tvar nLeft = col * nWidth;\n\t\t\t\t\t\tvar nTop = row * nHeight;\n\t\t\t\t\t\t_oContext.strokeStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;\n\t\t\t\t\t\t_oContext.lineWidth = 1;\n\t\t\t\t\t\t_oContext.fillStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;\n\t\t\t\t\t\t_oContext.fillRect(nLeft, nTop, nWidth, nHeight);\n\n\t\t\t\t\t\t// 안티 앨리어싱 방지 처리\n\t\t\t\t\t\t_oContext.strokeRect(Math.floor(nLeft) + 0.5, Math.floor(nTop) + 0.5, nRoundedWidth, nRoundedHeight);\n\n\t\t\t\t\t\t_oContext.strokeRect(Math.ceil(nLeft) - 0.5, Math.ceil(nTop) - 0.5, nRoundedWidth, nRoundedHeight);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis._bIsPainted = true;\n\t\t\t};\n\n\t\t\t/**\n\t   * Make the image from Canvas if the browser supports Data URI.\n\t   */\n\t\t\tDrawing.prototype.makeImage = function () {\n\t\t\t\tif (this._bIsPainted) {\n\t\t\t\t\t_safeSetDataURI.call(this, _onMakeImage);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t   * Return whether the QRCode is painted or not\n\t   *\n\t   * @return {Boolean}\n\t   */\n\t\t\tDrawing.prototype.isPainted = function () {\n\t\t\t\treturn this._bIsPainted;\n\t\t\t};\n\n\t\t\t/**\n\t   * Clear the QRCode\n\t   */\n\t\t\tDrawing.prototype.clear = function () {\n\t\t\t\tthis._oContext.clearRect(0, 0, this._elCanvas.width, this._elCanvas.height);\n\t\t\t\tthis._bIsPainted = false;\n\t\t\t};\n\n\t\t\t/**\n\t   * @private\n\t   * @param {Number} nNumber\n\t   */\n\t\t\tDrawing.prototype.round = function (nNumber) {\n\t\t\t\tif (!nNumber) {\n\t\t\t\t\treturn nNumber;\n\t\t\t\t}\n\n\t\t\t\treturn Math.floor(nNumber * 1000) / 1000;\n\t\t\t};\n\n\t\t\treturn Drawing;\n\t\t}(global);\n\n\t\t/**\n\t  * Get the type by string length\n\t  *\n\t  * @private\n\t  * @param {String} sText\n\t  * @param {Number} nCorrectLevel\n\t  * @return {Number} type\n\t  */\n\t\tfunction _getTypeNumber(sText, nCorrectLevel) {\n\t\t\tvar nType = 1;\n\t\t\tvar length = _getUTF8Length(sText);\n\n\t\t\tfor (var i = 0, len = QRCodeLimitLength.length; i <= len; i++) {\n\t\t\t\tvar nLimit = 0;\n\n\t\t\t\tswitch (nCorrectLevel) {\n\t\t\t\t\tcase QRErrorCorrectLevel.L:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][0];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase QRErrorCorrectLevel.M:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][1];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase QRErrorCorrectLevel.Q:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][2];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase QRErrorCorrectLevel.H:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][3];\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif (length <= nLimit) {\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\tnType++;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (nType > QRCodeLimitLength.length) {\n\t\t\t\tthrow new Error(\"Too long data\");\n\t\t\t}\n\n\t\t\treturn nType;\n\t\t}\n\n\t\tfunction _getUTF8Length(sText) {\n\t\t\tvar replacedText = encodeURI(sText).toString().replace(/\\%[0-9a-fA-F]{2}/g, 'a');\n\t\t\treturn replacedText.length + (replacedText.length != sText ? 3 : 0);\n\t\t}\n\n\t\t/**\n\t  * @class QRCode\n\t  * @constructor\n\t  * @example\n\t  * new QRCode(document.getElementById(\"test\"), \"http://jindo.dev.naver.com/collie\");\n\t  *\n\t  * @example\n\t  * var oQRCode = new QRCode(\"test\", {\n\t  *    text : \"http://naver.com\",\n\t  *    width : 128,\n\t  *    height : 128\n\t  * });\n\t  *\n\t  * oQRCode.clear(); // Clear the QRCode.\n\t  * oQRCode.makeCode(\"http://map.naver.com\"); // Re-create the QRCode.\n\t  *\n\t  * @param {HTMLElement|String} el target element or 'id' attribute of element.\n\t  * @param {Object|String} vOption\n\t  * @param {String} vOption.text QRCode link data\n\t  * @param {Number} [vOption.width=256]\n\t  * @param {Number} [vOption.height=256]\n\t  * @param {String} [vOption.colorDark=\"#000000\"]\n\t  * @param {String} [vOption.colorLight=\"#ffffff\"]\n\t  * @param {QRCode.CorrectLevel} [vOption.correctLevel=QRCode.CorrectLevel.H] [L|M|Q|H]\n\t  */\n\t\tQRCode = function QRCode(el, vOption) {\n\t\t\tthis._htOption = {\n\t\t\t\twidth: 256,\n\t\t\t\theight: 256,\n\t\t\t\ttypeNumber: 4,\n\t\t\t\tcolorDark: \"#000000\",\n\t\t\t\tcolorLight: \"#ffffff\",\n\t\t\t\tcorrectLevel: QRErrorCorrectLevel.H\n\t\t\t};\n\n\t\t\tif (typeof vOption === 'string') {\n\t\t\t\tvOption = {\n\t\t\t\t\ttext: vOption\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// Overwrites options\n\t\t\tif (vOption) {\n\t\t\t\tfor (var i in vOption) {\n\t\t\t\t\tthis._htOption[i] = vOption[i];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (typeof el == \"string\") {\n\t\t\t\tel = document.getElementById(el);\n\t\t\t}\n\n\t\t\tif (this._htOption.useSVG) {\n\t\t\t\tDrawing = svgDrawer;\n\t\t\t}\n\n\t\t\tthis._android = _getAndroid();\n\t\t\tthis._el = el;\n\t\t\tthis._oQRCode = null;\n\t\t\tthis._oDrawing = new Drawing(this._el, this._htOption);\n\n\t\t\tif (this._htOption.text) {\n\t\t\t\tthis.makeCode(this._htOption.text);\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t  * Make the QRCode\n\t  *\n\t  * @param {String} sText link data\n\t  */\n\t\tQRCode.prototype.makeCode = function (sText) {\n\t\t\tthis._oQRCode = new QRCodeModel(_getTypeNumber(sText, this._htOption.correctLevel), this._htOption.correctLevel);\n\t\t\tthis._oQRCode.addData(sText);\n\t\t\tthis._oQRCode.make();\n\t\t\tthis._el.title = sText;\n\t\t\tthis._oDrawing.draw(this._oQRCode);\n\t\t\tthis.makeImage();\n\t\t};\n\n\t\t/**\n\t  * Make the Image from Canvas element\n\t  * - It occurs automatically\n\t  * - Android below 3 doesn't support Data-URI spec.\n\t  *\n\t  * @private\n\t  */\n\t\tQRCode.prototype.makeImage = function () {\n\t\t\tif (typeof this._oDrawing.makeImage == \"function\" && (!this._android || this._android >= 3)) {\n\t\t\t\tthis._oDrawing.makeImage();\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t  * Clear the QRCode\n\t  */\n\t\tQRCode.prototype.clear = function () {\n\t\t\tthis._oDrawing.clear();\n\t\t};\n\n\t\t/**\n\t  * @name QRCode.CorrectLevel\n\t  */\n\t\tQRCode.CorrectLevel = QRErrorCorrectLevel;\n\t})(window);\n\n\texports.default = QRCode;\n\n/***/ }\n/******/ ])\n});\n;\n},{}],23:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar APP_NAME = 'frontend-dog';\nvar APP_VERSION = '0.0.1';\n\nexports.default = {\n  APP_NAME: APP_NAME,\n  APP_VERSION: APP_VERSION\n};\n\n},{}],24:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');\n\nvar _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\nvar _createClass2 = require('babel-runtime/helpers/createClass');\n\nvar _createClass3 = _interopRequireDefault(_createClass2);\n\nvar _html2canvas = require('html2canvas');\n\nvar _html2canvas2 = _interopRequireDefault(_html2canvas);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * 在chrome下截屏可以渲染出图片，但是在微信里面不行\n */\nvar Html2canvas = function () {\n  function Html2canvas() {\n    (0, _classCallCheck3.default)(this, Html2canvas);\n\n    this.$ctr = document.body;\n    this.imgW = 300;\n    this.imgH = 300;\n\n    this.registEvent();\n  }\n\n  (0, _createClass3.default)(Html2canvas, [{\n    key: 'registEvent',\n    value: function registEvent() {\n      var _this = this;\n\n      document.getElementById('J_Html2canvas').addEventListener('click', function (e) {\n        console.log('click');\n        (0, _html2canvas2.default)(_this.$ctr, {\n          width: _this.imgW,\n          height: _this.imgH,\n          onrendered: function onrendered(canvas) {\n            console.log('rendered', canvas);\n            document.body.appendChild(canvas);\n          }\n        });\n      });\n    }\n  }]);\n  return Html2canvas;\n}();\n\nexports.default = Html2canvas;\n\n},{\"babel-runtime/helpers/classCallCheck\":2,\"babel-runtime/helpers/createClass\":3,\"html2canvas\":21}],25:[function(require,module,exports){\n'use strict';\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _qrcode = require('./qrcode');\n\nvar _qrcode2 = _interopRequireDefault(_qrcode);\n\nvar _html2canvas = require('./html2canvas');\n\nvar _html2canvas2 = _interopRequireDefault(_html2canvas);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nnew _qrcode2.default(); /*\n                        * The Entry\n                        */\n\nnew _html2canvas2.default();\n\nvar title = 'Hello ' + _config2.default.APP_NAME + '!';\ndocument.getElementById('title').innerHTML = title;\n\n},{\"./config\":23,\"./html2canvas\":24,\"./qrcode\":26}],26:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');\n\nvar _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\nvar _createClass2 = require('babel-runtime/helpers/createClass');\n\nvar _createClass3 = _interopRequireDefault(_createClass2);\n\nvar _qrcode = require('qrcode2');\n\nvar _qrcode2 = _interopRequireDefault(_qrcode);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar QRCode = function () {\n  function QRCode() {\n    (0, _classCallCheck3.default)(this, QRCode);\n\n    this.$genQRCode = document.getElementById('J_GenQRCode');\n    this.$QRCodeInput = document.getElementById('J_QRCodeVal');\n    this.$QRCode = document.getElementById('J_QRCode');\n    this.qrWidth = this.qrHeight = 200;\n    this.colorDark = '#000';\n    this.colorLight = '#fff';\n    this.level = _qrcode2.default.CorrectLevel.H;\n    this.qrstring = 'https://github.com/0326/canvas';\n    this.qrcode = new _qrcode2.default(\"J_QRCode\", {\n      text: this.qrstring,\n      width: this.qrWidth,\n      height: this.qrHeight,\n      colorDark: this.colorDark,\n      colorLight: this.colorLight,\n      correctLevel: this.level\n    });\n\n    this.registEvent();\n  }\n\n  (0, _createClass3.default)(QRCode, [{\n    key: 'registEvent',\n    value: function registEvent() {\n      var _this = this;\n\n      this.$genQRCode.addEventListener('click', function () {\n        _this.qrstring = _this.$QRCodeInput.value;\n\n        if (!_this.qrstring) {\n          return _this.$QRCodeInput.setAttribute('placeholder', '请输入字符串');\n        }\n\n        _this.$QRCode.innerHTML = '';\n        _this.qrcode = new _qrcode2.default(\"J_QRCode\", {\n          text: _this.qrstring,\n          width: _this.qrWidth,\n          height: _this.qrHeight,\n          colorDark: _this.colorDark,\n          colorLight: _this.colorLight,\n          correctLevel: _this.level\n        });\n      });\n    }\n  }]);\n  return QRCode;\n}();\n\nexports.default = QRCode;\n\n},{\"babel-runtime/helpers/classCallCheck\":2,\"babel-runtime/helpers/createClass\":3,\"qrcode2\":22}]},{},[25]);\n"],"file":"bundle.js"}
\ No newline at end of file
+{"version":3,"names":[],"mappings":"","sources":["bundle.js"],"sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){\nmodule.exports = { \"default\": require(\"core-js/library/fn/object/define-property\"), __esModule: true };\n},{\"core-js/library/fn/object/define-property\":4}],2:[function(require,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n},{}],3:[function(require,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n},{\"../core-js/object/define-property\":1}],4:[function(require,module,exports){\nrequire('../../modules/es6.object.define-property');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function defineProperty(it, key, desc){\n  return $Object.defineProperty(it, key, desc);\n};\n},{\"../../modules/_core\":7,\"../../modules/es6.object.define-property\":20}],5:[function(require,module,exports){\nmodule.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};\n},{}],6:[function(require,module,exports){\nvar isObject = require('./_is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n},{\"./_is-object\":16}],7:[function(require,module,exports){\nvar core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n},{}],8:[function(require,module,exports){\n// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n},{\"./_a-function\":5}],9:[function(require,module,exports){\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n},{\"./_fails\":12}],10:[function(require,module,exports){\nvar isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n},{\"./_global\":13,\"./_is-object\":16}],11:[function(require,module,exports){\nvar global    = require('./_global')\n  , core      = require('./_core')\n  , ctx       = require('./_ctx')\n  , hide      = require('./_hide')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n},{\"./_core\":7,\"./_ctx\":8,\"./_global\":13,\"./_hide\":14}],12:[function(require,module,exports){\nmodule.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n},{}],13:[function(require,module,exports){\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n},{}],14:[function(require,module,exports){\nvar dP         = require('./_object-dp')\n  , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};\n},{\"./_descriptors\":9,\"./_object-dp\":17,\"./_property-desc\":18}],15:[function(require,module,exports){\nmodule.exports = !require('./_descriptors') && !require('./_fails')(function(){\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n},{\"./_descriptors\":9,\"./_dom-create\":10,\"./_fails\":12}],16:[function(require,module,exports){\nmodule.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n},{}],17:[function(require,module,exports){\nvar anObject       = require('./_an-object')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , toPrimitive    = require('./_to-primitive')\n  , dP             = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};\n},{\"./_an-object\":6,\"./_descriptors\":9,\"./_ie8-dom-define\":15,\"./_to-primitive\":19}],18:[function(require,module,exports){\nmodule.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n},{}],19:[function(require,module,exports){\n// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n},{\"./_is-object\":16}],20:[function(require,module,exports){\nvar $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', {defineProperty: require('./_object-dp').f});\n},{\"./_descriptors\":9,\"./_export\":11,\"./_object-dp\":17}],21:[function(require,module,exports){\n(function (global){\n/*\n  html2canvas 0.5.0-beta4 <http://html2canvas.hertzen.com>\n  Copyright (c) 2016 Niklas von Hertzen\n\n  Released under  License\n*/\n\n(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.html2canvas = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){\n(function (global){\n/*! https://mths.be/punycode v1.4.0 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.3.2',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n},{}],2:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\n\nfunction restoreOwnerScroll(ownerDocument, x, y) {\n    if (ownerDocument.defaultView && (x !== ownerDocument.defaultView.pageXOffset || y !== ownerDocument.defaultView.pageYOffset)) {\n        ownerDocument.defaultView.scrollTo(x, y);\n    }\n}\n\nfunction cloneCanvasContents(canvas, clonedCanvas) {\n    try {\n        if (clonedCanvas) {\n            clonedCanvas.width = canvas.width;\n            clonedCanvas.height = canvas.height;\n            clonedCanvas.getContext(\"2d\").putImageData(canvas.getContext(\"2d\").getImageData(0, 0, canvas.width, canvas.height), 0, 0);\n        }\n    } catch(e) {\n        log(\"Unable to copy canvas content from\", canvas, e);\n    }\n}\n\nfunction cloneNode(node, javascriptEnabled) {\n    var clone = node.nodeType === 3 ? document.createTextNode(node.nodeValue) : node.cloneNode(false);\n\n    var child = node.firstChild;\n    while(child) {\n        if (javascriptEnabled === true || child.nodeType !== 1 || child.nodeName !== 'SCRIPT') {\n            clone.appendChild(cloneNode(child, javascriptEnabled));\n        }\n        child = child.nextSibling;\n    }\n\n    if (node.nodeType === 1) {\n        clone._scrollTop = node.scrollTop;\n        clone._scrollLeft = node.scrollLeft;\n        if (node.nodeName === \"CANVAS\") {\n            cloneCanvasContents(node, clone);\n        } else if (node.nodeName === \"TEXTAREA\" || node.nodeName === \"SELECT\") {\n            clone.value = node.value;\n        }\n    }\n\n    return clone;\n}\n\nfunction initNode(node) {\n    if (node.nodeType === 1) {\n        node.scrollTop = node._scrollTop;\n        node.scrollLeft = node._scrollLeft;\n\n        var child = node.firstChild;\n        while(child) {\n            initNode(child);\n            child = child.nextSibling;\n        }\n    }\n}\n\nmodule.exports = function(ownerDocument, containerDocument, width, height, options, x ,y) {\n    var documentElement = cloneNode(ownerDocument.documentElement, options.javascriptEnabled);\n    var container = containerDocument.createElement(\"iframe\");\n\n    container.className = \"html2canvas-container\";\n    container.style.visibility = \"hidden\";\n    container.style.position = \"fixed\";\n    container.style.left = \"-10000px\";\n    container.style.top = \"0px\";\n    container.style.border = \"0\";\n    container.width = width;\n    container.height = height;\n    container.scrolling = \"no\"; // ios won't scroll without it\n    containerDocument.body.appendChild(container);\n\n    return new Promise(function(resolve) {\n        var documentClone = container.contentWindow.document;\n\n        /* Chrome doesn't detect relative background-images assigned in inline <style> sheets when fetched through getComputedStyle\n         if window url is about:blank, we can assign the url to current by writing onto the document\n         */\n        container.contentWindow.onload = container.onload = function() {\n            var interval = setInterval(function() {\n                if (documentClone.body.childNodes.length > 0) {\n                    initNode(documentClone.documentElement);\n                    clearInterval(interval);\n                    if (options.type === \"view\") {\n                        container.contentWindow.scrollTo(x, y);\n                        if ((/(iPad|iPhone|iPod)/g).test(navigator.userAgent) && (container.contentWindow.scrollY !== y || container.contentWindow.scrollX !== x)) {\n                            documentClone.documentElement.style.top = (-y) + \"px\";\n                            documentClone.documentElement.style.left = (-x) + \"px\";\n                            documentClone.documentElement.style.position = 'absolute';\n                        }\n                    }\n                    resolve(container);\n                }\n            }, 50);\n        };\n\n        documentClone.open();\n        documentClone.write(\"<!DOCTYPE html><html></html>\");\n        // Chrome scrolls the parent document for some reason after the write to the cloned window???\n        restoreOwnerScroll(ownerDocument, x, y);\n        documentClone.replaceChild(documentClone.adoptNode(documentElement), documentClone.documentElement);\n        documentClone.close();\n    });\n};\n\n},{\"./log\":13}],3:[function(_dereq_,module,exports){\n// http://dev.w3.org/csswg/css-color/\n\nfunction Color(value) {\n    this.r = 0;\n    this.g = 0;\n    this.b = 0;\n    this.a = null;\n    var result = this.fromArray(value) ||\n        this.namedColor(value) ||\n        this.rgb(value) ||\n        this.rgba(value) ||\n        this.hex6(value) ||\n        this.hex3(value);\n}\n\nColor.prototype.darken = function(amount) {\n    var a = 1 - amount;\n    return  new Color([\n        Math.round(this.r * a),\n        Math.round(this.g * a),\n        Math.round(this.b * a),\n        this.a\n    ]);\n};\n\nColor.prototype.isTransparent = function() {\n    return this.a === 0;\n};\n\nColor.prototype.isBlack = function() {\n    return this.r === 0 && this.g === 0 && this.b === 0;\n};\n\nColor.prototype.fromArray = function(array) {\n    if (Array.isArray(array)) {\n        this.r = Math.min(array[0], 255);\n        this.g = Math.min(array[1], 255);\n        this.b = Math.min(array[2], 255);\n        if (array.length > 3) {\n            this.a = array[3];\n        }\n    }\n\n    return (Array.isArray(array));\n};\n\nvar _hex3 = /^#([a-f0-9]{3})$/i;\n\nColor.prototype.hex3 = function(value) {\n    var match = null;\n    if ((match = value.match(_hex3)) !== null) {\n        this.r = parseInt(match[1][0] + match[1][0], 16);\n        this.g = parseInt(match[1][1] + match[1][1], 16);\n        this.b = parseInt(match[1][2] + match[1][2], 16);\n    }\n    return match !== null;\n};\n\nvar _hex6 = /^#([a-f0-9]{6})$/i;\n\nColor.prototype.hex6 = function(value) {\n    var match = null;\n    if ((match = value.match(_hex6)) !== null) {\n        this.r = parseInt(match[1].substring(0, 2), 16);\n        this.g = parseInt(match[1].substring(2, 4), 16);\n        this.b = parseInt(match[1].substring(4, 6), 16);\n    }\n    return match !== null;\n};\n\n\nvar _rgb = /^rgb\\(\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*\\)$/;\n\nColor.prototype.rgb = function(value) {\n    var match = null;\n    if ((match = value.match(_rgb)) !== null) {\n        this.r = Number(match[1]);\n        this.g = Number(match[2]);\n        this.b = Number(match[3]);\n    }\n    return match !== null;\n};\n\nvar _rgba = /^rgba\\(\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d?\\.?\\d+)\\s*\\)$/;\n\nColor.prototype.rgba = function(value) {\n    var match = null;\n    if ((match = value.match(_rgba)) !== null) {\n        this.r = Number(match[1]);\n        this.g = Number(match[2]);\n        this.b = Number(match[3]);\n        this.a = Number(match[4]);\n    }\n    return match !== null;\n};\n\nColor.prototype.toString = function() {\n    return this.a !== null && this.a !== 1 ?\n    \"rgba(\" + [this.r, this.g, this.b, this.a].join(\",\") + \")\" :\n    \"rgb(\" + [this.r, this.g, this.b].join(\",\") + \")\";\n};\n\nColor.prototype.namedColor = function(value) {\n    value = value.toLowerCase();\n    var color = colors[value];\n    if (color) {\n        this.r = color[0];\n        this.g = color[1];\n        this.b = color[2];\n    } else if (value === \"transparent\") {\n        this.r = this.g = this.b = this.a = 0;\n        return true;\n    }\n\n    return !!color;\n};\n\nColor.prototype.isColor = true;\n\n// JSON.stringify([].slice.call($$('.named-color-table tr'), 1).map(function(row) { return [row.childNodes[3].textContent, row.childNodes[5].textContent.trim().split(\",\").map(Number)] }).reduce(function(data, row) {data[row[0]] = row[1]; return data}, {}))\nvar colors = {\n    \"aliceblue\": [240, 248, 255],\n    \"antiquewhite\": [250, 235, 215],\n    \"aqua\": [0, 255, 255],\n    \"aquamarine\": [127, 255, 212],\n    \"azure\": [240, 255, 255],\n    \"beige\": [245, 245, 220],\n    \"bisque\": [255, 228, 196],\n    \"black\": [0, 0, 0],\n    \"blanchedalmond\": [255, 235, 205],\n    \"blue\": [0, 0, 255],\n    \"blueviolet\": [138, 43, 226],\n    \"brown\": [165, 42, 42],\n    \"burlywood\": [222, 184, 135],\n    \"cadetblue\": [95, 158, 160],\n    \"chartreuse\": [127, 255, 0],\n    \"chocolate\": [210, 105, 30],\n    \"coral\": [255, 127, 80],\n    \"cornflowerblue\": [100, 149, 237],\n    \"cornsilk\": [255, 248, 220],\n    \"crimson\": [220, 20, 60],\n    \"cyan\": [0, 255, 255],\n    \"darkblue\": [0, 0, 139],\n    \"darkcyan\": [0, 139, 139],\n    \"darkgoldenrod\": [184, 134, 11],\n    \"darkgray\": [169, 169, 169],\n    \"darkgreen\": [0, 100, 0],\n    \"darkgrey\": [169, 169, 169],\n    \"darkkhaki\": [189, 183, 107],\n    \"darkmagenta\": [139, 0, 139],\n    \"darkolivegreen\": [85, 107, 47],\n    \"darkorange\": [255, 140, 0],\n    \"darkorchid\": [153, 50, 204],\n    \"darkred\": [139, 0, 0],\n    \"darksalmon\": [233, 150, 122],\n    \"darkseagreen\": [143, 188, 143],\n    \"darkslateblue\": [72, 61, 139],\n    \"darkslategray\": [47, 79, 79],\n    \"darkslategrey\": [47, 79, 79],\n    \"darkturquoise\": [0, 206, 209],\n    \"darkviolet\": [148, 0, 211],\n    \"deeppink\": [255, 20, 147],\n    \"deepskyblue\": [0, 191, 255],\n    \"dimgray\": [105, 105, 105],\n    \"dimgrey\": [105, 105, 105],\n    \"dodgerblue\": [30, 144, 255],\n    \"firebrick\": [178, 34, 34],\n    \"floralwhite\": [255, 250, 240],\n    \"forestgreen\": [34, 139, 34],\n    \"fuchsia\": [255, 0, 255],\n    \"gainsboro\": [220, 220, 220],\n    \"ghostwhite\": [248, 248, 255],\n    \"gold\": [255, 215, 0],\n    \"goldenrod\": [218, 165, 32],\n    \"gray\": [128, 128, 128],\n    \"green\": [0, 128, 0],\n    \"greenyellow\": [173, 255, 47],\n    \"grey\": [128, 128, 128],\n    \"honeydew\": [240, 255, 240],\n    \"hotpink\": [255, 105, 180],\n    \"indianred\": [205, 92, 92],\n    \"indigo\": [75, 0, 130],\n    \"ivory\": [255, 255, 240],\n    \"khaki\": [240, 230, 140],\n    \"lavender\": [230, 230, 250],\n    \"lavenderblush\": [255, 240, 245],\n    \"lawngreen\": [124, 252, 0],\n    \"lemonchiffon\": [255, 250, 205],\n    \"lightblue\": [173, 216, 230],\n    \"lightcoral\": [240, 128, 128],\n    \"lightcyan\": [224, 255, 255],\n    \"lightgoldenrodyellow\": [250, 250, 210],\n    \"lightgray\": [211, 211, 211],\n    \"lightgreen\": [144, 238, 144],\n    \"lightgrey\": [211, 211, 211],\n    \"lightpink\": [255, 182, 193],\n    \"lightsalmon\": [255, 160, 122],\n    \"lightseagreen\": [32, 178, 170],\n    \"lightskyblue\": [135, 206, 250],\n    \"lightslategray\": [119, 136, 153],\n    \"lightslategrey\": [119, 136, 153],\n    \"lightsteelblue\": [176, 196, 222],\n    \"lightyellow\": [255, 255, 224],\n    \"lime\": [0, 255, 0],\n    \"limegreen\": [50, 205, 50],\n    \"linen\": [250, 240, 230],\n    \"magenta\": [255, 0, 255],\n    \"maroon\": [128, 0, 0],\n    \"mediumaquamarine\": [102, 205, 170],\n    \"mediumblue\": [0, 0, 205],\n    \"mediumorchid\": [186, 85, 211],\n    \"mediumpurple\": [147, 112, 219],\n    \"mediumseagreen\": [60, 179, 113],\n    \"mediumslateblue\": [123, 104, 238],\n    \"mediumspringgreen\": [0, 250, 154],\n    \"mediumturquoise\": [72, 209, 204],\n    \"mediumvioletred\": [199, 21, 133],\n    \"midnightblue\": [25, 25, 112],\n    \"mintcream\": [245, 255, 250],\n    \"mistyrose\": [255, 228, 225],\n    \"moccasin\": [255, 228, 181],\n    \"navajowhite\": [255, 222, 173],\n    \"navy\": [0, 0, 128],\n    \"oldlace\": [253, 245, 230],\n    \"olive\": [128, 128, 0],\n    \"olivedrab\": [107, 142, 35],\n    \"orange\": [255, 165, 0],\n    \"orangered\": [255, 69, 0],\n    \"orchid\": [218, 112, 214],\n    \"palegoldenrod\": [238, 232, 170],\n    \"palegreen\": [152, 251, 152],\n    \"paleturquoise\": [175, 238, 238],\n    \"palevioletred\": [219, 112, 147],\n    \"papayawhip\": [255, 239, 213],\n    \"peachpuff\": [255, 218, 185],\n    \"peru\": [205, 133, 63],\n    \"pink\": [255, 192, 203],\n    \"plum\": [221, 160, 221],\n    \"powderblue\": [176, 224, 230],\n    \"purple\": [128, 0, 128],\n    \"rebeccapurple\": [102, 51, 153],\n    \"red\": [255, 0, 0],\n    \"rosybrown\": [188, 143, 143],\n    \"royalblue\": [65, 105, 225],\n    \"saddlebrown\": [139, 69, 19],\n    \"salmon\": [250, 128, 114],\n    \"sandybrown\": [244, 164, 96],\n    \"seagreen\": [46, 139, 87],\n    \"seashell\": [255, 245, 238],\n    \"sienna\": [160, 82, 45],\n    \"silver\": [192, 192, 192],\n    \"skyblue\": [135, 206, 235],\n    \"slateblue\": [106, 90, 205],\n    \"slategray\": [112, 128, 144],\n    \"slategrey\": [112, 128, 144],\n    \"snow\": [255, 250, 250],\n    \"springgreen\": [0, 255, 127],\n    \"steelblue\": [70, 130, 180],\n    \"tan\": [210, 180, 140],\n    \"teal\": [0, 128, 128],\n    \"thistle\": [216, 191, 216],\n    \"tomato\": [255, 99, 71],\n    \"turquoise\": [64, 224, 208],\n    \"violet\": [238, 130, 238],\n    \"wheat\": [245, 222, 179],\n    \"white\": [255, 255, 255],\n    \"whitesmoke\": [245, 245, 245],\n    \"yellow\": [255, 255, 0],\n    \"yellowgreen\": [154, 205, 50]\n};\n\nmodule.exports = Color;\n\n},{}],4:[function(_dereq_,module,exports){\nvar Support = _dereq_('./support');\nvar CanvasRenderer = _dereq_('./renderers/canvas');\nvar ImageLoader = _dereq_('./imageloader');\nvar NodeParser = _dereq_('./nodeparser');\nvar NodeContainer = _dereq_('./nodecontainer');\nvar log = _dereq_('./log');\nvar utils = _dereq_('./utils');\nvar createWindowClone = _dereq_('./clone');\nvar loadUrlDocument = _dereq_('./proxy').loadUrlDocument;\nvar getBounds = utils.getBounds;\n\nvar html2canvasNodeAttribute = \"data-html2canvas-node\";\nvar html2canvasCloneIndex = 0;\n\nfunction html2canvas(nodeList, options) {\n    var index = html2canvasCloneIndex++;\n    options = options || {};\n    if (options.logging) {\n        log.options.logging = true;\n        log.options.start = Date.now();\n    }\n\n    options.async = typeof(options.async) === \"undefined\" ? true : options.async;\n    options.allowTaint = typeof(options.allowTaint) === \"undefined\" ? false : options.allowTaint;\n    options.removeContainer = typeof(options.removeContainer) === \"undefined\" ? true : options.removeContainer;\n    options.javascriptEnabled = typeof(options.javascriptEnabled) === \"undefined\" ? false : options.javascriptEnabled;\n    options.imageTimeout = typeof(options.imageTimeout) === \"undefined\" ? 10000 : options.imageTimeout;\n    options.renderer = typeof(options.renderer) === \"function\" ? options.renderer : CanvasRenderer;\n    options.strict = !!options.strict;\n\n    if (typeof(nodeList) === \"string\") {\n        if (typeof(options.proxy) !== \"string\") {\n            return Promise.reject(\"Proxy must be used when rendering url\");\n        }\n        var width = options.width != null ? options.width : window.innerWidth;\n        var height = options.height != null ? options.height : window.innerHeight;\n        return loadUrlDocument(absoluteUrl(nodeList), options.proxy, document, width, height, options).then(function(container) {\n            return renderWindow(container.contentWindow.document.documentElement, container, options, width, height);\n        });\n    }\n\n    var node = ((nodeList === undefined) ? [document.documentElement] : ((nodeList.length) ? nodeList : [nodeList]))[0];\n    node.setAttribute(html2canvasNodeAttribute + index, index);\n    return renderDocument(node.ownerDocument, options, node.ownerDocument.defaultView.innerWidth, node.ownerDocument.defaultView.innerHeight, index).then(function(canvas) {\n        if (typeof(options.onrendered) === \"function\") {\n            log(\"options.onrendered is deprecated, html2canvas returns a Promise containing the canvas\");\n            options.onrendered(canvas);\n        }\n        return canvas;\n    });\n}\n\nhtml2canvas.CanvasRenderer = CanvasRenderer;\nhtml2canvas.NodeContainer = NodeContainer;\nhtml2canvas.log = log;\nhtml2canvas.utils = utils;\n\nvar html2canvasExport = (typeof(document) === \"undefined\" || typeof(Object.create) !== \"function\" || typeof(document.createElement(\"canvas\").getContext) !== \"function\") ? function() {\n    return Promise.reject(\"No canvas support\");\n} : html2canvas;\n\nmodule.exports = html2canvasExport;\n\nif (typeof(define) === 'function' && define.amd) {\n    define('html2canvas', [], function() {\n        return html2canvasExport;\n    });\n}\n\nfunction renderDocument(document, options, windowWidth, windowHeight, html2canvasIndex) {\n    return createWindowClone(document, document, windowWidth, windowHeight, options, document.defaultView.pageXOffset, document.defaultView.pageYOffset).then(function(container) {\n        log(\"Document cloned\");\n        var attributeName = html2canvasNodeAttribute + html2canvasIndex;\n        var selector = \"[\" + attributeName + \"='\" + html2canvasIndex + \"']\";\n        document.querySelector(selector).removeAttribute(attributeName);\n        var clonedWindow = container.contentWindow;\n        var node = clonedWindow.document.querySelector(selector);\n        var oncloneHandler = (typeof(options.onclone) === \"function\") ? Promise.resolve(options.onclone(clonedWindow.document)) : Promise.resolve(true);\n        return oncloneHandler.then(function() {\n            return renderWindow(node, container, options, windowWidth, windowHeight);\n        });\n    });\n}\n\nfunction renderWindow(node, container, options, windowWidth, windowHeight) {\n    var clonedWindow = container.contentWindow;\n    var support = new Support(clonedWindow.document);\n    var imageLoader = new ImageLoader(options, support);\n    var bounds = getBounds(node);\n    var width = options.type === \"view\" ? windowWidth : documentWidth(clonedWindow.document);\n    var height = options.type === \"view\" ? windowHeight : documentHeight(clonedWindow.document);\n    var renderer = new options.renderer(width, height, imageLoader, options, document);\n    var parser = new NodeParser(node, renderer, support, imageLoader, options);\n    return parser.ready.then(function() {\n        log(\"Finished rendering\");\n        var canvas;\n\n        if (options.type === \"view\") {\n            canvas = crop(renderer.canvas, {width: renderer.canvas.width, height: renderer.canvas.height, top: 0, left: 0, x: 0, y: 0});\n        } else if (node === clonedWindow.document.body || node === clonedWindow.document.documentElement || options.canvas != null) {\n            canvas = renderer.canvas;\n        } else {\n            canvas = crop(renderer.canvas, {width:  options.width != null ? options.width : bounds.width, height: options.height != null ? options.height : bounds.height, top: bounds.top, left: bounds.left, x: 0, y: 0});\n        }\n\n        cleanupContainer(container, options);\n        return canvas;\n    });\n}\n\nfunction cleanupContainer(container, options) {\n    if (options.removeContainer) {\n        container.parentNode.removeChild(container);\n        log(\"Cleaned up container\");\n    }\n}\n\nfunction crop(canvas, bounds) {\n    var croppedCanvas = document.createElement(\"canvas\");\n    var x1 = Math.min(canvas.width - 1, Math.max(0, bounds.left));\n    var x2 = Math.min(canvas.width, Math.max(1, bounds.left + bounds.width));\n    var y1 = Math.min(canvas.height - 1, Math.max(0, bounds.top));\n    var y2 = Math.min(canvas.height, Math.max(1, bounds.top + bounds.height));\n    croppedCanvas.width = bounds.width;\n    croppedCanvas.height =  bounds.height;\n    var width = x2-x1;\n    var height = y2-y1;\n    log(\"Cropping canvas at:\", \"left:\", bounds.left, \"top:\", bounds.top, \"width:\", width, \"height:\", height);\n    log(\"Resulting crop with width\", bounds.width, \"and height\", bounds.height, \"with x\", x1, \"and y\", y1);\n    croppedCanvas.getContext(\"2d\").drawImage(canvas, x1, y1, width, height, bounds.x, bounds.y, width, height);\n    return croppedCanvas;\n}\n\nfunction documentWidth (doc) {\n    return Math.max(\n        Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth),\n        Math.max(doc.body.offsetWidth, doc.documentElement.offsetWidth),\n        Math.max(doc.body.clientWidth, doc.documentElement.clientWidth)\n    );\n}\n\nfunction documentHeight (doc) {\n    return Math.max(\n        Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight),\n        Math.max(doc.body.offsetHeight, doc.documentElement.offsetHeight),\n        Math.max(doc.body.clientHeight, doc.documentElement.clientHeight)\n    );\n}\n\nfunction absoluteUrl(url) {\n    var link = document.createElement(\"a\");\n    link.href = url;\n    link.href = link.href;\n    return link;\n}\n\n},{\"./clone\":2,\"./imageloader\":11,\"./log\":13,\"./nodecontainer\":14,\"./nodeparser\":15,\"./proxy\":16,\"./renderers/canvas\":20,\"./support\":22,\"./utils\":26}],5:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\nvar smallImage = _dereq_('./utils').smallImage;\n\nfunction DummyImageContainer(src) {\n    this.src = src;\n    log(\"DummyImageContainer for\", src);\n    if (!this.promise || !this.image) {\n        log(\"Initiating DummyImageContainer\");\n        DummyImageContainer.prototype.image = new Image();\n        var image = this.image;\n        DummyImageContainer.prototype.promise = new Promise(function(resolve, reject) {\n            image.onload = resolve;\n            image.onerror = reject;\n            image.src = smallImage();\n            if (image.complete === true) {\n                resolve(image);\n            }\n        });\n    }\n}\n\nmodule.exports = DummyImageContainer;\n\n},{\"./log\":13,\"./utils\":26}],6:[function(_dereq_,module,exports){\nvar smallImage = _dereq_('./utils').smallImage;\n\nfunction Font(family, size) {\n    var container = document.createElement('div'),\n        img = document.createElement('img'),\n        span = document.createElement('span'),\n        sampleText = 'Hidden Text',\n        baseline,\n        middle;\n\n    container.style.visibility = \"hidden\";\n    container.style.fontFamily = family;\n    container.style.fontSize = size;\n    container.style.margin = 0;\n    container.style.padding = 0;\n\n    document.body.appendChild(container);\n\n    img.src = smallImage();\n    img.width = 1;\n    img.height = 1;\n\n    img.style.margin = 0;\n    img.style.padding = 0;\n    img.style.verticalAlign = \"baseline\";\n\n    span.style.fontFamily = family;\n    span.style.fontSize = size;\n    span.style.margin = 0;\n    span.style.padding = 0;\n\n    span.appendChild(document.createTextNode(sampleText));\n    container.appendChild(span);\n    container.appendChild(img);\n    baseline = (img.offsetTop - span.offsetTop) + 1;\n\n    container.removeChild(span);\n    container.appendChild(document.createTextNode(sampleText));\n\n    container.style.lineHeight = \"normal\";\n    img.style.verticalAlign = \"super\";\n\n    middle = (img.offsetTop-container.offsetTop) + 1;\n\n    document.body.removeChild(container);\n\n    this.baseline = baseline;\n    this.lineWidth = 1;\n    this.middle = middle;\n}\n\nmodule.exports = Font;\n\n},{\"./utils\":26}],7:[function(_dereq_,module,exports){\nvar Font = _dereq_('./font');\n\nfunction FontMetrics() {\n    this.data = {};\n}\n\nFontMetrics.prototype.getMetrics = function(family, size) {\n    if (this.data[family + \"-\" + size] === undefined) {\n        this.data[family + \"-\" + size] = new Font(family, size);\n    }\n    return this.data[family + \"-\" + size];\n};\n\nmodule.exports = FontMetrics;\n\n},{\"./font\":6}],8:[function(_dereq_,module,exports){\nvar utils = _dereq_('./utils');\nvar getBounds = utils.getBounds;\nvar loadUrlDocument = _dereq_('./proxy').loadUrlDocument;\n\nfunction FrameContainer(container, sameOrigin, options) {\n    this.image = null;\n    this.src = container;\n    var self = this;\n    var bounds = getBounds(container);\n    this.promise = (!sameOrigin ? this.proxyLoad(options.proxy, bounds, options) : new Promise(function(resolve) {\n        if (container.contentWindow.document.URL === \"about:blank\" || container.contentWindow.document.documentElement == null) {\n            container.contentWindow.onload = container.onload = function() {\n                resolve(container);\n            };\n        } else {\n            resolve(container);\n        }\n    })).then(function(container) {\n        var html2canvas = _dereq_('./core');\n        return html2canvas(container.contentWindow.document.documentElement, {type: 'view', width: container.width, height: container.height, proxy: options.proxy, javascriptEnabled: options.javascriptEnabled, removeContainer: options.removeContainer, allowTaint: options.allowTaint, imageTimeout: options.imageTimeout / 2});\n    }).then(function(canvas) {\n        return self.image = canvas;\n    });\n}\n\nFrameContainer.prototype.proxyLoad = function(proxy, bounds, options) {\n    var container = this.src;\n    return loadUrlDocument(container.src, proxy, container.ownerDocument, bounds.width, bounds.height, options);\n};\n\nmodule.exports = FrameContainer;\n\n},{\"./core\":4,\"./proxy\":16,\"./utils\":26}],9:[function(_dereq_,module,exports){\nfunction GradientContainer(imageData) {\n    this.src = imageData.value;\n    this.colorStops = [];\n    this.type = null;\n    this.x0 = 0.5;\n    this.y0 = 0.5;\n    this.x1 = 0.5;\n    this.y1 = 0.5;\n    this.promise = Promise.resolve(true);\n}\n\nGradientContainer.TYPES = {\n    LINEAR: 1,\n    RADIAL: 2\n};\n\n// TODO: support hsl[a], negative %/length values\n// TODO: support <angle> (e.g. -?\\d{1,3}(?:\\.\\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )\nGradientContainer.REGEXP_COLORSTOP = /^\\s*(rgba?\\(\\s*\\d{1,3},\\s*\\d{1,3},\\s*\\d{1,3}(?:,\\s*[0-9\\.]+)?\\s*\\)|[a-z]{3,20}|#[a-f0-9]{3,6})(?:\\s+(\\d{1,3}(?:\\.\\d+)?)(%|px)?)?(?:\\s|$)/i;\n\nmodule.exports = GradientContainer;\n\n},{}],10:[function(_dereq_,module,exports){\nfunction ImageContainer(src, cors) {\n    this.src = src;\n    this.image = new Image();\n    var self = this;\n    this.tainted = null;\n    this.promise = new Promise(function(resolve, reject) {\n        self.image.onload = resolve;\n        self.image.onerror = reject;\n        if (cors) {\n            self.image.crossOrigin = \"anonymous\";\n        }\n        self.image.src = src;\n        if (self.image.complete === true) {\n            resolve(self.image);\n        }\n    });\n}\n\nmodule.exports = ImageContainer;\n\n},{}],11:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\nvar ImageContainer = _dereq_('./imagecontainer');\nvar DummyImageContainer = _dereq_('./dummyimagecontainer');\nvar ProxyImageContainer = _dereq_('./proxyimagecontainer');\nvar FrameContainer = _dereq_('./framecontainer');\nvar SVGContainer = _dereq_('./svgcontainer');\nvar SVGNodeContainer = _dereq_('./svgnodecontainer');\nvar LinearGradientContainer = _dereq_('./lineargradientcontainer');\nvar WebkitGradientContainer = _dereq_('./webkitgradientcontainer');\nvar bind = _dereq_('./utils').bind;\n\nfunction ImageLoader(options, support) {\n    this.link = null;\n    this.options = options;\n    this.support = support;\n    this.origin = this.getOrigin(window.location.href);\n}\n\nImageLoader.prototype.findImages = function(nodes) {\n    var images = [];\n    nodes.reduce(function(imageNodes, container) {\n        switch(container.node.nodeName) {\n        case \"IMG\":\n            return imageNodes.concat([{\n                args: [container.node.src],\n                method: \"url\"\n            }]);\n        case \"svg\":\n        case \"IFRAME\":\n            return imageNodes.concat([{\n                args: [container.node],\n                method: container.node.nodeName\n            }]);\n        }\n        return imageNodes;\n    }, []).forEach(this.addImage(images, this.loadImage), this);\n    return images;\n};\n\nImageLoader.prototype.findBackgroundImage = function(images, container) {\n    container.parseBackgroundImages().filter(this.hasImageBackground).forEach(this.addImage(images, this.loadImage), this);\n    return images;\n};\n\nImageLoader.prototype.addImage = function(images, callback) {\n    return function(newImage) {\n        newImage.args.forEach(function(image) {\n            if (!this.imageExists(images, image)) {\n                images.splice(0, 0, callback.call(this, newImage));\n                log('Added image #' + (images.length), typeof(image) === \"string\" ? image.substring(0, 100) : image);\n            }\n        }, this);\n    };\n};\n\nImageLoader.prototype.hasImageBackground = function(imageData) {\n    return imageData.method !== \"none\";\n};\n\nImageLoader.prototype.loadImage = function(imageData) {\n    if (imageData.method === \"url\") {\n        var src = imageData.args[0];\n        if (this.isSVG(src) && !this.support.svg && !this.options.allowTaint) {\n            return new SVGContainer(src);\n        } else if (src.match(/data:image\\/.*;base64,/i)) {\n            return new ImageContainer(src.replace(/url\\(['\"]{0,}|['\"]{0,}\\)$/ig, ''), false);\n        } else if (this.isSameOrigin(src) || this.options.allowTaint === true || this.isSVG(src)) {\n            return new ImageContainer(src, false);\n        } else if (this.support.cors && !this.options.allowTaint && this.options.useCORS) {\n            return new ImageContainer(src, true);\n        } else if (this.options.proxy) {\n            return new ProxyImageContainer(src, this.options.proxy);\n        } else {\n            return new DummyImageContainer(src);\n        }\n    } else if (imageData.method === \"linear-gradient\") {\n        return new LinearGradientContainer(imageData);\n    } else if (imageData.method === \"gradient\") {\n        return new WebkitGradientContainer(imageData);\n    } else if (imageData.method === \"svg\") {\n        return new SVGNodeContainer(imageData.args[0], this.support.svg);\n    } else if (imageData.method === \"IFRAME\") {\n        return new FrameContainer(imageData.args[0], this.isSameOrigin(imageData.args[0].src), this.options);\n    } else {\n        return new DummyImageContainer(imageData);\n    }\n};\n\nImageLoader.prototype.isSVG = function(src) {\n    return src.substring(src.length - 3).toLowerCase() === \"svg\" || SVGContainer.prototype.isInline(src);\n};\n\nImageLoader.prototype.imageExists = function(images, src) {\n    return images.some(function(image) {\n        return image.src === src;\n    });\n};\n\nImageLoader.prototype.isSameOrigin = function(url) {\n    return (this.getOrigin(url) === this.origin);\n};\n\nImageLoader.prototype.getOrigin = function(url) {\n    var link = this.link || (this.link = document.createElement(\"a\"));\n    link.href = url;\n    link.href = link.href; // IE9, LOL! - http://jsfiddle.net/niklasvh/2e48b/\n    return link.protocol + link.hostname + link.port;\n};\n\nImageLoader.prototype.getPromise = function(container) {\n    return this.timeout(container, this.options.imageTimeout)['catch'](function() {\n        var dummy = new DummyImageContainer(container.src);\n        return dummy.promise.then(function(image) {\n            container.image = image;\n        });\n    });\n};\n\nImageLoader.prototype.get = function(src) {\n    var found = null;\n    return this.images.some(function(img) {\n        return (found = img).src === src;\n    }) ? found : null;\n};\n\nImageLoader.prototype.fetch = function(nodes) {\n    this.images = nodes.reduce(bind(this.findBackgroundImage, this), this.findImages(nodes));\n    this.images.forEach(function(image, index) {\n        image.promise.then(function() {\n            log(\"Succesfully loaded image #\"+ (index+1), image);\n        }, function(e) {\n            log(\"Failed loading image #\"+ (index+1), image, e);\n        });\n    });\n    this.ready = Promise.all(this.images.map(this.getPromise, this));\n    log(\"Finished searching images\");\n    return this;\n};\n\nImageLoader.prototype.timeout = function(container, timeout) {\n    var timer;\n    var promise = Promise.race([container.promise, new Promise(function(res, reject) {\n        timer = setTimeout(function() {\n            log(\"Timed out loading image\", container);\n            reject(container);\n        }, timeout);\n    })]).then(function(container) {\n        clearTimeout(timer);\n        return container;\n    });\n    promise['catch'](function() {\n        clearTimeout(timer);\n    });\n    return promise;\n};\n\nmodule.exports = ImageLoader;\n\n},{\"./dummyimagecontainer\":5,\"./framecontainer\":8,\"./imagecontainer\":10,\"./lineargradientcontainer\":12,\"./log\":13,\"./proxyimagecontainer\":17,\"./svgcontainer\":23,\"./svgnodecontainer\":24,\"./utils\":26,\"./webkitgradientcontainer\":27}],12:[function(_dereq_,module,exports){\nvar GradientContainer = _dereq_('./gradientcontainer');\nvar Color = _dereq_('./color');\n\nfunction LinearGradientContainer(imageData) {\n    GradientContainer.apply(this, arguments);\n    this.type = GradientContainer.TYPES.LINEAR;\n\n    var hasDirection = LinearGradientContainer.REGEXP_DIRECTION.test( imageData.args[0] ) ||\n        !GradientContainer.REGEXP_COLORSTOP.test( imageData.args[0] );\n\n    if (hasDirection) {\n        imageData.args[0].split(/\\s+/).reverse().forEach(function(position, index) {\n            switch(position) {\n            case \"left\":\n                this.x0 = 0;\n                this.x1 = 1;\n                break;\n            case \"top\":\n                this.y0 = 0;\n                this.y1 = 1;\n                break;\n            case \"right\":\n                this.x0 = 1;\n                this.x1 = 0;\n                break;\n            case \"bottom\":\n                this.y0 = 1;\n                this.y1 = 0;\n                break;\n            case \"to\":\n                var y0 = this.y0;\n                var x0 = this.x0;\n                this.y0 = this.y1;\n                this.x0 = this.x1;\n                this.x1 = x0;\n                this.y1 = y0;\n                break;\n            case \"center\":\n                break; // centered by default\n            // Firefox internally converts position keywords to percentages:\n            // http://www.w3.org/TR/2010/WD-CSS2-20101207/colors.html#propdef-background-position\n            default: // percentage or absolute length\n                // TODO: support absolute start point positions (e.g., use bounds to convert px to a ratio)\n                var ratio = parseFloat(position, 10) * 1e-2;\n                if (isNaN(ratio)) { // invalid or unhandled value\n                    break;\n                }\n                if (index === 0) {\n                    this.y0 = ratio;\n                    this.y1 = 1 - this.y0;\n                } else {\n                    this.x0 = ratio;\n                    this.x1 = 1 - this.x0;\n                }\n                break;\n            }\n        }, this);\n    } else {\n        this.y0 = 0;\n        this.y1 = 1;\n    }\n\n    this.colorStops = imageData.args.slice(hasDirection ? 1 : 0).map(function(colorStop) {\n        var colorStopMatch = colorStop.match(GradientContainer.REGEXP_COLORSTOP);\n        var value = +colorStopMatch[2];\n        var unit = value === 0 ? \"%\" : colorStopMatch[3]; // treat \"0\" as \"0%\"\n        return {\n            color: new Color(colorStopMatch[1]),\n            // TODO: support absolute stop positions (e.g., compute gradient line length & convert px to ratio)\n            stop: unit === \"%\" ? value / 100 : null\n        };\n    });\n\n    if (this.colorStops[0].stop === null) {\n        this.colorStops[0].stop = 0;\n    }\n\n    if (this.colorStops[this.colorStops.length - 1].stop === null) {\n        this.colorStops[this.colorStops.length - 1].stop = 1;\n    }\n\n    // calculates and fills-in explicit stop positions when omitted from rule\n    this.colorStops.forEach(function(colorStop, index) {\n        if (colorStop.stop === null) {\n            this.colorStops.slice(index).some(function(find, count) {\n                if (find.stop !== null) {\n                    colorStop.stop = ((find.stop - this.colorStops[index - 1].stop) / (count + 1)) + this.colorStops[index - 1].stop;\n                    return true;\n                } else {\n                    return false;\n                }\n            }, this);\n        }\n    }, this);\n}\n\nLinearGradientContainer.prototype = Object.create(GradientContainer.prototype);\n\n// TODO: support <angle> (e.g. -?\\d{1,3}(?:\\.\\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )\nLinearGradientContainer.REGEXP_DIRECTION = /^\\s*(?:to|left|right|top|bottom|center|\\d{1,3}(?:\\.\\d+)?%?)(?:\\s|$)/i;\n\nmodule.exports = LinearGradientContainer;\n\n},{\"./color\":3,\"./gradientcontainer\":9}],13:[function(_dereq_,module,exports){\nvar logger = function() {\n    if (logger.options.logging && window.console && window.console.log) {\n        Function.prototype.bind.call(window.console.log, (window.console)).apply(window.console, [(Date.now() - logger.options.start) + \"ms\", \"html2canvas:\"].concat([].slice.call(arguments, 0)));\n    }\n};\n\nlogger.options = {logging: false};\nmodule.exports = logger;\n\n},{}],14:[function(_dereq_,module,exports){\nvar Color = _dereq_('./color');\nvar utils = _dereq_('./utils');\nvar getBounds = utils.getBounds;\nvar parseBackgrounds = utils.parseBackgrounds;\nvar offsetBounds = utils.offsetBounds;\n\nfunction NodeContainer(node, parent) {\n    this.node = node;\n    this.parent = parent;\n    this.stack = null;\n    this.bounds = null;\n    this.borders = null;\n    this.clip = [];\n    this.backgroundClip = [];\n    this.offsetBounds = null;\n    this.visible = null;\n    this.computedStyles = null;\n    this.colors = {};\n    this.styles = {};\n    this.backgroundImages = null;\n    this.transformData = null;\n    this.transformMatrix = null;\n    this.isPseudoElement = false;\n    this.opacity = null;\n}\n\nNodeContainer.prototype.cloneTo = function(stack) {\n    stack.visible = this.visible;\n    stack.borders = this.borders;\n    stack.bounds = this.bounds;\n    stack.clip = this.clip;\n    stack.backgroundClip = this.backgroundClip;\n    stack.computedStyles = this.computedStyles;\n    stack.styles = this.styles;\n    stack.backgroundImages = this.backgroundImages;\n    stack.opacity = this.opacity;\n};\n\nNodeContainer.prototype.getOpacity = function() {\n    return this.opacity === null ? (this.opacity = this.cssFloat('opacity')) : this.opacity;\n};\n\nNodeContainer.prototype.assignStack = function(stack) {\n    this.stack = stack;\n    stack.children.push(this);\n};\n\nNodeContainer.prototype.isElementVisible = function() {\n    return this.node.nodeType === Node.TEXT_NODE ? this.parent.visible : (\n        this.css('display') !== \"none\" &&\n        this.css('visibility') !== \"hidden\" &&\n        !this.node.hasAttribute(\"data-html2canvas-ignore\") &&\n        (this.node.nodeName !== \"INPUT\" || this.node.getAttribute(\"type\") !== \"hidden\")\n    );\n};\n\nNodeContainer.prototype.css = function(attribute) {\n    if (!this.computedStyles) {\n        this.computedStyles = this.isPseudoElement ? this.parent.computedStyle(this.before ? \":before\" : \":after\") : this.computedStyle(null);\n    }\n\n    return this.styles[attribute] || (this.styles[attribute] = this.computedStyles[attribute]);\n};\n\nNodeContainer.prototype.prefixedCss = function(attribute) {\n    var prefixes = [\"webkit\", \"moz\", \"ms\", \"o\"];\n    var value = this.css(attribute);\n    if (value === undefined) {\n        prefixes.some(function(prefix) {\n            value = this.css(prefix + attribute.substr(0, 1).toUpperCase() + attribute.substr(1));\n            return value !== undefined;\n        }, this);\n    }\n    return value === undefined ? null : value;\n};\n\nNodeContainer.prototype.computedStyle = function(type) {\n    return this.node.ownerDocument.defaultView.getComputedStyle(this.node, type);\n};\n\nNodeContainer.prototype.cssInt = function(attribute) {\n    var value = parseInt(this.css(attribute), 10);\n    return (isNaN(value)) ? 0 : value; // borders in old IE are throwing 'medium' for demo.html\n};\n\nNodeContainer.prototype.color = function(attribute) {\n    return this.colors[attribute] || (this.colors[attribute] = new Color(this.css(attribute)));\n};\n\nNodeContainer.prototype.cssFloat = function(attribute) {\n    var value = parseFloat(this.css(attribute));\n    return (isNaN(value)) ? 0 : value;\n};\n\nNodeContainer.prototype.fontWeight = function() {\n    var weight = this.css(\"fontWeight\");\n    switch(parseInt(weight, 10)){\n    case 401:\n        weight = \"bold\";\n        break;\n    case 400:\n        weight = \"normal\";\n        break;\n    }\n    return weight;\n};\n\nNodeContainer.prototype.parseClip = function() {\n    var matches = this.css('clip').match(this.CLIP);\n    if (matches) {\n        return {\n            top: parseInt(matches[1], 10),\n            right: parseInt(matches[2], 10),\n            bottom: parseInt(matches[3], 10),\n            left: parseInt(matches[4], 10)\n        };\n    }\n    return null;\n};\n\nNodeContainer.prototype.parseBackgroundImages = function() {\n    return this.backgroundImages || (this.backgroundImages = parseBackgrounds(this.css(\"backgroundImage\")));\n};\n\nNodeContainer.prototype.cssList = function(property, index) {\n    var value = (this.css(property) || '').split(',');\n    value = value[index || 0] || value[0] || 'auto';\n    value = value.trim().split(' ');\n    if (value.length === 1) {\n        value = [value[0], isPercentage(value[0]) ? 'auto' : value[0]];\n    }\n    return value;\n};\n\nNodeContainer.prototype.parseBackgroundSize = function(bounds, image, index) {\n    var size = this.cssList(\"backgroundSize\", index);\n    var width, height;\n\n    if (isPercentage(size[0])) {\n        width = bounds.width * parseFloat(size[0]) / 100;\n    } else if (/contain|cover/.test(size[0])) {\n        var targetRatio = bounds.width / bounds.height, currentRatio = image.width / image.height;\n        return (targetRatio < currentRatio ^ size[0] === 'contain') ?  {width: bounds.height * currentRatio, height: bounds.height} : {width: bounds.width, height: bounds.width / currentRatio};\n    } else {\n        width = parseInt(size[0], 10);\n    }\n\n    if (size[0] === 'auto' && size[1] === 'auto') {\n        height = image.height;\n    } else if (size[1] === 'auto') {\n        height = width / image.width * image.height;\n    } else if (isPercentage(size[1])) {\n        height =  bounds.height * parseFloat(size[1]) / 100;\n    } else {\n        height = parseInt(size[1], 10);\n    }\n\n    if (size[0] === 'auto') {\n        width = height / image.height * image.width;\n    }\n\n    return {width: width, height: height};\n};\n\nNodeContainer.prototype.parseBackgroundPosition = function(bounds, image, index, backgroundSize) {\n    var position = this.cssList('backgroundPosition', index);\n    var left, top;\n\n    if (isPercentage(position[0])){\n        left = (bounds.width - (backgroundSize || image).width) * (parseFloat(position[0]) / 100);\n    } else {\n        left = parseInt(position[0], 10);\n    }\n\n    if (position[1] === 'auto') {\n        top = left / image.width * image.height;\n    } else if (isPercentage(position[1])){\n        top =  (bounds.height - (backgroundSize || image).height) * parseFloat(position[1]) / 100;\n    } else {\n        top = parseInt(position[1], 10);\n    }\n\n    if (position[0] === 'auto') {\n        left = top / image.height * image.width;\n    }\n\n    return {left: left, top: top};\n};\n\nNodeContainer.prototype.parseBackgroundRepeat = function(index) {\n    return this.cssList(\"backgroundRepeat\", index)[0];\n};\n\nNodeContainer.prototype.parseTextShadows = function() {\n    var textShadow = this.css(\"textShadow\");\n    var results = [];\n\n    if (textShadow && textShadow !== 'none') {\n        var shadows = textShadow.match(this.TEXT_SHADOW_PROPERTY);\n        for (var i = 0; shadows && (i < shadows.length); i++) {\n            var s = shadows[i].match(this.TEXT_SHADOW_VALUES);\n            results.push({\n                color: new Color(s[0]),\n                offsetX: s[1] ? parseFloat(s[1].replace('px', '')) : 0,\n                offsetY: s[2] ? parseFloat(s[2].replace('px', '')) : 0,\n                blur: s[3] ? s[3].replace('px', '') : 0\n            });\n        }\n    }\n    return results;\n};\n\nNodeContainer.prototype.parseTransform = function() {\n    if (!this.transformData) {\n        if (this.hasTransform()) {\n            var offset = this.parseBounds();\n            var origin = this.prefixedCss(\"transformOrigin\").split(\" \").map(removePx).map(asFloat);\n            origin[0] += offset.left;\n            origin[1] += offset.top;\n            this.transformData = {\n                origin: origin,\n                matrix: this.parseTransformMatrix()\n            };\n        } else {\n            this.transformData = {\n                origin: [0, 0],\n                matrix: [1, 0, 0, 1, 0, 0]\n            };\n        }\n    }\n    return this.transformData;\n};\n\nNodeContainer.prototype.parseTransformMatrix = function() {\n    if (!this.transformMatrix) {\n        var transform = this.prefixedCss(\"transform\");\n        var matrix = transform ? parseMatrix(transform.match(this.MATRIX_PROPERTY)) : null;\n        this.transformMatrix = matrix ? matrix : [1, 0, 0, 1, 0, 0];\n    }\n    return this.transformMatrix;\n};\n\nNodeContainer.prototype.parseBounds = function() {\n    return this.bounds || (this.bounds = this.hasTransform() ? offsetBounds(this.node) : getBounds(this.node));\n};\n\nNodeContainer.prototype.hasTransform = function() {\n    return this.parseTransformMatrix().join(\",\") !== \"1,0,0,1,0,0\" || (this.parent && this.parent.hasTransform());\n};\n\nNodeContainer.prototype.getValue = function() {\n    var value = this.node.value || \"\";\n    if (this.node.tagName === \"SELECT\") {\n        value = selectionValue(this.node);\n    } else if (this.node.type === \"password\") {\n        value = Array(value.length + 1).join('\\u2022'); // jshint ignore:line\n    }\n    return value.length === 0 ? (this.node.placeholder || \"\") : value;\n};\n\nNodeContainer.prototype.MATRIX_PROPERTY = /(matrix|matrix3d)\\((.+)\\)/;\nNodeContainer.prototype.TEXT_SHADOW_PROPERTY = /((rgba|rgb)\\([^\\)]+\\)(\\s-?\\d+px){0,})/g;\nNodeContainer.prototype.TEXT_SHADOW_VALUES = /(-?\\d+px)|(#.+)|(rgb\\(.+\\))|(rgba\\(.+\\))/g;\nNodeContainer.prototype.CLIP = /^rect\\((\\d+)px,? (\\d+)px,? (\\d+)px,? (\\d+)px\\)$/;\n\nfunction selectionValue(node) {\n    var option = node.options[node.selectedIndex || 0];\n    return option ? (option.text || \"\") : \"\";\n}\n\nfunction parseMatrix(match) {\n    if (match && match[1] === \"matrix\") {\n        return match[2].split(\",\").map(function(s) {\n            return parseFloat(s.trim());\n        });\n    } else if (match && match[1] === \"matrix3d\") {\n        var matrix3d = match[2].split(\",\").map(function(s) {\n          return parseFloat(s.trim());\n        });\n        return [matrix3d[0], matrix3d[1], matrix3d[4], matrix3d[5], matrix3d[12], matrix3d[13]];\n    }\n}\n\nfunction isPercentage(value) {\n    return value.toString().indexOf(\"%\") !== -1;\n}\n\nfunction removePx(str) {\n    return str.replace(\"px\", \"\");\n}\n\nfunction asFloat(str) {\n    return parseFloat(str);\n}\n\nmodule.exports = NodeContainer;\n\n},{\"./color\":3,\"./utils\":26}],15:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\nvar punycode = _dereq_('punycode');\nvar NodeContainer = _dereq_('./nodecontainer');\nvar TextContainer = _dereq_('./textcontainer');\nvar PseudoElementContainer = _dereq_('./pseudoelementcontainer');\nvar FontMetrics = _dereq_('./fontmetrics');\nvar Color = _dereq_('./color');\nvar StackingContext = _dereq_('./stackingcontext');\nvar utils = _dereq_('./utils');\nvar bind = utils.bind;\nvar getBounds = utils.getBounds;\nvar parseBackgrounds = utils.parseBackgrounds;\nvar offsetBounds = utils.offsetBounds;\n\nfunction NodeParser(element, renderer, support, imageLoader, options) {\n    log(\"Starting NodeParser\");\n    this.renderer = renderer;\n    this.options = options;\n    this.range = null;\n    this.support = support;\n    this.renderQueue = [];\n    this.stack = new StackingContext(true, 1, element.ownerDocument, null);\n    var parent = new NodeContainer(element, null);\n    if (options.background) {\n        renderer.rectangle(0, 0, renderer.width, renderer.height, new Color(options.background));\n    }\n    if (element === element.ownerDocument.documentElement) {\n        // http://www.w3.org/TR/css3-background/#special-backgrounds\n        var canvasBackground = new NodeContainer(parent.color('backgroundColor').isTransparent() ? element.ownerDocument.body : element.ownerDocument.documentElement, null);\n        renderer.rectangle(0, 0, renderer.width, renderer.height, canvasBackground.color('backgroundColor'));\n    }\n    parent.visibile = parent.isElementVisible();\n    this.createPseudoHideStyles(element.ownerDocument);\n    this.disableAnimations(element.ownerDocument);\n    this.nodes = flatten([parent].concat(this.getChildren(parent)).filter(function(container) {\n        return container.visible = container.isElementVisible();\n    }).map(this.getPseudoElements, this));\n    this.fontMetrics = new FontMetrics();\n    log(\"Fetched nodes, total:\", this.nodes.length);\n    log(\"Calculate overflow clips\");\n    this.calculateOverflowClips();\n    log(\"Start fetching images\");\n    this.images = imageLoader.fetch(this.nodes.filter(isElement));\n    this.ready = this.images.ready.then(bind(function() {\n        log(\"Images loaded, starting parsing\");\n        log(\"Creating stacking contexts\");\n        this.createStackingContexts();\n        log(\"Sorting stacking contexts\");\n        this.sortStackingContexts(this.stack);\n        this.parse(this.stack);\n        log(\"Render queue created with \" + this.renderQueue.length + \" items\");\n        return new Promise(bind(function(resolve) {\n            if (!options.async) {\n                this.renderQueue.forEach(this.paint, this);\n                resolve();\n            } else if (typeof(options.async) === \"function\") {\n                options.async.call(this, this.renderQueue, resolve);\n            } else if (this.renderQueue.length > 0){\n                this.renderIndex = 0;\n                this.asyncRenderer(this.renderQueue, resolve);\n            } else {\n                resolve();\n            }\n        }, this));\n    }, this));\n}\n\nNodeParser.prototype.calculateOverflowClips = function() {\n    this.nodes.forEach(function(container) {\n        if (isElement(container)) {\n            if (isPseudoElement(container)) {\n                container.appendToDOM();\n            }\n            container.borders = this.parseBorders(container);\n            var clip = (container.css('overflow') === \"hidden\") ? [container.borders.clip] : [];\n            var cssClip = container.parseClip();\n            if (cssClip && [\"absolute\", \"fixed\"].indexOf(container.css('position')) !== -1) {\n                clip.push([[\"rect\",\n                        container.bounds.left + cssClip.left,\n                        container.bounds.top + cssClip.top,\n                        cssClip.right - cssClip.left,\n                        cssClip.bottom - cssClip.top\n                ]]);\n            }\n            container.clip = hasParentClip(container) ? container.parent.clip.concat(clip) : clip;\n            container.backgroundClip = (container.css('overflow') !== \"hidden\") ? container.clip.concat([container.borders.clip]) : container.clip;\n            if (isPseudoElement(container)) {\n                container.cleanDOM();\n            }\n        } else if (isTextNode(container)) {\n            container.clip = hasParentClip(container) ? container.parent.clip : [];\n        }\n        if (!isPseudoElement(container)) {\n            container.bounds = null;\n        }\n    }, this);\n};\n\nfunction hasParentClip(container) {\n    return container.parent && container.parent.clip.length;\n}\n\nNodeParser.prototype.asyncRenderer = function(queue, resolve, asyncTimer) {\n    asyncTimer = asyncTimer || Date.now();\n    this.paint(queue[this.renderIndex++]);\n    if (queue.length === this.renderIndex) {\n        resolve();\n    } else if (asyncTimer + 20 > Date.now()) {\n        this.asyncRenderer(queue, resolve, asyncTimer);\n    } else {\n        setTimeout(bind(function() {\n            this.asyncRenderer(queue, resolve);\n        }, this), 0);\n    }\n};\n\nNodeParser.prototype.createPseudoHideStyles = function(document) {\n    this.createStyles(document, '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + ':before { content: \"\" !important; display: none !important; }' +\n        '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER + ':after { content: \"\" !important; display: none !important; }');\n};\n\nNodeParser.prototype.disableAnimations = function(document) {\n    this.createStyles(document, '* { -webkit-animation: none !important; -moz-animation: none !important; -o-animation: none !important; animation: none !important; ' +\n        '-webkit-transition: none !important; -moz-transition: none !important; -o-transition: none !important; transition: none !important;}');\n};\n\nNodeParser.prototype.createStyles = function(document, styles) {\n    var hidePseudoElements = document.createElement('style');\n    hidePseudoElements.innerHTML = styles;\n    document.body.appendChild(hidePseudoElements);\n};\n\nNodeParser.prototype.getPseudoElements = function(container) {\n    var nodes = [[container]];\n    if (container.node.nodeType === Node.ELEMENT_NODE) {\n        var before = this.getPseudoElement(container, \":before\");\n        var after = this.getPseudoElement(container, \":after\");\n\n        if (before) {\n            nodes.push(before);\n        }\n\n        if (after) {\n            nodes.push(after);\n        }\n    }\n    return flatten(nodes);\n};\n\nfunction toCamelCase(str) {\n    return str.replace(/(\\-[a-z])/g, function(match){\n        return match.toUpperCase().replace('-','');\n    });\n}\n\nNodeParser.prototype.getPseudoElement = function(container, type) {\n    var style = container.computedStyle(type);\n    if(!style || !style.content || style.content === \"none\" || style.content === \"-moz-alt-content\" || style.display === \"none\") {\n        return null;\n    }\n\n    var content = stripQuotes(style.content);\n    var isImage = content.substr(0, 3) === 'url';\n    var pseudoNode = document.createElement(isImage ? 'img' : 'html2canvaspseudoelement');\n    var pseudoContainer = new PseudoElementContainer(pseudoNode, container, type);\n\n    for (var i = style.length-1; i >= 0; i--) {\n        var property = toCamelCase(style.item(i));\n        pseudoNode.style[property] = style[property];\n    }\n\n    pseudoNode.className = PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + \" \" + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER;\n\n    if (isImage) {\n        pseudoNode.src = parseBackgrounds(content)[0].args[0];\n        return [pseudoContainer];\n    } else {\n        var text = document.createTextNode(content);\n        pseudoNode.appendChild(text);\n        return [pseudoContainer, new TextContainer(text, pseudoContainer)];\n    }\n};\n\n\nNodeParser.prototype.getChildren = function(parentContainer) {\n    return flatten([].filter.call(parentContainer.node.childNodes, renderableNode).map(function(node) {\n        var container = [node.nodeType === Node.TEXT_NODE ? new TextContainer(node, parentContainer) : new NodeContainer(node, parentContainer)].filter(nonIgnoredElement);\n        return node.nodeType === Node.ELEMENT_NODE && container.length && node.tagName !== \"TEXTAREA\" ? (container[0].isElementVisible() ? container.concat(this.getChildren(container[0])) : []) : container;\n    }, this));\n};\n\nNodeParser.prototype.newStackingContext = function(container, hasOwnStacking) {\n    var stack = new StackingContext(hasOwnStacking, container.getOpacity(), container.node, container.parent);\n    container.cloneTo(stack);\n    var parentStack = hasOwnStacking ? stack.getParentStack(this) : stack.parent.stack;\n    parentStack.contexts.push(stack);\n    container.stack = stack;\n};\n\nNodeParser.prototype.createStackingContexts = function() {\n    this.nodes.forEach(function(container) {\n        if (isElement(container) && (this.isRootElement(container) || hasOpacity(container) || isPositionedForStacking(container) || this.isBodyWithTransparentRoot(container) || container.hasTransform())) {\n            this.newStackingContext(container, true);\n        } else if (isElement(container) && ((isPositioned(container) && zIndex0(container)) || isInlineBlock(container) || isFloating(container))) {\n            this.newStackingContext(container, false);\n        } else {\n            container.assignStack(container.parent.stack);\n        }\n    }, this);\n};\n\nNodeParser.prototype.isBodyWithTransparentRoot = function(container) {\n    return container.node.nodeName === \"BODY\" && container.parent.color('backgroundColor').isTransparent();\n};\n\nNodeParser.prototype.isRootElement = function(container) {\n    return container.parent === null;\n};\n\nNodeParser.prototype.sortStackingContexts = function(stack) {\n    stack.contexts.sort(zIndexSort(stack.contexts.slice(0)));\n    stack.contexts.forEach(this.sortStackingContexts, this);\n};\n\nNodeParser.prototype.parseTextBounds = function(container) {\n    return function(text, index, textList) {\n        if (container.parent.css(\"textDecoration\").substr(0, 4) !== \"none\" || text.trim().length !== 0) {\n            if (this.support.rangeBounds && !container.parent.hasTransform()) {\n                var offset = textList.slice(0, index).join(\"\").length;\n                return this.getRangeBounds(container.node, offset, text.length);\n            } else if (container.node && typeof(container.node.data) === \"string\") {\n                var replacementNode = container.node.splitText(text.length);\n                var bounds = this.getWrapperBounds(container.node, container.parent.hasTransform());\n                container.node = replacementNode;\n                return bounds;\n            }\n        } else if(!this.support.rangeBounds || container.parent.hasTransform()){\n            container.node = container.node.splitText(text.length);\n        }\n        return {};\n    };\n};\n\nNodeParser.prototype.getWrapperBounds = function(node, transform) {\n    var wrapper = node.ownerDocument.createElement('html2canvaswrapper');\n    var parent = node.parentNode,\n        backupText = node.cloneNode(true);\n\n    wrapper.appendChild(node.cloneNode(true));\n    parent.replaceChild(wrapper, node);\n    var bounds = transform ? offsetBounds(wrapper) : getBounds(wrapper);\n    parent.replaceChild(backupText, wrapper);\n    return bounds;\n};\n\nNodeParser.prototype.getRangeBounds = function(node, offset, length) {\n    var range = this.range || (this.range = node.ownerDocument.createRange());\n    range.setStart(node, offset);\n    range.setEnd(node, offset + length);\n    return range.getBoundingClientRect();\n};\n\nfunction ClearTransform() {}\n\nNodeParser.prototype.parse = function(stack) {\n    // http://www.w3.org/TR/CSS21/visuren.html#z-index\n    var negativeZindex = stack.contexts.filter(negativeZIndex); // 2. the child stacking contexts with negative stack levels (most negative first).\n    var descendantElements = stack.children.filter(isElement);\n    var descendantNonFloats = descendantElements.filter(not(isFloating));\n    var nonInlineNonPositionedDescendants = descendantNonFloats.filter(not(isPositioned)).filter(not(inlineLevel)); // 3 the in-flow, non-inline-level, non-positioned descendants.\n    var nonPositionedFloats = descendantElements.filter(not(isPositioned)).filter(isFloating); // 4. the non-positioned floats.\n    var inFlow = descendantNonFloats.filter(not(isPositioned)).filter(inlineLevel); // 5. the in-flow, inline-level, non-positioned descendants, including inline tables and inline blocks.\n    var stackLevel0 = stack.contexts.concat(descendantNonFloats.filter(isPositioned)).filter(zIndex0); // 6. the child stacking contexts with stack level 0 and the positioned descendants with stack level 0.\n    var text = stack.children.filter(isTextNode).filter(hasText);\n    var positiveZindex = stack.contexts.filter(positiveZIndex); // 7. the child stacking contexts with positive stack levels (least positive first).\n    negativeZindex.concat(nonInlineNonPositionedDescendants).concat(nonPositionedFloats)\n        .concat(inFlow).concat(stackLevel0).concat(text).concat(positiveZindex).forEach(function(container) {\n            this.renderQueue.push(container);\n            if (isStackingContext(container)) {\n                this.parse(container);\n                this.renderQueue.push(new ClearTransform());\n            }\n        }, this);\n};\n\nNodeParser.prototype.paint = function(container) {\n    try {\n        if (container instanceof ClearTransform) {\n            this.renderer.ctx.restore();\n        } else if (isTextNode(container)) {\n            if (isPseudoElement(container.parent)) {\n                container.parent.appendToDOM();\n            }\n            this.paintText(container);\n            if (isPseudoElement(container.parent)) {\n                container.parent.cleanDOM();\n            }\n        } else {\n            this.paintNode(container);\n        }\n    } catch(e) {\n        log(e);\n        if (this.options.strict) {\n            throw e;\n        }\n    }\n};\n\nNodeParser.prototype.paintNode = function(container) {\n    if (isStackingContext(container)) {\n        this.renderer.setOpacity(container.opacity);\n        this.renderer.ctx.save();\n        if (container.hasTransform()) {\n            this.renderer.setTransform(container.parseTransform());\n        }\n    }\n\n    if (container.node.nodeName === \"INPUT\" && container.node.type === \"checkbox\") {\n        this.paintCheckbox(container);\n    } else if (container.node.nodeName === \"INPUT\" && container.node.type === \"radio\") {\n        this.paintRadio(container);\n    } else {\n        this.paintElement(container);\n    }\n};\n\nNodeParser.prototype.paintElement = function(container) {\n    var bounds = container.parseBounds();\n    this.renderer.clip(container.backgroundClip, function() {\n        this.renderer.renderBackground(container, bounds, container.borders.borders.map(getWidth));\n    }, this);\n\n    this.renderer.clip(container.clip, function() {\n        this.renderer.renderBorders(container.borders.borders);\n    }, this);\n\n    this.renderer.clip(container.backgroundClip, function() {\n        switch (container.node.nodeName) {\n        case \"svg\":\n        case \"IFRAME\":\n            var imgContainer = this.images.get(container.node);\n            if (imgContainer) {\n                this.renderer.renderImage(container, bounds, container.borders, imgContainer);\n            } else {\n                log(\"Error loading <\" + container.node.nodeName + \">\", container.node);\n            }\n            break;\n        case \"IMG\":\n            var imageContainer = this.images.get(container.node.src);\n            if (imageContainer) {\n                this.renderer.renderImage(container, bounds, container.borders, imageContainer);\n            } else {\n                log(\"Error loading <img>\", container.node.src);\n            }\n            break;\n        case \"CANVAS\":\n            this.renderer.renderImage(container, bounds, container.borders, {image: container.node});\n            break;\n        case \"SELECT\":\n        case \"INPUT\":\n        case \"TEXTAREA\":\n            this.paintFormValue(container);\n            break;\n        }\n    }, this);\n};\n\nNodeParser.prototype.paintCheckbox = function(container) {\n    var b = container.parseBounds();\n\n    var size = Math.min(b.width, b.height);\n    var bounds = {width: size - 1, height: size - 1, top: b.top, left: b.left};\n    var r = [3, 3];\n    var radius = [r, r, r, r];\n    var borders = [1,1,1,1].map(function(w) {\n        return {color: new Color('#A5A5A5'), width: w};\n    });\n\n    var borderPoints = calculateCurvePoints(bounds, radius, borders);\n\n    this.renderer.clip(container.backgroundClip, function() {\n        this.renderer.rectangle(bounds.left + 1, bounds.top + 1, bounds.width - 2, bounds.height - 2, new Color(\"#DEDEDE\"));\n        this.renderer.renderBorders(calculateBorders(borders, bounds, borderPoints, radius));\n        if (container.node.checked) {\n            this.renderer.font(new Color('#424242'), 'normal', 'normal', 'bold', (size - 3) + \"px\", 'arial');\n            this.renderer.text(\"\\u2714\", bounds.left + size / 6, bounds.top + size - 1);\n        }\n    }, this);\n};\n\nNodeParser.prototype.paintRadio = function(container) {\n    var bounds = container.parseBounds();\n\n    var size = Math.min(bounds.width, bounds.height) - 2;\n\n    this.renderer.clip(container.backgroundClip, function() {\n        this.renderer.circleStroke(bounds.left + 1, bounds.top + 1, size, new Color('#DEDEDE'), 1, new Color('#A5A5A5'));\n        if (container.node.checked) {\n            this.renderer.circle(Math.ceil(bounds.left + size / 4) + 1, Math.ceil(bounds.top + size / 4) + 1, Math.floor(size / 2), new Color('#424242'));\n        }\n    }, this);\n};\n\nNodeParser.prototype.paintFormValue = function(container) {\n    var value = container.getValue();\n    if (value.length > 0) {\n        var document = container.node.ownerDocument;\n        var wrapper = document.createElement('html2canvaswrapper');\n        var properties = ['lineHeight', 'textAlign', 'fontFamily', 'fontWeight', 'fontSize', 'color',\n            'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom',\n            'width', 'height', 'borderLeftStyle', 'borderTopStyle', 'borderLeftWidth', 'borderTopWidth',\n            'boxSizing', 'whiteSpace', 'wordWrap'];\n\n        properties.forEach(function(property) {\n            try {\n                wrapper.style[property] = container.css(property);\n            } catch(e) {\n                // Older IE has issues with \"border\"\n                log(\"html2canvas: Parse: Exception caught in renderFormValue: \" + e.message);\n            }\n        });\n        var bounds = container.parseBounds();\n        wrapper.style.position = \"fixed\";\n        wrapper.style.left = bounds.left + \"px\";\n        wrapper.style.top = bounds.top + \"px\";\n        wrapper.textContent = value;\n        document.body.appendChild(wrapper);\n        this.paintText(new TextContainer(wrapper.firstChild, container));\n        document.body.removeChild(wrapper);\n    }\n};\n\nNodeParser.prototype.paintText = function(container) {\n    container.applyTextTransform();\n    var characters = punycode.ucs2.decode(container.node.data);\n    var textList = (!this.options.letterRendering || noLetterSpacing(container)) && !hasUnicode(container.node.data) ? getWords(characters) : characters.map(function(character) {\n        return punycode.ucs2.encode([character]);\n    });\n\n    var weight = container.parent.fontWeight();\n    var size = container.parent.css('fontSize');\n    var family = container.parent.css('fontFamily');\n    var shadows = container.parent.parseTextShadows();\n\n    this.renderer.font(container.parent.color('color'), container.parent.css('fontStyle'), container.parent.css('fontVariant'), weight, size, family);\n    if (shadows.length) {\n        // TODO: support multiple text shadows\n        this.renderer.fontShadow(shadows[0].color, shadows[0].offsetX, shadows[0].offsetY, shadows[0].blur);\n    } else {\n        this.renderer.clearShadow();\n    }\n\n    this.renderer.clip(container.parent.clip, function() {\n        textList.map(this.parseTextBounds(container), this).forEach(function(bounds, index) {\n            if (bounds) {\n                this.renderer.text(textList[index], bounds.left, bounds.bottom);\n                this.renderTextDecoration(container.parent, bounds, this.fontMetrics.getMetrics(family, size));\n            }\n        }, this);\n    }, this);\n};\n\nNodeParser.prototype.renderTextDecoration = function(container, bounds, metrics) {\n    switch(container.css(\"textDecoration\").split(\" \")[0]) {\n    case \"underline\":\n        // Draws a line at the baseline of the font\n        // TODO As some browsers display the line as more than 1px if the font-size is big, need to take that into account both in position and size\n        this.renderer.rectangle(bounds.left, Math.round(bounds.top + metrics.baseline + metrics.lineWidth), bounds.width, 1, container.color(\"color\"));\n        break;\n    case \"overline\":\n        this.renderer.rectangle(bounds.left, Math.round(bounds.top), bounds.width, 1, container.color(\"color\"));\n        break;\n    case \"line-through\":\n        // TODO try and find exact position for line-through\n        this.renderer.rectangle(bounds.left, Math.ceil(bounds.top + metrics.middle + metrics.lineWidth), bounds.width, 1, container.color(\"color\"));\n        break;\n    }\n};\n\nvar borderColorTransforms = {\n    inset: [\n        [\"darken\", 0.60],\n        [\"darken\", 0.10],\n        [\"darken\", 0.10],\n        [\"darken\", 0.60]\n    ]\n};\n\nNodeParser.prototype.parseBorders = function(container) {\n    var nodeBounds = container.parseBounds();\n    var radius = getBorderRadiusData(container);\n    var borders = [\"Top\", \"Right\", \"Bottom\", \"Left\"].map(function(side, index) {\n        var style = container.css('border' + side + 'Style');\n        var color = container.color('border' + side + 'Color');\n        if (style === \"inset\" && color.isBlack()) {\n            color = new Color([255, 255, 255, color.a]); // this is wrong, but\n        }\n        var colorTransform = borderColorTransforms[style] ? borderColorTransforms[style][index] : null;\n        return {\n            width: container.cssInt('border' + side + 'Width'),\n            color: colorTransform ? color[colorTransform[0]](colorTransform[1]) : color,\n            args: null\n        };\n    });\n    var borderPoints = calculateCurvePoints(nodeBounds, radius, borders);\n\n    return {\n        clip: this.parseBackgroundClip(container, borderPoints, borders, radius, nodeBounds),\n        borders: calculateBorders(borders, nodeBounds, borderPoints, radius)\n    };\n};\n\nfunction calculateBorders(borders, nodeBounds, borderPoints, radius) {\n    return borders.map(function(border, borderSide) {\n        if (border.width > 0) {\n            var bx = nodeBounds.left;\n            var by = nodeBounds.top;\n            var bw = nodeBounds.width;\n            var bh = nodeBounds.height - (borders[2].width);\n\n            switch(borderSide) {\n            case 0:\n                // top border\n                bh = borders[0].width;\n                border.args = drawSide({\n                        c1: [bx, by],\n                        c2: [bx + bw, by],\n                        c3: [bx + bw - borders[1].width, by + bh],\n                        c4: [bx + borders[3].width, by + bh]\n                    }, radius[0], radius[1],\n                    borderPoints.topLeftOuter, borderPoints.topLeftInner, borderPoints.topRightOuter, borderPoints.topRightInner);\n                break;\n            case 1:\n                // right border\n                bx = nodeBounds.left + nodeBounds.width - (borders[1].width);\n                bw = borders[1].width;\n\n                border.args = drawSide({\n                        c1: [bx + bw, by],\n                        c2: [bx + bw, by + bh + borders[2].width],\n                        c3: [bx, by + bh],\n                        c4: [bx, by + borders[0].width]\n                    }, radius[1], radius[2],\n                    borderPoints.topRightOuter, borderPoints.topRightInner, borderPoints.bottomRightOuter, borderPoints.bottomRightInner);\n                break;\n            case 2:\n                // bottom border\n                by = (by + nodeBounds.height) - (borders[2].width);\n                bh = borders[2].width;\n                border.args = drawSide({\n                        c1: [bx + bw, by + bh],\n                        c2: [bx, by + bh],\n                        c3: [bx + borders[3].width, by],\n                        c4: [bx + bw - borders[3].width, by]\n                    }, radius[2], radius[3],\n                    borderPoints.bottomRightOuter, borderPoints.bottomRightInner, borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner);\n                break;\n            case 3:\n                // left border\n                bw = borders[3].width;\n                border.args = drawSide({\n                        c1: [bx, by + bh + borders[2].width],\n                        c2: [bx, by],\n                        c3: [bx + bw, by + borders[0].width],\n                        c4: [bx + bw, by + bh]\n                    }, radius[3], radius[0],\n                    borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner, borderPoints.topLeftOuter, borderPoints.topLeftInner);\n                break;\n            }\n        }\n        return border;\n    });\n}\n\nNodeParser.prototype.parseBackgroundClip = function(container, borderPoints, borders, radius, bounds) {\n    var backgroundClip = container.css('backgroundClip'),\n        borderArgs = [];\n\n    switch(backgroundClip) {\n    case \"content-box\":\n    case \"padding-box\":\n        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftInner, borderPoints.topRightInner, bounds.left + borders[3].width, bounds.top + borders[0].width);\n        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightInner, borderPoints.bottomRightInner, bounds.left + bounds.width - borders[1].width, bounds.top + borders[0].width);\n        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightInner, borderPoints.bottomLeftInner, bounds.left + bounds.width - borders[1].width, bounds.top + bounds.height - borders[2].width);\n        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftInner, borderPoints.topLeftInner, bounds.left + borders[3].width, bounds.top + bounds.height - borders[2].width);\n        break;\n\n    default:\n        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftOuter, borderPoints.topRightOuter, bounds.left, bounds.top);\n        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightOuter, borderPoints.bottomRightOuter, bounds.left + bounds.width, bounds.top);\n        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightOuter, borderPoints.bottomLeftOuter, bounds.left + bounds.width, bounds.top + bounds.height);\n        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftOuter, borderPoints.topLeftOuter, bounds.left, bounds.top + bounds.height);\n        break;\n    }\n\n    return borderArgs;\n};\n\nfunction getCurvePoints(x, y, r1, r2) {\n    var kappa = 4 * ((Math.sqrt(2) - 1) / 3);\n    var ox = (r1) * kappa, // control point offset horizontal\n        oy = (r2) * kappa, // control point offset vertical\n        xm = x + r1, // x-middle\n        ym = y + r2; // y-middle\n    return {\n        topLeft: bezierCurve({x: x, y: ym}, {x: x, y: ym - oy}, {x: xm - ox, y: y}, {x: xm, y: y}),\n        topRight: bezierCurve({x: x, y: y}, {x: x + ox,y: y}, {x: xm, y: ym - oy}, {x: xm, y: ym}),\n        bottomRight: bezierCurve({x: xm, y: y}, {x: xm, y: y + oy}, {x: x + ox, y: ym}, {x: x, y: ym}),\n        bottomLeft: bezierCurve({x: xm, y: ym}, {x: xm - ox, y: ym}, {x: x, y: y + oy}, {x: x, y:y})\n    };\n}\n\nfunction calculateCurvePoints(bounds, borderRadius, borders) {\n    var x = bounds.left,\n        y = bounds.top,\n        width = bounds.width,\n        height = bounds.height,\n\n        tlh = borderRadius[0][0] < width / 2 ? borderRadius[0][0] : width / 2,\n        tlv = borderRadius[0][1] < height / 2 ? borderRadius[0][1] : height / 2,\n        trh = borderRadius[1][0] < width / 2 ? borderRadius[1][0] : width / 2,\n        trv = borderRadius[1][1] < height / 2 ? borderRadius[1][1] : height / 2,\n        brh = borderRadius[2][0] < width / 2 ? borderRadius[2][0] : width / 2,\n        brv = borderRadius[2][1] < height / 2 ? borderRadius[2][1] : height / 2,\n        blh = borderRadius[3][0] < width / 2 ? borderRadius[3][0] : width / 2,\n        blv = borderRadius[3][1] < height / 2 ? borderRadius[3][1] : height / 2;\n\n    var topWidth = width - trh,\n        rightHeight = height - brv,\n        bottomWidth = width - brh,\n        leftHeight = height - blv;\n\n    return {\n        topLeftOuter: getCurvePoints(x, y, tlh, tlv).topLeft.subdivide(0.5),\n        topLeftInner: getCurvePoints(x + borders[3].width, y + borders[0].width, Math.max(0, tlh - borders[3].width), Math.max(0, tlv - borders[0].width)).topLeft.subdivide(0.5),\n        topRightOuter: getCurvePoints(x + topWidth, y, trh, trv).topRight.subdivide(0.5),\n        topRightInner: getCurvePoints(x + Math.min(topWidth, width + borders[3].width), y + borders[0].width, (topWidth > width + borders[3].width) ? 0 :trh - borders[3].width, trv - borders[0].width).topRight.subdivide(0.5),\n        bottomRightOuter: getCurvePoints(x + bottomWidth, y + rightHeight, brh, brv).bottomRight.subdivide(0.5),\n        bottomRightInner: getCurvePoints(x + Math.min(bottomWidth, width - borders[3].width), y + Math.min(rightHeight, height + borders[0].width), Math.max(0, brh - borders[1].width),  brv - borders[2].width).bottomRight.subdivide(0.5),\n        bottomLeftOuter: getCurvePoints(x, y + leftHeight, blh, blv).bottomLeft.subdivide(0.5),\n        bottomLeftInner: getCurvePoints(x + borders[3].width, y + leftHeight, Math.max(0, blh - borders[3].width), blv - borders[2].width).bottomLeft.subdivide(0.5)\n    };\n}\n\nfunction bezierCurve(start, startControl, endControl, end) {\n    var lerp = function (a, b, t) {\n        return {\n            x: a.x + (b.x - a.x) * t,\n            y: a.y + (b.y - a.y) * t\n        };\n    };\n\n    return {\n        start: start,\n        startControl: startControl,\n        endControl: endControl,\n        end: end,\n        subdivide: function(t) {\n            var ab = lerp(start, startControl, t),\n                bc = lerp(startControl, endControl, t),\n                cd = lerp(endControl, end, t),\n                abbc = lerp(ab, bc, t),\n                bccd = lerp(bc, cd, t),\n                dest = lerp(abbc, bccd, t);\n            return [bezierCurve(start, ab, abbc, dest), bezierCurve(dest, bccd, cd, end)];\n        },\n        curveTo: function(borderArgs) {\n            borderArgs.push([\"bezierCurve\", startControl.x, startControl.y, endControl.x, endControl.y, end.x, end.y]);\n        },\n        curveToReversed: function(borderArgs) {\n            borderArgs.push([\"bezierCurve\", endControl.x, endControl.y, startControl.x, startControl.y, start.x, start.y]);\n        }\n    };\n}\n\nfunction drawSide(borderData, radius1, radius2, outer1, inner1, outer2, inner2) {\n    var borderArgs = [];\n\n    if (radius1[0] > 0 || radius1[1] > 0) {\n        borderArgs.push([\"line\", outer1[1].start.x, outer1[1].start.y]);\n        outer1[1].curveTo(borderArgs);\n    } else {\n        borderArgs.push([ \"line\", borderData.c1[0], borderData.c1[1]]);\n    }\n\n    if (radius2[0] > 0 || radius2[1] > 0) {\n        borderArgs.push([\"line\", outer2[0].start.x, outer2[0].start.y]);\n        outer2[0].curveTo(borderArgs);\n        borderArgs.push([\"line\", inner2[0].end.x, inner2[0].end.y]);\n        inner2[0].curveToReversed(borderArgs);\n    } else {\n        borderArgs.push([\"line\", borderData.c2[0], borderData.c2[1]]);\n        borderArgs.push([\"line\", borderData.c3[0], borderData.c3[1]]);\n    }\n\n    if (radius1[0] > 0 || radius1[1] > 0) {\n        borderArgs.push([\"line\", inner1[1].end.x, inner1[1].end.y]);\n        inner1[1].curveToReversed(borderArgs);\n    } else {\n        borderArgs.push([\"line\", borderData.c4[0], borderData.c4[1]]);\n    }\n\n    return borderArgs;\n}\n\nfunction parseCorner(borderArgs, radius1, radius2, corner1, corner2, x, y) {\n    if (radius1[0] > 0 || radius1[1] > 0) {\n        borderArgs.push([\"line\", corner1[0].start.x, corner1[0].start.y]);\n        corner1[0].curveTo(borderArgs);\n        corner1[1].curveTo(borderArgs);\n    } else {\n        borderArgs.push([\"line\", x, y]);\n    }\n\n    if (radius2[0] > 0 || radius2[1] > 0) {\n        borderArgs.push([\"line\", corner2[0].start.x, corner2[0].start.y]);\n    }\n}\n\nfunction negativeZIndex(container) {\n    return container.cssInt(\"zIndex\") < 0;\n}\n\nfunction positiveZIndex(container) {\n    return container.cssInt(\"zIndex\") > 0;\n}\n\nfunction zIndex0(container) {\n    return container.cssInt(\"zIndex\") === 0;\n}\n\nfunction inlineLevel(container) {\n    return [\"inline\", \"inline-block\", \"inline-table\"].indexOf(container.css(\"display\")) !== -1;\n}\n\nfunction isStackingContext(container) {\n    return (container instanceof StackingContext);\n}\n\nfunction hasText(container) {\n    return container.node.data.trim().length > 0;\n}\n\nfunction noLetterSpacing(container) {\n    return (/^(normal|none|0px)$/.test(container.parent.css(\"letterSpacing\")));\n}\n\nfunction getBorderRadiusData(container) {\n    return [\"TopLeft\", \"TopRight\", \"BottomRight\", \"BottomLeft\"].map(function(side) {\n        var value = container.css('border' + side + 'Radius');\n        var arr = value.split(\" \");\n        if (arr.length <= 1) {\n            arr[1] = arr[0];\n        }\n        return arr.map(asInt);\n    });\n}\n\nfunction renderableNode(node) {\n    return (node.nodeType === Node.TEXT_NODE || node.nodeType === Node.ELEMENT_NODE);\n}\n\nfunction isPositionedForStacking(container) {\n    var position = container.css(\"position\");\n    var zIndex = ([\"absolute\", \"relative\", \"fixed\"].indexOf(position) !== -1) ? container.css(\"zIndex\") : \"auto\";\n    return zIndex !== \"auto\";\n}\n\nfunction isPositioned(container) {\n    return container.css(\"position\") !== \"static\";\n}\n\nfunction isFloating(container) {\n    return container.css(\"float\") !== \"none\";\n}\n\nfunction isInlineBlock(container) {\n    return [\"inline-block\", \"inline-table\"].indexOf(container.css(\"display\")) !== -1;\n}\n\nfunction not(callback) {\n    var context = this;\n    return function() {\n        return !callback.apply(context, arguments);\n    };\n}\n\nfunction isElement(container) {\n    return container.node.nodeType === Node.ELEMENT_NODE;\n}\n\nfunction isPseudoElement(container) {\n    return container.isPseudoElement === true;\n}\n\nfunction isTextNode(container) {\n    return container.node.nodeType === Node.TEXT_NODE;\n}\n\nfunction zIndexSort(contexts) {\n    return function(a, b) {\n        return (a.cssInt(\"zIndex\") + (contexts.indexOf(a) / contexts.length)) - (b.cssInt(\"zIndex\") + (contexts.indexOf(b) / contexts.length));\n    };\n}\n\nfunction hasOpacity(container) {\n    return container.getOpacity() < 1;\n}\n\nfunction asInt(value) {\n    return parseInt(value, 10);\n}\n\nfunction getWidth(border) {\n    return border.width;\n}\n\nfunction nonIgnoredElement(nodeContainer) {\n    return (nodeContainer.node.nodeType !== Node.ELEMENT_NODE || [\"SCRIPT\", \"HEAD\", \"TITLE\", \"OBJECT\", \"BR\", \"OPTION\"].indexOf(nodeContainer.node.nodeName) === -1);\n}\n\nfunction flatten(arrays) {\n    return [].concat.apply([], arrays);\n}\n\nfunction stripQuotes(content) {\n    var first = content.substr(0, 1);\n    return (first === content.substr(content.length - 1) && first.match(/'|\"/)) ? content.substr(1, content.length - 2) : content;\n}\n\nfunction getWords(characters) {\n    var words = [], i = 0, onWordBoundary = false, word;\n    while(characters.length) {\n        if (isWordBoundary(characters[i]) === onWordBoundary) {\n            word = characters.splice(0, i);\n            if (word.length) {\n                words.push(punycode.ucs2.encode(word));\n            }\n            onWordBoundary =! onWordBoundary;\n            i = 0;\n        } else {\n            i++;\n        }\n\n        if (i >= characters.length) {\n            word = characters.splice(0, i);\n            if (word.length) {\n                words.push(punycode.ucs2.encode(word));\n            }\n        }\n    }\n    return words;\n}\n\nfunction isWordBoundary(characterCode) {\n    return [\n        32, // <space>\n        13, // \\r\n        10, // \\n\n        9, // \\t\n        45 // -\n    ].indexOf(characterCode) !== -1;\n}\n\nfunction hasUnicode(string) {\n    return (/[^\\u0000-\\u00ff]/).test(string);\n}\n\nmodule.exports = NodeParser;\n\n},{\"./color\":3,\"./fontmetrics\":7,\"./log\":13,\"./nodecontainer\":14,\"./pseudoelementcontainer\":18,\"./stackingcontext\":21,\"./textcontainer\":25,\"./utils\":26,\"punycode\":1}],16:[function(_dereq_,module,exports){\nvar XHR = _dereq_('./xhr');\nvar utils = _dereq_('./utils');\nvar log = _dereq_('./log');\nvar createWindowClone = _dereq_('./clone');\nvar decode64 = utils.decode64;\n\nfunction Proxy(src, proxyUrl, document) {\n    var supportsCORS = ('withCredentials' in new XMLHttpRequest());\n    if (!proxyUrl) {\n        return Promise.reject(\"No proxy configured\");\n    }\n    var callback = createCallback(supportsCORS);\n    var url = createProxyUrl(proxyUrl, src, callback);\n\n    return supportsCORS ? XHR(url) : (jsonp(document, url, callback).then(function(response) {\n        return decode64(response.content);\n    }));\n}\nvar proxyCount = 0;\n\nfunction ProxyURL(src, proxyUrl, document) {\n    var supportsCORSImage = ('crossOrigin' in new Image());\n    var callback = createCallback(supportsCORSImage);\n    var url = createProxyUrl(proxyUrl, src, callback);\n    return (supportsCORSImage ? Promise.resolve(url) : jsonp(document, url, callback).then(function(response) {\n        return \"data:\" + response.type + \";base64,\" + response.content;\n    }));\n}\n\nfunction jsonp(document, url, callback) {\n    return new Promise(function(resolve, reject) {\n        var s = document.createElement(\"script\");\n        var cleanup = function() {\n            delete window.html2canvas.proxy[callback];\n            document.body.removeChild(s);\n        };\n        window.html2canvas.proxy[callback] = function(response) {\n            cleanup();\n            resolve(response);\n        };\n        s.src = url;\n        s.onerror = function(e) {\n            cleanup();\n            reject(e);\n        };\n        document.body.appendChild(s);\n    });\n}\n\nfunction createCallback(useCORS) {\n    return !useCORS ? \"html2canvas_\" + Date.now() + \"_\" + (++proxyCount) + \"_\" + Math.round(Math.random() * 100000) : \"\";\n}\n\nfunction createProxyUrl(proxyUrl, src, callback) {\n    return proxyUrl + \"?url=\" + encodeURIComponent(src) + (callback.length ? \"&callback=html2canvas.proxy.\" + callback : \"\");\n}\n\nfunction documentFromHTML(src) {\n    return function(html) {\n        var parser = new DOMParser(), doc;\n        try {\n            doc = parser.parseFromString(html, \"text/html\");\n        } catch(e) {\n            log(\"DOMParser not supported, falling back to createHTMLDocument\");\n            doc = document.implementation.createHTMLDocument(\"\");\n            try {\n                doc.open();\n                doc.write(html);\n                doc.close();\n            } catch(ee) {\n                log(\"createHTMLDocument write not supported, falling back to document.body.innerHTML\");\n                doc.body.innerHTML = html; // ie9 doesnt support writing to documentElement\n            }\n        }\n\n        var b = doc.querySelector(\"base\");\n        if (!b || !b.href.host) {\n            var base = doc.createElement(\"base\");\n            base.href = src;\n            doc.head.insertBefore(base, doc.head.firstChild);\n        }\n\n        return doc;\n    };\n}\n\nfunction loadUrlDocument(src, proxy, document, width, height, options) {\n    return new Proxy(src, proxy, window.document).then(documentFromHTML(src)).then(function(doc) {\n        return createWindowClone(doc, document, width, height, options, 0, 0);\n    });\n}\n\nexports.Proxy = Proxy;\nexports.ProxyURL = ProxyURL;\nexports.loadUrlDocument = loadUrlDocument;\n\n},{\"./clone\":2,\"./log\":13,\"./utils\":26,\"./xhr\":28}],17:[function(_dereq_,module,exports){\nvar ProxyURL = _dereq_('./proxy').ProxyURL;\n\nfunction ProxyImageContainer(src, proxy) {\n    var link = document.createElement(\"a\");\n    link.href = src;\n    src = link.href;\n    this.src = src;\n    this.image = new Image();\n    var self = this;\n    this.promise = new Promise(function(resolve, reject) {\n        self.image.crossOrigin = \"Anonymous\";\n        self.image.onload = resolve;\n        self.image.onerror = reject;\n\n        new ProxyURL(src, proxy, document).then(function(url) {\n            self.image.src = url;\n        })['catch'](reject);\n    });\n}\n\nmodule.exports = ProxyImageContainer;\n\n},{\"./proxy\":16}],18:[function(_dereq_,module,exports){\nvar NodeContainer = _dereq_('./nodecontainer');\n\nfunction PseudoElementContainer(node, parent, type) {\n    NodeContainer.call(this, node, parent);\n    this.isPseudoElement = true;\n    this.before = type === \":before\";\n}\n\nPseudoElementContainer.prototype.cloneTo = function(stack) {\n    PseudoElementContainer.prototype.cloneTo.call(this, stack);\n    stack.isPseudoElement = true;\n    stack.before = this.before;\n};\n\nPseudoElementContainer.prototype = Object.create(NodeContainer.prototype);\n\nPseudoElementContainer.prototype.appendToDOM = function() {\n    if (this.before) {\n        this.parent.node.insertBefore(this.node, this.parent.node.firstChild);\n    } else {\n        this.parent.node.appendChild(this.node);\n    }\n    this.parent.node.className += \" \" + this.getHideClass();\n};\n\nPseudoElementContainer.prototype.cleanDOM = function() {\n    this.node.parentNode.removeChild(this.node);\n    this.parent.node.className = this.parent.node.className.replace(this.getHideClass(), \"\");\n};\n\nPseudoElementContainer.prototype.getHideClass = function() {\n    return this[\"PSEUDO_HIDE_ELEMENT_CLASS_\" + (this.before ? \"BEFORE\" : \"AFTER\")];\n};\n\nPseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE = \"___html2canvas___pseudoelement_before\";\nPseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER = \"___html2canvas___pseudoelement_after\";\n\nmodule.exports = PseudoElementContainer;\n\n},{\"./nodecontainer\":14}],19:[function(_dereq_,module,exports){\nvar log = _dereq_('./log');\n\nfunction Renderer(width, height, images, options, document) {\n    this.width = width;\n    this.height = height;\n    this.images = images;\n    this.options = options;\n    this.document = document;\n}\n\nRenderer.prototype.renderImage = function(container, bounds, borderData, imageContainer) {\n    var paddingLeft = container.cssInt('paddingLeft'),\n        paddingTop = container.cssInt('paddingTop'),\n        paddingRight = container.cssInt('paddingRight'),\n        paddingBottom = container.cssInt('paddingBottom'),\n        borders = borderData.borders;\n\n    var width = bounds.width - (borders[1].width + borders[3].width + paddingLeft + paddingRight);\n    var height = bounds.height - (borders[0].width + borders[2].width + paddingTop + paddingBottom);\n    this.drawImage(\n        imageContainer,\n        0,\n        0,\n        imageContainer.image.width || width,\n        imageContainer.image.height || height,\n        bounds.left + paddingLeft + borders[3].width,\n        bounds.top + paddingTop + borders[0].width,\n        width,\n        height\n    );\n};\n\nRenderer.prototype.renderBackground = function(container, bounds, borderData) {\n    if (bounds.height > 0 && bounds.width > 0) {\n        this.renderBackgroundColor(container, bounds);\n        this.renderBackgroundImage(container, bounds, borderData);\n    }\n};\n\nRenderer.prototype.renderBackgroundColor = function(container, bounds) {\n    var color = container.color(\"backgroundColor\");\n    if (!color.isTransparent()) {\n        this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, color);\n    }\n};\n\nRenderer.prototype.renderBorders = function(borders) {\n    borders.forEach(this.renderBorder, this);\n};\n\nRenderer.prototype.renderBorder = function(data) {\n    if (!data.color.isTransparent() && data.args !== null) {\n        this.drawShape(data.args, data.color);\n    }\n};\n\nRenderer.prototype.renderBackgroundImage = function(container, bounds, borderData) {\n    var backgroundImages = container.parseBackgroundImages();\n    backgroundImages.reverse().forEach(function(backgroundImage, index, arr) {\n        switch(backgroundImage.method) {\n        case \"url\":\n            var image = this.images.get(backgroundImage.args[0]);\n            if (image) {\n                this.renderBackgroundRepeating(container, bounds, image, arr.length - (index+1), borderData);\n            } else {\n                log(\"Error loading background-image\", backgroundImage.args[0]);\n            }\n            break;\n        case \"linear-gradient\":\n        case \"gradient\":\n            var gradientImage = this.images.get(backgroundImage.value);\n            if (gradientImage) {\n                this.renderBackgroundGradient(gradientImage, bounds, borderData);\n            } else {\n                log(\"Error loading background-image\", backgroundImage.args[0]);\n            }\n            break;\n        case \"none\":\n            break;\n        default:\n            log(\"Unknown background-image type\", backgroundImage.args[0]);\n        }\n    }, this);\n};\n\nRenderer.prototype.renderBackgroundRepeating = function(container, bounds, imageContainer, index, borderData) {\n    var size = container.parseBackgroundSize(bounds, imageContainer.image, index);\n    var position = container.parseBackgroundPosition(bounds, imageContainer.image, index, size);\n    var repeat = container.parseBackgroundRepeat(index);\n    switch (repeat) {\n    case \"repeat-x\":\n    case \"repeat no-repeat\":\n        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + borderData[3], bounds.top + position.top + borderData[0], 99999, size.height, borderData);\n        break;\n    case \"repeat-y\":\n    case \"no-repeat repeat\":\n        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + borderData[0], size.width, 99999, borderData);\n        break;\n    case \"no-repeat\":\n        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + position.top + borderData[0], size.width, size.height, borderData);\n        break;\n    default:\n        this.renderBackgroundRepeat(imageContainer, position, size, {top: bounds.top, left: bounds.left}, borderData[3], borderData[0]);\n        break;\n    }\n};\n\nmodule.exports = Renderer;\n\n},{\"./log\":13}],20:[function(_dereq_,module,exports){\nvar Renderer = _dereq_('../renderer');\nvar LinearGradientContainer = _dereq_('../lineargradientcontainer');\nvar log = _dereq_('../log');\n\nfunction CanvasRenderer(width, height) {\n    Renderer.apply(this, arguments);\n    this.canvas = this.options.canvas || this.document.createElement(\"canvas\");\n    if (!this.options.canvas) {\n        this.canvas.width = width;\n        this.canvas.height = height;\n    }\n    this.ctx = this.canvas.getContext(\"2d\");\n    this.taintCtx = this.document.createElement(\"canvas\").getContext(\"2d\");\n    this.ctx.textBaseline = \"bottom\";\n    this.variables = {};\n    log(\"Initialized CanvasRenderer with size\", width, \"x\", height);\n}\n\nCanvasRenderer.prototype = Object.create(Renderer.prototype);\n\nCanvasRenderer.prototype.setFillStyle = function(fillStyle) {\n    this.ctx.fillStyle = typeof(fillStyle) === \"object\" && !!fillStyle.isColor ? fillStyle.toString() : fillStyle;\n    return this.ctx;\n};\n\nCanvasRenderer.prototype.rectangle = function(left, top, width, height, color) {\n    this.setFillStyle(color).fillRect(left, top, width, height);\n};\n\nCanvasRenderer.prototype.circle = function(left, top, size, color) {\n    this.setFillStyle(color);\n    this.ctx.beginPath();\n    this.ctx.arc(left + size / 2, top + size / 2, size / 2, 0, Math.PI*2, true);\n    this.ctx.closePath();\n    this.ctx.fill();\n};\n\nCanvasRenderer.prototype.circleStroke = function(left, top, size, color, stroke, strokeColor) {\n    this.circle(left, top, size, color);\n    this.ctx.strokeStyle = strokeColor.toString();\n    this.ctx.stroke();\n};\n\nCanvasRenderer.prototype.drawShape = function(shape, color) {\n    this.shape(shape);\n    this.setFillStyle(color).fill();\n};\n\nCanvasRenderer.prototype.taints = function(imageContainer) {\n    if (imageContainer.tainted === null) {\n        this.taintCtx.drawImage(imageContainer.image, 0, 0);\n        try {\n            this.taintCtx.getImageData(0, 0, 1, 1);\n            imageContainer.tainted = false;\n        } catch(e) {\n            this.taintCtx = document.createElement(\"canvas\").getContext(\"2d\");\n            imageContainer.tainted = true;\n        }\n    }\n\n    return imageContainer.tainted;\n};\n\nCanvasRenderer.prototype.drawImage = function(imageContainer, sx, sy, sw, sh, dx, dy, dw, dh) {\n    if (!this.taints(imageContainer) || this.options.allowTaint) {\n        this.ctx.drawImage(imageContainer.image, sx, sy, sw, sh, dx, dy, dw, dh);\n    }\n};\n\nCanvasRenderer.prototype.clip = function(shapes, callback, context) {\n    this.ctx.save();\n    shapes.filter(hasEntries).forEach(function(shape) {\n        this.shape(shape).clip();\n    }, this);\n    callback.call(context);\n    this.ctx.restore();\n};\n\nCanvasRenderer.prototype.shape = function(shape) {\n    this.ctx.beginPath();\n    shape.forEach(function(point, index) {\n        if (point[0] === \"rect\") {\n            this.ctx.rect.apply(this.ctx, point.slice(1));\n        } else {\n            this.ctx[(index === 0) ? \"moveTo\" : point[0] + \"To\" ].apply(this.ctx, point.slice(1));\n        }\n    }, this);\n    this.ctx.closePath();\n    return this.ctx;\n};\n\nCanvasRenderer.prototype.font = function(color, style, variant, weight, size, family) {\n    this.setFillStyle(color).font = [style, variant, weight, size, family].join(\" \").split(\",\")[0];\n};\n\nCanvasRenderer.prototype.fontShadow = function(color, offsetX, offsetY, blur) {\n    this.setVariable(\"shadowColor\", color.toString())\n        .setVariable(\"shadowOffsetY\", offsetX)\n        .setVariable(\"shadowOffsetX\", offsetY)\n        .setVariable(\"shadowBlur\", blur);\n};\n\nCanvasRenderer.prototype.clearShadow = function() {\n    this.setVariable(\"shadowColor\", \"rgba(0,0,0,0)\");\n};\n\nCanvasRenderer.prototype.setOpacity = function(opacity) {\n    this.ctx.globalAlpha = opacity;\n};\n\nCanvasRenderer.prototype.setTransform = function(transform) {\n    this.ctx.translate(transform.origin[0], transform.origin[1]);\n    this.ctx.transform.apply(this.ctx, transform.matrix);\n    this.ctx.translate(-transform.origin[0], -transform.origin[1]);\n};\n\nCanvasRenderer.prototype.setVariable = function(property, value) {\n    if (this.variables[property] !== value) {\n        this.variables[property] = this.ctx[property] = value;\n    }\n\n    return this;\n};\n\nCanvasRenderer.prototype.text = function(text, left, bottom) {\n    this.ctx.fillText(text, left, bottom);\n};\n\nCanvasRenderer.prototype.backgroundRepeatShape = function(imageContainer, backgroundPosition, size, bounds, left, top, width, height, borderData) {\n    var shape = [\n        [\"line\", Math.round(left), Math.round(top)],\n        [\"line\", Math.round(left + width), Math.round(top)],\n        [\"line\", Math.round(left + width), Math.round(height + top)],\n        [\"line\", Math.round(left), Math.round(height + top)]\n    ];\n    this.clip([shape], function() {\n        this.renderBackgroundRepeat(imageContainer, backgroundPosition, size, bounds, borderData[3], borderData[0]);\n    }, this);\n};\n\nCanvasRenderer.prototype.renderBackgroundRepeat = function(imageContainer, backgroundPosition, size, bounds, borderLeft, borderTop) {\n    var offsetX = Math.round(bounds.left + backgroundPosition.left + borderLeft), offsetY = Math.round(bounds.top + backgroundPosition.top + borderTop);\n    this.setFillStyle(this.ctx.createPattern(this.resizeImage(imageContainer, size), \"repeat\"));\n    this.ctx.translate(offsetX, offsetY);\n    this.ctx.fill();\n    this.ctx.translate(-offsetX, -offsetY);\n};\n\nCanvasRenderer.prototype.renderBackgroundGradient = function(gradientImage, bounds) {\n    if (gradientImage instanceof LinearGradientContainer) {\n        var gradient = this.ctx.createLinearGradient(\n            bounds.left + bounds.width * gradientImage.x0,\n            bounds.top + bounds.height * gradientImage.y0,\n            bounds.left +  bounds.width * gradientImage.x1,\n            bounds.top +  bounds.height * gradientImage.y1);\n        gradientImage.colorStops.forEach(function(colorStop) {\n            gradient.addColorStop(colorStop.stop, colorStop.color.toString());\n        });\n        this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, gradient);\n    }\n};\n\nCanvasRenderer.prototype.resizeImage = function(imageContainer, size) {\n    var image = imageContainer.image;\n    if(image.width === size.width && image.height === size.height) {\n        return image;\n    }\n\n    var ctx, canvas = document.createElement('canvas');\n    canvas.width = size.width;\n    canvas.height = size.height;\n    ctx = canvas.getContext(\"2d\");\n    ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, size.width, size.height );\n    return canvas;\n};\n\nfunction hasEntries(array) {\n    return array.length > 0;\n}\n\nmodule.exports = CanvasRenderer;\n\n},{\"../lineargradientcontainer\":12,\"../log\":13,\"../renderer\":19}],21:[function(_dereq_,module,exports){\nvar NodeContainer = _dereq_('./nodecontainer');\n\nfunction StackingContext(hasOwnStacking, opacity, element, parent) {\n    NodeContainer.call(this, element, parent);\n    this.ownStacking = hasOwnStacking;\n    this.contexts = [];\n    this.children = [];\n    this.opacity = (this.parent ? this.parent.stack.opacity : 1) * opacity;\n}\n\nStackingContext.prototype = Object.create(NodeContainer.prototype);\n\nStackingContext.prototype.getParentStack = function(context) {\n    var parentStack = (this.parent) ? this.parent.stack : null;\n    return parentStack ? (parentStack.ownStacking ? parentStack : parentStack.getParentStack(context)) : context.stack;\n};\n\nmodule.exports = StackingContext;\n\n},{\"./nodecontainer\":14}],22:[function(_dereq_,module,exports){\nfunction Support(document) {\n    this.rangeBounds = this.testRangeBounds(document);\n    this.cors = this.testCORS();\n    this.svg = this.testSVG();\n}\n\nSupport.prototype.testRangeBounds = function(document) {\n    var range, testElement, rangeBounds, rangeHeight, support = false;\n\n    if (document.createRange) {\n        range = document.createRange();\n        if (range.getBoundingClientRect) {\n            testElement = document.createElement('boundtest');\n            testElement.style.height = \"123px\";\n            testElement.style.display = \"block\";\n            document.body.appendChild(testElement);\n\n            range.selectNode(testElement);\n            rangeBounds = range.getBoundingClientRect();\n            rangeHeight = rangeBounds.height;\n\n            if (rangeHeight === 123) {\n                support = true;\n            }\n            document.body.removeChild(testElement);\n        }\n    }\n\n    return support;\n};\n\nSupport.prototype.testCORS = function() {\n    return typeof((new Image()).crossOrigin) !== \"undefined\";\n};\n\nSupport.prototype.testSVG = function() {\n    var img = new Image();\n    var canvas = document.createElement(\"canvas\");\n    var ctx =  canvas.getContext(\"2d\");\n    img.src = \"data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>\";\n\n    try {\n        ctx.drawImage(img, 0, 0);\n        canvas.toDataURL();\n    } catch(e) {\n        return false;\n    }\n    return true;\n};\n\nmodule.exports = Support;\n\n},{}],23:[function(_dereq_,module,exports){\nvar XHR = _dereq_('./xhr');\nvar decode64 = _dereq_('./utils').decode64;\n\nfunction SVGContainer(src) {\n    this.src = src;\n    this.image = null;\n    var self = this;\n\n    this.promise = this.hasFabric().then(function() {\n        return (self.isInline(src) ? Promise.resolve(self.inlineFormatting(src)) : XHR(src));\n    }).then(function(svg) {\n        return new Promise(function(resolve) {\n            window.html2canvas.svg.fabric.loadSVGFromString(svg, self.createCanvas.call(self, resolve));\n        });\n    });\n}\n\nSVGContainer.prototype.hasFabric = function() {\n    return !window.html2canvas.svg || !window.html2canvas.svg.fabric ? Promise.reject(new Error(\"html2canvas.svg.js is not loaded, cannot render svg\")) : Promise.resolve();\n};\n\nSVGContainer.prototype.inlineFormatting = function(src) {\n    return (/^data:image\\/svg\\+xml;base64,/.test(src)) ? this.decode64(this.removeContentType(src)) : this.removeContentType(src);\n};\n\nSVGContainer.prototype.removeContentType = function(src) {\n    return src.replace(/^data:image\\/svg\\+xml(;base64)?,/,'');\n};\n\nSVGContainer.prototype.isInline = function(src) {\n    return (/^data:image\\/svg\\+xml/i.test(src));\n};\n\nSVGContainer.prototype.createCanvas = function(resolve) {\n    var self = this;\n    return function (objects, options) {\n        var canvas = new window.html2canvas.svg.fabric.StaticCanvas('c');\n        self.image = canvas.lowerCanvasEl;\n        canvas\n            .setWidth(options.width)\n            .setHeight(options.height)\n            .add(window.html2canvas.svg.fabric.util.groupSVGElements(objects, options))\n            .renderAll();\n        resolve(canvas.lowerCanvasEl);\n    };\n};\n\nSVGContainer.prototype.decode64 = function(str) {\n    return (typeof(window.atob) === \"function\") ? window.atob(str) : decode64(str);\n};\n\nmodule.exports = SVGContainer;\n\n},{\"./utils\":26,\"./xhr\":28}],24:[function(_dereq_,module,exports){\nvar SVGContainer = _dereq_('./svgcontainer');\n\nfunction SVGNodeContainer(node, _native) {\n    this.src = node;\n    this.image = null;\n    var self = this;\n\n    this.promise = _native ? new Promise(function(resolve, reject) {\n        self.image = new Image();\n        self.image.onload = resolve;\n        self.image.onerror = reject;\n        self.image.src = \"data:image/svg+xml,\" + (new XMLSerializer()).serializeToString(node);\n        if (self.image.complete === true) {\n            resolve(self.image);\n        }\n    }) : this.hasFabric().then(function() {\n        return new Promise(function(resolve) {\n            window.html2canvas.svg.fabric.parseSVGDocument(node, self.createCanvas.call(self, resolve));\n        });\n    });\n}\n\nSVGNodeContainer.prototype = Object.create(SVGContainer.prototype);\n\nmodule.exports = SVGNodeContainer;\n\n},{\"./svgcontainer\":23}],25:[function(_dereq_,module,exports){\nvar NodeContainer = _dereq_('./nodecontainer');\n\nfunction TextContainer(node, parent) {\n    NodeContainer.call(this, node, parent);\n}\n\nTextContainer.prototype = Object.create(NodeContainer.prototype);\n\nTextContainer.prototype.applyTextTransform = function() {\n    this.node.data = this.transform(this.parent.css(\"textTransform\"));\n};\n\nTextContainer.prototype.transform = function(transform) {\n    var text = this.node.data;\n    switch(transform){\n        case \"lowercase\":\n            return text.toLowerCase();\n        case \"capitalize\":\n            return text.replace(/(^|\\s|:|-|\\(|\\))([a-z])/g, capitalize);\n        case \"uppercase\":\n            return text.toUpperCase();\n        default:\n            return text;\n    }\n};\n\nfunction capitalize(m, p1, p2) {\n    if (m.length > 0) {\n        return p1 + p2.toUpperCase();\n    }\n}\n\nmodule.exports = TextContainer;\n\n},{\"./nodecontainer\":14}],26:[function(_dereq_,module,exports){\nexports.smallImage = function smallImage() {\n    return \"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7\";\n};\n\nexports.bind = function(callback, context) {\n    return function() {\n        return callback.apply(context, arguments);\n    };\n};\n\n/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n\nexports.decode64 = function(base64) {\n    var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    var len = base64.length, i, encoded1, encoded2, encoded3, encoded4, byte1, byte2, byte3;\n\n    var output = \"\";\n\n    for (i = 0; i < len; i+=4) {\n        encoded1 = chars.indexOf(base64[i]);\n        encoded2 = chars.indexOf(base64[i+1]);\n        encoded3 = chars.indexOf(base64[i+2]);\n        encoded4 = chars.indexOf(base64[i+3]);\n\n        byte1 = (encoded1 << 2) | (encoded2 >> 4);\n        byte2 = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n        byte3 = ((encoded3 & 3) << 6) | encoded4;\n        if (encoded3 === 64) {\n            output += String.fromCharCode(byte1);\n        } else if (encoded4 === 64 || encoded4 === -1) {\n            output += String.fromCharCode(byte1, byte2);\n        } else{\n            output += String.fromCharCode(byte1, byte2, byte3);\n        }\n    }\n\n    return output;\n};\n\nexports.getBounds = function(node) {\n    if (node.getBoundingClientRect) {\n        var clientRect = node.getBoundingClientRect();\n        var width = node.offsetWidth == null ? clientRect.width : node.offsetWidth;\n        return {\n            top: clientRect.top,\n            bottom: clientRect.bottom || (clientRect.top + clientRect.height),\n            right: clientRect.left + width,\n            left: clientRect.left,\n            width:  width,\n            height: node.offsetHeight == null ? clientRect.height : node.offsetHeight\n        };\n    }\n    return {};\n};\n\nexports.offsetBounds = function(node) {\n    var parent = node.offsetParent ? exports.offsetBounds(node.offsetParent) : {top: 0, left: 0};\n\n    return {\n        top: node.offsetTop + parent.top,\n        bottom: node.offsetTop + node.offsetHeight + parent.top,\n        right: node.offsetLeft + parent.left + node.offsetWidth,\n        left: node.offsetLeft + parent.left,\n        width: node.offsetWidth,\n        height: node.offsetHeight\n    };\n};\n\nexports.parseBackgrounds = function(backgroundImage) {\n    var whitespace = ' \\r\\n\\t',\n        method, definition, prefix, prefix_i, block, results = [],\n        mode = 0, numParen = 0, quote, args;\n    var appendResult = function() {\n        if(method) {\n            if (definition.substr(0, 1) === '\"') {\n                definition = definition.substr(1, definition.length - 2);\n            }\n            if (definition) {\n                args.push(definition);\n            }\n            if (method.substr(0, 1) === '-' && (prefix_i = method.indexOf('-', 1 ) + 1) > 0) {\n                prefix = method.substr(0, prefix_i);\n                method = method.substr(prefix_i);\n            }\n            results.push({\n                prefix: prefix,\n                method: method.toLowerCase(),\n                value: block,\n                args: args,\n                image: null\n            });\n        }\n        args = [];\n        method = prefix = definition = block = '';\n    };\n    args = [];\n    method = prefix = definition = block = '';\n    backgroundImage.split(\"\").forEach(function(c) {\n        if (mode === 0 && whitespace.indexOf(c) > -1) {\n            return;\n        }\n        switch(c) {\n        case '\"':\n            if(!quote) {\n                quote = c;\n            } else if(quote === c) {\n                quote = null;\n            }\n            break;\n        case '(':\n            if(quote) {\n                break;\n            } else if(mode === 0) {\n                mode = 1;\n                block += c;\n                return;\n            } else {\n                numParen++;\n            }\n            break;\n        case ')':\n            if (quote) {\n                break;\n            } else if(mode === 1) {\n                if(numParen === 0) {\n                    mode = 0;\n                    block += c;\n                    appendResult();\n                    return;\n                } else {\n                    numParen--;\n                }\n            }\n            break;\n\n        case ',':\n            if (quote) {\n                break;\n            } else if(mode === 0) {\n                appendResult();\n                return;\n            } else if (mode === 1) {\n                if (numParen === 0 && !method.match(/^url$/i)) {\n                    args.push(definition);\n                    definition = '';\n                    block += c;\n                    return;\n                }\n            }\n            break;\n        }\n\n        block += c;\n        if (mode === 0) {\n            method += c;\n        } else {\n            definition += c;\n        }\n    });\n\n    appendResult();\n    return results;\n};\n\n},{}],27:[function(_dereq_,module,exports){\nvar GradientContainer = _dereq_('./gradientcontainer');\n\nfunction WebkitGradientContainer(imageData) {\n    GradientContainer.apply(this, arguments);\n    this.type = imageData.args[0] === \"linear\" ? GradientContainer.TYPES.LINEAR : GradientContainer.TYPES.RADIAL;\n}\n\nWebkitGradientContainer.prototype = Object.create(GradientContainer.prototype);\n\nmodule.exports = WebkitGradientContainer;\n\n},{\"./gradientcontainer\":9}],28:[function(_dereq_,module,exports){\nfunction XHR(url) {\n    return new Promise(function(resolve, reject) {\n        var xhr = new XMLHttpRequest();\n        xhr.open('GET', url);\n\n        xhr.onload = function() {\n            if (xhr.status === 200) {\n                resolve(xhr.responseText);\n            } else {\n                reject(new Error(xhr.statusText));\n            }\n        };\n\n        xhr.onerror = function() {\n            reject(new Error(\"Network Error\"));\n        };\n\n        xhr.send();\n    });\n}\n\nmodule.exports = XHR;\n\n},{}]},{},[4])(4)\n});\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n},{}],22:[function(require,module,exports){\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"QRCode2\"] = factory();\n\telse\n\t\troot[\"QRCode2\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\n\tObject.defineProperty(exports, \"__esModule\", {\n\t\tvalue: true\n\t});\n\t/**\n\t * @fileoverview\n\t * - Using the 'QRCode for Javascript library'\n\t * - Fixed dataset of 'QRCode for Javascript library' for support full-spec.\n\t * - this library has no dependencies.\n\t * \n\t * @author davidshimjs\n\t * @see <a href=\"http://www.d-project.com/\" target=\"_blank\">http://www.d-project.com/</a>\n\t * @see <a href=\"http://jeromeetienne.github.com/jquery-qrcode/\" target=\"_blank\">http://jeromeetienne.github.com/jquery-qrcode/</a>\n\t */\n\tvar QRCode;\n\n\t(function (global) {\n\t\t//---------------------------------------------------------------------\n\t\t// QRCode for JavaScript\n\t\t//\n\t\t// Copyright (c) 2009 Kazuhiko Arase\n\t\t//\n\t\t// URL: http://www.d-project.com/\n\t\t//\n\t\t// Licensed under the MIT license:\n\t\t//   http://www.opensource.org/licenses/mit-license.php\n\t\t//\n\t\t// The word \"QR Code\" is registered trademark of\n\t\t// DENSO WAVE INCORPORATED\n\t\t//   http://www.denso-wave.com/qrcode/faqpatent-e.html\n\t\t//\n\t\t//---------------------------------------------------------------------\n\t\tfunction QR8bitByte(data) {\n\t\t\tthis.mode = QRMode.MODE_8BIT_BYTE;\n\t\t\tthis.data = data;\n\t\t\tthis.parsedData = [];\n\n\t\t\t// Added to support UTF-8 Characters\n\t\t\tfor (var i = 0, l = this.data.length; i < l; i++) {\n\t\t\t\tvar byteArray = [];\n\t\t\t\tvar code = this.data.charCodeAt(i);\n\n\t\t\t\tif (code > 0x10000) {\n\t\t\t\t\tbyteArray[0] = 0xF0 | (code & 0x1C0000) >>> 18;\n\t\t\t\t\tbyteArray[1] = 0x80 | (code & 0x3F000) >>> 12;\n\t\t\t\t\tbyteArray[2] = 0x80 | (code & 0xFC0) >>> 6;\n\t\t\t\t\tbyteArray[3] = 0x80 | code & 0x3F;\n\t\t\t\t} else if (code > 0x800) {\n\t\t\t\t\tbyteArray[0] = 0xE0 | (code & 0xF000) >>> 12;\n\t\t\t\t\tbyteArray[1] = 0x80 | (code & 0xFC0) >>> 6;\n\t\t\t\t\tbyteArray[2] = 0x80 | code & 0x3F;\n\t\t\t\t} else if (code > 0x80) {\n\t\t\t\t\tbyteArray[0] = 0xC0 | (code & 0x7C0) >>> 6;\n\t\t\t\t\tbyteArray[1] = 0x80 | code & 0x3F;\n\t\t\t\t} else {\n\t\t\t\t\tbyteArray[0] = code;\n\t\t\t\t}\n\n\t\t\t\tthis.parsedData.push(byteArray);\n\t\t\t}\n\n\t\t\tthis.parsedData = Array.prototype.concat.apply([], this.parsedData);\n\n\t\t\tif (this.parsedData.length != this.data.length) {\n\t\t\t\tthis.parsedData.unshift(191);\n\t\t\t\tthis.parsedData.unshift(187);\n\t\t\t\tthis.parsedData.unshift(239);\n\t\t\t}\n\t\t}\n\n\t\tQR8bitByte.prototype = {\n\t\t\tgetLength: function getLength(buffer) {\n\t\t\t\treturn this.parsedData.length;\n\t\t\t},\n\t\t\twrite: function write(buffer) {\n\t\t\t\tfor (var i = 0, l = this.parsedData.length; i < l; i++) {\n\t\t\t\t\tbuffer.put(this.parsedData[i], 8);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tfunction QRCodeModel(typeNumber, errorCorrectLevel) {\n\t\t\tthis.typeNumber = typeNumber;\n\t\t\tthis.errorCorrectLevel = errorCorrectLevel;\n\t\t\tthis.modules = null;\n\t\t\tthis.moduleCount = 0;\n\t\t\tthis.dataCache = null;\n\t\t\tthis.dataList = [];\n\t\t}\n\n\t\tQRCodeModel.prototype = { addData: function addData(data) {\n\t\t\t\tvar newData = new QR8bitByte(data);this.dataList.push(newData);this.dataCache = null;\n\t\t\t}, isDark: function isDark(row, col) {\n\t\t\t\tif (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {\n\t\t\t\t\tthrow new Error(row + \",\" + col);\n\t\t\t\t}\n\t\t\t\treturn this.modules[row][col];\n\t\t\t}, getModuleCount: function getModuleCount() {\n\t\t\t\treturn this.moduleCount;\n\t\t\t}, make: function make() {\n\t\t\t\tthis.makeImpl(false, this.getBestMaskPattern());\n\t\t\t}, makeImpl: function makeImpl(test, maskPattern) {\n\t\t\t\tthis.moduleCount = this.typeNumber * 4 + 17;this.modules = new Array(this.moduleCount);for (var row = 0; row < this.moduleCount; row++) {\n\t\t\t\t\tthis.modules[row] = new Array(this.moduleCount);for (var col = 0; col < this.moduleCount; col++) {\n\t\t\t\t\t\tthis.modules[row][col] = null;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tthis.setupPositionProbePattern(0, 0);this.setupPositionProbePattern(this.moduleCount - 7, 0);this.setupPositionProbePattern(0, this.moduleCount - 7);this.setupPositionAdjustPattern();this.setupTimingPattern();this.setupTypeInfo(test, maskPattern);if (this.typeNumber >= 7) {\n\t\t\t\t\tthis.setupTypeNumber(test);\n\t\t\t\t}\n\t\t\t\tif (this.dataCache == null) {\n\t\t\t\t\tthis.dataCache = QRCodeModel.createData(this.typeNumber, this.errorCorrectLevel, this.dataList);\n\t\t\t\t}\n\t\t\t\tthis.mapData(this.dataCache, maskPattern);\n\t\t\t}, setupPositionProbePattern: function setupPositionProbePattern(row, col) {\n\t\t\t\tfor (var r = -1; r <= 7; r++) {\n\t\t\t\t\tif (row + r <= -1 || this.moduleCount <= row + r) continue;for (var c = -1; c <= 7; c++) {\n\t\t\t\t\t\tif (col + c <= -1 || this.moduleCount <= col + c) continue;if (0 <= r && r <= 6 && (c == 0 || c == 6) || 0 <= c && c <= 6 && (r == 0 || r == 6) || 2 <= r && r <= 4 && 2 <= c && c <= 4) {\n\t\t\t\t\t\t\tthis.modules[row + r][col + c] = true;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.modules[row + r][col + c] = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}, getBestMaskPattern: function getBestMaskPattern() {\n\t\t\t\tvar minLostPoint = 0;var pattern = 0;for (var i = 0; i < 8; i++) {\n\t\t\t\t\tthis.makeImpl(true, i);var lostPoint = QRUtil.getLostPoint(this);if (i == 0 || minLostPoint > lostPoint) {\n\t\t\t\t\t\tminLostPoint = lostPoint;pattern = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn pattern;\n\t\t\t}, createMovieClip: function createMovieClip(target_mc, instance_name, depth) {\n\t\t\t\tvar qr_mc = target_mc.createEmptyMovieClip(instance_name, depth);var cs = 1;this.make();for (var row = 0; row < this.modules.length; row++) {\n\t\t\t\t\tvar y = row * cs;for (var col = 0; col < this.modules[row].length; col++) {\n\t\t\t\t\t\tvar x = col * cs;var dark = this.modules[row][col];if (dark) {\n\t\t\t\t\t\t\tqr_mc.beginFill(0, 100);qr_mc.moveTo(x, y);qr_mc.lineTo(x + cs, y);qr_mc.lineTo(x + cs, y + cs);qr_mc.lineTo(x, y + cs);qr_mc.endFill();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn qr_mc;\n\t\t\t}, setupTimingPattern: function setupTimingPattern() {\n\t\t\t\tfor (var r = 8; r < this.moduleCount - 8; r++) {\n\t\t\t\t\tif (this.modules[r][6] != null) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tthis.modules[r][6] = r % 2 == 0;\n\t\t\t\t}\n\t\t\t\tfor (var c = 8; c < this.moduleCount - 8; c++) {\n\t\t\t\t\tif (this.modules[6][c] != null) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tthis.modules[6][c] = c % 2 == 0;\n\t\t\t\t}\n\t\t\t}, setupPositionAdjustPattern: function setupPositionAdjustPattern() {\n\t\t\t\tvar pos = QRUtil.getPatternPosition(this.typeNumber);for (var i = 0; i < pos.length; i++) {\n\t\t\t\t\tfor (var j = 0; j < pos.length; j++) {\n\t\t\t\t\t\tvar row = pos[i];var col = pos[j];if (this.modules[row][col] != null) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tfor (var r = -2; r <= 2; r++) {\n\t\t\t\t\t\t\tfor (var c = -2; c <= 2; c++) {\n\t\t\t\t\t\t\t\tif (r == -2 || r == 2 || c == -2 || c == 2 || r == 0 && c == 0) {\n\t\t\t\t\t\t\t\t\tthis.modules[row + r][col + c] = true;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tthis.modules[row + r][col + c] = false;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}, setupTypeNumber: function setupTypeNumber(test) {\n\t\t\t\tvar bits = QRUtil.getBCHTypeNumber(this.typeNumber);for (var i = 0; i < 18; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;\n\t\t\t\t}\n\t\t\t\tfor (var i = 0; i < 18; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;this.modules[i % 3 + this.moduleCount - 8 - 3][Math.floor(i / 3)] = mod;\n\t\t\t\t}\n\t\t\t}, setupTypeInfo: function setupTypeInfo(test, maskPattern) {\n\t\t\t\tvar data = this.errorCorrectLevel << 3 | maskPattern;var bits = QRUtil.getBCHTypeInfo(data);for (var i = 0; i < 15; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;if (i < 6) {\n\t\t\t\t\t\tthis.modules[i][8] = mod;\n\t\t\t\t\t} else if (i < 8) {\n\t\t\t\t\t\tthis.modules[i + 1][8] = mod;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.modules[this.moduleCount - 15 + i][8] = mod;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var i = 0; i < 15; i++) {\n\t\t\t\t\tvar mod = !test && (bits >> i & 1) == 1;if (i < 8) {\n\t\t\t\t\t\tthis.modules[8][this.moduleCount - i - 1] = mod;\n\t\t\t\t\t} else if (i < 9) {\n\t\t\t\t\t\tthis.modules[8][15 - i - 1 + 1] = mod;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.modules[8][15 - i - 1] = mod;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tthis.modules[this.moduleCount - 8][8] = !test;\n\t\t\t}, mapData: function mapData(data, maskPattern) {\n\t\t\t\tvar inc = -1;var row = this.moduleCount - 1;var bitIndex = 7;var byteIndex = 0;for (var col = this.moduleCount - 1; col > 0; col -= 2) {\n\t\t\t\t\tif (col == 6) col--;while (true) {\n\t\t\t\t\t\tfor (var c = 0; c < 2; c++) {\n\t\t\t\t\t\t\tif (this.modules[row][col - c] == null) {\n\t\t\t\t\t\t\t\tvar dark = false;if (byteIndex < data.length) {\n\t\t\t\t\t\t\t\t\tdark = (data[byteIndex] >>> bitIndex & 1) == 1;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tvar mask = QRUtil.getMask(maskPattern, row, col - c);if (mask) {\n\t\t\t\t\t\t\t\t\tdark = !dark;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tthis.modules[row][col - c] = dark;bitIndex--;if (bitIndex == -1) {\n\t\t\t\t\t\t\t\t\tbyteIndex++;bitIndex = 7;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\trow += inc;if (row < 0 || this.moduleCount <= row) {\n\t\t\t\t\t\t\trow -= inc;inc = -inc;break;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} };QRCodeModel.PAD0 = 0xEC;QRCodeModel.PAD1 = 0x11;QRCodeModel.createData = function (typeNumber, errorCorrectLevel, dataList) {\n\t\t\tvar rsBlocks = QRRSBlock.getRSBlocks(typeNumber, errorCorrectLevel);var buffer = new QRBitBuffer();for (var i = 0; i < dataList.length; i++) {\n\t\t\t\tvar data = dataList[i];buffer.put(data.mode, 4);buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber));data.write(buffer);\n\t\t\t}\n\t\t\tvar totalDataCount = 0;for (var i = 0; i < rsBlocks.length; i++) {\n\t\t\t\ttotalDataCount += rsBlocks[i].dataCount;\n\t\t\t}\n\t\t\tif (buffer.getLengthInBits() > totalDataCount * 8) {\n\t\t\t\tthrow new Error(\"code length overflow. (\" + buffer.getLengthInBits() + \">\" + totalDataCount * 8 + \")\");\n\t\t\t}\n\t\t\tif (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {\n\t\t\t\tbuffer.put(0, 4);\n\t\t\t}\n\t\t\twhile (buffer.getLengthInBits() % 8 != 0) {\n\t\t\t\tbuffer.putBit(false);\n\t\t\t}\n\t\t\twhile (true) {\n\t\t\t\tif (buffer.getLengthInBits() >= totalDataCount * 8) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tbuffer.put(QRCodeModel.PAD0, 8);if (buffer.getLengthInBits() >= totalDataCount * 8) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tbuffer.put(QRCodeModel.PAD1, 8);\n\t\t\t}\n\t\t\treturn QRCodeModel.createBytes(buffer, rsBlocks);\n\t\t};QRCodeModel.createBytes = function (buffer, rsBlocks) {\n\t\t\tvar offset = 0;var maxDcCount = 0;var maxEcCount = 0;var dcdata = new Array(rsBlocks.length);var ecdata = new Array(rsBlocks.length);for (var r = 0; r < rsBlocks.length; r++) {\n\t\t\t\tvar dcCount = rsBlocks[r].dataCount;var ecCount = rsBlocks[r].totalCount - dcCount;maxDcCount = Math.max(maxDcCount, dcCount);maxEcCount = Math.max(maxEcCount, ecCount);dcdata[r] = new Array(dcCount);for (var i = 0; i < dcdata[r].length; i++) {\n\t\t\t\t\tdcdata[r][i] = 0xff & buffer.buffer[i + offset];\n\t\t\t\t}\n\t\t\t\toffset += dcCount;var rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount);var rawPoly = new QRPolynomial(dcdata[r], rsPoly.getLength() - 1);var modPoly = rawPoly.mod(rsPoly);ecdata[r] = new Array(rsPoly.getLength() - 1);for (var i = 0; i < ecdata[r].length; i++) {\n\t\t\t\t\tvar modIndex = i + modPoly.getLength() - ecdata[r].length;ecdata[r][i] = modIndex >= 0 ? modPoly.get(modIndex) : 0;\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar totalCodeCount = 0;for (var i = 0; i < rsBlocks.length; i++) {\n\t\t\t\ttotalCodeCount += rsBlocks[i].totalCount;\n\t\t\t}\n\t\t\tvar data = new Array(totalCodeCount);var index = 0;for (var i = 0; i < maxDcCount; i++) {\n\t\t\t\tfor (var r = 0; r < rsBlocks.length; r++) {\n\t\t\t\t\tif (i < dcdata[r].length) {\n\t\t\t\t\t\tdata[index++] = dcdata[r][i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i = 0; i < maxEcCount; i++) {\n\t\t\t\tfor (var r = 0; r < rsBlocks.length; r++) {\n\t\t\t\t\tif (i < ecdata[r].length) {\n\t\t\t\t\t\tdata[index++] = ecdata[r][i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn data;\n\t\t};var QRMode = { MODE_NUMBER: 1 << 0, MODE_ALPHA_NUM: 1 << 1, MODE_8BIT_BYTE: 1 << 2, MODE_KANJI: 1 << 3 };var QRErrorCorrectLevel = { L: 1, M: 0, Q: 3, H: 2 };var QRMaskPattern = { PATTERN000: 0, PATTERN001: 1, PATTERN010: 2, PATTERN011: 3, PATTERN100: 4, PATTERN101: 5, PATTERN110: 6, PATTERN111: 7 };var QRUtil = { PATTERN_POSITION_TABLE: [[], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34], [6, 22, 38], [6, 24, 42], [6, 26, 46], [6, 28, 50], [6, 30, 54], [6, 32, 58], [6, 34, 62], [6, 26, 46, 66], [6, 26, 48, 70], [6, 26, 50, 74], [6, 30, 54, 78], [6, 30, 56, 82], [6, 30, 58, 86], [6, 34, 62, 90], [6, 28, 50, 72, 94], [6, 26, 50, 74, 98], [6, 30, 54, 78, 102], [6, 28, 54, 80, 106], [6, 32, 58, 84, 110], [6, 30, 58, 86, 114], [6, 34, 62, 90, 118], [6, 26, 50, 74, 98, 122], [6, 30, 54, 78, 102, 126], [6, 26, 52, 78, 104, 130], [6, 30, 56, 82, 108, 134], [6, 34, 60, 86, 112, 138], [6, 30, 58, 86, 114, 142], [6, 34, 62, 90, 118, 146], [6, 30, 54, 78, 102, 126, 150], [6, 24, 50, 76, 102, 128, 154], [6, 28, 54, 80, 106, 132, 158], [6, 32, 58, 84, 110, 136, 162], [6, 26, 54, 82, 110, 138, 166], [6, 30, 58, 86, 114, 142, 170]], G15: 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0, G18: 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0, G15_MASK: 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1, getBCHTypeInfo: function getBCHTypeInfo(data) {\n\t\t\t\tvar d = data << 10;while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) >= 0) {\n\t\t\t\t\td ^= QRUtil.G15 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15);\n\t\t\t\t}\n\t\t\t\treturn (data << 10 | d) ^ QRUtil.G15_MASK;\n\t\t\t}, getBCHTypeNumber: function getBCHTypeNumber(data) {\n\t\t\t\tvar d = data << 12;while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) >= 0) {\n\t\t\t\t\td ^= QRUtil.G18 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18);\n\t\t\t\t}\n\t\t\t\treturn data << 12 | d;\n\t\t\t}, getBCHDigit: function getBCHDigit(data) {\n\t\t\t\tvar digit = 0;while (data != 0) {\n\t\t\t\t\tdigit++;data >>>= 1;\n\t\t\t\t}\n\t\t\t\treturn digit;\n\t\t\t}, getPatternPosition: function getPatternPosition(typeNumber) {\n\t\t\t\treturn QRUtil.PATTERN_POSITION_TABLE[typeNumber - 1];\n\t\t\t}, getMask: function getMask(maskPattern, i, j) {\n\t\t\t\tswitch (maskPattern) {case QRMaskPattern.PATTERN000:\n\t\t\t\t\t\treturn (i + j) % 2 == 0;case QRMaskPattern.PATTERN001:\n\t\t\t\t\t\treturn i % 2 == 0;case QRMaskPattern.PATTERN010:\n\t\t\t\t\t\treturn j % 3 == 0;case QRMaskPattern.PATTERN011:\n\t\t\t\t\t\treturn (i + j) % 3 == 0;case QRMaskPattern.PATTERN100:\n\t\t\t\t\t\treturn (Math.floor(i / 2) + Math.floor(j / 3)) % 2 == 0;case QRMaskPattern.PATTERN101:\n\t\t\t\t\t\treturn i * j % 2 + i * j % 3 == 0;case QRMaskPattern.PATTERN110:\n\t\t\t\t\t\treturn (i * j % 2 + i * j % 3) % 2 == 0;case QRMaskPattern.PATTERN111:\n\t\t\t\t\t\treturn (i * j % 3 + (i + j) % 2) % 2 == 0;default:\n\t\t\t\t\t\tthrow new Error(\"bad maskPattern:\" + maskPattern);}\n\t\t\t}, getErrorCorrectPolynomial: function getErrorCorrectPolynomial(errorCorrectLength) {\n\t\t\t\tvar a = new QRPolynomial([1], 0);for (var i = 0; i < errorCorrectLength; i++) {\n\t\t\t\t\ta = a.multiply(new QRPolynomial([1, QRMath.gexp(i)], 0));\n\t\t\t\t}\n\t\t\t\treturn a;\n\t\t\t}, getLengthInBits: function getLengthInBits(mode, type) {\n\t\t\t\tif (1 <= type && type < 10) {\n\t\t\t\t\tswitch (mode) {case QRMode.MODE_NUMBER:\n\t\t\t\t\t\t\treturn 10;case QRMode.MODE_ALPHA_NUM:\n\t\t\t\t\t\t\treturn 9;case QRMode.MODE_8BIT_BYTE:\n\t\t\t\t\t\t\treturn 8;case QRMode.MODE_KANJI:\n\t\t\t\t\t\t\treturn 8;default:\n\t\t\t\t\t\t\tthrow new Error(\"mode:\" + mode);}\n\t\t\t\t} else if (type < 27) {\n\t\t\t\t\tswitch (mode) {case QRMode.MODE_NUMBER:\n\t\t\t\t\t\t\treturn 12;case QRMode.MODE_ALPHA_NUM:\n\t\t\t\t\t\t\treturn 11;case QRMode.MODE_8BIT_BYTE:\n\t\t\t\t\t\t\treturn 16;case QRMode.MODE_KANJI:\n\t\t\t\t\t\t\treturn 10;default:\n\t\t\t\t\t\t\tthrow new Error(\"mode:\" + mode);}\n\t\t\t\t} else if (type < 41) {\n\t\t\t\t\tswitch (mode) {case QRMode.MODE_NUMBER:\n\t\t\t\t\t\t\treturn 14;case QRMode.MODE_ALPHA_NUM:\n\t\t\t\t\t\t\treturn 13;case QRMode.MODE_8BIT_BYTE:\n\t\t\t\t\t\t\treturn 16;case QRMode.MODE_KANJI:\n\t\t\t\t\t\t\treturn 12;default:\n\t\t\t\t\t\t\tthrow new Error(\"mode:\" + mode);}\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error(\"type:\" + type);\n\t\t\t\t}\n\t\t\t}, getLostPoint: function getLostPoint(qrCode) {\n\t\t\t\tvar moduleCount = qrCode.getModuleCount();var lostPoint = 0;for (var row = 0; row < moduleCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < moduleCount; col++) {\n\t\t\t\t\t\tvar sameCount = 0;var dark = qrCode.isDark(row, col);for (var r = -1; r <= 1; r++) {\n\t\t\t\t\t\t\tif (row + r < 0 || moduleCount <= row + r) {\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tfor (var c = -1; c <= 1; c++) {\n\t\t\t\t\t\t\t\tif (col + c < 0 || moduleCount <= col + c) {\n\t\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif (r == 0 && c == 0) {\n\t\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tif (dark == qrCode.isDark(row + r, col + c)) {\n\t\t\t\t\t\t\t\t\tsameCount++;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (sameCount > 5) {\n\t\t\t\t\t\t\tlostPoint += 3 + sameCount - 5;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var row = 0; row < moduleCount - 1; row++) {\n\t\t\t\t\tfor (var col = 0; col < moduleCount - 1; col++) {\n\t\t\t\t\t\tvar count = 0;if (qrCode.isDark(row, col)) count++;if (qrCode.isDark(row + 1, col)) count++;if (qrCode.isDark(row, col + 1)) count++;if (qrCode.isDark(row + 1, col + 1)) count++;if (count == 0 || count == 4) {\n\t\t\t\t\t\t\tlostPoint += 3;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var row = 0; row < moduleCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < moduleCount - 6; col++) {\n\t\t\t\t\t\tif (qrCode.isDark(row, col) && !qrCode.isDark(row, col + 1) && qrCode.isDark(row, col + 2) && qrCode.isDark(row, col + 3) && qrCode.isDark(row, col + 4) && !qrCode.isDark(row, col + 5) && qrCode.isDark(row, col + 6)) {\n\t\t\t\t\t\t\tlostPoint += 40;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (var col = 0; col < moduleCount; col++) {\n\t\t\t\t\tfor (var row = 0; row < moduleCount - 6; row++) {\n\t\t\t\t\t\tif (qrCode.isDark(row, col) && !qrCode.isDark(row + 1, col) && qrCode.isDark(row + 2, col) && qrCode.isDark(row + 3, col) && qrCode.isDark(row + 4, col) && !qrCode.isDark(row + 5, col) && qrCode.isDark(row + 6, col)) {\n\t\t\t\t\t\t\tlostPoint += 40;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tvar darkCount = 0;for (var col = 0; col < moduleCount; col++) {\n\t\t\t\t\tfor (var row = 0; row < moduleCount; row++) {\n\t\t\t\t\t\tif (qrCode.isDark(row, col)) {\n\t\t\t\t\t\t\tdarkCount++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tvar ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;lostPoint += ratio * 10;return lostPoint;\n\t\t\t} };var QRMath = { glog: function glog(n) {\n\t\t\t\tif (n < 1) {\n\t\t\t\t\tthrow new Error(\"glog(\" + n + \")\");\n\t\t\t\t}\n\t\t\t\treturn QRMath.LOG_TABLE[n];\n\t\t\t}, gexp: function gexp(n) {\n\t\t\t\twhile (n < 0) {\n\t\t\t\t\tn += 255;\n\t\t\t\t}\n\t\t\t\twhile (n >= 256) {\n\t\t\t\t\tn -= 255;\n\t\t\t\t}\n\t\t\t\treturn QRMath.EXP_TABLE[n];\n\t\t\t}, EXP_TABLE: new Array(256), LOG_TABLE: new Array(256) };for (var i = 0; i < 8; i++) {\n\t\t\tQRMath.EXP_TABLE[i] = 1 << i;\n\t\t}\n\t\tfor (var i = 8; i < 256; i++) {\n\t\t\tQRMath.EXP_TABLE[i] = QRMath.EXP_TABLE[i - 4] ^ QRMath.EXP_TABLE[i - 5] ^ QRMath.EXP_TABLE[i - 6] ^ QRMath.EXP_TABLE[i - 8];\n\t\t}\n\t\tfor (var i = 0; i < 255; i++) {\n\t\t\tQRMath.LOG_TABLE[QRMath.EXP_TABLE[i]] = i;\n\t\t}\n\t\tfunction QRPolynomial(num, shift) {\n\t\t\tif (num.length == undefined) {\n\t\t\t\tthrow new Error(num.length + \"/\" + shift);\n\t\t\t}\n\t\t\tvar offset = 0;while (offset < num.length && num[offset] == 0) {\n\t\t\t\toffset++;\n\t\t\t}\n\t\t\tthis.num = new Array(num.length - offset + shift);for (var i = 0; i < num.length - offset; i++) {\n\t\t\t\tthis.num[i] = num[i + offset];\n\t\t\t}\n\t\t}\n\t\tQRPolynomial.prototype = { get: function get(index) {\n\t\t\t\treturn this.num[index];\n\t\t\t}, getLength: function getLength() {\n\t\t\t\treturn this.num.length;\n\t\t\t}, multiply: function multiply(e) {\n\t\t\t\tvar num = new Array(this.getLength() + e.getLength() - 1);for (var i = 0; i < this.getLength(); i++) {\n\t\t\t\t\tfor (var j = 0; j < e.getLength(); j++) {\n\t\t\t\t\t\tnum[i + j] ^= QRMath.gexp(QRMath.glog(this.get(i)) + QRMath.glog(e.get(j)));\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn new QRPolynomial(num, 0);\n\t\t\t}, mod: function mod(e) {\n\t\t\t\tif (this.getLength() - e.getLength() < 0) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tvar ratio = QRMath.glog(this.get(0)) - QRMath.glog(e.get(0));var num = new Array(this.getLength());for (var i = 0; i < this.getLength(); i++) {\n\t\t\t\t\tnum[i] = this.get(i);\n\t\t\t\t}\n\t\t\t\tfor (var i = 0; i < e.getLength(); i++) {\n\t\t\t\t\tnum[i] ^= QRMath.gexp(QRMath.glog(e.get(i)) + ratio);\n\t\t\t\t}\n\t\t\t\treturn new QRPolynomial(num, 0).mod(e);\n\t\t\t} };function QRRSBlock(totalCount, dataCount) {\n\t\t\tthis.totalCount = totalCount;this.dataCount = dataCount;\n\t\t}\n\t\tQRRSBlock.RS_BLOCK_TABLE = [[1, 26, 19], [1, 26, 16], [1, 26, 13], [1, 26, 9], [1, 44, 34], [1, 44, 28], [1, 44, 22], [1, 44, 16], [1, 70, 55], [1, 70, 44], [2, 35, 17], [2, 35, 13], [1, 100, 80], [2, 50, 32], [2, 50, 24], [4, 25, 9], [1, 134, 108], [2, 67, 43], [2, 33, 15, 2, 34, 16], [2, 33, 11, 2, 34, 12], [2, 86, 68], [4, 43, 27], [4, 43, 19], [4, 43, 15], [2, 98, 78], [4, 49, 31], [2, 32, 14, 4, 33, 15], [4, 39, 13, 1, 40, 14], [2, 121, 97], [2, 60, 38, 2, 61, 39], [4, 40, 18, 2, 41, 19], [4, 40, 14, 2, 41, 15], [2, 146, 116], [3, 58, 36, 2, 59, 37], [4, 36, 16, 4, 37, 17], [4, 36, 12, 4, 37, 13], [2, 86, 68, 2, 87, 69], [4, 69, 43, 1, 70, 44], [6, 43, 19, 2, 44, 20], [6, 43, 15, 2, 44, 16], [4, 101, 81], [1, 80, 50, 4, 81, 51], [4, 50, 22, 4, 51, 23], [3, 36, 12, 8, 37, 13], [2, 116, 92, 2, 117, 93], [6, 58, 36, 2, 59, 37], [4, 46, 20, 6, 47, 21], [7, 42, 14, 4, 43, 15], [4, 133, 107], [8, 59, 37, 1, 60, 38], [8, 44, 20, 4, 45, 21], [12, 33, 11, 4, 34, 12], [3, 145, 115, 1, 146, 116], [4, 64, 40, 5, 65, 41], [11, 36, 16, 5, 37, 17], [11, 36, 12, 5, 37, 13], [5, 109, 87, 1, 110, 88], [5, 65, 41, 5, 66, 42], [5, 54, 24, 7, 55, 25], [11, 36, 12], [5, 122, 98, 1, 123, 99], [7, 73, 45, 3, 74, 46], [15, 43, 19, 2, 44, 20], [3, 45, 15, 13, 46, 16], [1, 135, 107, 5, 136, 108], [10, 74, 46, 1, 75, 47], [1, 50, 22, 15, 51, 23], [2, 42, 14, 17, 43, 15], [5, 150, 120, 1, 151, 121], [9, 69, 43, 4, 70, 44], [17, 50, 22, 1, 51, 23], [2, 42, 14, 19, 43, 15], [3, 141, 113, 4, 142, 114], [3, 70, 44, 11, 71, 45], [17, 47, 21, 4, 48, 22], [9, 39, 13, 16, 40, 14], [3, 135, 107, 5, 136, 108], [3, 67, 41, 13, 68, 42], [15, 54, 24, 5, 55, 25], [15, 43, 15, 10, 44, 16], [4, 144, 116, 4, 145, 117], [17, 68, 42], [17, 50, 22, 6, 51, 23], [19, 46, 16, 6, 47, 17], [2, 139, 111, 7, 140, 112], [17, 74, 46], [7, 54, 24, 16, 55, 25], [34, 37, 13], [4, 151, 121, 5, 152, 122], [4, 75, 47, 14, 76, 48], [11, 54, 24, 14, 55, 25], [16, 45, 15, 14, 46, 16], [6, 147, 117, 4, 148, 118], [6, 73, 45, 14, 74, 46], [11, 54, 24, 16, 55, 25], [30, 46, 16, 2, 47, 17], [8, 132, 106, 4, 133, 107], [8, 75, 47, 13, 76, 48], [7, 54, 24, 22, 55, 25], [22, 45, 15, 13, 46, 16], [10, 142, 114, 2, 143, 115], [19, 74, 46, 4, 75, 47], [28, 50, 22, 6, 51, 23], [33, 46, 16, 4, 47, 17], [8, 152, 122, 4, 153, 123], [22, 73, 45, 3, 74, 46], [8, 53, 23, 26, 54, 24], [12, 45, 15, 28, 46, 16], [3, 147, 117, 10, 148, 118], [3, 73, 45, 23, 74, 46], [4, 54, 24, 31, 55, 25], [11, 45, 15, 31, 46, 16], [7, 146, 116, 7, 147, 117], [21, 73, 45, 7, 74, 46], [1, 53, 23, 37, 54, 24], [19, 45, 15, 26, 46, 16], [5, 145, 115, 10, 146, 116], [19, 75, 47, 10, 76, 48], [15, 54, 24, 25, 55, 25], [23, 45, 15, 25, 46, 16], [13, 145, 115, 3, 146, 116], [2, 74, 46, 29, 75, 47], [42, 54, 24, 1, 55, 25], [23, 45, 15, 28, 46, 16], [17, 145, 115], [10, 74, 46, 23, 75, 47], [10, 54, 24, 35, 55, 25], [19, 45, 15, 35, 46, 16], [17, 145, 115, 1, 146, 116], [14, 74, 46, 21, 75, 47], [29, 54, 24, 19, 55, 25], [11, 45, 15, 46, 46, 16], [13, 145, 115, 6, 146, 116], [14, 74, 46, 23, 75, 47], [44, 54, 24, 7, 55, 25], [59, 46, 16, 1, 47, 17], [12, 151, 121, 7, 152, 122], [12, 75, 47, 26, 76, 48], [39, 54, 24, 14, 55, 25], [22, 45, 15, 41, 46, 16], [6, 151, 121, 14, 152, 122], [6, 75, 47, 34, 76, 48], [46, 54, 24, 10, 55, 25], [2, 45, 15, 64, 46, 16], [17, 152, 122, 4, 153, 123], [29, 74, 46, 14, 75, 47], [49, 54, 24, 10, 55, 25], [24, 45, 15, 46, 46, 16], [4, 152, 122, 18, 153, 123], [13, 74, 46, 32, 75, 47], [48, 54, 24, 14, 55, 25], [42, 45, 15, 32, 46, 16], [20, 147, 117, 4, 148, 118], [40, 75, 47, 7, 76, 48], [43, 54, 24, 22, 55, 25], [10, 45, 15, 67, 46, 16], [19, 148, 118, 6, 149, 119], [18, 75, 47, 31, 76, 48], [34, 54, 24, 34, 55, 25], [20, 45, 15, 61, 46, 16]];QRRSBlock.getRSBlocks = function (typeNumber, errorCorrectLevel) {\n\t\t\tvar rsBlock = QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);if (rsBlock == undefined) {\n\t\t\t\tthrow new Error(\"bad rs block @ typeNumber:\" + typeNumber + \"/errorCorrectLevel:\" + errorCorrectLevel);\n\t\t\t}\n\t\t\tvar length = rsBlock.length / 3;var list = [];for (var i = 0; i < length; i++) {\n\t\t\t\tvar count = rsBlock[i * 3 + 0];var totalCount = rsBlock[i * 3 + 1];var dataCount = rsBlock[i * 3 + 2];for (var j = 0; j < count; j++) {\n\t\t\t\t\tlist.push(new QRRSBlock(totalCount, dataCount));\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn list;\n\t\t};QRRSBlock.getRsBlockTable = function (typeNumber, errorCorrectLevel) {\n\t\t\tswitch (errorCorrectLevel) {case QRErrorCorrectLevel.L:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];case QRErrorCorrectLevel.M:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];case QRErrorCorrectLevel.Q:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];case QRErrorCorrectLevel.H:\n\t\t\t\t\treturn QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];default:\n\t\t\t\t\treturn undefined;}\n\t\t};function QRBitBuffer() {\n\t\t\tthis.buffer = [];this.length = 0;\n\t\t}\n\t\tQRBitBuffer.prototype = { get: function get(index) {\n\t\t\t\tvar bufIndex = Math.floor(index / 8);return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;\n\t\t\t}, put: function put(num, length) {\n\t\t\t\tfor (var i = 0; i < length; i++) {\n\t\t\t\t\tthis.putBit((num >>> length - i - 1 & 1) == 1);\n\t\t\t\t}\n\t\t\t}, getLengthInBits: function getLengthInBits() {\n\t\t\t\treturn this.length;\n\t\t\t}, putBit: function putBit(bit) {\n\t\t\t\tvar bufIndex = Math.floor(this.length / 8);if (this.buffer.length <= bufIndex) {\n\t\t\t\t\tthis.buffer.push(0);\n\t\t\t\t}\n\t\t\t\tif (bit) {\n\t\t\t\t\tthis.buffer[bufIndex] |= 0x80 >>> this.length % 8;\n\t\t\t\t}\n\t\t\t\tthis.length++;\n\t\t\t} };var QRCodeLimitLength = [[17, 14, 11, 7], [32, 26, 20, 14], [53, 42, 32, 24], [78, 62, 46, 34], [106, 84, 60, 44], [134, 106, 74, 58], [154, 122, 86, 64], [192, 152, 108, 84], [230, 180, 130, 98], [271, 213, 151, 119], [321, 251, 177, 137], [367, 287, 203, 155], [425, 331, 241, 177], [458, 362, 258, 194], [520, 412, 292, 220], [586, 450, 322, 250], [644, 504, 364, 280], [718, 560, 394, 310], [792, 624, 442, 338], [858, 666, 482, 382], [929, 711, 509, 403], [1003, 779, 565, 439], [1091, 857, 611, 461], [1171, 911, 661, 511], [1273, 997, 715, 535], [1367, 1059, 751, 593], [1465, 1125, 805, 625], [1528, 1190, 868, 658], [1628, 1264, 908, 698], [1732, 1370, 982, 742], [1840, 1452, 1030, 790], [1952, 1538, 1112, 842], [2068, 1628, 1168, 898], [2188, 1722, 1228, 958], [2303, 1809, 1283, 983], [2431, 1911, 1351, 1051], [2563, 1989, 1423, 1093], [2699, 2099, 1499, 1139], [2809, 2213, 1579, 1219], [2953, 2331, 1663, 1273]];\n\n\t\tfunction _isSupportCanvas() {\n\t\t\treturn typeof CanvasRenderingContext2D != \"undefined\";\n\t\t}\n\n\t\t// android 2.x doesn't support Data-URI spec\n\t\tfunction _getAndroid() {\n\t\t\tvar android = false;\n\t\t\tvar sAgent = navigator.userAgent;\n\n\t\t\tif (/android/i.test(sAgent)) {\n\t\t\t\t// android\n\t\t\t\tandroid = true;\n\t\t\t\tvar aMat = sAgent.toString().match(/android ([0-9]\\.[0-9])/i);\n\n\t\t\t\tif (aMat && aMat[1]) {\n\t\t\t\t\tandroid = parseFloat(aMat[1]);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn android;\n\t\t}\n\n\t\tvar svgDrawer = function () {\n\n\t\t\tvar Drawing = function Drawing(el, htOption) {\n\t\t\t\tthis._el = el;\n\t\t\t\tthis._htOption = htOption;\n\t\t\t};\n\n\t\t\tDrawing.prototype.draw = function (oQRCode) {\n\t\t\t\tvar _htOption = this._htOption;\n\t\t\t\tvar _el = this._el;\n\t\t\t\tvar nCount = oQRCode.getModuleCount();\n\t\t\t\tvar nWidth = Math.floor(_htOption.width / nCount);\n\t\t\t\tvar nHeight = Math.floor(_htOption.height / nCount);\n\n\t\t\t\tthis.clear();\n\n\t\t\t\tfunction makeSVG(tag, attrs) {\n\t\t\t\t\tvar el = document.createElementNS('http://www.w3.org/2000/svg', tag);\n\t\t\t\t\tfor (var k in attrs) {\n\t\t\t\t\t\tif (attrs.hasOwnProperty(k)) el.setAttribute(k, attrs[k]);\n\t\t\t\t\t}return el;\n\t\t\t\t}\n\n\t\t\t\tvar svg = makeSVG(\"svg\", { 'viewBox': '0 0 ' + String(nCount) + \" \" + String(nCount), 'width': '100%', 'height': '100%', 'fill': _htOption.colorLight });\n\t\t\t\tsvg.setAttributeNS(\"http://www.w3.org/2000/xmlns/\", \"xmlns:xlink\", \"http://www.w3.org/1999/xlink\");\n\t\t\t\t_el.appendChild(svg);\n\n\t\t\t\tsvg.appendChild(makeSVG(\"rect\", { \"fill\": _htOption.colorLight, \"width\": \"100%\", \"height\": \"100%\" }));\n\t\t\t\tsvg.appendChild(makeSVG(\"rect\", { \"fill\": _htOption.colorDark, \"width\": \"1\", \"height\": \"1\", \"id\": \"template\" }));\n\n\t\t\t\tfor (var row = 0; row < nCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < nCount; col++) {\n\t\t\t\t\t\tif (oQRCode.isDark(row, col)) {\n\t\t\t\t\t\t\tvar child = makeSVG(\"use\", { \"x\": String(col), \"y\": String(row) });\n\t\t\t\t\t\t\tchild.setAttributeNS(\"http://www.w3.org/1999/xlink\", \"href\", \"#template\");\n\t\t\t\t\t\t\tsvg.appendChild(child);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tDrawing.prototype.clear = function () {\n\t\t\t\twhile (this._el.hasChildNodes()) {\n\t\t\t\t\tthis._el.removeChild(this._el.lastChild);\n\t\t\t\t}\n\t\t\t};\n\t\t\treturn Drawing;\n\t\t}();\n\n\t\tvar useSVG = document.documentElement.tagName.toLowerCase() === \"svg\";\n\n\t\t// Drawing in DOM by using Table tag\n\t\tvar Drawing = useSVG ? svgDrawer : !_isSupportCanvas() ? function () {\n\t\t\tvar Drawing = function Drawing(el, htOption) {\n\t\t\t\tthis._el = el;\n\t\t\t\tthis._htOption = htOption;\n\t\t\t};\n\n\t\t\t/**\n\t   * Draw the QRCode\n\t   *\n\t   * @param {QRCode} oQRCode\n\t   */\n\t\t\tDrawing.prototype.draw = function (oQRCode) {\n\t\t\t\tvar _htOption = this._htOption;\n\t\t\t\tvar _el = this._el;\n\t\t\t\tvar nCount = oQRCode.getModuleCount();\n\t\t\t\tvar nWidth = Math.floor(_htOption.width / nCount);\n\t\t\t\tvar nHeight = Math.floor(_htOption.height / nCount);\n\t\t\t\tvar aHTML = ['<table style=\"border:0;border-collapse:collapse;\">'];\n\n\t\t\t\tfor (var row = 0; row < nCount; row++) {\n\t\t\t\t\taHTML.push('<tr>');\n\n\t\t\t\t\tfor (var col = 0; col < nCount; col++) {\n\t\t\t\t\t\taHTML.push('<td style=\"border:0;border-collapse:collapse;padding:0;margin:0;width:' + nWidth + 'px;height:' + nHeight + 'px;background-color:' + (oQRCode.isDark(row, col) ? _htOption.colorDark : _htOption.colorLight) + ';\"></td>');\n\t\t\t\t\t}\n\n\t\t\t\t\taHTML.push('</tr>');\n\t\t\t\t}\n\n\t\t\t\taHTML.push('</table>');\n\t\t\t\t_el.innerHTML = aHTML.join('');\n\n\t\t\t\t// Fix the margin values as real size.\n\t\t\t\tvar elTable = _el.childNodes[0];\n\t\t\t\tvar nLeftMarginTable = (_htOption.width - elTable.offsetWidth) / 2;\n\t\t\t\tvar nTopMarginTable = (_htOption.height - elTable.offsetHeight) / 2;\n\n\t\t\t\tif (nLeftMarginTable > 0 && nTopMarginTable > 0) {\n\t\t\t\t\telTable.style.margin = nTopMarginTable + \"px \" + nLeftMarginTable + \"px\";\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t   * Clear the QRCode\n\t   */\n\t\t\tDrawing.prototype.clear = function () {\n\t\t\t\tthis._el.innerHTML = '';\n\t\t\t};\n\n\t\t\treturn Drawing;\n\t\t}() : function () {\n\t\t\t// Drawing in Canvas\n\t\t\tfunction _onMakeImage() {\n\t\t\t\tthis._elImage.src = this._elCanvas.toDataURL(\"image/png\");\n\t\t\t\tthis._elImage.style.display = \"block\";\n\t\t\t\tthis._elCanvas.style.display = \"none\";\n\t\t\t}\n\n\t\t\t// Android 2.1 bug workaround\n\t\t\t// http://code.google.com/p/android/issues/detail?id=5141\n\t\t\tif (global._android && global._android <= 2.1) {\n\t\t\t\tvar factor = 1 / window.devicePixelRatio;\n\t\t\t\tvar drawImage = CanvasRenderingContext2D.prototype.drawImage;\n\t\t\t\tCanvasRenderingContext2D.prototype.drawImage = function (image, sx, sy, sw, sh, dx, dy, dw, dh) {\n\t\t\t\t\tif (\"nodeName\" in image && /img/i.test(image.nodeName)) {\n\t\t\t\t\t\tfor (var i = arguments.length - 1; i >= 1; i--) {\n\t\t\t\t\t\t\targuments[i] = arguments[i] * factor;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (typeof dw == \"undefined\") {\n\t\t\t\t\t\targuments[1] *= factor;\n\t\t\t\t\t\targuments[2] *= factor;\n\t\t\t\t\t\targuments[3] *= factor;\n\t\t\t\t\t\targuments[4] *= factor;\n\t\t\t\t\t}\n\n\t\t\t\t\tdrawImage.apply(this, arguments);\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t/**\n\t   * Check whether the user's browser supports Data URI or not\n\t   *\n\t   * @private\n\t   * @param {Function} fSuccess Occurs if it supports Data URI\n\t   * @param {Function} fFail Occurs if it doesn't support Data URI\n\t   */\n\t\t\tfunction _safeSetDataURI(fSuccess, fFail) {\n\t\t\t\tvar self = this;\n\t\t\t\tself._fFail = fFail;\n\t\t\t\tself._fSuccess = fSuccess;\n\n\t\t\t\t// Check it just once\n\t\t\t\tif (self._bSupportDataURI === null) {\n\t\t\t\t\tvar el = document.createElement(\"img\");\n\t\t\t\t\tvar fOnError = function fOnError() {\n\t\t\t\t\t\tself._bSupportDataURI = false;\n\n\t\t\t\t\t\tif (self._fFail) {\n\t\t\t\t\t\t\tself._fFail.call(self);\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\tvar fOnSuccess = function fOnSuccess() {\n\t\t\t\t\t\tself._bSupportDataURI = true;\n\n\t\t\t\t\t\tif (self._fSuccess) {\n\t\t\t\t\t\t\tself._fSuccess.call(self);\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\n\t\t\t\t\tel.onabort = fOnError;\n\t\t\t\t\tel.onerror = fOnError;\n\t\t\t\t\tel.onload = fOnSuccess;\n\t\t\t\t\tel.src = \"data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==\"; // the Image contains 1px data.\n\t\t\t\t\treturn;\n\t\t\t\t} else if (self._bSupportDataURI === true && self._fSuccess) {\n\t\t\t\t\tself._fSuccess.call(self);\n\t\t\t\t} else if (self._bSupportDataURI === false && self._fFail) {\n\t\t\t\t\tself._fFail.call(self);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t   * Drawing QRCode by using canvas\n\t   *\n\t   * @constructor\n\t   * @param {HTMLElement} el\n\t   * @param {Object} htOption QRCode Options\n\t   */\n\t\t\tvar Drawing = function Drawing(el, htOption) {\n\t\t\t\tthis._bIsPainted = false;\n\t\t\t\tthis._android = _getAndroid();\n\n\t\t\t\tthis._htOption = htOption;\n\t\t\t\tthis._elCanvas = document.createElement(\"canvas\");\n\t\t\t\tthis._elCanvas.width = htOption.width;\n\t\t\t\tthis._elCanvas.height = htOption.height;\n\t\t\t\tel.appendChild(this._elCanvas);\n\t\t\t\tthis._el = el;\n\t\t\t\tthis._oContext = this._elCanvas.getContext(\"2d\");\n\t\t\t\tthis._bIsPainted = false;\n\t\t\t\tthis._elImage = document.createElement(\"img\");\n\t\t\t\tthis._elImage.alt = \"Scan me!\";\n\t\t\t\tthis._elImage.style.display = \"none\";\n\t\t\t\tthis._el.appendChild(this._elImage);\n\t\t\t\tthis._bSupportDataURI = null;\n\t\t\t};\n\n\t\t\t/**\n\t   * Draw the QRCode\n\t   *\n\t   * @param {QRCode} oQRCode\n\t   */\n\t\t\tDrawing.prototype.draw = function (oQRCode) {\n\t\t\t\tvar _elImage = this._elImage;\n\t\t\t\tvar _oContext = this._oContext;\n\t\t\t\tvar _htOption = this._htOption;\n\n\t\t\t\tvar nCount = oQRCode.getModuleCount();\n\t\t\t\tvar nWidth = _htOption.width / nCount;\n\t\t\t\tvar nHeight = _htOption.height / nCount;\n\t\t\t\tvar nRoundedWidth = Math.round(nWidth);\n\t\t\t\tvar nRoundedHeight = Math.round(nHeight);\n\n\t\t\t\t_elImage.style.display = \"none\";\n\t\t\t\tthis.clear();\n\n\t\t\t\tfor (var row = 0; row < nCount; row++) {\n\t\t\t\t\tfor (var col = 0; col < nCount; col++) {\n\t\t\t\t\t\tvar bIsDark = oQRCode.isDark(row, col);\n\t\t\t\t\t\tvar nLeft = col * nWidth;\n\t\t\t\t\t\tvar nTop = row * nHeight;\n\t\t\t\t\t\t_oContext.strokeStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;\n\t\t\t\t\t\t_oContext.lineWidth = 1;\n\t\t\t\t\t\t_oContext.fillStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;\n\t\t\t\t\t\t_oContext.fillRect(nLeft, nTop, nWidth, nHeight);\n\n\t\t\t\t\t\t// 안티 앨리어싱 방지 처리\n\t\t\t\t\t\t_oContext.strokeRect(Math.floor(nLeft) + 0.5, Math.floor(nTop) + 0.5, nRoundedWidth, nRoundedHeight);\n\n\t\t\t\t\t\t_oContext.strokeRect(Math.ceil(nLeft) - 0.5, Math.ceil(nTop) - 0.5, nRoundedWidth, nRoundedHeight);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis._bIsPainted = true;\n\t\t\t};\n\n\t\t\t/**\n\t   * Make the image from Canvas if the browser supports Data URI.\n\t   */\n\t\t\tDrawing.prototype.makeImage = function () {\n\t\t\t\tif (this._bIsPainted) {\n\t\t\t\t\t_safeSetDataURI.call(this, _onMakeImage);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t   * Return whether the QRCode is painted or not\n\t   *\n\t   * @return {Boolean}\n\t   */\n\t\t\tDrawing.prototype.isPainted = function () {\n\t\t\t\treturn this._bIsPainted;\n\t\t\t};\n\n\t\t\t/**\n\t   * Clear the QRCode\n\t   */\n\t\t\tDrawing.prototype.clear = function () {\n\t\t\t\tthis._oContext.clearRect(0, 0, this._elCanvas.width, this._elCanvas.height);\n\t\t\t\tthis._bIsPainted = false;\n\t\t\t};\n\n\t\t\t/**\n\t   * @private\n\t   * @param {Number} nNumber\n\t   */\n\t\t\tDrawing.prototype.round = function (nNumber) {\n\t\t\t\tif (!nNumber) {\n\t\t\t\t\treturn nNumber;\n\t\t\t\t}\n\n\t\t\t\treturn Math.floor(nNumber * 1000) / 1000;\n\t\t\t};\n\n\t\t\treturn Drawing;\n\t\t}(global);\n\n\t\t/**\n\t  * Get the type by string length\n\t  *\n\t  * @private\n\t  * @param {String} sText\n\t  * @param {Number} nCorrectLevel\n\t  * @return {Number} type\n\t  */\n\t\tfunction _getTypeNumber(sText, nCorrectLevel) {\n\t\t\tvar nType = 1;\n\t\t\tvar length = _getUTF8Length(sText);\n\n\t\t\tfor (var i = 0, len = QRCodeLimitLength.length; i <= len; i++) {\n\t\t\t\tvar nLimit = 0;\n\n\t\t\t\tswitch (nCorrectLevel) {\n\t\t\t\t\tcase QRErrorCorrectLevel.L:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][0];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase QRErrorCorrectLevel.M:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][1];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase QRErrorCorrectLevel.Q:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][2];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase QRErrorCorrectLevel.H:\n\t\t\t\t\t\tnLimit = QRCodeLimitLength[i][3];\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif (length <= nLimit) {\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\tnType++;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (nType > QRCodeLimitLength.length) {\n\t\t\t\tthrow new Error(\"Too long data\");\n\t\t\t}\n\n\t\t\treturn nType;\n\t\t}\n\n\t\tfunction _getUTF8Length(sText) {\n\t\t\tvar replacedText = encodeURI(sText).toString().replace(/\\%[0-9a-fA-F]{2}/g, 'a');\n\t\t\treturn replacedText.length + (replacedText.length != sText ? 3 : 0);\n\t\t}\n\n\t\t/**\n\t  * @class QRCode\n\t  * @constructor\n\t  * @example\n\t  * new QRCode(document.getElementById(\"test\"), \"http://jindo.dev.naver.com/collie\");\n\t  *\n\t  * @example\n\t  * var oQRCode = new QRCode(\"test\", {\n\t  *    text : \"http://naver.com\",\n\t  *    width : 128,\n\t  *    height : 128\n\t  * });\n\t  *\n\t  * oQRCode.clear(); // Clear the QRCode.\n\t  * oQRCode.makeCode(\"http://map.naver.com\"); // Re-create the QRCode.\n\t  *\n\t  * @param {HTMLElement|String} el target element or 'id' attribute of element.\n\t  * @param {Object|String} vOption\n\t  * @param {String} vOption.text QRCode link data\n\t  * @param {Number} [vOption.width=256]\n\t  * @param {Number} [vOption.height=256]\n\t  * @param {String} [vOption.colorDark=\"#000000\"]\n\t  * @param {String} [vOption.colorLight=\"#ffffff\"]\n\t  * @param {QRCode.CorrectLevel} [vOption.correctLevel=QRCode.CorrectLevel.H] [L|M|Q|H]\n\t  */\n\t\tQRCode = function QRCode(el, vOption) {\n\t\t\tthis._htOption = {\n\t\t\t\twidth: 256,\n\t\t\t\theight: 256,\n\t\t\t\ttypeNumber: 4,\n\t\t\t\tcolorDark: \"#000000\",\n\t\t\t\tcolorLight: \"#ffffff\",\n\t\t\t\tcorrectLevel: QRErrorCorrectLevel.H\n\t\t\t};\n\n\t\t\tif (typeof vOption === 'string') {\n\t\t\t\tvOption = {\n\t\t\t\t\ttext: vOption\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// Overwrites options\n\t\t\tif (vOption) {\n\t\t\t\tfor (var i in vOption) {\n\t\t\t\t\tthis._htOption[i] = vOption[i];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (typeof el == \"string\") {\n\t\t\t\tel = document.getElementById(el);\n\t\t\t}\n\n\t\t\tif (this._htOption.useSVG) {\n\t\t\t\tDrawing = svgDrawer;\n\t\t\t}\n\n\t\t\tthis._android = _getAndroid();\n\t\t\tthis._el = el;\n\t\t\tthis._oQRCode = null;\n\t\t\tthis._oDrawing = new Drawing(this._el, this._htOption);\n\n\t\t\tif (this._htOption.text) {\n\t\t\t\tthis.makeCode(this._htOption.text);\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t  * Make the QRCode\n\t  *\n\t  * @param {String} sText link data\n\t  */\n\t\tQRCode.prototype.makeCode = function (sText) {\n\t\t\tthis._oQRCode = new QRCodeModel(_getTypeNumber(sText, this._htOption.correctLevel), this._htOption.correctLevel);\n\t\t\tthis._oQRCode.addData(sText);\n\t\t\tthis._oQRCode.make();\n\t\t\tthis._el.title = sText;\n\t\t\tthis._oDrawing.draw(this._oQRCode);\n\t\t\tthis.makeImage();\n\t\t};\n\n\t\t/**\n\t  * Make the Image from Canvas element\n\t  * - It occurs automatically\n\t  * - Android below 3 doesn't support Data-URI spec.\n\t  *\n\t  * @private\n\t  */\n\t\tQRCode.prototype.makeImage = function () {\n\t\t\tif (typeof this._oDrawing.makeImage == \"function\" && (!this._android || this._android >= 3)) {\n\t\t\t\tthis._oDrawing.makeImage();\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t  * Clear the QRCode\n\t  */\n\t\tQRCode.prototype.clear = function () {\n\t\t\tthis._oDrawing.clear();\n\t\t};\n\n\t\t/**\n\t  * @name QRCode.CorrectLevel\n\t  */\n\t\tQRCode.CorrectLevel = QRErrorCorrectLevel;\n\t})(window);\n\n\texports.default = QRCode;\n\n/***/ }\n/******/ ])\n});\n;\n},{}],23:[function(require,module,exports){\n/**\n * tracking - A modern approach for Computer Vision on the web.\n * @author Eduardo Lundgren <edu@rdo.io>\n * @version v1.1.2\n * @link http://trackingjs.com\n * @license BSD\n */\n(function(window, undefined) {\n  window.tracking = window.tracking || {};\n\n  /**\n   * Inherit the prototype methods from one constructor into another.\n   *\n   * Usage:\n   * <pre>\n   * function ParentClass(a, b) { }\n   * ParentClass.prototype.foo = function(a) { }\n   *\n   * function ChildClass(a, b, c) {\n   *   tracking.base(this, a, b);\n   * }\n   * tracking.inherits(ChildClass, ParentClass);\n   *\n   * var child = new ChildClass('a', 'b', 'c');\n   * child.foo();\n   * </pre>\n   *\n   * @param {Function} childCtor Child class.\n   * @param {Function} parentCtor Parent class.\n   */\n  tracking.inherits = function(childCtor, parentCtor) {\n    function TempCtor() {\n    }\n    TempCtor.prototype = parentCtor.prototype;\n    childCtor.superClass_ = parentCtor.prototype;\n    childCtor.prototype = new TempCtor();\n    childCtor.prototype.constructor = childCtor;\n\n    /**\n     * Calls superclass constructor/method.\n     *\n     * This function is only available if you use tracking.inherits to express\n     * inheritance relationships between classes.\n     *\n     * @param {!object} me Should always be \"this\".\n     * @param {string} methodName The method name to call. Calling superclass\n     *     constructor can be done with the special string 'constructor'.\n     * @param {...*} var_args The arguments to pass to superclass\n     *     method/constructor.\n     * @return {*} The return value of the superclass method/constructor.\n     */\n    childCtor.base = function(me, methodName) {\n      var args = Array.prototype.slice.call(arguments, 2);\n      return parentCtor.prototype[methodName].apply(me, args);\n    };\n  };\n\n  /**\n   * Captures the user camera when tracking a video element and set its source\n   * to the camera stream.\n   * @param {HTMLVideoElement} element Canvas element to track.\n   * @param {object} opt_options Optional configuration to the tracker.\n   */\n  tracking.initUserMedia_ = function(element, opt_options) {\n    window.navigator.getUserMedia({\n      video: true,\n      audio: !!(opt_options && opt_options.audio)\n    }, function(stream) {\n        try {\n          element.src = window.URL.createObjectURL(stream);\n        } catch (err) {\n          element.src = stream;\n        }\n      }, function() {\n        throw Error('Cannot capture user camera.');\n      }\n    );\n  };\n\n  /**\n   * Tests whether the object is a dom node.\n   * @param {object} o Object to be tested.\n   * @return {boolean} True if the object is a dom node.\n   */\n  tracking.isNode = function(o) {\n    return o.nodeType || this.isWindow(o);\n  };\n\n  /**\n   * Tests whether the object is the `window` object.\n   * @param {object} o Object to be tested.\n   * @return {boolean} True if the object is the `window` object.\n   */\n  tracking.isWindow = function(o) {\n    return !!(o && o.alert && o.document);\n  };\n\n  /**\n   * Selects a dom node from a CSS3 selector using `document.querySelector`.\n   * @param {string} selector\n   * @param {object} opt_element The root element for the query. When not\n   *     specified `document` is used as root element.\n   * @return {HTMLElement} The first dom element that matches to the selector.\n   *     If not found, returns `null`.\n   */\n  tracking.one = function(selector, opt_element) {\n    if (this.isNode(selector)) {\n      return selector;\n    }\n    return (opt_element || document).querySelector(selector);\n  };\n\n  /**\n   * Tracks a canvas, image or video element based on the specified `tracker`\n   * instance. This method extract the pixel information of the input element\n   * to pass to the `tracker` instance. When tracking a video, the\n   * `tracker.track(pixels, width, height)` will be in a\n   * `requestAnimationFrame` loop in order to track all video frames.\n   *\n   * Example:\n   * var tracker = new tracking.ColorTracker();\n   *\n   * tracking.track('#video', tracker);\n   * or\n   * tracking.track('#video', tracker, { camera: true });\n   *\n   * tracker.on('track', function(event) {\n   *   // console.log(event.data[0].x, event.data[0].y)\n   * });\n   *\n   * @param {HTMLElement} element The element to track, canvas, image or\n   *     video.\n   * @param {tracking.Tracker} tracker The tracker instance used to track the\n   *     element.\n   * @param {object} opt_options Optional configuration to the tracker.\n   */\n  tracking.track = function(element, tracker, opt_options) {\n    element = tracking.one(element);\n    if (!element) {\n      throw new Error('Element not found, try a different element or selector.');\n    }\n    if (!tracker) {\n      throw new Error('Tracker not specified, try `tracking.track(element, new tracking.FaceTracker())`.');\n    }\n\n    switch (element.nodeName.toLowerCase()) {\n      case 'canvas':\n        return this.trackCanvas_(element, tracker, opt_options);\n      case 'img':\n        return this.trackImg_(element, tracker, opt_options);\n      case 'video':\n        if (opt_options) {\n          if (opt_options.camera) {\n            this.initUserMedia_(element, opt_options);\n          }\n        }\n        return this.trackVideo_(element, tracker, opt_options);\n      default:\n        throw new Error('Element not supported, try in a canvas, img, or video.');\n    }\n  };\n\n  /**\n   * Tracks a canvas element based on the specified `tracker` instance and\n   * returns a `TrackerTask` for this track.\n   * @param {HTMLCanvasElement} element Canvas element to track.\n   * @param {tracking.Tracker} tracker The tracker instance used to track the\n   *     element.\n   * @param {object} opt_options Optional configuration to the tracker.\n   * @return {tracking.TrackerTask}\n   * @private\n   */\n  tracking.trackCanvas_ = function(element, tracker) {\n    var self = this;\n    var task = new tracking.TrackerTask(tracker);\n    task.on('run', function() {\n      self.trackCanvasInternal_(element, tracker);\n    });\n    return task.run();\n  };\n\n  /**\n   * Tracks a canvas element based on the specified `tracker` instance. This\n   * method extract the pixel information of the input element to pass to the\n   * `tracker` instance.\n   * @param {HTMLCanvasElement} element Canvas element to track.\n   * @param {tracking.Tracker} tracker The tracker instance used to track the\n   *     element.\n   * @param {object} opt_options Optional configuration to the tracker.\n   * @private\n   */\n  tracking.trackCanvasInternal_ = function(element, tracker) {\n    var width = element.width;\n    var height = element.height;\n    var context = element.getContext('2d');\n    var imageData = context.getImageData(0, 0, width, height);\n    tracker.track(imageData.data, width, height);\n  };\n\n  /**\n   * Tracks a image element based on the specified `tracker` instance. This\n   * method extract the pixel information of the input element to pass to the\n   * `tracker` instance.\n   * @param {HTMLImageElement} element Canvas element to track.\n   * @param {tracking.Tracker} tracker The tracker instance used to track the\n   *     element.\n   * @param {object} opt_options Optional configuration to the tracker.\n   * @private\n   */\n  tracking.trackImg_ = function(element, tracker) {\n    var width = element.width;\n    var height = element.height;\n    var canvas = document.createElement('canvas');\n\n    canvas.width = width;\n    canvas.height = height;\n\n    var task = new tracking.TrackerTask(tracker);\n    task.on('run', function() {\n      tracking.Canvas.loadImage(canvas, element.src, 0, 0, width, height, function() {\n        tracking.trackCanvasInternal_(canvas, tracker);\n      });\n    });\n    return task.run();\n  };\n\n  /**\n   * Tracks a video element based on the specified `tracker` instance. This\n   * method extract the pixel information of the input element to pass to the\n   * `tracker` instance. The `tracker.track(pixels, width, height)` will be in\n   * a `requestAnimationFrame` loop in order to track all video frames.\n   * @param {HTMLVideoElement} element Canvas element to track.\n   * @param {tracking.Tracker} tracker The tracker instance used to track the\n   *     element.\n   * @param {object} opt_options Optional configuration to the tracker.\n   * @private\n   */\n  tracking.trackVideo_ = function(element, tracker) {\n    var canvas = document.createElement('canvas');\n    var context = canvas.getContext('2d');\n    var width;\n    var height;\n\n    var resizeCanvas_ = function() {\n      width = element.offsetWidth;\n      height = element.offsetHeight;\n      canvas.width = width;\n      canvas.height = height;\n    };\n    resizeCanvas_();\n    element.addEventListener('resize', resizeCanvas_);\n\n    var requestId;\n    var requestAnimationFrame_ = function() {\n      requestId = window.requestAnimationFrame(function() {\n        if (element.readyState === element.HAVE_ENOUGH_DATA) {\n          try {\n            // Firefox v~30.0 gets confused with the video readyState firing an\n            // erroneous HAVE_ENOUGH_DATA just before HAVE_CURRENT_DATA state,\n            // hence keep trying to read it until resolved.\n            context.drawImage(element, 0, 0, width, height);\n          } catch (err) {}\n          tracking.trackCanvasInternal_(canvas, tracker);\n        }\n        requestAnimationFrame_();\n      });\n    };\n\n    var task = new tracking.TrackerTask(tracker);\n    task.on('stop', function() {\n      window.cancelAnimationFrame(requestId);\n    });\n    task.on('run', function() {\n      requestAnimationFrame_();\n    });\n    return task.run();\n  };\n\n  // Browser polyfills\n  //===================\n\n  if (!window.URL) {\n    window.URL = window.URL || window.webkitURL || window.msURL || window.oURL;\n  }\n\n  if (!navigator.getUserMedia) {\n    navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia ||\n    navigator.mozGetUserMedia || navigator.msGetUserMedia;\n  }\n}(window));\n\n(function() {\n  /**\n   * EventEmitter utility.\n   * @constructor\n   */\n  tracking.EventEmitter = function() {};\n\n  /**\n   * Holds event listeners scoped by event type.\n   * @type {object}\n   * @private\n   */\n  tracking.EventEmitter.prototype.events_ = null;\n\n  /**\n   * Adds a listener to the end of the listeners array for the specified event.\n   * @param {string} event\n   * @param {function} listener\n   * @return {object} Returns emitter, so calls can be chained.\n   */\n  tracking.EventEmitter.prototype.addListener = function(event, listener) {\n    if (typeof listener !== 'function') {\n      throw new TypeError('Listener must be a function');\n    }\n    if (!this.events_) {\n      this.events_ = {};\n    }\n\n    this.emit('newListener', event, listener);\n\n    if (!this.events_[event]) {\n      this.events_[event] = [];\n    }\n\n    this.events_[event].push(listener);\n\n    return this;\n  };\n\n  /**\n   * Returns an array of listeners for the specified event.\n   * @param {string} event\n   * @return {array} Array of listeners.\n   */\n  tracking.EventEmitter.prototype.listeners = function(event) {\n    return this.events_ && this.events_[event];\n  };\n\n  /**\n   * Execute each of the listeners in order with the supplied arguments.\n   * @param {string} event\n   * @param {*} opt_args [arg1], [arg2], [...]\n   * @return {boolean} Returns true if event had listeners, false otherwise.\n   */\n  tracking.EventEmitter.prototype.emit = function(event) {\n    var listeners = this.listeners(event);\n    if (listeners) {\n      var args = Array.prototype.slice.call(arguments, 1);\n      for (var i = 0; i < listeners.length; i++) {\n        if (listeners[i]) {\n          listeners[i].apply(this, args);\n        }\n      }\n      return true;\n    }\n    return false;\n  };\n\n  /**\n   * Adds a listener to the end of the listeners array for the specified event.\n   * @param {string} event\n   * @param {function} listener\n   * @return {object} Returns emitter, so calls can be chained.\n   */\n  tracking.EventEmitter.prototype.on = tracking.EventEmitter.prototype.addListener;\n\n  /**\n   * Adds a one time listener for the event. This listener is invoked only the\n   * next time the event is fired, after which it is removed.\n   * @param {string} event\n   * @param {function} listener\n   * @return {object} Returns emitter, so calls can be chained.\n   */\n  tracking.EventEmitter.prototype.once = function(event, listener) {\n    var self = this;\n    self.on(event, function handlerInternal() {\n      self.removeListener(event, handlerInternal);\n      listener.apply(this, arguments);\n    });\n  };\n\n  /**\n   * Removes all listeners, or those of the specified event. It's not a good\n   * idea to remove listeners that were added elsewhere in the code,\n   * especially when it's on an emitter that you didn't create.\n   * @param {string} event\n   * @return {object} Returns emitter, so calls can be chained.\n   */\n  tracking.EventEmitter.prototype.removeAllListeners = function(opt_event) {\n    if (!this.events_) {\n      return this;\n    }\n    if (opt_event) {\n      delete this.events_[opt_event];\n    } else {\n      delete this.events_;\n    }\n    return this;\n  };\n\n  /**\n   * Remove a listener from the listener array for the specified event.\n   * Caution: changes array indices in the listener array behind the listener.\n   * @param {string} event\n   * @param {function} listener\n   * @return {object} Returns emitter, so calls can be chained.\n   */\n  tracking.EventEmitter.prototype.removeListener = function(event, listener) {\n    if (typeof listener !== 'function') {\n      throw new TypeError('Listener must be a function');\n    }\n    if (!this.events_) {\n      return this;\n    }\n\n    var listeners = this.listeners(event);\n    if (Array.isArray(listeners)) {\n      var i = listeners.indexOf(listener);\n      if (i < 0) {\n        return this;\n      }\n      listeners.splice(i, 1);\n    }\n\n    return this;\n  };\n\n  /**\n   * By default EventEmitters will print a warning if more than 10 listeners\n   * are added for a particular event. This is a useful default which helps\n   * finding memory leaks. Obviously not all Emitters should be limited to 10.\n   * This function allows that to be increased. Set to zero for unlimited.\n   * @param {number} n The maximum number of listeners.\n   */\n  tracking.EventEmitter.prototype.setMaxListeners = function() {\n    throw new Error('Not implemented');\n  };\n\n}());\n\n(function() {\n  /**\n   * Canvas utility.\n   * @static\n   * @constructor\n   */\n  tracking.Canvas = {};\n\n  /**\n   * Loads an image source into the canvas.\n   * @param {HTMLCanvasElement} canvas The canvas dom element.\n   * @param {string} src The image source.\n   * @param {number} x The canvas horizontal coordinate to load the image.\n   * @param {number} y The canvas vertical coordinate to load the image.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {function} opt_callback Callback that fires when the image is loaded\n   *     into the canvas.\n   * @static\n   */\n  tracking.Canvas.loadImage = function(canvas, src, x, y, width, height, opt_callback) {\n    var instance = this;\n    var img = new window.Image();\n    img.crossOrigin = '*';\n    img.onload = function() {\n      var context = canvas.getContext('2d');\n      canvas.width = width;\n      canvas.height = height;\n      context.drawImage(img, x, y, width, height);\n      if (opt_callback) {\n        opt_callback.call(instance);\n      }\n      img = null;\n    };\n    img.src = src;\n  };\n}());\n\n(function() {\n  /**\n   * DisjointSet utility with path compression. Some applications involve\n   * grouping n distinct objects into a collection of disjoint sets. Two\n   * important operations are then finding which set a given object belongs to\n   * and uniting the two sets. A disjoint set data structure maintains a\n   * collection S={ S1 , S2 ,..., Sk } of disjoint dynamic sets. Each set is\n   * identified by a representative, which usually is a member in the set.\n   * @static\n   * @constructor\n   */\n  tracking.DisjointSet = function(length) {\n    if (length === undefined) {\n      throw new Error('DisjointSet length not specified.');\n    }\n    this.length = length;\n    this.parent = new Uint32Array(length);\n    for (var i = 0; i < length; i++) {\n      this.parent[i] = i;\n    }\n  };\n\n  /**\n   * Holds the length of the internal set.\n   * @type {number}\n   */\n  tracking.DisjointSet.prototype.length = null;\n\n  /**\n   * Holds the set containing the representative values.\n   * @type {Array.<number>}\n   */\n  tracking.DisjointSet.prototype.parent = null;\n\n  /**\n   * Finds a pointer to the representative of the set containing i.\n   * @param {number} i\n   * @return {number} The representative set of i.\n   */\n  tracking.DisjointSet.prototype.find = function(i) {\n    if (this.parent[i] === i) {\n      return i;\n    } else {\n      return (this.parent[i] = this.find(this.parent[i]));\n    }\n  };\n\n  /**\n   * Unites two dynamic sets containing objects i and j, say Si and Sj, into\n   * a new set that Si ∪ Sj, assuming that Si ∩ Sj = ∅;\n   * @param {number} i\n   * @param {number} j\n   */\n  tracking.DisjointSet.prototype.union = function(i, j) {\n    var iRepresentative = this.find(i);\n    var jRepresentative = this.find(j);\n    this.parent[iRepresentative] = jRepresentative;\n  };\n\n}());\n\n(function() {\n  /**\n   * Image utility.\n   * @static\n   * @constructor\n   */\n  tracking.Image = {};\n\n  /**\n   * Computes gaussian blur. Adapted from\n   * https://github.com/kig/canvasfilters.\n   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {number} diameter Gaussian blur diameter, must be greater than 1.\n   * @return {array} The edge pixels in a linear [r,g,b,a,...] array.\n   */\n  tracking.Image.blur = function(pixels, width, height, diameter) {\n    diameter = Math.abs(diameter);\n    if (diameter <= 1) {\n      throw new Error('Diameter should be greater than 1.');\n    }\n    var radius = diameter / 2;\n    var len = Math.ceil(diameter) + (1 - (Math.ceil(diameter) % 2));\n    var weights = new Float32Array(len);\n    var rho = (radius + 0.5) / 3;\n    var rhoSq = rho * rho;\n    var gaussianFactor = 1 / Math.sqrt(2 * Math.PI * rhoSq);\n    var rhoFactor = -1 / (2 * rho * rho);\n    var wsum = 0;\n    var middle = Math.floor(len / 2);\n    for (var i = 0; i < len; i++) {\n      var x = i - middle;\n      var gx = gaussianFactor * Math.exp(x * x * rhoFactor);\n      weights[i] = gx;\n      wsum += gx;\n    }\n    for (var j = 0; j < weights.length; j++) {\n      weights[j] /= wsum;\n    }\n    return this.separableConvolve(pixels, width, height, weights, weights, false);\n  };\n\n  /**\n   * Computes the integral image for summed, squared, rotated and sobel pixels.\n   * @param {array} pixels The pixels in a linear [r,g,b,a,...] array to loop\n   *     through.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {array} opt_integralImage Empty array of size `width * height` to\n   *     be filled with the integral image values. If not specified compute sum\n   *     values will be skipped.\n   * @param {array} opt_integralImageSquare Empty array of size `width *\n   *     height` to be filled with the integral image squared values. If not\n   *     specified compute squared values will be skipped.\n   * @param {array} opt_tiltedIntegralImage Empty array of size `width *\n   *     height` to be filled with the rotated integral image values. If not\n   *     specified compute sum values will be skipped.\n   * @param {array} opt_integralImageSobel Empty array of size `width *\n   *     height` to be filled with the integral image of sobel values. If not\n   *     specified compute sobel filtering will be skipped.\n   * @static\n   */\n  tracking.Image.computeIntegralImage = function(pixels, width, height, opt_integralImage, opt_integralImageSquare, opt_tiltedIntegralImage, opt_integralImageSobel) {\n    if (arguments.length < 4) {\n      throw new Error('You should specify at least one output array in the order: sum, square, tilted, sobel.');\n    }\n    var pixelsSobel;\n    if (opt_integralImageSobel) {\n      pixelsSobel = tracking.Image.sobel(pixels, width, height);\n    }\n    for (var i = 0; i < height; i++) {\n      for (var j = 0; j < width; j++) {\n        var w = i * width * 4 + j * 4;\n        var pixel = ~~(pixels[w] * 0.299 + pixels[w + 1] * 0.587 + pixels[w + 2] * 0.114);\n        if (opt_integralImage) {\n          this.computePixelValueSAT_(opt_integralImage, width, i, j, pixel);\n        }\n        if (opt_integralImageSquare) {\n          this.computePixelValueSAT_(opt_integralImageSquare, width, i, j, pixel * pixel);\n        }\n        if (opt_tiltedIntegralImage) {\n          var w1 = w - width * 4;\n          var pixelAbove = ~~(pixels[w1] * 0.299 + pixels[w1 + 1] * 0.587 + pixels[w1 + 2] * 0.114);\n          this.computePixelValueRSAT_(opt_tiltedIntegralImage, width, i, j, pixel, pixelAbove || 0);\n        }\n        if (opt_integralImageSobel) {\n          this.computePixelValueSAT_(opt_integralImageSobel, width, i, j, pixelsSobel[w]);\n        }\n      }\n    }\n  };\n\n  /**\n   * Helper method to compute the rotated summed area table (RSAT) by the\n   * formula:\n   *\n   * RSAT(x, y) = RSAT(x-1, y-1) + RSAT(x+1, y-1) - RSAT(x, y-2) + I(x, y) + I(x, y-1)\n   *\n   * @param {number} width The image width.\n   * @param {array} RSAT Empty array of size `width * height` to be filled with\n   *     the integral image values. If not specified compute sum values will be\n   *     skipped.\n   * @param {number} i Vertical position of the pixel to be evaluated.\n   * @param {number} j Horizontal position of the pixel to be evaluated.\n   * @param {number} pixel Pixel value to be added to the integral image.\n   * @static\n   * @private\n   */\n  tracking.Image.computePixelValueRSAT_ = function(RSAT, width, i, j, pixel, pixelAbove) {\n    var w = i * width + j;\n    RSAT[w] = (RSAT[w - width - 1] || 0) + (RSAT[w - width + 1] || 0) - (RSAT[w - width - width] || 0) + pixel + pixelAbove;\n  };\n\n  /**\n   * Helper method to compute the summed area table (SAT) by the formula:\n   *\n   * SAT(x, y) = SAT(x, y-1) + SAT(x-1, y) + I(x, y) - SAT(x-1, y-1)\n   *\n   * @param {number} width The image width.\n   * @param {array} SAT Empty array of size `width * height` to be filled with\n   *     the integral image values. If not specified compute sum values will be\n   *     skipped.\n   * @param {number} i Vertical position of the pixel to be evaluated.\n   * @param {number} j Horizontal position of the pixel to be evaluated.\n   * @param {number} pixel Pixel value to be added to the integral image.\n   * @static\n   * @private\n   */\n  tracking.Image.computePixelValueSAT_ = function(SAT, width, i, j, pixel) {\n    var w = i * width + j;\n    SAT[w] = (SAT[w - width] || 0) + (SAT[w - 1] || 0) + pixel - (SAT[w - width - 1] || 0);\n  };\n\n  /**\n   * Converts a color from a colorspace based on an RGB color model to a\n   * grayscale representation of its luminance. The coefficients represent the\n   * measured intensity perception of typical trichromat humans, in\n   * particular, human vision is most sensitive to green and least sensitive\n   * to blue.\n   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {boolean} fillRGBA If the result should fill all RGBA values with the gray scale\n   *  values, instead of returning a single value per pixel.\n   * @param {Uint8ClampedArray} The grayscale pixels in a linear array ([p,p,p,a,...] if fillRGBA\n   *  is true and [p1, p2, p3, ...] if fillRGBA is false).\n   * @static\n   */\n  tracking.Image.grayscale = function(pixels, width, height, fillRGBA) {\n    var gray = new Uint8ClampedArray(fillRGBA ? pixels.length : pixels.length >> 2);\n    var p = 0;\n    var w = 0;\n    for (var i = 0; i < height; i++) {\n      for (var j = 0; j < width; j++) {\n        var value = pixels[w] * 0.299 + pixels[w + 1] * 0.587 + pixels[w + 2] * 0.114;\n        gray[p++] = value;\n\n        if (fillRGBA) {\n          gray[p++] = value;\n          gray[p++] = value;\n          gray[p++] = pixels[w + 3];\n        }\n\n        w += 4;\n      }\n    }\n    return gray;\n  };\n\n  /**\n   * Fast horizontal separable convolution. A point spread function (PSF) is\n   * said to be separable if it can be broken into two one-dimensional\n   * signals: a vertical and a horizontal projection. The convolution is\n   * performed by sliding the kernel over the image, generally starting at the\n   * top left corner, so as to move the kernel through all the positions where\n   * the kernel fits entirely within the boundaries of the image. Adapted from\n   * https://github.com/kig/canvasfilters.\n   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {array} weightsVector The weighting vector, e.g [-1,0,1].\n   * @param {number} opaque\n   * @return {array} The convoluted pixels in a linear [r,g,b,a,...] array.\n   */\n  tracking.Image.horizontalConvolve = function(pixels, width, height, weightsVector, opaque) {\n    var side = weightsVector.length;\n    var halfSide = Math.floor(side / 2);\n    var output = new Float32Array(width * height * 4);\n    var alphaFac = opaque ? 1 : 0;\n\n    for (var y = 0; y < height; y++) {\n      for (var x = 0; x < width; x++) {\n        var sy = y;\n        var sx = x;\n        var offset = (y * width + x) * 4;\n        var r = 0;\n        var g = 0;\n        var b = 0;\n        var a = 0;\n        for (var cx = 0; cx < side; cx++) {\n          var scy = sy;\n          var scx = Math.min(width - 1, Math.max(0, sx + cx - halfSide));\n          var poffset = (scy * width + scx) * 4;\n          var wt = weightsVector[cx];\n          r += pixels[poffset] * wt;\n          g += pixels[poffset + 1] * wt;\n          b += pixels[poffset + 2] * wt;\n          a += pixels[poffset + 3] * wt;\n        }\n        output[offset] = r;\n        output[offset + 1] = g;\n        output[offset + 2] = b;\n        output[offset + 3] = a + alphaFac * (255 - a);\n      }\n    }\n    return output;\n  };\n\n  /**\n   * Fast vertical separable convolution. A point spread function (PSF) is\n   * said to be separable if it can be broken into two one-dimensional\n   * signals: a vertical and a horizontal projection. The convolution is\n   * performed by sliding the kernel over the image, generally starting at the\n   * top left corner, so as to move the kernel through all the positions where\n   * the kernel fits entirely within the boundaries of the image. Adapted from\n   * https://github.com/kig/canvasfilters.\n   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {array} weightsVector The weighting vector, e.g [-1,0,1].\n   * @param {number} opaque\n   * @return {array} The convoluted pixels in a linear [r,g,b,a,...] array.\n   */\n  tracking.Image.verticalConvolve = function(pixels, width, height, weightsVector, opaque) {\n    var side = weightsVector.length;\n    var halfSide = Math.floor(side / 2);\n    var output = new Float32Array(width * height * 4);\n    var alphaFac = opaque ? 1 : 0;\n\n    for (var y = 0; y < height; y++) {\n      for (var x = 0; x < width; x++) {\n        var sy = y;\n        var sx = x;\n        var offset = (y * width + x) * 4;\n        var r = 0;\n        var g = 0;\n        var b = 0;\n        var a = 0;\n        for (var cy = 0; cy < side; cy++) {\n          var scy = Math.min(height - 1, Math.max(0, sy + cy - halfSide));\n          var scx = sx;\n          var poffset = (scy * width + scx) * 4;\n          var wt = weightsVector[cy];\n          r += pixels[poffset] * wt;\n          g += pixels[poffset + 1] * wt;\n          b += pixels[poffset + 2] * wt;\n          a += pixels[poffset + 3] * wt;\n        }\n        output[offset] = r;\n        output[offset + 1] = g;\n        output[offset + 2] = b;\n        output[offset + 3] = a + alphaFac * (255 - a);\n      }\n    }\n    return output;\n  };\n\n  /**\n   * Fast separable convolution. A point spread function (PSF) is said to be\n   * separable if it can be broken into two one-dimensional signals: a\n   * vertical and a horizontal projection. The convolution is performed by\n   * sliding the kernel over the image, generally starting at the top left\n   * corner, so as to move the kernel through all the positions where the\n   * kernel fits entirely within the boundaries of the image. Adapted from\n   * https://github.com/kig/canvasfilters.\n   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {array} horizWeights The horizontal weighting vector, e.g [-1,0,1].\n   * @param {array} vertWeights The vertical vector, e.g [-1,0,1].\n   * @param {number} opaque\n   * @return {array} The convoluted pixels in a linear [r,g,b,a,...] array.\n   */\n  tracking.Image.separableConvolve = function(pixels, width, height, horizWeights, vertWeights, opaque) {\n    var vertical = this.verticalConvolve(pixels, width, height, vertWeights, opaque);\n    return this.horizontalConvolve(vertical, width, height, horizWeights, opaque);\n  };\n\n  /**\n   * Compute image edges using Sobel operator. Computes the vertical and\n   * horizontal gradients of the image and combines the computed images to\n   * find edges in the image. The way we implement the Sobel filter here is by\n   * first grayscaling the image, then taking the horizontal and vertical\n   * gradients and finally combining the gradient images to make up the final\n   * image. Adapted from https://github.com/kig/canvasfilters.\n   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @return {array} The edge pixels in a linear [r,g,b,a,...] array.\n   */\n  tracking.Image.sobel = function(pixels, width, height) {\n    pixels = this.grayscale(pixels, width, height, true);\n    var output = new Float32Array(width * height * 4);\n    var sobelSignVector = new Float32Array([-1, 0, 1]);\n    var sobelScaleVector = new Float32Array([1, 2, 1]);\n    var vertical = this.separableConvolve(pixels, width, height, sobelSignVector, sobelScaleVector);\n    var horizontal = this.separableConvolve(pixels, width, height, sobelScaleVector, sobelSignVector);\n\n    for (var i = 0; i < output.length; i += 4) {\n      var v = vertical[i];\n      var h = horizontal[i];\n      var p = Math.sqrt(h * h + v * v);\n      output[i] = p;\n      output[i + 1] = p;\n      output[i + 2] = p;\n      output[i + 3] = 255;\n    }\n\n    return output;\n  };\n\n}());\n\n(function() {\n  /**\n   * ViolaJones utility.\n   * @static\n   * @constructor\n   */\n  tracking.ViolaJones = {};\n\n  /**\n   * Holds the minimum area of intersection that defines when a rectangle is\n   * from the same group. Often when a face is matched multiple rectangles are\n   * classified as possible rectangles to represent the face, when they\n   * intersects they are grouped as one face.\n   * @type {number}\n   * @default 0.5\n   * @static\n   */\n  tracking.ViolaJones.REGIONS_OVERLAP = 0.5;\n\n  /**\n   * Holds the HAAR cascade classifiers converted from OpenCV training.\n   * @type {array}\n   * @static\n   */\n  tracking.ViolaJones.classifiers = {};\n\n  /**\n   * Detects through the HAAR cascade data rectangles matches.\n   * @param {pixels} pixels The pixels in a linear [r,g,b,a,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {number} initialScale The initial scale to start the block\n   *     scaling.\n   * @param {number} scaleFactor The scale factor to scale the feature block.\n   * @param {number} stepSize The block step size.\n   * @param {number} edgesDensity Percentage density edges inside the\n   *     classifier block. Value from [0.0, 1.0], defaults to 0.2. If specified\n   *     edge detection will be applied to the image to prune dead areas of the\n   *     image, this can improve significantly performance.\n   * @param {number} data The HAAR cascade data.\n   * @return {array} Found rectangles.\n   * @static\n   */\n  tracking.ViolaJones.detect = function(pixels, width, height, initialScale, scaleFactor, stepSize, edgesDensity, data) {\n    var total = 0;\n    var rects = [];\n    var integralImage = new Int32Array(width * height);\n    var integralImageSquare = new Int32Array(width * height);\n    var tiltedIntegralImage = new Int32Array(width * height);\n\n    var integralImageSobel;\n    if (edgesDensity > 0) {\n      integralImageSobel = new Int32Array(width * height);\n    }\n\n    tracking.Image.computeIntegralImage(pixels, width, height, integralImage, integralImageSquare, tiltedIntegralImage, integralImageSobel);\n\n    var minWidth = data[0];\n    var minHeight = data[1];\n    var scale = initialScale * scaleFactor;\n    var blockWidth = (scale * minWidth) | 0;\n    var blockHeight = (scale * minHeight) | 0;\n\n    while (blockWidth < width && blockHeight < height) {\n      var step = (scale * stepSize + 0.5) | 0;\n      for (var i = 0; i < (height - blockHeight); i += step) {\n        for (var j = 0; j < (width - blockWidth); j += step) {\n\n          if (edgesDensity > 0) {\n            if (this.isTriviallyExcluded(edgesDensity, integralImageSobel, i, j, width, blockWidth, blockHeight)) {\n              continue;\n            }\n          }\n\n          if (this.evalStages_(data, integralImage, integralImageSquare, tiltedIntegralImage, i, j, width, blockWidth, blockHeight, scale)) {\n            rects[total++] = {\n              width: blockWidth,\n              height: blockHeight,\n              x: j,\n              y: i\n            };\n          }\n        }\n      }\n\n      scale *= scaleFactor;\n      blockWidth = (scale * minWidth) | 0;\n      blockHeight = (scale * minHeight) | 0;\n    }\n    return this.mergeRectangles_(rects);\n  };\n\n  /**\n   * Fast check to test whether the edges density inside the block is greater\n   * than a threshold, if true it tests the stages. This can improve\n   * significantly performance.\n   * @param {number} edgesDensity Percentage density edges inside the\n   *     classifier block.\n   * @param {array} integralImageSobel The integral image of a sobel image.\n   * @param {number} i Vertical position of the pixel to be evaluated.\n   * @param {number} j Horizontal position of the pixel to be evaluated.\n   * @param {number} width The image width.\n   * @return {boolean} True whether the block at position i,j can be skipped,\n   *     false otherwise.\n   * @static\n   * @protected\n   */\n  tracking.ViolaJones.isTriviallyExcluded = function(edgesDensity, integralImageSobel, i, j, width, blockWidth, blockHeight) {\n    var wbA = i * width + j;\n    var wbB = wbA + blockWidth;\n    var wbD = wbA + blockHeight * width;\n    var wbC = wbD + blockWidth;\n    var blockEdgesDensity = (integralImageSobel[wbA] - integralImageSobel[wbB] - integralImageSobel[wbD] + integralImageSobel[wbC]) / (blockWidth * blockHeight * 255);\n    if (blockEdgesDensity < edgesDensity) {\n      return true;\n    }\n    return false;\n  };\n\n  /**\n   * Evaluates if the block size on i,j position is a valid HAAR cascade\n   * stage.\n   * @param {number} data The HAAR cascade data.\n   * @param {number} i Vertical position of the pixel to be evaluated.\n   * @param {number} j Horizontal position of the pixel to be evaluated.\n   * @param {number} width The image width.\n   * @param {number} blockSize The block size.\n   * @param {number} scale The scale factor of the block size and its original\n   *     size.\n   * @param {number} inverseArea The inverse area of the block size.\n   * @return {boolean} Whether the region passes all the stage tests.\n   * @private\n   * @static\n   */\n  tracking.ViolaJones.evalStages_ = function(data, integralImage, integralImageSquare, tiltedIntegralImage, i, j, width, blockWidth, blockHeight, scale) {\n    var inverseArea = 1.0 / (blockWidth * blockHeight);\n    var wbA = i * width + j;\n    var wbB = wbA + blockWidth;\n    var wbD = wbA + blockHeight * width;\n    var wbC = wbD + blockWidth;\n    var mean = (integralImage[wbA] - integralImage[wbB] - integralImage[wbD] + integralImage[wbC]) * inverseArea;\n    var variance = (integralImageSquare[wbA] - integralImageSquare[wbB] - integralImageSquare[wbD] + integralImageSquare[wbC]) * inverseArea - mean * mean;\n\n    var standardDeviation = 1;\n    if (variance > 0) {\n      standardDeviation = Math.sqrt(variance);\n    }\n\n    var length = data.length;\n\n    for (var w = 2; w < length; ) {\n      var stageSum = 0;\n      var stageThreshold = data[w++];\n      var nodeLength = data[w++];\n\n      while (nodeLength--) {\n        var rectsSum = 0;\n        var tilted = data[w++];\n        var rectsLength = data[w++];\n\n        for (var r = 0; r < rectsLength; r++) {\n          var rectLeft = (j + data[w++] * scale + 0.5) | 0;\n          var rectTop = (i + data[w++] * scale + 0.5) | 0;\n          var rectWidth = (data[w++] * scale + 0.5) | 0;\n          var rectHeight = (data[w++] * scale + 0.5) | 0;\n          var rectWeight = data[w++];\n\n          var w1;\n          var w2;\n          var w3;\n          var w4;\n          if (tilted) {\n            // RectSum(r) = RSAT(x-h+w, y+w+h-1) + RSAT(x, y-1) - RSAT(x-h, y+h-1) - RSAT(x+w, y+w-1)\n            w1 = (rectLeft - rectHeight + rectWidth) + (rectTop + rectWidth + rectHeight - 1) * width;\n            w2 = rectLeft + (rectTop - 1) * width;\n            w3 = (rectLeft - rectHeight) + (rectTop + rectHeight - 1) * width;\n            w4 = (rectLeft + rectWidth) + (rectTop + rectWidth - 1) * width;\n            rectsSum += (tiltedIntegralImage[w1] + tiltedIntegralImage[w2] - tiltedIntegralImage[w3] - tiltedIntegralImage[w4]) * rectWeight;\n          } else {\n            // RectSum(r) = SAT(x-1, y-1) + SAT(x+w-1, y+h-1) - SAT(x-1, y+h-1) - SAT(x+w-1, y-1)\n            w1 = rectTop * width + rectLeft;\n            w2 = w1 + rectWidth;\n            w3 = w1 + rectHeight * width;\n            w4 = w3 + rectWidth;\n            rectsSum += (integralImage[w1] - integralImage[w2] - integralImage[w3] + integralImage[w4]) * rectWeight;\n            // TODO: Review the code below to analyze performance when using it instead.\n            // w1 = (rectLeft - 1) + (rectTop - 1) * width;\n            // w2 = (rectLeft + rectWidth - 1) + (rectTop + rectHeight - 1) * width;\n            // w3 = (rectLeft - 1) + (rectTop + rectHeight - 1) * width;\n            // w4 = (rectLeft + rectWidth - 1) + (rectTop - 1) * width;\n            // rectsSum += (integralImage[w1] + integralImage[w2] - integralImage[w3] - integralImage[w4]) * rectWeight;\n          }\n        }\n\n        var nodeThreshold = data[w++];\n        var nodeLeft = data[w++];\n        var nodeRight = data[w++];\n\n        if (rectsSum * inverseArea < nodeThreshold * standardDeviation) {\n          stageSum += nodeLeft;\n        } else {\n          stageSum += nodeRight;\n        }\n      }\n\n      if (stageSum < stageThreshold) {\n        return false;\n      }\n    }\n    return true;\n  };\n\n  /**\n   * Postprocess the detected sub-windows in order to combine overlapping\n   * detections into a single detection.\n   * @param {array} rects\n   * @return {array}\n   * @private\n   * @static\n   */\n  tracking.ViolaJones.mergeRectangles_ = function(rects) {\n    var disjointSet = new tracking.DisjointSet(rects.length);\n\n    for (var i = 0; i < rects.length; i++) {\n      var r1 = rects[i];\n      for (var j = 0; j < rects.length; j++) {\n        var r2 = rects[j];\n        if (tracking.Math.intersectRect(r1.x, r1.y, r1.x + r1.width, r1.y + r1.height, r2.x, r2.y, r2.x + r2.width, r2.y + r2.height)) {\n          var x1 = Math.max(r1.x, r2.x);\n          var y1 = Math.max(r1.y, r2.y);\n          var x2 = Math.min(r1.x + r1.width, r2.x + r2.width);\n          var y2 = Math.min(r1.y + r1.height, r2.y + r2.height);\n          var overlap = (x1 - x2) * (y1 - y2);\n          var area1 = (r1.width * r1.height);\n          var area2 = (r2.width * r2.height);\n\n          if ((overlap / (area1 * (area1 / area2)) >= this.REGIONS_OVERLAP) &&\n            (overlap / (area2 * (area1 / area2)) >= this.REGIONS_OVERLAP)) {\n            disjointSet.union(i, j);\n          }\n        }\n      }\n    }\n\n    var map = {};\n    for (var k = 0; k < disjointSet.length; k++) {\n      var rep = disjointSet.find(k);\n      if (!map[rep]) {\n        map[rep] = {\n          total: 1,\n          width: rects[k].width,\n          height: rects[k].height,\n          x: rects[k].x,\n          y: rects[k].y\n        };\n        continue;\n      }\n      map[rep].total++;\n      map[rep].width += rects[k].width;\n      map[rep].height += rects[k].height;\n      map[rep].x += rects[k].x;\n      map[rep].y += rects[k].y;\n    }\n\n    var result = [];\n    Object.keys(map).forEach(function(key) {\n      var rect = map[key];\n      result.push({\n        total: rect.total,\n        width: (rect.width / rect.total + 0.5) | 0,\n        height: (rect.height / rect.total + 0.5) | 0,\n        x: (rect.x / rect.total + 0.5) | 0,\n        y: (rect.y / rect.total + 0.5) | 0\n      });\n    });\n\n    return result;\n  };\n\n}());\n\n(function() {\n  /**\n   * Brief intends for \"Binary Robust Independent Elementary Features\".This\n   * method generates a binary string for each keypoint found by an extractor\n   * method.\n   * @static\n   * @constructor\n   */\n  tracking.Brief = {};\n\n  /**\n   * The set of binary tests is defined by the nd (x,y)-location pairs\n   * uniquely chosen during the initialization. Values could vary between N =\n   * 128,256,512. N=128 yield good compromises between speed, storage\n   * efficiency, and recognition rate.\n   * @type {number}\n   */\n  tracking.Brief.N = 512;\n\n  /**\n   * Caches coordinates values of (x,y)-location pairs uniquely chosen during\n   * the initialization.\n   * @type {Object.<number, Int32Array>}\n   * @private\n   * @static\n   */\n  tracking.Brief.randomImageOffsets_ = {};\n\n  /**\n   * Caches delta values of (x,y)-location pairs uniquely chosen during\n   * the initialization.\n   * @type {Int32Array}\n   * @private\n   * @static\n   */\n  tracking.Brief.randomWindowOffsets_ = null;\n\n  /**\n   * Generates a binary string for each found keypoints extracted using an\n   * extractor method.\n   * @param {array} The grayscale pixels in a linear [p1,p2,...] array.\n   * @param {number} width The image width.\n   * @param {array} keypoints\n   * @return {Int32Array} Returns an array where for each four sequence int\n   *     values represent the descriptor binary string (128 bits) necessary\n   *     to describe the corner, e.g. [0,0,0,0, 0,0,0,0, ...].\n   * @static\n   */\n  tracking.Brief.getDescriptors = function(pixels, width, keypoints) {\n    // Optimizing divide by 32 operation using binary shift\n    // (this.N >> 5) === this.N/32.\n    var descriptors = new Int32Array((keypoints.length >> 1) * (this.N >> 5));\n    var descriptorWord = 0;\n    var offsets = this.getRandomOffsets_(width);\n    var position = 0;\n\n    for (var i = 0; i < keypoints.length; i += 2) {\n      var w = width * keypoints[i + 1] + keypoints[i];\n\n      var offsetsPosition = 0;\n      for (var j = 0, n = this.N; j < n; j++) {\n        if (pixels[offsets[offsetsPosition++] + w] < pixels[offsets[offsetsPosition++] + w]) {\n          // The bit in the position `j % 32` of descriptorWord should be set to 1. We do\n          // this by making an OR operation with a binary number that only has the bit\n          // in that position set to 1. That binary number is obtained by shifting 1 left by\n          // `j % 32` (which is the same as `j & 31` left) positions.\n          descriptorWord |= 1 << (j & 31);\n        }\n\n        // If the next j is a multiple of 32, we will need to use a new descriptor word to hold\n        // the next results.\n        if (!((j + 1) & 31)) {\n          descriptors[position++] = descriptorWord;\n          descriptorWord = 0;\n        }\n      }\n    }\n\n    return descriptors;\n  };\n\n  /**\n   * Matches sets of features {mi} and {m′j} extracted from two images taken\n   * from similar, and often successive, viewpoints. A classical procedure\n   * runs as follows. For each point {mi} in the first image, search in a\n   * region of the second image around location {mi} for point {m′j}. The\n   * search is based on the similarity of the local image windows, also known\n   * as kernel windows, centered on the points, which strongly characterizes\n   * the points when the images are sufficiently close. Once each keypoint is\n   * described with its binary string, they need to be compared with the\n   * closest matching point. Distance metric is critical to the performance of\n   * in- trusion detection systems. Thus using binary strings reduces the size\n   * of the descriptor and provides an interesting data structure that is fast\n   * to operate whose similarity can be measured by the Hamming distance.\n   * @param {array} keypoints1\n   * @param {array} descriptors1\n   * @param {array} keypoints2\n   * @param {array} descriptors2\n   * @return {Int32Array} Returns an array where the index is the corner1\n   *     index coordinate, and the value is the corresponding match index of\n   *     corner2, e.g. keypoints1=[x0,y0,x1,y1,...] and\n   *     keypoints2=[x'0,y'0,x'1,y'1,...], if x0 matches x'1 and x1 matches x'0,\n   *     the return array would be [3,0].\n   * @static\n   */\n  tracking.Brief.match = function(keypoints1, descriptors1, keypoints2, descriptors2) {\n    var len1 = keypoints1.length >> 1;\n    var len2 = keypoints2.length >> 1;\n    var matches = new Array(len1);\n\n    for (var i = 0; i < len1; i++) {\n      var min = Infinity;\n      var minj = 0;\n      for (var j = 0; j < len2; j++) {\n        var dist = 0;\n        // Optimizing divide by 32 operation using binary shift\n        // (this.N >> 5) === this.N/32.\n        for (var k = 0, n = this.N >> 5; k < n; k++) {\n          dist += tracking.Math.hammingWeight(descriptors1[i * n + k] ^ descriptors2[j * n + k]);\n        }\n        if (dist < min) {\n          min = dist;\n          minj = j;\n        }\n      }\n      matches[i] = {\n        index1: i,\n        index2: minj,\n        keypoint1: [keypoints1[2 * i], keypoints1[2 * i + 1]],\n        keypoint2: [keypoints2[2 * minj], keypoints2[2 * minj + 1]],\n        confidence: 1 - min / this.N\n      };\n    }\n\n    return matches;\n  };\n\n  /**\n   * Removes matches outliers by testing matches on both directions.\n   * @param {array} keypoints1\n   * @param {array} descriptors1\n   * @param {array} keypoints2\n   * @param {array} descriptors2\n   * @return {Int32Array} Returns an array where the index is the corner1\n   *     index coordinate, and the value is the corresponding match index of\n   *     corner2, e.g. keypoints1=[x0,y0,x1,y1,...] and\n   *     keypoints2=[x'0,y'0,x'1,y'1,...], if x0 matches x'1 and x1 matches x'0,\n   *     the return array would be [3,0].\n   * @static\n   */\n  tracking.Brief.reciprocalMatch = function(keypoints1, descriptors1, keypoints2, descriptors2) {\n    var matches = [];\n    if (keypoints1.length === 0 || keypoints2.length === 0) {\n      return matches;\n    }\n\n    var matches1 = tracking.Brief.match(keypoints1, descriptors1, keypoints2, descriptors2);\n    var matches2 = tracking.Brief.match(keypoints2, descriptors2, keypoints1, descriptors1);\n    for (var i = 0; i < matches1.length; i++) {\n      if (matches2[matches1[i].index2].index2 === i) {\n        matches.push(matches1[i]);\n      }\n    }\n    return matches;\n  };\n\n  /**\n   * Gets the coordinates values of (x,y)-location pairs uniquely chosen\n   * during the initialization.\n   * @return {array} Array with the random offset values.\n   * @private\n   */\n  tracking.Brief.getRandomOffsets_ = function(width) {\n    if (!this.randomWindowOffsets_) {\n      var windowPosition = 0;\n      var windowOffsets = new Int32Array(4 * this.N);\n      for (var i = 0; i < this.N; i++) {\n        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));\n        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));\n        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));\n        windowOffsets[windowPosition++] = Math.round(tracking.Math.uniformRandom(-15, 16));\n      }\n      this.randomWindowOffsets_ = windowOffsets;\n    }\n\n    if (!this.randomImageOffsets_[width]) {\n      var imagePosition = 0;\n      var imageOffsets = new Int32Array(2 * this.N);\n      for (var j = 0; j < this.N; j++) {\n        imageOffsets[imagePosition++] = this.randomWindowOffsets_[4 * j] * width + this.randomWindowOffsets_[4 * j + 1];\n        imageOffsets[imagePosition++] = this.randomWindowOffsets_[4 * j + 2] * width + this.randomWindowOffsets_[4 * j + 3];\n      }\n      this.randomImageOffsets_[width] = imageOffsets;\n    }\n\n    return this.randomImageOffsets_[width];\n  };\n}());\n\n(function() {\n  /**\n   * FAST intends for \"Features from Accelerated Segment Test\". This method\n   * performs a point segment test corner detection. The segment test\n   * criterion operates by considering a circle of sixteen pixels around the\n   * corner candidate p. The detector classifies p as a corner if there exists\n   * a set of n contiguous pixelsin the circle which are all brighter than the\n   * intensity of the candidate pixel Ip plus a threshold t, or all darker\n   * than Ip − t.\n   *\n   *       15 00 01\n   *    14          02\n   * 13                03\n   * 12       []       04\n   * 11                05\n   *    10          06\n   *       09 08 07\n   *\n   * For more reference:\n   * http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.60.3991&rep=rep1&type=pdf\n   * @static\n   * @constructor\n   */\n  tracking.Fast = {};\n\n  /**\n   * Holds the threshold to determine whether the tested pixel is brighter or\n   * darker than the corner candidate p.\n   * @type {number}\n   * @default 40\n   * @static\n   */\n  tracking.Fast.THRESHOLD = 40;\n\n  /**\n   * Caches coordinates values of the circle surrounding the pixel candidate p.\n   * @type {Object.<number, Int32Array>}\n   * @private\n   * @static\n   */\n  tracking.Fast.circles_ = {};\n\n  /**\n   * Finds corners coordinates on the graysacaled image.\n   * @param {array} The grayscale pixels in a linear [p1,p2,...] array.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {number} threshold to determine whether the tested pixel is brighter or\n   *     darker than the corner candidate p. Default value is 40.\n   * @return {array} Array containing the coordinates of all found corners,\n   *     e.g. [x0,y0,x1,y1,...], where P(x0,y0) represents a corner coordinate.\n   * @static\n   */\n  tracking.Fast.findCorners = function(pixels, width, height, opt_threshold) {\n    var circleOffsets = this.getCircleOffsets_(width);\n    var circlePixels = new Int32Array(16);\n    var corners = [];\n\n    if (opt_threshold === undefined) {\n      opt_threshold = this.THRESHOLD;\n    }\n\n    // When looping through the image pixels, skips the first three lines from\n    // the image boundaries to constrain the surrounding circle inside the image\n    // area.\n    for (var i = 3; i < height - 3; i++) {\n      for (var j = 3; j < width - 3; j++) {\n        var w = i * width + j;\n        var p = pixels[w];\n\n        // Loops the circle offsets to read the pixel value for the sixteen\n        // surrounding pixels.\n        for (var k = 0; k < 16; k++) {\n          circlePixels[k] = pixels[w + circleOffsets[k]];\n        }\n\n        if (this.isCorner(p, circlePixels, opt_threshold)) {\n          // The pixel p is classified as a corner, as optimization increment j\n          // by the circle radius 3 to skip the neighbor pixels inside the\n          // surrounding circle. This can be removed without compromising the\n          // result.\n          corners.push(j, i);\n          j += 3;\n        }\n      }\n    }\n\n    return corners;\n  };\n\n  /**\n   * Checks if the circle pixel is brighter than the candidate pixel p by\n   * a threshold.\n   * @param {number} circlePixel The circle pixel value.\n   * @param {number} p The value of the candidate pixel p.\n   * @param {number} threshold\n   * @return {Boolean}\n   * @static\n   */\n  tracking.Fast.isBrighter = function(circlePixel, p, threshold) {\n    return circlePixel - p > threshold;\n  };\n\n  /**\n   * Checks if the circle pixel is within the corner of the candidate pixel p\n   * by a threshold.\n   * @param {number} p The value of the candidate pixel p.\n   * @param {number} circlePixel The circle pixel value.\n   * @param {number} threshold\n   * @return {Boolean}\n   * @static\n   */\n  tracking.Fast.isCorner = function(p, circlePixels, threshold) {\n    if (this.isTriviallyExcluded(circlePixels, p, threshold)) {\n      return false;\n    }\n\n    for (var x = 0; x < 16; x++) {\n      var darker = true;\n      var brighter = true;\n\n      for (var y = 0; y < 9; y++) {\n        var circlePixel = circlePixels[(x + y) & 15];\n\n        if (!this.isBrighter(p, circlePixel, threshold)) {\n          brighter = false;\n          if (darker === false) {\n            break;\n          }\n        }\n\n        if (!this.isDarker(p, circlePixel, threshold)) {\n          darker = false;\n          if (brighter === false) {\n            break;\n          }\n        }\n      }\n\n      if (brighter || darker) {\n        return true;\n      }\n    }\n\n    return false;\n  };\n\n  /**\n   * Checks if the circle pixel is darker than the candidate pixel p by\n   * a threshold.\n   * @param {number} circlePixel The circle pixel value.\n   * @param {number} p The value of the candidate pixel p.\n   * @param {number} threshold\n   * @return {Boolean}\n   * @static\n   */\n  tracking.Fast.isDarker = function(circlePixel, p, threshold) {\n    return p - circlePixel > threshold;\n  };\n\n  /**\n   * Fast check to test if the candidate pixel is a trivially excluded value.\n   * In order to be a corner, the candidate pixel value should be darker or\n   * brighter than 9-12 surrounding pixels, when at least three of the top,\n   * bottom, left and right pixels are brighter or darker it can be\n   * automatically excluded improving the performance.\n   * @param {number} circlePixel The circle pixel value.\n   * @param {number} p The value of the candidate pixel p.\n   * @param {number} threshold\n   * @return {Boolean}\n   * @static\n   * @protected\n   */\n  tracking.Fast.isTriviallyExcluded = function(circlePixels, p, threshold) {\n    var count = 0;\n    var circleBottom = circlePixels[8];\n    var circleLeft = circlePixels[12];\n    var circleRight = circlePixels[4];\n    var circleTop = circlePixels[0];\n\n    if (this.isBrighter(circleTop, p, threshold)) {\n      count++;\n    }\n    if (this.isBrighter(circleRight, p, threshold)) {\n      count++;\n    }\n    if (this.isBrighter(circleBottom, p, threshold)) {\n      count++;\n    }\n    if (this.isBrighter(circleLeft, p, threshold)) {\n      count++;\n    }\n\n    if (count < 3) {\n      count = 0;\n      if (this.isDarker(circleTop, p, threshold)) {\n        count++;\n      }\n      if (this.isDarker(circleRight, p, threshold)) {\n        count++;\n      }\n      if (this.isDarker(circleBottom, p, threshold)) {\n        count++;\n      }\n      if (this.isDarker(circleLeft, p, threshold)) {\n        count++;\n      }\n      if (count < 3) {\n        return true;\n      }\n    }\n\n    return false;\n  };\n\n  /**\n   * Gets the sixteen offset values of the circle surrounding pixel.\n   * @param {number} width The image width.\n   * @return {array} Array with the sixteen offset values of the circle\n   *     surrounding pixel.\n   * @private\n   */\n  tracking.Fast.getCircleOffsets_ = function(width) {\n    if (this.circles_[width]) {\n      return this.circles_[width];\n    }\n\n    var circle = new Int32Array(16);\n\n    circle[0] = -width - width - width;\n    circle[1] = circle[0] + 1;\n    circle[2] = circle[1] + width + 1;\n    circle[3] = circle[2] + width + 1;\n    circle[4] = circle[3] + width;\n    circle[5] = circle[4] + width;\n    circle[6] = circle[5] + width - 1;\n    circle[7] = circle[6] + width - 1;\n    circle[8] = circle[7] - 1;\n    circle[9] = circle[8] - 1;\n    circle[10] = circle[9] - width - 1;\n    circle[11] = circle[10] - width - 1;\n    circle[12] = circle[11] - width;\n    circle[13] = circle[12] - width;\n    circle[14] = circle[13] - width + 1;\n    circle[15] = circle[14] - width + 1;\n\n    this.circles_[width] = circle;\n    return circle;\n  };\n}());\n\n(function() {\n  /**\n   * Math utility.\n   * @static\n   * @constructor\n   */\n  tracking.Math = {};\n\n  /**\n   * Euclidean distance between two points P(x0, y0) and P(x1, y1).\n   * @param {number} x0 Horizontal coordinate of P0.\n   * @param {number} y0 Vertical coordinate of P0.\n   * @param {number} x1 Horizontal coordinate of P1.\n   * @param {number} y1 Vertical coordinate of P1.\n   * @return {number} The euclidean distance.\n   */\n  tracking.Math.distance = function(x0, y0, x1, y1) {\n    var dx = x1 - x0;\n    var dy = y1 - y0;\n\n    return Math.sqrt(dx * dx + dy * dy);\n  };\n\n  /**\n   * Calculates the Hamming weight of a string, which is the number of symbols that are\n   * different from the zero-symbol of the alphabet used. It is thus\n   * equivalent to the Hamming distance from the all-zero string of the same\n   * length. For the most typical case, a string of bits, this is the number\n   * of 1's in the string.\n   *\n   * Example:\n   *\n   * <pre>\n   *  Binary string     Hamming weight\n   *   11101                 4\n   *   11101010              5\n   * </pre>\n   *\n   * @param {number} i Number that holds the binary string to extract the hamming weight.\n   * @return {number} The hamming weight.\n   */\n  tracking.Math.hammingWeight = function(i) {\n    i = i - ((i >> 1) & 0x55555555);\n    i = (i & 0x33333333) + ((i >> 2) & 0x33333333);\n\n    return ((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;\n  };\n\n  /**\n   * Generates a random number between [a, b] interval.\n   * @param {number} a\n   * @param {number} b\n   * @return {number}\n   */\n  tracking.Math.uniformRandom = function(a, b) {\n    return a + Math.random() * (b - a);\n  };\n\n  /**\n   * Tests if a rectangle intersects with another.\n   *\n   *  <pre>\n   *  x0y0 --------       x2y2 --------\n   *      |       |           |       |\n   *      -------- x1y1       -------- x3y3\n   * </pre>\n   *\n   * @param {number} x0 Horizontal coordinate of P0.\n   * @param {number} y0 Vertical coordinate of P0.\n   * @param {number} x1 Horizontal coordinate of P1.\n   * @param {number} y1 Vertical coordinate of P1.\n   * @param {number} x2 Horizontal coordinate of P2.\n   * @param {number} y2 Vertical coordinate of P2.\n   * @param {number} x3 Horizontal coordinate of P3.\n   * @param {number} y3 Vertical coordinate of P3.\n   * @return {boolean}\n   */\n  tracking.Math.intersectRect = function(x0, y0, x1, y1, x2, y2, x3, y3) {\n    return !(x2 > x1 || x3 < x0 || y2 > y1 || y3 < y0);\n  };\n\n}());\n\n(function() {\n  /**\n   * Matrix utility.\n   * @static\n   * @constructor\n   */\n  tracking.Matrix = {};\n\n  /**\n   * Loops the array organized as major-row order and executes `fn` callback\n   * for each iteration. The `fn` callback receives the following parameters:\n   * `(r,g,b,a,index,i,j)`, where `r,g,b,a` represents the pixel color with\n   * alpha channel, `index` represents the position in the major-row order\n   * array and `i,j` the respective indexes positions in two dimensions.\n   * @param {array} pixels The pixels in a linear [r,g,b,a,...] array to loop\n   *     through.\n   * @param {number} width The image width.\n   * @param {number} height The image height.\n   * @param {function} fn The callback function for each pixel.\n   * @param {number} opt_jump Optional jump for the iteration, by default it\n   *     is 1, hence loops all the pixels of the array.\n   * @static\n   */\n  tracking.Matrix.forEach = function(pixels, width, height, fn, opt_jump) {\n    opt_jump = opt_jump || 1;\n    for (var i = 0; i < height; i += opt_jump) {\n      for (var j = 0; j < width; j += opt_jump) {\n        var w = i * width * 4 + j * 4;\n        fn.call(this, pixels[w], pixels[w + 1], pixels[w + 2], pixels[w + 3], w, i, j);\n      }\n    }\n  };\n\n}());\n\n(function() {\n  /**\n   * EPnp utility.\n   * @static\n   * @constructor\n   */\n  tracking.EPnP = {};\n\n  tracking.EPnP.solve = function(objectPoints, imagePoints, cameraMatrix) {};\n}());\n\n(function() {\n  /**\n   * Tracker utility.\n   * @constructor\n   * @extends {tracking.EventEmitter}\n   */\n  tracking.Tracker = function() {\n    tracking.Tracker.base(this, 'constructor');\n  };\n\n  tracking.inherits(tracking.Tracker, tracking.EventEmitter);\n\n  /**\n   * Tracks the pixels on the array. This method is called for each video\n   * frame in order to emit `track` event.\n   * @param {Uint8ClampedArray} pixels The pixels data to track.\n   * @param {number} width The pixels canvas width.\n   * @param {number} height The pixels canvas height.\n   */\n  tracking.Tracker.prototype.track = function() {};\n}());\n\n(function() {\n  /**\n   * TrackerTask utility.\n   * @constructor\n   * @extends {tracking.EventEmitter}\n   */\n  tracking.TrackerTask = function(tracker) {\n    tracking.TrackerTask.base(this, 'constructor');\n\n    if (!tracker) {\n      throw new Error('Tracker instance not specified.');\n    }\n\n    this.setTracker(tracker);\n  };\n\n  tracking.inherits(tracking.TrackerTask, tracking.EventEmitter);\n\n  /**\n   * Holds the tracker instance managed by this task.\n   * @type {tracking.Tracker}\n   * @private\n   */\n  tracking.TrackerTask.prototype.tracker_ = null;\n\n  /**\n   * Holds if the tracker task is in running.\n   * @type {boolean}\n   * @private\n   */\n  tracking.TrackerTask.prototype.running_ = false;\n\n  /**\n   * Gets the tracker instance managed by this task.\n   * @return {tracking.Tracker}\n   */\n  tracking.TrackerTask.prototype.getTracker = function() {\n    return this.tracker_;\n  };\n\n  /**\n   * Returns true if the tracker task is in running, false otherwise.\n   * @return {boolean}\n   * @private\n   */\n  tracking.TrackerTask.prototype.inRunning = function() {\n    return this.running_;\n  };\n\n  /**\n   * Sets if the tracker task is in running.\n   * @param {boolean} running\n   * @private\n   */\n  tracking.TrackerTask.prototype.setRunning = function(running) {\n    this.running_ = running;\n  };\n\n  /**\n   * Sets the tracker instance managed by this task.\n   * @return {tracking.Tracker}\n   */\n  tracking.TrackerTask.prototype.setTracker = function(tracker) {\n    this.tracker_ = tracker;\n  };\n\n  /**\n   * Emits a `run` event on the tracker task for the implementers to run any\n   * child action, e.g. `requestAnimationFrame`.\n   * @return {object} Returns itself, so calls can be chained.\n   */\n  tracking.TrackerTask.prototype.run = function() {\n    var self = this;\n\n    if (this.inRunning()) {\n      return;\n    }\n\n    this.setRunning(true);\n    this.reemitTrackEvent_ = function(event) {\n      self.emit('track', event);\n    };\n    this.tracker_.on('track', this.reemitTrackEvent_);\n    this.emit('run');\n    return this;\n  };\n\n  /**\n   * Emits a `stop` event on the tracker task for the implementers to stop any\n   * child action being done, e.g. `requestAnimationFrame`.\n   * @return {object} Returns itself, so calls can be chained.\n   */\n  tracking.TrackerTask.prototype.stop = function() {\n    if (!this.inRunning()) {\n      return;\n    }\n\n    this.setRunning(false);\n    this.emit('stop');\n    this.tracker_.removeListener('track', this.reemitTrackEvent_);\n    return this;\n  };\n}());\n\n(function() {\n  /**\n   * ColorTracker utility to track colored blobs in a frame using color\n   * difference evaluation.\n   * @constructor\n   * @param {string|Array.<string>} opt_colors Optional colors to track.\n   * @extends {tracking.Tracker}\n   */\n  tracking.ColorTracker = function(opt_colors) {\n    tracking.ColorTracker.base(this, 'constructor');\n\n    if (typeof opt_colors === 'string') {\n      opt_colors = [opt_colors];\n    }\n\n    if (opt_colors) {\n      opt_colors.forEach(function(color) {\n        if (!tracking.ColorTracker.getColor(color)) {\n          throw new Error('Color not valid, try `new tracking.ColorTracker(\"magenta\")`.');\n        }\n      });\n      this.setColors(opt_colors);\n    }\n  };\n\n  tracking.inherits(tracking.ColorTracker, tracking.Tracker);\n\n  /**\n   * Holds the known colors.\n   * @type {Object.<string, function>}\n   * @private\n   * @static\n   */\n  tracking.ColorTracker.knownColors_ = {};\n\n  /**\n   * Caches coordinates values of the neighbours surrounding a pixel.\n   * @type {Object.<number, Int32Array>}\n   * @private\n   * @static\n   */\n  tracking.ColorTracker.neighbours_ = {};\n\n  /**\n   * Registers a color as known color.\n   * @param {string} name The color name.\n   * @param {function} fn The color function to test if the passed (r,g,b) is\n   *     the desired color.\n   * @static\n   */\n  tracking.ColorTracker.registerColor = function(name, fn) {\n    tracking.ColorTracker.knownColors_[name] = fn;\n  };\n\n  /**\n   * Gets the known color function that is able to test whether an (r,g,b) is\n   * the desired color.\n   * @param {string} name The color name.\n   * @return {function} The known color test function.\n   * @static\n   */\n  tracking.ColorTracker.getColor = function(name) {\n    return tracking.ColorTracker.knownColors_[name];\n  };\n\n  /**\n   * Holds the colors to be tracked by the `ColorTracker` instance.\n   * @default ['magenta']\n   * @type {Array.<string>}\n   */\n  tracking.ColorTracker.prototype.colors = ['magenta'];\n\n  /**\n   * Holds the minimum dimension to classify a rectangle.\n   * @default 20\n   * @type {number}\n   */\n  tracking.ColorTracker.prototype.minDimension = 20;\n\n  /**\n   * Holds the maximum dimension to classify a rectangle.\n   * @default Infinity\n   * @type {number}\n   */\n  tracking.ColorTracker.prototype.maxDimension = Infinity;\n\n\n  /**\n   * Holds the minimum group size to be classified as a rectangle.\n   * @default 30\n   * @type {number}\n   */\n  tracking.ColorTracker.prototype.minGroupSize = 30;\n\n  /**\n   * Calculates the central coordinate from the cloud points. The cloud points\n   * are all points that matches the desired color.\n   * @param {Array.<number>} cloud Major row order array containing all the\n   *     points from the desired color, e.g. [x1, y1, c2, y2, ...].\n   * @param {number} total Total numbers of pixels of the desired color.\n   * @return {object} Object containing the x, y and estimated z coordinate of\n   *     the blog extracted from the cloud points.\n   * @private\n   */\n  tracking.ColorTracker.prototype.calculateDimensions_ = function(cloud, total) {\n    var maxx = -1;\n    var maxy = -1;\n    var minx = Infinity;\n    var miny = Infinity;\n\n    for (var c = 0; c < total; c += 2) {\n      var x = cloud[c];\n      var y = cloud[c + 1];\n\n      if (x < minx) {\n        minx = x;\n      }\n      if (x > maxx) {\n        maxx = x;\n      }\n      if (y < miny) {\n        miny = y;\n      }\n      if (y > maxy) {\n        maxy = y;\n      }\n    }\n\n    return {\n      width: maxx - minx,\n      height: maxy - miny,\n      x: minx,\n      y: miny\n    };\n  };\n\n  /**\n   * Gets the colors being tracked by the `ColorTracker` instance.\n   * @return {Array.<string>}\n   */\n  tracking.ColorTracker.prototype.getColors = function() {\n    return this.colors;\n  };\n\n  /**\n   * Gets the minimum dimension to classify a rectangle.\n   * @return {number}\n   */\n  tracking.ColorTracker.prototype.getMinDimension = function() {\n    return this.minDimension;\n  };\n\n  /**\n   * Gets the maximum dimension to classify a rectangle.\n   * @return {number}\n   */\n  tracking.ColorTracker.prototype.getMaxDimension = function() {\n    return this.maxDimension;\n  };\n\n  /**\n   * Gets the minimum group size to be classified as a rectangle.\n   * @return {number}\n   */\n  tracking.ColorTracker.prototype.getMinGroupSize = function() {\n    return this.minGroupSize;\n  };\n\n  /**\n   * Gets the eight offset values of the neighbours surrounding a pixel.\n   * @param {number} width The image width.\n   * @return {array} Array with the eight offset values of the neighbours\n   *     surrounding a pixel.\n   * @private\n   */\n  tracking.ColorTracker.prototype.getNeighboursForWidth_ = function(width) {\n    if (tracking.ColorTracker.neighbours_[width]) {\n      return tracking.ColorTracker.neighbours_[width];\n    }\n\n    var neighbours = new Int32Array(8);\n\n    neighbours[0] = -width * 4;\n    neighbours[1] = -width * 4 + 4;\n    neighbours[2] = 4;\n    neighbours[3] = width * 4 + 4;\n    neighbours[4] = width * 4;\n    neighbours[5] = width * 4 - 4;\n    neighbours[6] = -4;\n    neighbours[7] = -width * 4 - 4;\n\n    tracking.ColorTracker.neighbours_[width] = neighbours;\n\n    return neighbours;\n  };\n\n  /**\n   * Unites groups whose bounding box intersect with each other.\n   * @param {Array.<Object>} rects\n   * @private\n   */\n  tracking.ColorTracker.prototype.mergeRectangles_ = function(rects) {\n    var intersects;\n    var results = [];\n    var minDimension = this.getMinDimension();\n    var maxDimension = this.getMaxDimension();\n\n    for (var r = 0; r < rects.length; r++) {\n      var r1 = rects[r];\n      intersects = true;\n      for (var s = r + 1; s < rects.length; s++) {\n        var r2 = rects[s];\n        if (tracking.Math.intersectRect(r1.x, r1.y, r1.x + r1.width, r1.y + r1.height, r2.x, r2.y, r2.x + r2.width, r2.y + r2.height)) {\n          intersects = false;\n          var x1 = Math.min(r1.x, r2.x);\n          var y1 = Math.min(r1.y, r2.y);\n          var x2 = Math.max(r1.x + r1.width, r2.x + r2.width);\n          var y2 = Math.max(r1.y + r1.height, r2.y + r2.height);\n          r2.height = y2 - y1;\n          r2.width = x2 - x1;\n          r2.x = x1;\n          r2.y = y1;\n          break;\n        }\n      }\n\n      if (intersects) {\n        if (r1.width >= minDimension && r1.height >= minDimension) {\n          if (r1.width <= maxDimension && r1.height <= maxDimension) {\n            results.push(r1);\n          }\n        }\n      }\n    }\n\n    return results;\n  };\n\n  /**\n   * Sets the colors to be tracked by the `ColorTracker` instance.\n   * @param {Array.<string>} colors\n   */\n  tracking.ColorTracker.prototype.setColors = function(colors) {\n    this.colors = colors;\n  };\n\n  /**\n   * Sets the minimum dimension to classify a rectangle.\n   * @param {number} minDimension\n   */\n  tracking.ColorTracker.prototype.setMinDimension = function(minDimension) {\n    this.minDimension = minDimension;\n  };\n\n  /**\n   * Sets the maximum dimension to classify a rectangle.\n   * @param {number} maxDimension\n   */\n  tracking.ColorTracker.prototype.setMaxDimension = function(maxDimension) {\n    this.maxDimension = maxDimension;\n  };\n\n  /**\n   * Sets the minimum group size to be classified as a rectangle.\n   * @param {number} minGroupSize\n   */\n  tracking.ColorTracker.prototype.setMinGroupSize = function(minGroupSize) {\n    this.minGroupSize = minGroupSize;\n  };\n\n  /**\n   * Tracks the `Video` frames. This method is called for each video frame in\n   * order to emit `track` event.\n   * @param {Uint8ClampedArray} pixels The pixels data to track.\n   * @param {number} width The pixels canvas width.\n   * @param {number} height The pixels canvas height.\n   */\n  tracking.ColorTracker.prototype.track = function(pixels, width, height) {\n    var self = this;\n    var colors = this.getColors();\n\n    if (!colors) {\n      throw new Error('Colors not specified, try `new tracking.ColorTracker(\"magenta\")`.');\n    }\n\n    var results = [];\n\n    colors.forEach(function(color) {\n      results = results.concat(self.trackColor_(pixels, width, height, color));\n    });\n\n    this.emit('track', {\n      data: results\n    });\n  };\n\n  /**\n   * Find the given color in the given matrix of pixels using Flood fill\n   * algorithm to determines the area connected to a given node in a\n   * multi-dimensional array.\n   * @param {Uint8ClampedArray} pixels The pixels data to track.\n   * @param {number} width The pixels canvas width.\n   * @param {number} height The pixels canvas height.\n   * @param {string} color The color to be found\n   * @private\n   */\n  tracking.ColorTracker.prototype.trackColor_ = function(pixels, width, height, color) {\n    var colorFn = tracking.ColorTracker.knownColors_[color];\n    var currGroup = new Int32Array(pixels.length >> 2);\n    var currGroupSize;\n    var currI;\n    var currJ;\n    var currW;\n    var marked = new Int8Array(pixels.length);\n    var minGroupSize = this.getMinGroupSize();\n    var neighboursW = this.getNeighboursForWidth_(width);\n    var queue = new Int32Array(pixels.length);\n    var queuePosition;\n    var results = [];\n    var w = -4;\n\n    if (!colorFn) {\n      return results;\n    }\n\n    for (var i = 0; i < height; i++) {\n      for (var j = 0; j < width; j++) {\n        w += 4;\n\n        if (marked[w]) {\n          continue;\n        }\n\n        currGroupSize = 0;\n\n        queuePosition = -1;\n        queue[++queuePosition] = w;\n        queue[++queuePosition] = i;\n        queue[++queuePosition] = j;\n\n        marked[w] = 1;\n\n        while (queuePosition >= 0) {\n          currJ = queue[queuePosition--];\n          currI = queue[queuePosition--];\n          currW = queue[queuePosition--];\n\n          if (colorFn(pixels[currW], pixels[currW + 1], pixels[currW + 2], pixels[currW + 3], currW, currI, currJ)) {\n            currGroup[currGroupSize++] = currJ;\n            currGroup[currGroupSize++] = currI;\n\n            for (var k = 0; k < neighboursW.length; k++) {\n              var otherW = currW + neighboursW[k];\n              var otherI = currI + neighboursI[k];\n              var otherJ = currJ + neighboursJ[k];\n              if (!marked[otherW] && otherI >= 0 && otherI < height && otherJ >= 0 && otherJ < width) {\n                queue[++queuePosition] = otherW;\n                queue[++queuePosition] = otherI;\n                queue[++queuePosition] = otherJ;\n\n                marked[otherW] = 1;\n              }\n            }\n          }\n        }\n\n        if (currGroupSize >= minGroupSize) {\n          var data = this.calculateDimensions_(currGroup, currGroupSize);\n          if (data) {\n            data.color = color;\n            results.push(data);\n          }\n        }\n      }\n    }\n\n    return this.mergeRectangles_(results);\n  };\n\n  // Default colors\n  //===================\n\n  tracking.ColorTracker.registerColor('cyan', function(r, g, b) {\n    var thresholdGreen = 50,\n      thresholdBlue = 70,\n      dx = r - 0,\n      dy = g - 255,\n      dz = b - 255;\n\n    if ((g - r) >= thresholdGreen && (b - r) >= thresholdBlue) {\n      return true;\n    }\n    return dx * dx + dy * dy + dz * dz < 6400;\n  });\n\n  tracking.ColorTracker.registerColor('magenta', function(r, g, b) {\n    var threshold = 50,\n      dx = r - 255,\n      dy = g - 0,\n      dz = b - 255;\n\n    if ((r - g) >= threshold && (b - g) >= threshold) {\n      return true;\n    }\n    return dx * dx + dy * dy + dz * dz < 19600;\n  });\n\n  tracking.ColorTracker.registerColor('yellow', function(r, g, b) {\n    var threshold = 50,\n      dx = r - 255,\n      dy = g - 255,\n      dz = b - 0;\n\n    if ((r - b) >= threshold && (g - b) >= threshold) {\n      return true;\n    }\n    return dx * dx + dy * dy + dz * dz < 10000;\n  });\n\n\n  // Caching neighbour i/j offset values.\n  //=====================================\n  var neighboursI = new Int32Array([-1, -1, 0, 1, 1, 1, 0, -1]);\n  var neighboursJ = new Int32Array([0, 1, 1, 1, 0, -1, -1, -1]);\n}());\n\n(function() {\n  /**\n   * ObjectTracker utility.\n   * @constructor\n   * @param {string|Array.<string|Array.<number>>} opt_classifiers Optional\n   *     object classifiers to track.\n   * @extends {tracking.Tracker}\n   */\n  tracking.ObjectTracker = function(opt_classifiers) {\n    tracking.ObjectTracker.base(this, 'constructor');\n\n    if (opt_classifiers) {\n      if (!Array.isArray(opt_classifiers)) {\n        opt_classifiers = [opt_classifiers];\n      }\n\n      if (Array.isArray(opt_classifiers)) {\n        opt_classifiers.forEach(function(classifier, i) {\n          if (typeof classifier === 'string') {\n            opt_classifiers[i] = tracking.ViolaJones.classifiers[classifier];\n          }\n          if (!opt_classifiers[i]) {\n            throw new Error('Object classifier not valid, try `new tracking.ObjectTracker(\"face\")`.');\n          }\n        });\n      }\n    }\n\n    this.setClassifiers(opt_classifiers);\n  };\n\n  tracking.inherits(tracking.ObjectTracker, tracking.Tracker);\n\n  /**\n   * Specifies the edges density of a block in order to decide whether to skip\n   * it or not.\n   * @default 0.2\n   * @type {number}\n   */\n  tracking.ObjectTracker.prototype.edgesDensity = 0.2;\n\n  /**\n   * Specifies the initial scale to start the feature block scaling.\n   * @default 1.0\n   * @type {number}\n   */\n  tracking.ObjectTracker.prototype.initialScale = 1.0;\n\n  /**\n   * Specifies the scale factor to scale the feature block.\n   * @default 1.25\n   * @type {number}\n   */\n  tracking.ObjectTracker.prototype.scaleFactor = 1.25;\n\n  /**\n   * Specifies the block step size.\n   * @default 1.5\n   * @type {number}\n   */\n  tracking.ObjectTracker.prototype.stepSize = 1.5;\n\n  /**\n   * Gets the tracker HAAR classifiers.\n   * @return {TypedArray.<number>}\n   */\n  tracking.ObjectTracker.prototype.getClassifiers = function() {\n    return this.classifiers;\n  };\n\n  /**\n   * Gets the edges density value.\n   * @return {number}\n   */\n  tracking.ObjectTracker.prototype.getEdgesDensity = function() {\n    return this.edgesDensity;\n  };\n\n  /**\n   * Gets the initial scale to start the feature block scaling.\n   * @return {number}\n   */\n  tracking.ObjectTracker.prototype.getInitialScale = function() {\n    return this.initialScale;\n  };\n\n  /**\n   * Gets the scale factor to scale the feature block.\n   * @return {number}\n   */\n  tracking.ObjectTracker.prototype.getScaleFactor = function() {\n    return this.scaleFactor;\n  };\n\n  /**\n   * Gets the block step size.\n   * @return {number}\n   */\n  tracking.ObjectTracker.prototype.getStepSize = function() {\n    return this.stepSize;\n  };\n\n  /**\n   * Tracks the `Video` frames. This method is called for each video frame in\n   * order to emit `track` event.\n   * @param {Uint8ClampedArray} pixels The pixels data to track.\n   * @param {number} width The pixels canvas width.\n   * @param {number} height The pixels canvas height.\n   */\n  tracking.ObjectTracker.prototype.track = function(pixels, width, height) {\n    var self = this;\n    var classifiers = this.getClassifiers();\n\n    if (!classifiers) {\n      throw new Error('Object classifier not specified, try `new tracking.ObjectTracker(\"face\")`.');\n    }\n\n    var results = [];\n\n    classifiers.forEach(function(classifier) {\n      results = results.concat(tracking.ViolaJones.detect(pixels, width, height, self.getInitialScale(), self.getScaleFactor(), self.getStepSize(), self.getEdgesDensity(), classifier));\n    });\n\n    this.emit('track', {\n      data: results\n    });\n  };\n\n  /**\n   * Sets the tracker HAAR classifiers.\n   * @param {TypedArray.<number>} classifiers\n   */\n  tracking.ObjectTracker.prototype.setClassifiers = function(classifiers) {\n    this.classifiers = classifiers;\n  };\n\n  /**\n   * Sets the edges density.\n   * @param {number} edgesDensity\n   */\n  tracking.ObjectTracker.prototype.setEdgesDensity = function(edgesDensity) {\n    this.edgesDensity = edgesDensity;\n  };\n\n  /**\n   * Sets the initial scale to start the block scaling.\n   * @param {number} initialScale\n   */\n  tracking.ObjectTracker.prototype.setInitialScale = function(initialScale) {\n    this.initialScale = initialScale;\n  };\n\n  /**\n   * Sets the scale factor to scale the feature block.\n   * @param {number} scaleFactor\n   */\n  tracking.ObjectTracker.prototype.setScaleFactor = function(scaleFactor) {\n    this.scaleFactor = scaleFactor;\n  };\n\n  /**\n   * Sets the block step size.\n   * @param {number} stepSize\n   */\n  tracking.ObjectTracker.prototype.setStepSize = function(stepSize) {\n    this.stepSize = stepSize;\n  };\n\n}());\n\n},{}],24:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar APP_NAME = 'frontend-dog';\nvar APP_VERSION = '0.0.1';\n\nexports.default = {\n  APP_NAME: APP_NAME,\n  APP_VERSION: APP_VERSION\n};\n\n},{}],25:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');\n\nvar _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\nvar _createClass2 = require('babel-runtime/helpers/createClass');\n\nvar _createClass3 = _interopRequireDefault(_createClass2);\n\nvar _tracking = require('tracking');\n\nvar _tracking2 = _interopRequireDefault(_tracking);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * 在chrome下截屏可以渲染出图片，但是在微信里面不行\n */\nvar Face = function () {\n  function Face() {\n    (0, _classCallCheck3.default)(this, Face);\n\n    this.registEvent();\n  }\n\n  (0, _createClass3.default)(Face, [{\n    key: 'registEvent',\n    value: function registEvent() {\n      document.getElementById('J_FaceDetech').addEventListener('click', function (e) {\n        var img = document.getElementById('J_ImgFace');\n        var tracker = new _tracking2.default.ObjectTracker(['face', 'eye', 'mouth']);\n        tracker.setStepSize(1.7);\n        _tracking2.default.track('#J_FaceDetech', tracker);\n        tracker.on('track', function (event) {\n          event.data.forEach(function (rect) {\n            window.plot(rect.x, rect.y, rect.width, rect.height);\n          });\n        });\n        window.plot = function (x, y, w, h) {\n          var rect = document.createElement('div');\n          document.querySelector('.face-wrapper').appendChild(rect);\n          rect.classList.add('rect');\n          rect.style.width = w + 'px';\n          rect.style.height = h + 'px';\n          rect.style.left = img.offsetLeft + x + 'px';\n          rect.style.top = img.offsetTop + y + 'px';\n        };\n      });\n    }\n  }]);\n  return Face;\n}();\n\nexports.default = Face;\n\n},{\"babel-runtime/helpers/classCallCheck\":2,\"babel-runtime/helpers/createClass\":3,\"tracking\":23}],26:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');\n\nvar _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\nvar _createClass2 = require('babel-runtime/helpers/createClass');\n\nvar _createClass3 = _interopRequireDefault(_createClass2);\n\nvar _html2canvas = require('html2canvas');\n\nvar _html2canvas2 = _interopRequireDefault(_html2canvas);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * 在chrome下截屏可以渲染出图片，但是在微信里面不行\n */\nvar Html2canvas = function () {\n  function Html2canvas() {\n    (0, _classCallCheck3.default)(this, Html2canvas);\n\n    this.$ctr = document.body;\n    this.imgW = 300;\n    this.imgH = 300;\n\n    this.registEvent();\n  }\n\n  (0, _createClass3.default)(Html2canvas, [{\n    key: 'registEvent',\n    value: function registEvent() {\n      var _this = this;\n\n      document.getElementById('J_Html2canvas').addEventListener('click', function (e) {\n        console.log('click');\n        (0, _html2canvas2.default)(_this.$ctr, {\n          width: _this.imgW,\n          height: _this.imgH,\n          onrendered: function onrendered(canvas) {\n            console.log('rendered', canvas);\n            document.body.appendChild(canvas);\n          }\n        });\n      });\n    }\n  }]);\n  return Html2canvas;\n}();\n\nexports.default = Html2canvas;\n\n},{\"babel-runtime/helpers/classCallCheck\":2,\"babel-runtime/helpers/createClass\":3,\"html2canvas\":21}],27:[function(require,module,exports){\n'use strict';\n\nvar _config = require('./config');\n\nvar _config2 = _interopRequireDefault(_config);\n\nvar _qrcode = require('./qrcode');\n\nvar _qrcode2 = _interopRequireDefault(_qrcode);\n\nvar _html2canvas = require('./html2canvas');\n\nvar _html2canvas2 = _interopRequireDefault(_html2canvas);\n\nvar _face = require('./face');\n\nvar _face2 = _interopRequireDefault(_face);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/*\n* The Entry\n*/\nnew _qrcode2.default();\nnew _html2canvas2.default();\nnew _face2.default();\n\nvar title = 'Hello ' + _config2.default.APP_NAME + '!';\ndocument.getElementById('title').innerHTML = title;\n\n},{\"./config\":24,\"./face\":25,\"./html2canvas\":26,\"./qrcode\":28}],28:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');\n\nvar _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\nvar _createClass2 = require('babel-runtime/helpers/createClass');\n\nvar _createClass3 = _interopRequireDefault(_createClass2);\n\nvar _qrcode = require('qrcode2');\n\nvar _qrcode2 = _interopRequireDefault(_qrcode);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar QRCode = function () {\n  function QRCode() {\n    (0, _classCallCheck3.default)(this, QRCode);\n\n    this.$genQRCode = document.getElementById('J_GenQRCode');\n    this.$QRCodeInput = document.getElementById('J_QRCodeVal');\n    this.$QRCode = document.getElementById('J_QRCode');\n    this.qrWidth = this.qrHeight = 200;\n    this.colorDark = '#000';\n    this.colorLight = '#fff';\n    this.level = _qrcode2.default.CorrectLevel.H;\n    this.qrstring = 'https://github.com/0326/canvas';\n    this.qrcode = new _qrcode2.default(\"J_QRCode\", {\n      text: this.qrstring,\n      width: this.qrWidth,\n      height: this.qrHeight,\n      colorDark: this.colorDark,\n      colorLight: this.colorLight,\n      correctLevel: this.level\n    });\n\n    this.registEvent();\n  }\n\n  (0, _createClass3.default)(QRCode, [{\n    key: 'registEvent',\n    value: function registEvent() {\n      var _this = this;\n\n      this.$genQRCode.addEventListener('click', function () {\n        _this.qrstring = _this.$QRCodeInput.value;\n\n        if (!_this.qrstring) {\n          return _this.$QRCodeInput.setAttribute('placeholder', '请输入字符串');\n        }\n\n        _this.$QRCode.innerHTML = '';\n        _this.qrcode = new _qrcode2.default(\"J_QRCode\", {\n          text: _this.qrstring,\n          width: _this.qrWidth,\n          height: _this.qrHeight,\n          colorDark: _this.colorDark,\n          colorLight: _this.colorLight,\n          correctLevel: _this.level\n        });\n      });\n    }\n  }]);\n  return QRCode;\n}();\n\nexports.default = QRCode;\n\n},{\"babel-runtime/helpers/classCallCheck\":2,\"babel-runtime/helpers/createClass\":3,\"qrcode2\":22}]},{},[27]);\n"],"file":"bundle.js"}
\ No newline at end of file
diff --git a/index.html b/index.html
index ba787ec..8090f61 100644
--- a/index.html
+++ b/index.html
@@ -20,6 +20,10 @@ <h1 id="title"></h1>
     <div class="wrapper">
       <button id="J_Html2canvas">截屏</button>
     </div>
+    <div class="wrapper face-wrapper">
+      <button id="J_FaceDetech">人脸识别</button>
+      <img id="J_ImgFace" src="/assets/faces.jpg" width="500" height="300"/>
+    </div>
     <script src="/build/bundle.js"></script>
 </body>
 </html>
diff --git a/package.json b/package.json
index 9c8ed79..cec4de1 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,7 @@
     "babel-polyfill": "^6.13.0",
     "babel-runtime": "^6.11.6",
     "html2canvas": "^0.5.0-beta4",
-    "qrcode2": "^1.2.3"
+    "qrcode2": "^1.2.3",
+    "tracking": "^1.1.3"
   }
 }
diff --git a/src/js/face.js b/src/js/face.js
new file mode 100644
index 0000000..1d59a57
--- /dev/null
+++ b/src/js/face.js
@@ -0,0 +1,34 @@
+import tracking from 'tracking'
+
+/**
+ * 在chrome下截屏可以渲染出图片，但是在微信里面不行
+ */
+export default class Face {
+  constructor() {
+    this.registEvent()
+  }
+
+  registEvent() {
+    document.getElementById('J_FaceDetech').addEventListener('click', (e) => {
+      let img = document.getElementById('J_ImgFace')
+      let tracker = new tracking.ObjectTracker(['face', 'eye', 'mouth'])
+      tracker.setStepSize(1.7)
+      tracking.track('#J_FaceDetech', tracker)
+      tracker.on('track', function(event) {
+        event.data.forEach(function(rect) {
+          window.plot(rect.x, rect.y, rect.width, rect.height)
+        })
+      })
+      window.plot = function(x, y, w, h) {
+        let rect = document.createElement('div')
+        document.querySelector('.face-wrapper').appendChild(rect)
+        rect.classList.add('rect')
+        rect.style.width = w + 'px'
+        rect.style.height = h + 'px'
+        rect.style.left = (img.offsetLeft + x) + 'px'
+        rect.style.top = (img.offsetTop + y) + 'px'
+      }
+    })
+  }
+
+}
diff --git a/src/js/index.js b/src/js/index.js
index b66b7c9..388bfd8 100644
--- a/src/js/index.js
+++ b/src/js/index.js
@@ -4,9 +4,11 @@
 import config from './config'
 import QRCode from './qrcode'
 import Html2canvas from './html2canvas'
+import Face from './face'
 
 new QRCode()
 new Html2canvas()
+new Face()
 
 let title = 'Hello ' + config.APP_NAME + '!'
 document.getElementById('title').innerHTML = title