|
|
@@ -0,0 +1,3519 @@
|
|
|
+
|
|
|
+ html2canvas 0.5.0-beta3 <http:
|
|
|
+ Copyright (c) 2016 Niklas von Hertzen
|
|
|
+
|
|
|
+ Released under License
|
|
|
+*/
|
|
|
+
|
|
|
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.html2canvas=e()}}(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){
|
|
|
+(function (global){
|
|
|
+
|
|
|
+;(function(root) {
|
|
|
+
|
|
|
+
|
|
|
+ var freeExports = typeof exports == 'object' && exports;
|
|
|
+ var freeModule = typeof module == 'object' && module &&
|
|
|
+ module.exports == freeExports && module;
|
|
|
+ var freeGlobal = typeof global == 'object' && global;
|
|
|
+ if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
|
|
|
+ root = freeGlobal;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * The `punycode` object.
|
|
|
+ * @name punycode
|
|
|
+ * @type Object
|
|
|
+ */
|
|
|
+ var punycode,
|
|
|
+
|
|
|
+
|
|
|
+ maxInt = 2147483647,
|
|
|
+
|
|
|
+
|
|
|
+ base = 36,
|
|
|
+ tMin = 1,
|
|
|
+ tMax = 26,
|
|
|
+ skew = 38,
|
|
|
+ damp = 700,
|
|
|
+ initialBias = 72,
|
|
|
+ initialN = 128,
|
|
|
+ delimiter = '-',
|
|
|
+
|
|
|
+
|
|
|
+ regexPunycode = /^xn--/,
|
|
|
+ regexNonASCII = /[^ -~]/,
|
|
|
+ regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g,
|
|
|
+
|
|
|
+
|
|
|
+ errors = {
|
|
|
+ 'overflow': 'Overflow: input needs wider integers to process',
|
|
|
+ 'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
|
|
|
+ 'invalid-input': 'Invalid input'
|
|
|
+ },
|
|
|
+
|
|
|
+
|
|
|
+ baseMinusTMin = base - tMin,
|
|
|
+ floor = Math.floor,
|
|
|
+ stringFromCharCode = String.fromCharCode,
|
|
|
+
|
|
|
+
|
|
|
+ key;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ * A generic error utility function.
|
|
|
+ * @private
|
|
|
+ * @param {String} type The error type.
|
|
|
+ * @returns {Error} Throws a `RangeError` with the applicable error message.
|
|
|
+ */
|
|
|
+ function error(type) {
|
|
|
+ throw RangeError(errors[type]);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * A generic `Array#map` utility function.
|
|
|
+ * @private
|
|
|
+ * @param {Array} array The array to iterate over.
|
|
|
+ * @param {Function} callback The function that gets called for every array
|
|
|
+ * item.
|
|
|
+ * @returns {Array} A new array of values returned by the callback function.
|
|
|
+ */
|
|
|
+ function map(array, fn) {
|
|
|
+ var length = array.length;
|
|
|
+ while (length--) {
|
|
|
+ array[length] = fn(array[length]);
|
|
|
+ }
|
|
|
+ return array;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * A simple `Array#map`-like wrapper to work with domain name strings.
|
|
|
+ * @private
|
|
|
+ * @param {String} domain The domain name.
|
|
|
+ * @param {Function} callback The function that gets called for every
|
|
|
+ * character.
|
|
|
+ * @returns {Array} A new string of characters returned by the callback
|
|
|
+ * function.
|
|
|
+ */
|
|
|
+ function mapDomain(string, fn) {
|
|
|
+ return map(string.split(regexSeparators), fn).join('.');
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Creates an array containing the numeric code points of each Unicode
|
|
|
+ * character in the string. While JavaScript uses UCS-2 internally,
|
|
|
+ * this function will convert a pair of surrogate halves (each of which
|
|
|
+ * UCS-2 exposes as separate characters) into a single code point,
|
|
|
+ * matching UTF-16.
|
|
|
+ * @see `punycode.ucs2.encode`
|
|
|
+ * @see <http:
|
|
|
+ * @memberOf punycode.ucs2
|
|
|
+ * @name decode
|
|
|
+ * @param {String} string The Unicode input string (UCS-2).
|
|
|
+ * @returns {Array} The new array of code points.
|
|
|
+ */
|
|
|
+ function ucs2decode(string) {
|
|
|
+ var output = [],
|
|
|
+ counter = 0,
|
|
|
+ length = string.length,
|
|
|
+ value,
|
|
|
+ extra;
|
|
|
+ while (counter < length) {
|
|
|
+ value = string.charCodeAt(counter++);
|
|
|
+ if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
|
|
|
+
|
|
|
+ extra = string.charCodeAt(counter++);
|
|
|
+ if ((extra & 0xFC00) == 0xDC00) {
|
|
|
+ output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
|
|
|
+ } else {
|
|
|
+
|
|
|
+
|
|
|
+ output.push(value);
|
|
|
+ counter--;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ output.push(value);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return output;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Creates a string based on an array of numeric code points.
|
|
|
+ * @see `punycode.ucs2.decode`
|
|
|
+ * @memberOf punycode.ucs2
|
|
|
+ * @name encode
|
|
|
+ * @param {Array} codePoints The array of numeric code points.
|
|
|
+ * @returns {String} The new Unicode string (UCS-2).
|
|
|
+ */
|
|
|
+ function ucs2encode(array) {
|
|
|
+ return map(array, function(value) {
|
|
|
+ var output = '';
|
|
|
+ if (value > 0xFFFF) {
|
|
|
+ value -= 0x10000;
|
|
|
+ output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
|
|
|
+ value = 0xDC00 | value & 0x3FF;
|
|
|
+ }
|
|
|
+ output += stringFromCharCode(value);
|
|
|
+ return output;
|
|
|
+ }).join('');
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Converts a basic code point into a digit/integer.
|
|
|
+ * @see `digitToBasic()`
|
|
|
+ * @private
|
|
|
+ * @param {Number} codePoint The basic numeric code point value.
|
|
|
+ * @returns {Number} The numeric value of a basic code point (for use in
|
|
|
+ * representing integers) in the range `0` to `base - 1`, or `base` if
|
|
|
+ * the code point does not represent a value.
|
|
|
+ */
|
|
|
+ function basicToDigit(codePoint) {
|
|
|
+ if (codePoint - 48 < 10) {
|
|
|
+ return codePoint - 22;
|
|
|
+ }
|
|
|
+ if (codePoint - 65 < 26) {
|
|
|
+ return codePoint - 65;
|
|
|
+ }
|
|
|
+ if (codePoint - 97 < 26) {
|
|
|
+ return codePoint - 97;
|
|
|
+ }
|
|
|
+ return base;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Converts a digit/integer into a basic code point.
|
|
|
+ * @see `basicToDigit()`
|
|
|
+ * @private
|
|
|
+ * @param {Number} digit The numeric value of a basic code point.
|
|
|
+ * @returns {Number} The basic code point whose value (when used for
|
|
|
+ * representing integers) is `digit`, which needs to be in the range
|
|
|
+ * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
|
|
|
+ * used; else, the lowercase form is used. The behavior is undefined
|
|
|
+ * if `flag` is non-zero and `digit` has no uppercase form.
|
|
|
+ */
|
|
|
+ function digitToBasic(digit, flag) {
|
|
|
+
|
|
|
+
|
|
|
+ return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Bias adaptation function as per section 3.4 of RFC 3492.
|
|
|
+ * http:
|
|
|
+ * @private
|
|
|
+ */
|
|
|
+ function adapt(delta, numPoints, firstTime) {
|
|
|
+ var k = 0;
|
|
|
+ delta = firstTime ? floor(delta / damp) : delta >> 1;
|
|
|
+ delta += floor(delta / numPoints);
|
|
|
+ for (; delta > baseMinusTMin * tMax >> 1; k += base) {
|
|
|
+ delta = floor(delta / baseMinusTMin);
|
|
|
+ }
|
|
|
+ return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Converts a Punycode string of ASCII-only symbols to a string of Unicode
|
|
|
+ * symbols.
|
|
|
+ * @memberOf punycode
|
|
|
+ * @param {String} input The Punycode string of ASCII-only symbols.
|
|
|
+ * @returns {String} The resulting string of Unicode symbols.
|
|
|
+ */
|
|
|
+ function decode(input) {
|
|
|
+
|
|
|
+ var output = [],
|
|
|
+ inputLength = input.length,
|
|
|
+ out,
|
|
|
+ i = 0,
|
|
|
+ n = initialN,
|
|
|
+ bias = initialBias,
|
|
|
+ basic,
|
|
|
+ j,
|
|
|
+ index,
|
|
|
+ oldi,
|
|
|
+ w,
|
|
|
+ k,
|
|
|
+ digit,
|
|
|
+ t,
|
|
|
+
|
|
|
+ baseMinusT;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ basic = input.lastIndexOf(delimiter);
|
|
|
+ if (basic < 0) {
|
|
|
+ basic = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (j = 0; j < basic; ++j) {
|
|
|
+
|
|
|
+ if (input.charCodeAt(j) >= 0x80) {
|
|
|
+ error('not-basic');
|
|
|
+ }
|
|
|
+ output.push(input.charCodeAt(j));
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for (index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for (oldi = i, w = 1, k = base; ; k += base) {
|
|
|
+
|
|
|
+ if (index >= inputLength) {
|
|
|
+ error('invalid-input');
|
|
|
+ }
|
|
|
+
|
|
|
+ digit = basicToDigit(input.charCodeAt(index++));
|
|
|
+
|
|
|
+ if (digit >= base || digit > floor((maxInt - i) / w)) {
|
|
|
+ error('overflow');
|
|
|
+ }
|
|
|
+
|
|
|
+ i += digit * w;
|
|
|
+ t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
|
+
|
|
|
+ if (digit < t) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ baseMinusT = base - t;
|
|
|
+ if (w > floor(maxInt / baseMinusT)) {
|
|
|
+ error('overflow');
|
|
|
+ }
|
|
|
+
|
|
|
+ w *= baseMinusT;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ out = output.length + 1;
|
|
|
+ bias = adapt(i - oldi, out, oldi == 0);
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if (floor(i / out) > maxInt - n) {
|
|
|
+ error('overflow');
|
|
|
+ }
|
|
|
+
|
|
|
+ n += floor(i / out);
|
|
|
+ i %= out;
|
|
|
+
|
|
|
+
|
|
|
+ output.splice(i++, 0, n);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return ucs2encode(output);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Converts a string of Unicode symbols to a Punycode string of ASCII-only
|
|
|
+ * symbols.
|
|
|
+ * @memberOf punycode
|
|
|
+ * @param {String} input The string of Unicode symbols.
|
|
|
+ * @returns {String} The resulting Punycode string of ASCII-only symbols.
|
|
|
+ */
|
|
|
+ function encode(input) {
|
|
|
+ var n,
|
|
|
+ delta,
|
|
|
+ handledCPCount,
|
|
|
+ basicLength,
|
|
|
+ bias,
|
|
|
+ j,
|
|
|
+ m,
|
|
|
+ q,
|
|
|
+ k,
|
|
|
+ t,
|
|
|
+ currentValue,
|
|
|
+ output = [],
|
|
|
+
|
|
|
+ inputLength,
|
|
|
+
|
|
|
+ handledCPCountPlusOne,
|
|
|
+ baseMinusT,
|
|
|
+ qMinusT;
|
|
|
+
|
|
|
+
|
|
|
+ input = ucs2decode(input);
|
|
|
+
|
|
|
+
|
|
|
+ inputLength = input.length;
|
|
|
+
|
|
|
+
|
|
|
+ n = initialN;
|
|
|
+ delta = 0;
|
|
|
+ bias = initialBias;
|
|
|
+
|
|
|
+
|
|
|
+ for (j = 0; j < inputLength; ++j) {
|
|
|
+ currentValue = input[j];
|
|
|
+ if (currentValue < 0x80) {
|
|
|
+ output.push(stringFromCharCode(currentValue));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ handledCPCount = basicLength = output.length;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if (basicLength) {
|
|
|
+ output.push(delimiter);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ while (handledCPCount < inputLength) {
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for (m = maxInt, j = 0; j < inputLength; ++j) {
|
|
|
+ currentValue = input[j];
|
|
|
+ if (currentValue >= n && currentValue < m) {
|
|
|
+ m = currentValue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ handledCPCountPlusOne = handledCPCount + 1;
|
|
|
+ if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
|
|
+ error('overflow');
|
|
|
+ }
|
|
|
+
|
|
|
+ delta += (m - n) * handledCPCountPlusOne;
|
|
|
+ n = m;
|
|
|
+
|
|
|
+ for (j = 0; j < inputLength; ++j) {
|
|
|
+ currentValue = input[j];
|
|
|
+
|
|
|
+ if (currentValue < n && ++delta > maxInt) {
|
|
|
+ error('overflow');
|
|
|
+ }
|
|
|
+
|
|
|
+ if (currentValue == n) {
|
|
|
+
|
|
|
+ for (q = delta, k = base; ; k += base) {
|
|
|
+ t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
|
+ if (q < t) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ qMinusT = q - t;
|
|
|
+ baseMinusT = base - t;
|
|
|
+ output.push(
|
|
|
+ stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
|
|
+ );
|
|
|
+ q = floor(qMinusT / baseMinusT);
|
|
|
+ }
|
|
|
+
|
|
|
+ output.push(stringFromCharCode(digitToBasic(q, 0)));
|
|
|
+ bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
|
|
|
+ delta = 0;
|
|
|
+ ++handledCPCount;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ++delta;
|
|
|
+ ++n;
|
|
|
+
|
|
|
+ }
|
|
|
+ return output.join('');
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Converts a Punycode string representing a domain name to Unicode. Only the
|
|
|
+ * Punycoded parts of the domain name will be converted, i.e. it doesn't
|
|
|
+ * matter if you call it on a string that has already been converted to
|
|
|
+ * Unicode.
|
|
|
+ * @memberOf punycode
|
|
|
+ * @param {String} domain The Punycode domain name to convert to Unicode.
|
|
|
+ * @returns {String} The Unicode representation of the given Punycode
|
|
|
+ * string.
|
|
|
+ */
|
|
|
+ function toUnicode(domain) {
|
|
|
+ return mapDomain(domain, function(string) {
|
|
|
+ return regexPunycode.test(string)
|
|
|
+ ? decode(string.slice(4).toLowerCase())
|
|
|
+ : string;
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ * Converts a Unicode string representing a domain name to Punycode. Only the
|
|
|
+ * non-ASCII parts of the domain name will be converted, i.e. it doesn't
|
|
|
+ * matter if you call it with a domain that's already in ASCII.
|
|
|
+ * @memberOf punycode
|
|
|
+ * @param {String} domain The domain name to convert, as a Unicode string.
|
|
|
+ * @returns {String} The Punycode representation of the given domain name.
|
|
|
+ */
|
|
|
+ function toASCII(domain) {
|
|
|
+ return mapDomain(domain, function(string) {
|
|
|
+ return regexNonASCII.test(string)
|
|
|
+ ? 'xn--' + encode(string)
|
|
|
+ : string;
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ punycode = {
|
|
|
+
|
|
|
+ * A string representing the current Punycode.js version number.
|
|
|
+ * @memberOf punycode
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+ 'version': '1.2.4',
|
|
|
+
|
|
|
+ * An object of methods to convert from JavaScript's internal character
|
|
|
+ * representation (UCS-2) to Unicode code points, and back.
|
|
|
+ * @see <http:
|
|
|
+ * @memberOf punycode
|
|
|
+ * @type Object
|
|
|
+ */
|
|
|
+ 'ucs2': {
|
|
|
+ 'decode': ucs2decode,
|
|
|
+ 'encode': ucs2encode
|
|
|
+ },
|
|
|
+ 'decode': decode,
|
|
|
+ 'encode': encode,
|
|
|
+ 'toASCII': toASCII,
|
|
|
+ 'toUnicode': toUnicode
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if (
|
|
|
+ typeof define == 'function' &&
|
|
|
+ typeof define.amd == 'object' &&
|
|
|
+ define.amd
|
|
|
+ ) {
|
|
|
+ define('punycode', function() {
|
|
|
+ return punycode;
|
|
|
+ });
|
|
|
+ } else if (freeExports && !freeExports.nodeType) {
|
|
|
+ if (freeModule) {
|
|
|
+ freeModule.exports = punycode;
|
|
|
+ } else {
|
|
|
+ for (key in punycode) {
|
|
|
+ punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ root.punycode = punycode;
|
|
|
+ }
|
|
|
+
|
|
|
+}(this));
|
|
|
+
|
|
|
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
+},{}],2:[function(_dereq_,module,exports){
|
|
|
+var log = _dereq_('./log');
|
|
|
+
|
|
|
+function restoreOwnerScroll(ownerDocument, x, y) {
|
|
|
+ if (ownerDocument.defaultView && (x !== ownerDocument.defaultView.pageXOffset || y !== ownerDocument.defaultView.pageYOffset)) {
|
|
|
+ ownerDocument.defaultView.scrollTo(x, y);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function cloneCanvasContents(canvas, clonedCanvas) {
|
|
|
+ try {
|
|
|
+ if (clonedCanvas) {
|
|
|
+ clonedCanvas.width = canvas.width;
|
|
|
+ clonedCanvas.height = canvas.height;
|
|
|
+ clonedCanvas.getContext("2d").putImageData(canvas.getContext("2d").getImageData(0, 0, canvas.width, canvas.height), 0, 0);
|
|
|
+ }
|
|
|
+ } catch(e) {
|
|
|
+ log("Unable to copy canvas content from", canvas, e);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function cloneNode(node, javascriptEnabled) {
|
|
|
+ var clone = node.nodeType === 3 ? document.createTextNode(node.nodeValue) : node.cloneNode(false);
|
|
|
+
|
|
|
+ var child = node.firstChild;
|
|
|
+ while(child) {
|
|
|
+ if (javascriptEnabled === true || child.nodeType !== 1 || child.nodeName !== 'SCRIPT') {
|
|
|
+ clone.appendChild(cloneNode(child, javascriptEnabled));
|
|
|
+ }
|
|
|
+ child = child.nextSibling;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (node.nodeType === 1) {
|
|
|
+ clone._scrollTop = node.scrollTop;
|
|
|
+ clone._scrollLeft = node.scrollLeft;
|
|
|
+ if (node.nodeName === "CANVAS") {
|
|
|
+ cloneCanvasContents(node, clone);
|
|
|
+ } else if (node.nodeName === "TEXTAREA" || node.nodeName === "SELECT") {
|
|
|
+ clone.value = node.value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return clone;
|
|
|
+}
|
|
|
+
|
|
|
+function initNode(node) {
|
|
|
+ if (node.nodeType === 1) {
|
|
|
+ node.scrollTop = node._scrollTop;
|
|
|
+ node.scrollLeft = node._scrollLeft;
|
|
|
+
|
|
|
+ var child = node.firstChild;
|
|
|
+ while(child) {
|
|
|
+ initNode(child);
|
|
|
+ child = child.nextSibling;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = function(ownerDocument, containerDocument, width, height, options, x ,y) {
|
|
|
+ var documentElement = cloneNode(ownerDocument.documentElement, options.javascriptEnabled);
|
|
|
+ var container = containerDocument.createElement("iframe");
|
|
|
+
|
|
|
+ container.className = "html2canvas-container";
|
|
|
+ container.style.visibility = "hidden";
|
|
|
+ container.style.position = "fixed";
|
|
|
+ container.style.left = "-10000px";
|
|
|
+ container.style.top = "0px";
|
|
|
+ container.style.border = "0";
|
|
|
+ container.width = width;
|
|
|
+ container.height = height;
|
|
|
+ container.scrolling = "no";
|
|
|
+ containerDocument.body.appendChild(container);
|
|
|
+
|
|
|
+ return new Promise(function(resolve) {
|
|
|
+ var documentClone = container.contentWindow.document;
|
|
|
+
|
|
|
+
|
|
|
+ if window url is about:blank, we can assign the url to current by writing onto the document
|
|
|
+ */
|
|
|
+ container.contentWindow.onload = container.onload = function() {
|
|
|
+ var interval = setInterval(function() {
|
|
|
+ if (documentClone.body.childNodes.length > 0) {
|
|
|
+ initNode(documentClone.documentElement);
|
|
|
+ clearInterval(interval);
|
|
|
+ if (options.type === "view") {
|
|
|
+ container.contentWindow.scrollTo(x, y);
|
|
|
+ if ((/(iPad|iPhone|iPod)/g).test(navigator.userAgent) && (container.contentWindow.scrollY !== y || container.contentWindow.scrollX !== x)) {
|
|
|
+ documentClone.documentElement.style.top = (-y) + "px";
|
|
|
+ documentClone.documentElement.style.left = (-x) + "px";
|
|
|
+ documentClone.documentElement.style.position = 'absolute';
|
|
|
+ }
|
|
|
+ }
|
|
|
+ resolve(container);
|
|
|
+ }
|
|
|
+ }, 50);
|
|
|
+ };
|
|
|
+
|
|
|
+ documentClone.open();
|
|
|
+ documentClone.write("<!DOCTYPE html><html></html>");
|
|
|
+
|
|
|
+ restoreOwnerScroll(ownerDocument, x, y);
|
|
|
+ documentClone.replaceChild(documentClone.adoptNode(documentElement), documentClone.documentElement);
|
|
|
+ documentClone.close();
|
|
|
+ });
|
|
|
+};
|
|
|
+
|
|
|
+},{"./log":13}],3:[function(_dereq_,module,exports){
|
|
|
+
|
|
|
+
|
|
|
+function Color(value) {
|
|
|
+ this.r = 0;
|
|
|
+ this.g = 0;
|
|
|
+ this.b = 0;
|
|
|
+ this.a = null;
|
|
|
+ var result = this.fromArray(value) ||
|
|
|
+ this.namedColor(value) ||
|
|
|
+ this.rgb(value) ||
|
|
|
+ this.rgba(value) ||
|
|
|
+ this.hex6(value) ||
|
|
|
+ this.hex3(value);
|
|
|
+}
|
|
|
+
|
|
|
+Color.prototype.darken = function(amount) {
|
|
|
+ var a = 1 - amount;
|
|
|
+ return new Color([
|
|
|
+ Math.round(this.r * a),
|
|
|
+ Math.round(this.g * a),
|
|
|
+ Math.round(this.b * a),
|
|
|
+ this.a
|
|
|
+ ]);
|
|
|
+};
|
|
|
+
|
|
|
+Color.prototype.isTransparent = function() {
|
|
|
+ return this.a === 0;
|
|
|
+};
|
|
|
+
|
|
|
+Color.prototype.isBlack = function() {
|
|
|
+ return this.r === 0 && this.g === 0 && this.b === 0;
|
|
|
+};
|
|
|
+
|
|
|
+Color.prototype.fromArray = function(array) {
|
|
|
+ if (Array.isArray(array)) {
|
|
|
+ this.r = Math.min(array[0], 255);
|
|
|
+ this.g = Math.min(array[1], 255);
|
|
|
+ this.b = Math.min(array[2], 255);
|
|
|
+ if (array.length > 3) {
|
|
|
+ this.a = array[3];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return (Array.isArray(array));
|
|
|
+};
|
|
|
+
|
|
|
+var _hex3 = /^#([a-f0-9]{3})$/i;
|
|
|
+
|
|
|
+Color.prototype.hex3 = function(value) {
|
|
|
+ var match = null;
|
|
|
+ if ((match = value.match(_hex3)) !== null) {
|
|
|
+ this.r = parseInt(match[1][0] + match[1][0], 16);
|
|
|
+ this.g = parseInt(match[1][1] + match[1][1], 16);
|
|
|
+ this.b = parseInt(match[1][2] + match[1][2], 16);
|
|
|
+ }
|
|
|
+ return match !== null;
|
|
|
+};
|
|
|
+
|
|
|
+var _hex6 = /^#([a-f0-9]{6})$/i;
|
|
|
+
|
|
|
+Color.prototype.hex6 = function(value) {
|
|
|
+ var match = null;
|
|
|
+ if ((match = value.match(_hex6)) !== null) {
|
|
|
+ this.r = parseInt(match[1].substring(0, 2), 16);
|
|
|
+ this.g = parseInt(match[1].substring(2, 4), 16);
|
|
|
+ this.b = parseInt(match[1].substring(4, 6), 16);
|
|
|
+ }
|
|
|
+ return match !== null;
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+var _rgb = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;
|
|
|
+
|
|
|
+Color.prototype.rgb = function(value) {
|
|
|
+ var match = null;
|
|
|
+ if ((match = value.match(_rgb)) !== null) {
|
|
|
+ this.r = Number(match[1]);
|
|
|
+ this.g = Number(match[2]);
|
|
|
+ this.b = Number(match[3]);
|
|
|
+ }
|
|
|
+ return match !== null;
|
|
|
+};
|
|
|
+
|
|
|
+var _rgba = /^rgba\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d?\.?\d+)\s*\)$/;
|
|
|
+
|
|
|
+Color.prototype.rgba = function(value) {
|
|
|
+ var match = null;
|
|
|
+ if ((match = value.match(_rgba)) !== null) {
|
|
|
+ this.r = Number(match[1]);
|
|
|
+ this.g = Number(match[2]);
|
|
|
+ this.b = Number(match[3]);
|
|
|
+ this.a = Number(match[4]);
|
|
|
+ }
|
|
|
+ return match !== null;
|
|
|
+};
|
|
|
+
|
|
|
+Color.prototype.toString = function() {
|
|
|
+ return this.a !== null && this.a !== 1 ?
|
|
|
+ "rgba(" + [this.r, this.g, this.b, this.a].join(",") + ")" :
|
|
|
+ "rgb(" + [this.r, this.g, this.b].join(",") + ")";
|
|
|
+};
|
|
|
+
|
|
|
+Color.prototype.namedColor = function(value) {
|
|
|
+ value = value.toLowerCase();
|
|
|
+ var color = colors[value];
|
|
|
+ if (color) {
|
|
|
+ this.r = color[0];
|
|
|
+ this.g = color[1];
|
|
|
+ this.b = color[2];
|
|
|
+ } else if (value === "transparent") {
|
|
|
+ this.r = this.g = this.b = this.a = 0;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return !!color;
|
|
|
+};
|
|
|
+
|
|
|
+Color.prototype.isColor = true;
|
|
|
+
|
|
|
+
|
|
|
+var colors = {
|
|
|
+ "aliceblue": [240, 248, 255],
|
|
|
+ "antiquewhite": [250, 235, 215],
|
|
|
+ "aqua": [0, 255, 255],
|
|
|
+ "aquamarine": [127, 255, 212],
|
|
|
+ "azure": [240, 255, 255],
|
|
|
+ "beige": [245, 245, 220],
|
|
|
+ "bisque": [255, 228, 196],
|
|
|
+ "black": [0, 0, 0],
|
|
|
+ "blanchedalmond": [255, 235, 205],
|
|
|
+ "blue": [0, 0, 255],
|
|
|
+ "blueviolet": [138, 43, 226],
|
|
|
+ "brown": [165, 42, 42],
|
|
|
+ "burlywood": [222, 184, 135],
|
|
|
+ "cadetblue": [95, 158, 160],
|
|
|
+ "chartreuse": [127, 255, 0],
|
|
|
+ "chocolate": [210, 105, 30],
|
|
|
+ "coral": [255, 127, 80],
|
|
|
+ "cornflowerblue": [100, 149, 237],
|
|
|
+ "cornsilk": [255, 248, 220],
|
|
|
+ "crimson": [220, 20, 60],
|
|
|
+ "cyan": [0, 255, 255],
|
|
|
+ "darkblue": [0, 0, 139],
|
|
|
+ "darkcyan": [0, 139, 139],
|
|
|
+ "darkgoldenrod": [184, 134, 11],
|
|
|
+ "darkgray": [169, 169, 169],
|
|
|
+ "darkgreen": [0, 100, 0],
|
|
|
+ "darkgrey": [169, 169, 169],
|
|
|
+ "darkkhaki": [189, 183, 107],
|
|
|
+ "darkmagenta": [139, 0, 139],
|
|
|
+ "darkolivegreen": [85, 107, 47],
|
|
|
+ "darkorange": [255, 140, 0],
|
|
|
+ "darkorchid": [153, 50, 204],
|
|
|
+ "darkred": [139, 0, 0],
|
|
|
+ "darksalmon": [233, 150, 122],
|
|
|
+ "darkseagreen": [143, 188, 143],
|
|
|
+ "darkslateblue": [72, 61, 139],
|
|
|
+ "darkslategray": [47, 79, 79],
|
|
|
+ "darkslategrey": [47, 79, 79],
|
|
|
+ "darkturquoise": [0, 206, 209],
|
|
|
+ "darkviolet": [148, 0, 211],
|
|
|
+ "deeppink": [255, 20, 147],
|
|
|
+ "deepskyblue": [0, 191, 255],
|
|
|
+ "dimgray": [105, 105, 105],
|
|
|
+ "dimgrey": [105, 105, 105],
|
|
|
+ "dodgerblue": [30, 144, 255],
|
|
|
+ "firebrick": [178, 34, 34],
|
|
|
+ "floralwhite": [255, 250, 240],
|
|
|
+ "forestgreen": [34, 139, 34],
|
|
|
+ "fuchsia": [255, 0, 255],
|
|
|
+ "gainsboro": [220, 220, 220],
|
|
|
+ "ghostwhite": [248, 248, 255],
|
|
|
+ "gold": [255, 215, 0],
|
|
|
+ "goldenrod": [218, 165, 32],
|
|
|
+ "gray": [128, 128, 128],
|
|
|
+ "green": [0, 128, 0],
|
|
|
+ "greenyellow": [173, 255, 47],
|
|
|
+ "grey": [128, 128, 128],
|
|
|
+ "honeydew": [240, 255, 240],
|
|
|
+ "hotpink": [255, 105, 180],
|
|
|
+ "indianred": [205, 92, 92],
|
|
|
+ "indigo": [75, 0, 130],
|
|
|
+ "ivory": [255, 255, 240],
|
|
|
+ "khaki": [240, 230, 140],
|
|
|
+ "lavender": [230, 230, 250],
|
|
|
+ "lavenderblush": [255, 240, 245],
|
|
|
+ "lawngreen": [124, 252, 0],
|
|
|
+ "lemonchiffon": [255, 250, 205],
|
|
|
+ "lightblue": [173, 216, 230],
|
|
|
+ "lightcoral": [240, 128, 128],
|
|
|
+ "lightcyan": [224, 255, 255],
|
|
|
+ "lightgoldenrodyellow": [250, 250, 210],
|
|
|
+ "lightgray": [211, 211, 211],
|
|
|
+ "lightgreen": [144, 238, 144],
|
|
|
+ "lightgrey": [211, 211, 211],
|
|
|
+ "lightpink": [255, 182, 193],
|
|
|
+ "lightsalmon": [255, 160, 122],
|
|
|
+ "lightseagreen": [32, 178, 170],
|
|
|
+ "lightskyblue": [135, 206, 250],
|
|
|
+ "lightslategray": [119, 136, 153],
|
|
|
+ "lightslategrey": [119, 136, 153],
|
|
|
+ "lightsteelblue": [176, 196, 222],
|
|
|
+ "lightyellow": [255, 255, 224],
|
|
|
+ "lime": [0, 255, 0],
|
|
|
+ "limegreen": [50, 205, 50],
|
|
|
+ "linen": [250, 240, 230],
|
|
|
+ "magenta": [255, 0, 255],
|
|
|
+ "maroon": [128, 0, 0],
|
|
|
+ "mediumaquamarine": [102, 205, 170],
|
|
|
+ "mediumblue": [0, 0, 205],
|
|
|
+ "mediumorchid": [186, 85, 211],
|
|
|
+ "mediumpurple": [147, 112, 219],
|
|
|
+ "mediumseagreen": [60, 179, 113],
|
|
|
+ "mediumslateblue": [123, 104, 238],
|
|
|
+ "mediumspringgreen": [0, 250, 154],
|
|
|
+ "mediumturquoise": [72, 209, 204],
|
|
|
+ "mediumvioletred": [199, 21, 133],
|
|
|
+ "midnightblue": [25, 25, 112],
|
|
|
+ "mintcream": [245, 255, 250],
|
|
|
+ "mistyrose": [255, 228, 225],
|
|
|
+ "moccasin": [255, 228, 181],
|
|
|
+ "navajowhite": [255, 222, 173],
|
|
|
+ "navy": [0, 0, 128],
|
|
|
+ "oldlace": [253, 245, 230],
|
|
|
+ "olive": [128, 128, 0],
|
|
|
+ "olivedrab": [107, 142, 35],
|
|
|
+ "orange": [255, 165, 0],
|
|
|
+ "orangered": [255, 69, 0],
|
|
|
+ "orchid": [218, 112, 214],
|
|
|
+ "palegoldenrod": [238, 232, 170],
|
|
|
+ "palegreen": [152, 251, 152],
|
|
|
+ "paleturquoise": [175, 238, 238],
|
|
|
+ "palevioletred": [219, 112, 147],
|
|
|
+ "papayawhip": [255, 239, 213],
|
|
|
+ "peachpuff": [255, 218, 185],
|
|
|
+ "peru": [205, 133, 63],
|
|
|
+ "pink": [255, 192, 203],
|
|
|
+ "plum": [221, 160, 221],
|
|
|
+ "powderblue": [176, 224, 230],
|
|
|
+ "purple": [128, 0, 128],
|
|
|
+ "rebeccapurple": [102, 51, 153],
|
|
|
+ "red": [255, 0, 0],
|
|
|
+ "rosybrown": [188, 143, 143],
|
|
|
+ "royalblue": [65, 105, 225],
|
|
|
+ "saddlebrown": [139, 69, 19],
|
|
|
+ "salmon": [250, 128, 114],
|
|
|
+ "sandybrown": [244, 164, 96],
|
|
|
+ "seagreen": [46, 139, 87],
|
|
|
+ "seashell": [255, 245, 238],
|
|
|
+ "sienna": [160, 82, 45],
|
|
|
+ "silver": [192, 192, 192],
|
|
|
+ "skyblue": [135, 206, 235],
|
|
|
+ "slateblue": [106, 90, 205],
|
|
|
+ "slategray": [112, 128, 144],
|
|
|
+ "slategrey": [112, 128, 144],
|
|
|
+ "snow": [255, 250, 250],
|
|
|
+ "springgreen": [0, 255, 127],
|
|
|
+ "steelblue": [70, 130, 180],
|
|
|
+ "tan": [210, 180, 140],
|
|
|
+ "teal": [0, 128, 128],
|
|
|
+ "thistle": [216, 191, 216],
|
|
|
+ "tomato": [255, 99, 71],
|
|
|
+ "turquoise": [64, 224, 208],
|
|
|
+ "violet": [238, 130, 238],
|
|
|
+ "wheat": [245, 222, 179],
|
|
|
+ "white": [255, 255, 255],
|
|
|
+ "whitesmoke": [245, 245, 245],
|
|
|
+ "yellow": [255, 255, 0],
|
|
|
+ "yellowgreen": [154, 205, 50]
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = Color;
|
|
|
+
|
|
|
+},{}],4:[function(_dereq_,module,exports){
|
|
|
+var Support = _dereq_('./support');
|
|
|
+var CanvasRenderer = _dereq_('./renderers/canvas');
|
|
|
+var ImageLoader = _dereq_('./imageloader');
|
|
|
+var NodeParser = _dereq_('./nodeparser');
|
|
|
+var NodeContainer = _dereq_('./nodecontainer');
|
|
|
+var log = _dereq_('./log');
|
|
|
+var utils = _dereq_('./utils');
|
|
|
+var createWindowClone = _dereq_('./clone');
|
|
|
+var loadUrlDocument = _dereq_('./proxy').loadUrlDocument;
|
|
|
+var getBounds = utils.getBounds;
|
|
|
+
|
|
|
+var html2canvasNodeAttribute = "data-html2canvas-node";
|
|
|
+var html2canvasCloneIndex = 0;
|
|
|
+
|
|
|
+function html2canvas(nodeList, options) {
|
|
|
+ var index = html2canvasCloneIndex++;
|
|
|
+ options = options || {};
|
|
|
+ if (options.logging) {
|
|
|
+ log.options.logging = true;
|
|
|
+ log.options.start = Date.now();
|
|
|
+ }
|
|
|
+
|
|
|
+ options.async = typeof(options.async) === "undefined" ? true : options.async;
|
|
|
+ options.allowTaint = typeof(options.allowTaint) === "undefined" ? false : options.allowTaint;
|
|
|
+ options.removeContainer = typeof(options.removeContainer) === "undefined" ? true : options.removeContainer;
|
|
|
+ options.javascriptEnabled = typeof(options.javascriptEnabled) === "undefined" ? false : options.javascriptEnabled;
|
|
|
+ options.imageTimeout = typeof(options.imageTimeout) === "undefined" ? 10000 : options.imageTimeout;
|
|
|
+ options.renderer = typeof(options.renderer) === "function" ? options.renderer : CanvasRenderer;
|
|
|
+ options.strict = !!options.strict;
|
|
|
+
|
|
|
+ if (typeof(nodeList) === "string") {
|
|
|
+ if (typeof(options.proxy) !== "string") {
|
|
|
+ return Promise.reject("Proxy must be used when rendering url");
|
|
|
+ }
|
|
|
+ var width = options.width != null ? options.width : window.innerWidth;
|
|
|
+ var height = options.height != null ? options.height : window.innerHeight;
|
|
|
+ return loadUrlDocument(absoluteUrl(nodeList), options.proxy, document, width, height, options).then(function(container) {
|
|
|
+ return renderWindow(container.contentWindow.document.documentElement, container, options, width, height);
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ var node = ((nodeList === undefined) ? [document.documentElement] : ((nodeList.length) ? nodeList : [nodeList]))[0];
|
|
|
+ node.setAttribute(html2canvasNodeAttribute + index, index);
|
|
|
+ return renderDocument(node.ownerDocument, options, node.ownerDocument.defaultView.innerWidth, node.ownerDocument.defaultView.innerHeight, index).then(function(canvas) {
|
|
|
+ if (typeof(options.onrendered) === "function") {
|
|
|
+ log("options.onrendered is deprecated, html2canvas returns a Promise containing the canvas");
|
|
|
+ options.onrendered(canvas);
|
|
|
+ }
|
|
|
+ return canvas;
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+html2canvas.CanvasRenderer = CanvasRenderer;
|
|
|
+html2canvas.NodeContainer = NodeContainer;
|
|
|
+html2canvas.log = log;
|
|
|
+html2canvas.utils = utils;
|
|
|
+
|
|
|
+var html2canvasExport = (typeof(document) === "undefined" || typeof(Object.create) !== "function" || typeof(document.createElement("canvas").getContext) !== "function") ? function() {
|
|
|
+ return Promise.reject("No canvas support");
|
|
|
+} : html2canvas;
|
|
|
+
|
|
|
+module.exports = html2canvasExport;
|
|
|
+
|
|
|
+if (typeof(define) === 'function' && define.amd) {
|
|
|
+ define('html2canvas', [], function() {
|
|
|
+ return html2canvasExport;
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+function renderDocument(document, options, windowWidth, windowHeight, html2canvasIndex) {
|
|
|
+ return createWindowClone(document, document, windowWidth, windowHeight, options, document.defaultView.pageXOffset, document.defaultView.pageYOffset).then(function(container) {
|
|
|
+ log("Document cloned");
|
|
|
+ var attributeName = html2canvasNodeAttribute + html2canvasIndex;
|
|
|
+ var selector = "[" + attributeName + "='" + html2canvasIndex + "']";
|
|
|
+ document.querySelector(selector).removeAttribute(attributeName);
|
|
|
+ var clonedWindow = container.contentWindow;
|
|
|
+ var node = clonedWindow.document.querySelector(selector);
|
|
|
+ var oncloneHandler = (typeof(options.onclone) === "function") ? Promise.resolve(options.onclone(clonedWindow.document)) : Promise.resolve(true);
|
|
|
+ return oncloneHandler.then(function() {
|
|
|
+ return renderWindow(node, container, options, windowWidth, windowHeight);
|
|
|
+ });
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+function renderWindow(node, container, options, windowWidth, windowHeight) {
|
|
|
+ var clonedWindow = container.contentWindow;
|
|
|
+ var support = new Support(clonedWindow.document);
|
|
|
+ var imageLoader = new ImageLoader(options, support);
|
|
|
+ var bounds = getBounds(node);
|
|
|
+ var width = options.type === "view" ? windowWidth : documentWidth(clonedWindow.document);
|
|
|
+ var height = options.type === "view" ? windowHeight : documentHeight(clonedWindow.document);
|
|
|
+ var renderer = new options.renderer(width, height, imageLoader, options, document);
|
|
|
+ var parser = new NodeParser(node, renderer, support, imageLoader, options);
|
|
|
+ return parser.ready.then(function() {
|
|
|
+ log("Finished rendering");
|
|
|
+ var canvas;
|
|
|
+
|
|
|
+ if (options.type === "view") {
|
|
|
+ canvas = crop(renderer.canvas, {width: renderer.canvas.width, height: renderer.canvas.height, top: 0, left: 0, x: 0, y: 0});
|
|
|
+ } else if (node === clonedWindow.document.body || node === clonedWindow.document.documentElement || options.canvas != null) {
|
|
|
+ canvas = renderer.canvas;
|
|
|
+ } else {
|
|
|
+ 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});
|
|
|
+ }
|
|
|
+
|
|
|
+ cleanupContainer(container, options);
|
|
|
+ return canvas;
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+function cleanupContainer(container, options) {
|
|
|
+ if (options.removeContainer) {
|
|
|
+ container.parentNode.removeChild(container);
|
|
|
+ log("Cleaned up container");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function crop(canvas, bounds) {
|
|
|
+ var croppedCanvas = document.createElement("canvas");
|
|
|
+ var x1 = Math.min(canvas.width - 1, Math.max(0, bounds.left));
|
|
|
+ var x2 = Math.min(canvas.width, Math.max(1, bounds.left + bounds.width));
|
|
|
+ var y1 = Math.min(canvas.height - 1, Math.max(0, bounds.top));
|
|
|
+ var y2 = Math.min(canvas.height, Math.max(1, bounds.top + bounds.height));
|
|
|
+ croppedCanvas.width = bounds.width;
|
|
|
+ croppedCanvas.height = bounds.height;
|
|
|
+ var width = x2-x1;
|
|
|
+ var height = y2-y1;
|
|
|
+ log("Cropping canvas at:", "left:", bounds.left, "top:", bounds.top, "width:", width, "height:", height);
|
|
|
+ log("Resulting crop with width", bounds.width, "and height", bounds.height, "with x", x1, "and y", y1);
|
|
|
+ croppedCanvas.getContext("2d").drawImage(canvas, x1, y1, width, height, bounds.x, bounds.y, width, height);
|
|
|
+ return croppedCanvas;
|
|
|
+}
|
|
|
+
|
|
|
+function documentWidth (doc) {
|
|
|
+ return Math.max(
|
|
|
+ Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth),
|
|
|
+ Math.max(doc.body.offsetWidth, doc.documentElement.offsetWidth),
|
|
|
+ Math.max(doc.body.clientWidth, doc.documentElement.clientWidth)
|
|
|
+ );
|
|
|
+}
|
|
|
+
|
|
|
+function documentHeight (doc) {
|
|
|
+ return Math.max(
|
|
|
+ Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight),
|
|
|
+ Math.max(doc.body.offsetHeight, doc.documentElement.offsetHeight),
|
|
|
+ Math.max(doc.body.clientHeight, doc.documentElement.clientHeight)
|
|
|
+ );
|
|
|
+}
|
|
|
+
|
|
|
+function absoluteUrl(url) {
|
|
|
+ var link = document.createElement("a");
|
|
|
+ link.href = url;
|
|
|
+ link.href = link.href;
|
|
|
+ return link;
|
|
|
+}
|
|
|
+
|
|
|
+},{"./clone":2,"./imageloader":11,"./log":13,"./nodecontainer":14,"./nodeparser":15,"./proxy":16,"./renderers/canvas":20,"./support":22,"./utils":26}],5:[function(_dereq_,module,exports){
|
|
|
+var log = _dereq_('./log');
|
|
|
+var smallImage = _dereq_('./utils').smallImage;
|
|
|
+
|
|
|
+function DummyImageContainer(src) {
|
|
|
+ this.src = src;
|
|
|
+ log("DummyImageContainer for", src);
|
|
|
+ if (!this.promise || !this.image) {
|
|
|
+ log("Initiating DummyImageContainer");
|
|
|
+ DummyImageContainer.prototype.image = new Image();
|
|
|
+ var image = this.image;
|
|
|
+ DummyImageContainer.prototype.promise = new Promise(function(resolve, reject) {
|
|
|
+ image.onload = resolve;
|
|
|
+ image.onerror = reject;
|
|
|
+ image.src = smallImage();
|
|
|
+ if (image.complete === true) {
|
|
|
+ resolve(image);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = DummyImageContainer;
|
|
|
+
|
|
|
+},{"./log":13,"./utils":26}],6:[function(_dereq_,module,exports){
|
|
|
+var smallImage = _dereq_('./utils').smallImage;
|
|
|
+
|
|
|
+function Font(family, size) {
|
|
|
+ var container = document.createElement('div'),
|
|
|
+ img = document.createElement('img'),
|
|
|
+ span = document.createElement('span'),
|
|
|
+ sampleText = 'Hidden Text',
|
|
|
+ baseline,
|
|
|
+ middle;
|
|
|
+
|
|
|
+ container.style.visibility = "hidden";
|
|
|
+ container.style.fontFamily = family;
|
|
|
+ container.style.fontSize = size;
|
|
|
+ container.style.margin = 0;
|
|
|
+ container.style.padding = 0;
|
|
|
+
|
|
|
+ document.body.appendChild(container);
|
|
|
+
|
|
|
+ img.src = smallImage();
|
|
|
+ img.width = 1;
|
|
|
+ img.height = 1;
|
|
|
+
|
|
|
+ img.style.margin = 0;
|
|
|
+ img.style.padding = 0;
|
|
|
+ img.style.verticalAlign = "baseline";
|
|
|
+
|
|
|
+ span.style.fontFamily = family;
|
|
|
+ span.style.fontSize = size;
|
|
|
+ span.style.margin = 0;
|
|
|
+ span.style.padding = 0;
|
|
|
+
|
|
|
+ span.appendChild(document.createTextNode(sampleText));
|
|
|
+ container.appendChild(span);
|
|
|
+ container.appendChild(img);
|
|
|
+ baseline = (img.offsetTop - span.offsetTop) + 1;
|
|
|
+
|
|
|
+ container.removeChild(span);
|
|
|
+ container.appendChild(document.createTextNode(sampleText));
|
|
|
+
|
|
|
+ container.style.lineHeight = "normal";
|
|
|
+ img.style.verticalAlign = "super";
|
|
|
+
|
|
|
+ middle = (img.offsetTop-container.offsetTop) + 1;
|
|
|
+
|
|
|
+ document.body.removeChild(container);
|
|
|
+
|
|
|
+ this.baseline = baseline;
|
|
|
+ this.lineWidth = 1;
|
|
|
+ this.middle = middle;
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = Font;
|
|
|
+
|
|
|
+},{"./utils":26}],7:[function(_dereq_,module,exports){
|
|
|
+var Font = _dereq_('./font');
|
|
|
+
|
|
|
+function FontMetrics() {
|
|
|
+ this.data = {};
|
|
|
+}
|
|
|
+
|
|
|
+FontMetrics.prototype.getMetrics = function(family, size) {
|
|
|
+ if (this.data[family + "-" + size] === undefined) {
|
|
|
+ this.data[family + "-" + size] = new Font(family, size);
|
|
|
+ }
|
|
|
+ return this.data[family + "-" + size];
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = FontMetrics;
|
|
|
+
|
|
|
+},{"./font":6}],8:[function(_dereq_,module,exports){
|
|
|
+var utils = _dereq_('./utils');
|
|
|
+var getBounds = utils.getBounds;
|
|
|
+var loadUrlDocument = _dereq_('./proxy').loadUrlDocument;
|
|
|
+
|
|
|
+function FrameContainer(container, sameOrigin, options) {
|
|
|
+ this.image = null;
|
|
|
+ this.src = container;
|
|
|
+ var self = this;
|
|
|
+ var bounds = getBounds(container);
|
|
|
+ this.promise = (!sameOrigin ? this.proxyLoad(options.proxy, bounds, options) : new Promise(function(resolve) {
|
|
|
+ if (container.contentWindow.document.URL === "about:blank" || container.contentWindow.document.documentElement == null) {
|
|
|
+ container.contentWindow.onload = container.onload = function() {
|
|
|
+ resolve(container);
|
|
|
+ };
|
|
|
+ } else {
|
|
|
+ resolve(container);
|
|
|
+ }
|
|
|
+ })).then(function(container) {
|
|
|
+ var html2canvas = _dereq_('./core');
|
|
|
+ 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});
|
|
|
+ }).then(function(canvas) {
|
|
|
+ return self.image = canvas;
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+FrameContainer.prototype.proxyLoad = function(proxy, bounds, options) {
|
|
|
+ var container = this.src;
|
|
|
+ return loadUrlDocument(container.src, proxy, container.ownerDocument, bounds.width, bounds.height, options);
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = FrameContainer;
|
|
|
+
|
|
|
+},{"./core":4,"./proxy":16,"./utils":26}],9:[function(_dereq_,module,exports){
|
|
|
+function GradientContainer(imageData) {
|
|
|
+ this.src = imageData.value;
|
|
|
+ this.colorStops = [];
|
|
|
+ this.type = null;
|
|
|
+ this.x0 = 0.5;
|
|
|
+ this.y0 = 0.5;
|
|
|
+ this.x1 = 0.5;
|
|
|
+ this.y1 = 0.5;
|
|
|
+ this.promise = Promise.resolve(true);
|
|
|
+}
|
|
|
+
|
|
|
+GradientContainer.TYPES = {
|
|
|
+ LINEAR: 1,
|
|
|
+ RADIAL: 2
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+GradientContainer.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;
|
|
|
+
|
|
|
+module.exports = GradientContainer;
|
|
|
+
|
|
|
+},{}],10:[function(_dereq_,module,exports){
|
|
|
+function ImageContainer(src, cors) {
|
|
|
+ this.src = src;
|
|
|
+ this.image = new Image();
|
|
|
+ var self = this;
|
|
|
+ this.tainted = null;
|
|
|
+ this.promise = new Promise(function(resolve, reject) {
|
|
|
+ self.image.onload = resolve;
|
|
|
+ self.image.onerror = reject;
|
|
|
+ if (cors) {
|
|
|
+ self.image.crossOrigin = "anonymous";
|
|
|
+ }
|
|
|
+ self.image.src = src;
|
|
|
+ if (self.image.complete === true) {
|
|
|
+ resolve(self.image);
|
|
|
+ }
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = ImageContainer;
|
|
|
+
|
|
|
+},{}],11:[function(_dereq_,module,exports){
|
|
|
+var log = _dereq_('./log');
|
|
|
+var ImageContainer = _dereq_('./imagecontainer');
|
|
|
+var DummyImageContainer = _dereq_('./dummyimagecontainer');
|
|
|
+var ProxyImageContainer = _dereq_('./proxyimagecontainer');
|
|
|
+var FrameContainer = _dereq_('./framecontainer');
|
|
|
+var SVGContainer = _dereq_('./svgcontainer');
|
|
|
+var SVGNodeContainer = _dereq_('./svgnodecontainer');
|
|
|
+var LinearGradientContainer = _dereq_('./lineargradientcontainer');
|
|
|
+var WebkitGradientContainer = _dereq_('./webkitgradientcontainer');
|
|
|
+var bind = _dereq_('./utils').bind;
|
|
|
+
|
|
|
+function ImageLoader(options, support) {
|
|
|
+ this.link = null;
|
|
|
+ this.options = options;
|
|
|
+ this.support = support;
|
|
|
+ this.origin = this.getOrigin(window.location.href);
|
|
|
+}
|
|
|
+
|
|
|
+ImageLoader.prototype.findImages = function(nodes) {
|
|
|
+ var images = [];
|
|
|
+ nodes.reduce(function(imageNodes, container) {
|
|
|
+ switch(container.node.nodeName) {
|
|
|
+ case "IMG":
|
|
|
+ return imageNodes.concat([{
|
|
|
+ args: [container.node.src],
|
|
|
+ method: "url"
|
|
|
+ }]);
|
|
|
+ case "svg":
|
|
|
+ case "IFRAME":
|
|
|
+ return imageNodes.concat([{
|
|
|
+ args: [container.node],
|
|
|
+ method: container.node.nodeName
|
|
|
+ }]);
|
|
|
+ }
|
|
|
+ return imageNodes;
|
|
|
+ }, []).forEach(this.addImage(images, this.loadImage), this);
|
|
|
+ return images;
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.findBackgroundImage = function(images, container) {
|
|
|
+ container.parseBackgroundImages().filter(this.hasImageBackground).forEach(this.addImage(images, this.loadImage), this);
|
|
|
+ return images;
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.addImage = function(images, callback) {
|
|
|
+ return function(newImage) {
|
|
|
+ newImage.args.forEach(function(image) {
|
|
|
+ if (!this.imageExists(images, image)) {
|
|
|
+ images.splice(0, 0, callback.call(this, newImage));
|
|
|
+ log('Added image #' + (images.length), typeof(image) === "string" ? image.substring(0, 100) : image);
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.hasImageBackground = function(imageData) {
|
|
|
+ return imageData.method !== "none";
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.loadImage = function(imageData) {
|
|
|
+ if (imageData.method === "url") {
|
|
|
+ var src = imageData.args[0];
|
|
|
+ if (this.isSVG(src) && !this.support.svg && !this.options.allowTaint) {
|
|
|
+ return new SVGContainer(src);
|
|
|
+ } else if (src.match(/data:image\/.*;base64,/i)) {
|
|
|
+ return new ImageContainer(src.replace(/url\(['"]{0,}|['"]{0,}\)$/ig, ''), false);
|
|
|
+ } else if (this.isSameOrigin(src) || this.options.allowTaint === true || this.isSVG(src)) {
|
|
|
+ return new ImageContainer(src, false);
|
|
|
+ } else if (this.support.cors && !this.options.allowTaint && this.options.useCORS) {
|
|
|
+ return new ImageContainer(src, true);
|
|
|
+ } else if (this.options.proxy) {
|
|
|
+ return new ProxyImageContainer(src, this.options.proxy);
|
|
|
+ } else {
|
|
|
+ return new DummyImageContainer(src);
|
|
|
+ }
|
|
|
+ } else if (imageData.method === "linear-gradient") {
|
|
|
+ return new LinearGradientContainer(imageData);
|
|
|
+ } else if (imageData.method === "gradient") {
|
|
|
+ return new WebkitGradientContainer(imageData);
|
|
|
+ } else if (imageData.method === "svg") {
|
|
|
+ return new SVGNodeContainer(imageData.args[0], this.support.svg);
|
|
|
+ } else if (imageData.method === "IFRAME") {
|
|
|
+ return new FrameContainer(imageData.args[0], this.isSameOrigin(imageData.args[0].src), this.options);
|
|
|
+ } else {
|
|
|
+ return new DummyImageContainer(imageData);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.isSVG = function(src) {
|
|
|
+ return src.substring(src.length - 3).toLowerCase() === "svg" || SVGContainer.prototype.isInline(src);
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.imageExists = function(images, src) {
|
|
|
+ return images.some(function(image) {
|
|
|
+ return image.src === src;
|
|
|
+ });
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.isSameOrigin = function(url) {
|
|
|
+ return (this.getOrigin(url) === this.origin);
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.getOrigin = function(url) {
|
|
|
+ var link = this.link || (this.link = document.createElement("a"));
|
|
|
+ link.href = url;
|
|
|
+ link.href = link.href;
|
|
|
+ return link.protocol + link.hostname + link.port;
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.getPromise = function(container) {
|
|
|
+ return this.timeout(container, this.options.imageTimeout)['catch'](function() {
|
|
|
+ var dummy = new DummyImageContainer(container.src);
|
|
|
+ return dummy.promise.then(function(image) {
|
|
|
+ container.image = image;
|
|
|
+ });
|
|
|
+ });
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.get = function(src) {
|
|
|
+ var found = null;
|
|
|
+ return this.images.some(function(img) {
|
|
|
+ return (found = img).src === src;
|
|
|
+ }) ? found : null;
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.fetch = function(nodes) {
|
|
|
+ this.images = nodes.reduce(bind(this.findBackgroundImage, this), this.findImages(nodes));
|
|
|
+ this.images.forEach(function(image, index) {
|
|
|
+ image.promise.then(function() {
|
|
|
+ log("Succesfully loaded image #"+ (index+1), image);
|
|
|
+ }, function(e) {
|
|
|
+ log("Failed loading image #"+ (index+1), image, e);
|
|
|
+ });
|
|
|
+ });
|
|
|
+ this.ready = Promise.all(this.images.map(this.getPromise, this));
|
|
|
+ log("Finished searching images");
|
|
|
+ return this;
|
|
|
+};
|
|
|
+
|
|
|
+ImageLoader.prototype.timeout = function(container, timeout) {
|
|
|
+ var timer;
|
|
|
+ var promise = Promise.race([container.promise, new Promise(function(res, reject) {
|
|
|
+ timer = setTimeout(function() {
|
|
|
+ log("Timed out loading image", container);
|
|
|
+ reject(container);
|
|
|
+ }, timeout);
|
|
|
+ })]).then(function(container) {
|
|
|
+ clearTimeout(timer);
|
|
|
+ return container;
|
|
|
+ });
|
|
|
+ promise['catch'](function() {
|
|
|
+ clearTimeout(timer);
|
|
|
+ });
|
|
|
+ return promise;
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = ImageLoader;
|
|
|
+
|
|
|
+},{"./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){
|
|
|
+var GradientContainer = _dereq_('./gradientcontainer');
|
|
|
+var Color = _dereq_('./color');
|
|
|
+
|
|
|
+function LinearGradientContainer(imageData) {
|
|
|
+ GradientContainer.apply(this, arguments);
|
|
|
+ this.type = GradientContainer.TYPES.LINEAR;
|
|
|
+
|
|
|
+ var hasDirection = LinearGradientContainer.REGEXP_DIRECTION.test( imageData.args[0] ) ||
|
|
|
+ !GradientContainer.REGEXP_COLORSTOP.test( imageData.args[0] );
|
|
|
+
|
|
|
+ if (hasDirection) {
|
|
|
+ imageData.args[0].split(/\s+/).reverse().forEach(function(position, index) {
|
|
|
+ switch(position) {
|
|
|
+ case "left":
|
|
|
+ this.x0 = 0;
|
|
|
+ this.x1 = 1;
|
|
|
+ break;
|
|
|
+ case "top":
|
|
|
+ this.y0 = 0;
|
|
|
+ this.y1 = 1;
|
|
|
+ break;
|
|
|
+ case "right":
|
|
|
+ this.x0 = 1;
|
|
|
+ this.x1 = 0;
|
|
|
+ break;
|
|
|
+ case "bottom":
|
|
|
+ this.y0 = 1;
|
|
|
+ this.y1 = 0;
|
|
|
+ break;
|
|
|
+ case "to":
|
|
|
+ var y0 = this.y0;
|
|
|
+ var x0 = this.x0;
|
|
|
+ this.y0 = this.y1;
|
|
|
+ this.x0 = this.x1;
|
|
|
+ this.x1 = x0;
|
|
|
+ this.y1 = y0;
|
|
|
+ break;
|
|
|
+ case "center":
|
|
|
+ break;
|
|
|
+
|
|
|
+
|
|
|
+ default:
|
|
|
+
|
|
|
+ var ratio = parseFloat(position, 10) * 1e-2;
|
|
|
+ if (isNaN(ratio)) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (index === 0) {
|
|
|
+ this.y0 = ratio;
|
|
|
+ this.y1 = 1 - this.y0;
|
|
|
+ } else {
|
|
|
+ this.x0 = ratio;
|
|
|
+ this.x1 = 1 - this.x0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+ } else {
|
|
|
+ this.y0 = 0;
|
|
|
+ this.y1 = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ this.colorStops = imageData.args.slice(hasDirection ? 1 : 0).map(function(colorStop) {
|
|
|
+ var colorStopMatch = colorStop.match(GradientContainer.REGEXP_COLORSTOP);
|
|
|
+ var value = +colorStopMatch[2];
|
|
|
+ var unit = value === 0 ? "%" : colorStopMatch[3];
|
|
|
+ return {
|
|
|
+ color: new Color(colorStopMatch[1]),
|
|
|
+
|
|
|
+ stop: unit === "%" ? value / 100 : null
|
|
|
+ };
|
|
|
+ });
|
|
|
+
|
|
|
+ if (this.colorStops[0].stop === null) {
|
|
|
+ this.colorStops[0].stop = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this.colorStops[this.colorStops.length - 1].stop === null) {
|
|
|
+ this.colorStops[this.colorStops.length - 1].stop = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ this.colorStops.forEach(function(colorStop, index) {
|
|
|
+ if (colorStop.stop === null) {
|
|
|
+ this.colorStops.slice(index).some(function(find, count) {
|
|
|
+ if (find.stop !== null) {
|
|
|
+ colorStop.stop = ((find.stop - this.colorStops[index - 1].stop) / (count + 1)) + this.colorStops[index - 1].stop;
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+}
|
|
|
+
|
|
|
+LinearGradientContainer.prototype = Object.create(GradientContainer.prototype);
|
|
|
+
|
|
|
+
|
|
|
+LinearGradientContainer.REGEXP_DIRECTION = /^\s*(?:to|left|right|top|bottom|center|\d{1,3}(?:\.\d+)?%?)(?:\s|$)/i;
|
|
|
+
|
|
|
+module.exports = LinearGradientContainer;
|
|
|
+
|
|
|
+},{"./color":3,"./gradientcontainer":9}],13:[function(_dereq_,module,exports){
|
|
|
+var logger = function() {
|
|
|
+ if (logger.options.logging && window.console && window.console.log) {
|
|
|
+ Function.prototype.bind.call(window.console.log, (window.console)).apply(window.console, [(Date.now() - logger.options.start) + "ms", "html2canvas:"].concat([].slice.call(arguments, 0)));
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+logger.options = {logging: false};
|
|
|
+module.exports = logger;
|
|
|
+
|
|
|
+},{}],14:[function(_dereq_,module,exports){
|
|
|
+var Color = _dereq_('./color');
|
|
|
+var utils = _dereq_('./utils');
|
|
|
+var getBounds = utils.getBounds;
|
|
|
+var parseBackgrounds = utils.parseBackgrounds;
|
|
|
+var offsetBounds = utils.offsetBounds;
|
|
|
+
|
|
|
+function NodeContainer(node, parent) {
|
|
|
+ this.node = node;
|
|
|
+ this.parent = parent;
|
|
|
+ this.stack = null;
|
|
|
+ this.bounds = null;
|
|
|
+ this.borders = null;
|
|
|
+ this.clip = [];
|
|
|
+ this.backgroundClip = [];
|
|
|
+ this.offsetBounds = null;
|
|
|
+ this.visible = null;
|
|
|
+ this.computedStyles = null;
|
|
|
+ this.colors = {};
|
|
|
+ this.styles = {};
|
|
|
+ this.backgroundImages = null;
|
|
|
+ this.transformData = null;
|
|
|
+ this.transformMatrix = null;
|
|
|
+ this.isPseudoElement = false;
|
|
|
+ this.opacity = null;
|
|
|
+}
|
|
|
+
|
|
|
+NodeContainer.prototype.cloneTo = function(stack) {
|
|
|
+ stack.visible = this.visible;
|
|
|
+ stack.borders = this.borders;
|
|
|
+ stack.bounds = this.bounds;
|
|
|
+ stack.clip = this.clip;
|
|
|
+ stack.backgroundClip = this.backgroundClip;
|
|
|
+ stack.computedStyles = this.computedStyles;
|
|
|
+ stack.styles = this.styles;
|
|
|
+ stack.backgroundImages = this.backgroundImages;
|
|
|
+ stack.opacity = this.opacity;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.getOpacity = function() {
|
|
|
+ return this.opacity === null ? (this.opacity = this.cssFloat('opacity')) : this.opacity;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.assignStack = function(stack) {
|
|
|
+ this.stack = stack;
|
|
|
+ stack.children.push(this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.isElementVisible = function() {
|
|
|
+ return this.node.nodeType === Node.TEXT_NODE ? this.parent.visible : (
|
|
|
+ this.css('display') !== "none" &&
|
|
|
+ this.css('visibility') !== "hidden" &&
|
|
|
+ !this.node.hasAttribute("data-html2canvas-ignore") &&
|
|
|
+ (this.node.nodeName !== "INPUT" || this.node.getAttribute("type") !== "hidden")
|
|
|
+ );
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.css = function(attribute) {
|
|
|
+ if (!this.computedStyles) {
|
|
|
+ this.computedStyles = this.isPseudoElement ? this.parent.computedStyle(this.before ? ":before" : ":after") : this.computedStyle(null);
|
|
|
+ }
|
|
|
+
|
|
|
+ return this.styles[attribute] || (this.styles[attribute] = this.computedStyles[attribute]);
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.prefixedCss = function(attribute) {
|
|
|
+ var prefixes = ["webkit", "moz", "ms", "o"];
|
|
|
+ var value = this.css(attribute);
|
|
|
+ if (value === undefined) {
|
|
|
+ prefixes.some(function(prefix) {
|
|
|
+ value = this.css(prefix + attribute.substr(0, 1).toUpperCase() + attribute.substr(1));
|
|
|
+ return value !== undefined;
|
|
|
+ }, this);
|
|
|
+ }
|
|
|
+ return value === undefined ? null : value;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.computedStyle = function(type) {
|
|
|
+ return this.node.ownerDocument.defaultView.getComputedStyle(this.node, type);
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.cssInt = function(attribute) {
|
|
|
+ var value = parseInt(this.css(attribute), 10);
|
|
|
+ return (isNaN(value)) ? 0 : value;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.color = function(attribute) {
|
|
|
+ return this.colors[attribute] || (this.colors[attribute] = new Color(this.css(attribute)));
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.cssFloat = function(attribute) {
|
|
|
+ var value = parseFloat(this.css(attribute));
|
|
|
+ return (isNaN(value)) ? 0 : value;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.fontWeight = function() {
|
|
|
+ var weight = this.css("fontWeight");
|
|
|
+ switch(parseInt(weight, 10)){
|
|
|
+ case 401:
|
|
|
+ weight = "bold";
|
|
|
+ break;
|
|
|
+ case 400:
|
|
|
+ weight = "normal";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return weight;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseClip = function() {
|
|
|
+ var matches = this.css('clip').match(this.CLIP);
|
|
|
+ if (matches) {
|
|
|
+ return {
|
|
|
+ top: parseInt(matches[1], 10),
|
|
|
+ right: parseInt(matches[2], 10),
|
|
|
+ bottom: parseInt(matches[3], 10),
|
|
|
+ left: parseInt(matches[4], 10)
|
|
|
+ };
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseBackgroundImages = function() {
|
|
|
+ return this.backgroundImages || (this.backgroundImages = parseBackgrounds(this.css("backgroundImage")));
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.cssList = function(property, index) {
|
|
|
+ var value = (this.css(property) || '').split(',');
|
|
|
+ value = value[index || 0] || value[0] || 'auto';
|
|
|
+ value = value.trim().split(' ');
|
|
|
+ if (value.length === 1) {
|
|
|
+ value = [value[0], isPercentage(value[0]) ? 'auto' : value[0]];
|
|
|
+ }
|
|
|
+ return value;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseBackgroundSize = function(bounds, image, index) {
|
|
|
+ var size = this.cssList("backgroundSize", index);
|
|
|
+ var width, height;
|
|
|
+
|
|
|
+ if (isPercentage(size[0])) {
|
|
|
+ width = bounds.width * parseFloat(size[0]) / 100;
|
|
|
+ } else if (/contain|cover/.test(size[0])) {
|
|
|
+ var targetRatio = bounds.width / bounds.height, currentRatio = image.width / image.height;
|
|
|
+ return (targetRatio < currentRatio ^ size[0] === 'contain') ? {width: bounds.height * currentRatio, height: bounds.height} : {width: bounds.width, height: bounds.width / currentRatio};
|
|
|
+ } else {
|
|
|
+ width = parseInt(size[0], 10);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (size[0] === 'auto' && size[1] === 'auto') {
|
|
|
+ height = image.height;
|
|
|
+ } else if (size[1] === 'auto') {
|
|
|
+ height = width / image.width * image.height;
|
|
|
+ } else if (isPercentage(size[1])) {
|
|
|
+ height = bounds.height * parseFloat(size[1]) / 100;
|
|
|
+ } else {
|
|
|
+ height = parseInt(size[1], 10);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (size[0] === 'auto') {
|
|
|
+ width = height / image.height * image.width;
|
|
|
+ }
|
|
|
+
|
|
|
+ return {width: width, height: height};
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseBackgroundPosition = function(bounds, image, index, backgroundSize) {
|
|
|
+ var position = this.cssList('backgroundPosition', index);
|
|
|
+ var left, top;
|
|
|
+
|
|
|
+ if (isPercentage(position[0])){
|
|
|
+ left = (bounds.width - (backgroundSize || image).width) * (parseFloat(position[0]) / 100);
|
|
|
+ } else {
|
|
|
+ left = parseInt(position[0], 10);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (position[1] === 'auto') {
|
|
|
+ top = left / image.width * image.height;
|
|
|
+ } else if (isPercentage(position[1])){
|
|
|
+ top = (bounds.height - (backgroundSize || image).height) * parseFloat(position[1]) / 100;
|
|
|
+ } else {
|
|
|
+ top = parseInt(position[1], 10);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (position[0] === 'auto') {
|
|
|
+ left = top / image.height * image.width;
|
|
|
+ }
|
|
|
+
|
|
|
+ return {left: left, top: top};
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseBackgroundRepeat = function(index) {
|
|
|
+ return this.cssList("backgroundRepeat", index)[0];
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseTextShadows = function() {
|
|
|
+ var textShadow = this.css("textShadow");
|
|
|
+ var results = [];
|
|
|
+
|
|
|
+ if (textShadow && textShadow !== 'none') {
|
|
|
+ var shadows = textShadow.match(this.TEXT_SHADOW_PROPERTY);
|
|
|
+ for (var i = 0; shadows && (i < shadows.length); i++) {
|
|
|
+ var s = shadows[i].match(this.TEXT_SHADOW_VALUES);
|
|
|
+ results.push({
|
|
|
+ color: new Color(s[0]),
|
|
|
+ offsetX: s[1] ? parseFloat(s[1].replace('px', '')) : 0,
|
|
|
+ offsetY: s[2] ? parseFloat(s[2].replace('px', '')) : 0,
|
|
|
+ blur: s[3] ? s[3].replace('px', '') : 0
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return results;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseTransform = function() {
|
|
|
+ if (!this.transformData) {
|
|
|
+ if (this.hasTransform()) {
|
|
|
+ var offset = this.parseBounds();
|
|
|
+ var origin = this.prefixedCss("transformOrigin").split(" ").map(removePx).map(asFloat);
|
|
|
+ origin[0] += offset.left;
|
|
|
+ origin[1] += offset.top;
|
|
|
+ this.transformData = {
|
|
|
+ origin: origin,
|
|
|
+ matrix: this.parseTransformMatrix()
|
|
|
+ };
|
|
|
+ } else {
|
|
|
+ this.transformData = {
|
|
|
+ origin: [0, 0],
|
|
|
+ matrix: [1, 0, 0, 1, 0, 0]
|
|
|
+ };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return this.transformData;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseTransformMatrix = function() {
|
|
|
+ if (!this.transformMatrix) {
|
|
|
+ var transform = this.prefixedCss("transform");
|
|
|
+ var matrix = transform ? parseMatrix(transform.match(this.MATRIX_PROPERTY)) : null;
|
|
|
+ this.transformMatrix = matrix ? matrix : [1, 0, 0, 1, 0, 0];
|
|
|
+ }
|
|
|
+ return this.transformMatrix;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.parseBounds = function() {
|
|
|
+ return this.bounds || (this.bounds = this.hasTransform() ? offsetBounds(this.node) : getBounds(this.node));
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.hasTransform = function() {
|
|
|
+ return this.parseTransformMatrix().join(",") !== "1,0,0,1,0,0" || (this.parent && this.parent.hasTransform());
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.getValue = function() {
|
|
|
+ var value = this.node.value || "";
|
|
|
+ if (this.node.tagName === "SELECT") {
|
|
|
+ value = selectionValue(this.node);
|
|
|
+ } else if (this.node.type === "password") {
|
|
|
+ value = Array(value.length + 1).join('\u2022');
|
|
|
+ }
|
|
|
+ return value.length === 0 ? (this.node.placeholder || "") : value;
|
|
|
+};
|
|
|
+
|
|
|
+NodeContainer.prototype.MATRIX_PROPERTY = /(matrix|matrix3d)\((.+)\)/;
|
|
|
+NodeContainer.prototype.TEXT_SHADOW_PROPERTY = /((rgba|rgb)\([^\)]+\)(\s-?\d+px){0,})/g;
|
|
|
+NodeContainer.prototype.TEXT_SHADOW_VALUES = /(-?\d+px)|(#.+)|(rgb\(.+\))|(rgba\(.+\))/g;
|
|
|
+NodeContainer.prototype.CLIP = /^rect\((\d+)px,? (\d+)px,? (\d+)px,? (\d+)px\)$/;
|
|
|
+
|
|
|
+function selectionValue(node) {
|
|
|
+ var option = node.options[node.selectedIndex || 0];
|
|
|
+ return option ? (option.text || "") : "";
|
|
|
+}
|
|
|
+
|
|
|
+function parseMatrix(match) {
|
|
|
+ if (match && match[1] === "matrix") {
|
|
|
+ return match[2].split(",").map(function(s) {
|
|
|
+ return parseFloat(s.trim());
|
|
|
+ });
|
|
|
+ } else if (match && match[1] === "matrix3d") {
|
|
|
+ var matrix3d = match[2].split(",").map(function(s) {
|
|
|
+ return parseFloat(s.trim());
|
|
|
+ });
|
|
|
+ return [matrix3d[0], matrix3d[1], matrix3d[4], matrix3d[5], matrix3d[12], matrix3d[13]];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function isPercentage(value) {
|
|
|
+ return value.toString().indexOf("%") !== -1;
|
|
|
+}
|
|
|
+
|
|
|
+function removePx(str) {
|
|
|
+ return str.replace("px", "");
|
|
|
+}
|
|
|
+
|
|
|
+function asFloat(str) {
|
|
|
+ return parseFloat(str);
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = NodeContainer;
|
|
|
+
|
|
|
+},{"./color":3,"./utils":26}],15:[function(_dereq_,module,exports){
|
|
|
+var log = _dereq_('./log');
|
|
|
+var punycode = _dereq_('punycode');
|
|
|
+var NodeContainer = _dereq_('./nodecontainer');
|
|
|
+var TextContainer = _dereq_('./textcontainer');
|
|
|
+var PseudoElementContainer = _dereq_('./pseudoelementcontainer');
|
|
|
+var FontMetrics = _dereq_('./fontmetrics');
|
|
|
+var Color = _dereq_('./color');
|
|
|
+var StackingContext = _dereq_('./stackingcontext');
|
|
|
+var utils = _dereq_('./utils');
|
|
|
+var bind = utils.bind;
|
|
|
+var getBounds = utils.getBounds;
|
|
|
+var parseBackgrounds = utils.parseBackgrounds;
|
|
|
+var offsetBounds = utils.offsetBounds;
|
|
|
+
|
|
|
+function NodeParser(element, renderer, support, imageLoader, options) {
|
|
|
+ log("Starting NodeParser");
|
|
|
+ this.renderer = renderer;
|
|
|
+ this.options = options;
|
|
|
+ this.range = null;
|
|
|
+ this.support = support;
|
|
|
+ this.renderQueue = [];
|
|
|
+ this.stack = new StackingContext(true, 1, element.ownerDocument, null);
|
|
|
+ var parent = new NodeContainer(element, null);
|
|
|
+ if (options.background) {
|
|
|
+ renderer.rectangle(0, 0, renderer.width, renderer.height, new Color(options.background));
|
|
|
+ }
|
|
|
+ if (element === element.ownerDocument.documentElement) {
|
|
|
+
|
|
|
+ var canvasBackground = new NodeContainer(parent.color('backgroundColor').isTransparent() ? element.ownerDocument.body : element.ownerDocument.documentElement, null);
|
|
|
+ renderer.rectangle(0, 0, renderer.width, renderer.height, canvasBackground.color('backgroundColor'));
|
|
|
+ }
|
|
|
+ parent.visibile = parent.isElementVisible();
|
|
|
+ this.createPseudoHideStyles(element.ownerDocument);
|
|
|
+ this.disableAnimations(element.ownerDocument);
|
|
|
+ this.nodes = flatten([parent].concat(this.getChildren(parent)).filter(function(container) {
|
|
|
+ return container.visible = container.isElementVisible();
|
|
|
+ }).map(this.getPseudoElements, this));
|
|
|
+ this.fontMetrics = new FontMetrics();
|
|
|
+ log("Fetched nodes, total:", this.nodes.length);
|
|
|
+ log("Calculate overflow clips");
|
|
|
+ this.calculateOverflowClips();
|
|
|
+ log("Start fetching images");
|
|
|
+ this.images = imageLoader.fetch(this.nodes.filter(isElement));
|
|
|
+ this.ready = this.images.ready.then(bind(function() {
|
|
|
+ log("Images loaded, starting parsing");
|
|
|
+ log("Creating stacking contexts");
|
|
|
+ this.createStackingContexts();
|
|
|
+ log("Sorting stacking contexts");
|
|
|
+ this.sortStackingContexts(this.stack);
|
|
|
+ this.parse(this.stack);
|
|
|
+ log("Render queue created with " + this.renderQueue.length + " items");
|
|
|
+ return new Promise(bind(function(resolve) {
|
|
|
+ if (!options.async) {
|
|
|
+ this.renderQueue.forEach(this.paint, this);
|
|
|
+ resolve();
|
|
|
+ } else if (typeof(options.async) === "function") {
|
|
|
+ options.async.call(this, this.renderQueue, resolve);
|
|
|
+ } else if (this.renderQueue.length > 0){
|
|
|
+ this.renderIndex = 0;
|
|
|
+ this.asyncRenderer(this.renderQueue, resolve);
|
|
|
+ } else {
|
|
|
+ resolve();
|
|
|
+ }
|
|
|
+ }, this));
|
|
|
+ }, this));
|
|
|
+}
|
|
|
+
|
|
|
+NodeParser.prototype.calculateOverflowClips = function() {
|
|
|
+ this.nodes.forEach(function(container) {
|
|
|
+ if (isElement(container)) {
|
|
|
+ if (isPseudoElement(container)) {
|
|
|
+ container.appendToDOM();
|
|
|
+ }
|
|
|
+ container.borders = this.parseBorders(container);
|
|
|
+ var clip = (container.css('overflow') === "hidden") ? [container.borders.clip] : [];
|
|
|
+ var cssClip = container.parseClip();
|
|
|
+ if (cssClip && ["absolute", "fixed"].indexOf(container.css('position')) !== -1) {
|
|
|
+ clip.push([["rect",
|
|
|
+ container.bounds.left + cssClip.left,
|
|
|
+ container.bounds.top + cssClip.top,
|
|
|
+ cssClip.right - cssClip.left,
|
|
|
+ cssClip.bottom - cssClip.top
|
|
|
+ ]]);
|
|
|
+ }
|
|
|
+ container.clip = hasParentClip(container) ? container.parent.clip.concat(clip) : clip;
|
|
|
+ container.backgroundClip = (container.css('overflow') !== "hidden") ? container.clip.concat([container.borders.clip]) : container.clip;
|
|
|
+ if (isPseudoElement(container)) {
|
|
|
+ container.cleanDOM();
|
|
|
+ }
|
|
|
+ } else if (isTextNode(container)) {
|
|
|
+ container.clip = hasParentClip(container) ? container.parent.clip : [];
|
|
|
+ }
|
|
|
+ if (!isPseudoElement(container)) {
|
|
|
+ container.bounds = null;
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+function hasParentClip(container) {
|
|
|
+ return container.parent && container.parent.clip.length;
|
|
|
+}
|
|
|
+
|
|
|
+NodeParser.prototype.asyncRenderer = function(queue, resolve, asyncTimer) {
|
|
|
+ asyncTimer = asyncTimer || Date.now();
|
|
|
+ this.paint(queue[this.renderIndex++]);
|
|
|
+ if (queue.length === this.renderIndex) {
|
|
|
+ resolve();
|
|
|
+ } else if (asyncTimer + 20 > Date.now()) {
|
|
|
+ this.asyncRenderer(queue, resolve, asyncTimer);
|
|
|
+ } else {
|
|
|
+ setTimeout(bind(function() {
|
|
|
+ this.asyncRenderer(queue, resolve);
|
|
|
+ }, this), 0);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.createPseudoHideStyles = function(document) {
|
|
|
+ this.createStyles(document, '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + ':before { content: "" !important; display: none !important; }' +
|
|
|
+ '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER + ':after { content: "" !important; display: none !important; }');
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.disableAnimations = function(document) {
|
|
|
+ this.createStyles(document, '* { -webkit-animation: none !important; -moz-animation: none !important; -o-animation: none !important; animation: none !important; ' +
|
|
|
+ '-webkit-transition: none !important; -moz-transition: none !important; -o-transition: none !important; transition: none !important;}');
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.createStyles = function(document, styles) {
|
|
|
+ var hidePseudoElements = document.createElement('style');
|
|
|
+ hidePseudoElements.innerHTML = styles;
|
|
|
+ document.body.appendChild(hidePseudoElements);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.getPseudoElements = function(container) {
|
|
|
+ var nodes = [[container]];
|
|
|
+ if (container.node.nodeType === Node.ELEMENT_NODE) {
|
|
|
+ var before = this.getPseudoElement(container, ":before");
|
|
|
+ var after = this.getPseudoElement(container, ":after");
|
|
|
+
|
|
|
+ if (before) {
|
|
|
+ nodes.push(before);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (after) {
|
|
|
+ nodes.push(after);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return flatten(nodes);
|
|
|
+};
|
|
|
+
|
|
|
+function toCamelCase(str) {
|
|
|
+ return str.replace(/(\-[a-z])/g, function(match){
|
|
|
+ return match.toUpperCase().replace('-','');
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+NodeParser.prototype.getPseudoElement = function(container, type) {
|
|
|
+ var style = container.computedStyle(type);
|
|
|
+ if(!style || !style.content || style.content === "none" || style.content === "-moz-alt-content" || style.display === "none") {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ var content = stripQuotes(style.content);
|
|
|
+ var isImage = content.substr(0, 3) === 'url';
|
|
|
+ var pseudoNode = document.createElement(isImage ? 'img' : 'html2canvaspseudoelement');
|
|
|
+ var pseudoContainer = new PseudoElementContainer(pseudoNode, container, type);
|
|
|
+
|
|
|
+ for (var i = style.length-1; i >= 0; i--) {
|
|
|
+ var property = toCamelCase(style.item(i));
|
|
|
+ pseudoNode.style[property] = style[property];
|
|
|
+ }
|
|
|
+
|
|
|
+ pseudoNode.className = PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + " " + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER;
|
|
|
+
|
|
|
+ if (isImage) {
|
|
|
+ pseudoNode.src = parseBackgrounds(content)[0].args[0];
|
|
|
+ return [pseudoContainer];
|
|
|
+ } else {
|
|
|
+ var text = document.createTextNode(content);
|
|
|
+ pseudoNode.appendChild(text);
|
|
|
+ return [pseudoContainer, new TextContainer(text, pseudoContainer)];
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+NodeParser.prototype.getChildren = function(parentContainer) {
|
|
|
+ return flatten([].filter.call(parentContainer.node.childNodes, renderableNode).map(function(node) {
|
|
|
+ var container = [node.nodeType === Node.TEXT_NODE ? new TextContainer(node, parentContainer) : new NodeContainer(node, parentContainer)].filter(nonIgnoredElement);
|
|
|
+ return node.nodeType === Node.ELEMENT_NODE && container.length && node.tagName !== "TEXTAREA" ? (container[0].isElementVisible() ? container.concat(this.getChildren(container[0])) : []) : container;
|
|
|
+ }, this));
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.newStackingContext = function(container, hasOwnStacking) {
|
|
|
+ var stack = new StackingContext(hasOwnStacking, container.getOpacity(), container.node, container.parent);
|
|
|
+ container.cloneTo(stack);
|
|
|
+ var parentStack = hasOwnStacking ? stack.getParentStack(this) : stack.parent.stack;
|
|
|
+ parentStack.contexts.push(stack);
|
|
|
+ container.stack = stack;
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.createStackingContexts = function() {
|
|
|
+ this.nodes.forEach(function(container) {
|
|
|
+ if (isElement(container) && (this.isRootElement(container) || hasOpacity(container) || isPositionedForStacking(container) || this.isBodyWithTransparentRoot(container) || container.hasTransform())) {
|
|
|
+ this.newStackingContext(container, true);
|
|
|
+ } else if (isElement(container) && ((isPositioned(container) && zIndex0(container)) || isInlineBlock(container) || isFloating(container))) {
|
|
|
+ this.newStackingContext(container, false);
|
|
|
+ } else {
|
|
|
+ container.assignStack(container.parent.stack);
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.isBodyWithTransparentRoot = function(container) {
|
|
|
+ return container.node.nodeName === "BODY" && container.parent.color('backgroundColor').isTransparent();
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.isRootElement = function(container) {
|
|
|
+ return container.parent === null;
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.sortStackingContexts = function(stack) {
|
|
|
+ stack.contexts.sort(zIndexSort(stack.contexts.slice(0)));
|
|
|
+ stack.contexts.forEach(this.sortStackingContexts, this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.parseTextBounds = function(container) {
|
|
|
+ return function(text, index, textList) {
|
|
|
+ if (container.parent.css("textDecoration").substr(0, 4) !== "none" || text.trim().length !== 0) {
|
|
|
+ if (this.support.rangeBounds && !container.parent.hasTransform()) {
|
|
|
+ var offset = textList.slice(0, index).join("").length;
|
|
|
+ return this.getRangeBounds(container.node, offset, text.length);
|
|
|
+ } else if (container.node && typeof(container.node.data) === "string") {
|
|
|
+ var replacementNode = container.node.splitText(text.length);
|
|
|
+ var bounds = this.getWrapperBounds(container.node, container.parent.hasTransform());
|
|
|
+ container.node = replacementNode;
|
|
|
+ return bounds;
|
|
|
+ }
|
|
|
+ } else if(!this.support.rangeBounds || container.parent.hasTransform()){
|
|
|
+ container.node = container.node.splitText(text.length);
|
|
|
+ }
|
|
|
+ return {};
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.getWrapperBounds = function(node, transform) {
|
|
|
+ var wrapper = node.ownerDocument.createElement('html2canvaswrapper');
|
|
|
+ var parent = node.parentNode,
|
|
|
+ backupText = node.cloneNode(true);
|
|
|
+
|
|
|
+ wrapper.appendChild(node.cloneNode(true));
|
|
|
+ parent.replaceChild(wrapper, node);
|
|
|
+ var bounds = transform ? offsetBounds(wrapper) : getBounds(wrapper);
|
|
|
+ parent.replaceChild(backupText, wrapper);
|
|
|
+ return bounds;
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.getRangeBounds = function(node, offset, length) {
|
|
|
+ var range = this.range || (this.range = node.ownerDocument.createRange());
|
|
|
+ range.setStart(node, offset);
|
|
|
+ range.setEnd(node, offset + length);
|
|
|
+ return range.getBoundingClientRect();
|
|
|
+};
|
|
|
+
|
|
|
+function ClearTransform() {}
|
|
|
+
|
|
|
+NodeParser.prototype.parse = function(stack) {
|
|
|
+
|
|
|
+ var negativeZindex = stack.contexts.filter(negativeZIndex);
|
|
|
+ var descendantElements = stack.children.filter(isElement);
|
|
|
+ var descendantNonFloats = descendantElements.filter(not(isFloating));
|
|
|
+ var nonInlineNonPositionedDescendants = descendantNonFloats.filter(not(isPositioned)).filter(not(inlineLevel));
|
|
|
+ var nonPositionedFloats = descendantElements.filter(not(isPositioned)).filter(isFloating);
|
|
|
+ var inFlow = descendantNonFloats.filter(not(isPositioned)).filter(inlineLevel);
|
|
|
+ var stackLevel0 = stack.contexts.concat(descendantNonFloats.filter(isPositioned)).filter(zIndex0);
|
|
|
+ var text = stack.children.filter(isTextNode).filter(hasText);
|
|
|
+ var positiveZindex = stack.contexts.filter(positiveZIndex);
|
|
|
+ negativeZindex.concat(nonInlineNonPositionedDescendants).concat(nonPositionedFloats)
|
|
|
+ .concat(inFlow).concat(stackLevel0).concat(text).concat(positiveZindex).forEach(function(container) {
|
|
|
+ this.renderQueue.push(container);
|
|
|
+ if (isStackingContext(container)) {
|
|
|
+ this.parse(container);
|
|
|
+ this.renderQueue.push(new ClearTransform());
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.paint = function(container) {
|
|
|
+ try {
|
|
|
+ if (container instanceof ClearTransform) {
|
|
|
+ this.renderer.ctx.restore();
|
|
|
+ } else if (isTextNode(container)) {
|
|
|
+ if (isPseudoElement(container.parent)) {
|
|
|
+ container.parent.appendToDOM();
|
|
|
+ }
|
|
|
+ this.paintText(container);
|
|
|
+ if (isPseudoElement(container.parent)) {
|
|
|
+ container.parent.cleanDOM();
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ this.paintNode(container);
|
|
|
+ }
|
|
|
+ } catch(e) {
|
|
|
+ log(e);
|
|
|
+ if (this.options.strict) {
|
|
|
+ throw e;
|
|
|
+ }
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.paintNode = function(container) {
|
|
|
+ if (isStackingContext(container)) {
|
|
|
+ this.renderer.setOpacity(container.opacity);
|
|
|
+ this.renderer.ctx.save();
|
|
|
+ if (container.hasTransform()) {
|
|
|
+ this.renderer.setTransform(container.parseTransform());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (container.node.nodeName === "INPUT" && container.node.type === "checkbox") {
|
|
|
+ this.paintCheckbox(container);
|
|
|
+ } else if (container.node.nodeName === "INPUT" && container.node.type === "radio") {
|
|
|
+ this.paintRadio(container);
|
|
|
+ } else {
|
|
|
+ this.paintElement(container);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.paintElement = function(container) {
|
|
|
+ var bounds = container.parseBounds();
|
|
|
+ this.renderer.clip(container.backgroundClip, function() {
|
|
|
+ this.renderer.renderBackground(container, bounds, container.borders.borders.map(getWidth));
|
|
|
+ }, this);
|
|
|
+
|
|
|
+ this.renderer.clip(container.clip, function() {
|
|
|
+ this.renderer.renderBorders(container.borders.borders);
|
|
|
+ }, this);
|
|
|
+
|
|
|
+ this.renderer.clip(container.backgroundClip, function() {
|
|
|
+ switch (container.node.nodeName) {
|
|
|
+ case "svg":
|
|
|
+ case "IFRAME":
|
|
|
+ var imgContainer = this.images.get(container.node);
|
|
|
+ if (imgContainer) {
|
|
|
+ this.renderer.renderImage(container, bounds, container.borders, imgContainer);
|
|
|
+ } else {
|
|
|
+ log("Error loading <" + container.node.nodeName + ">", container.node);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case "IMG":
|
|
|
+ var imageContainer = this.images.get(container.node.src);
|
|
|
+ if (imageContainer) {
|
|
|
+ this.renderer.renderImage(container, bounds, container.borders, imageContainer);
|
|
|
+ } else {
|
|
|
+ log("Error loading <img>", container.node.src);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case "CANVAS":
|
|
|
+ this.renderer.renderImage(container, bounds, container.borders, {image: container.node});
|
|
|
+ break;
|
|
|
+ case "SELECT":
|
|
|
+ case "INPUT":
|
|
|
+ case "TEXTAREA":
|
|
|
+ this.paintFormValue(container);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.paintCheckbox = function(container) {
|
|
|
+ var b = container.parseBounds();
|
|
|
+
|
|
|
+ var size = Math.min(b.width, b.height);
|
|
|
+ var bounds = {width: size - 1, height: size - 1, top: b.top, left: b.left};
|
|
|
+ var r = [3, 3];
|
|
|
+ var radius = [r, r, r, r];
|
|
|
+ var borders = [1,1,1,1].map(function(w) {
|
|
|
+ return {color: new Color('#A5A5A5'), width: w};
|
|
|
+ });
|
|
|
+
|
|
|
+ var borderPoints = calculateCurvePoints(bounds, radius, borders);
|
|
|
+
|
|
|
+ this.renderer.clip(container.backgroundClip, function() {
|
|
|
+ this.renderer.rectangle(bounds.left + 1, bounds.top + 1, bounds.width - 2, bounds.height - 2, new Color("#DEDEDE"));
|
|
|
+ this.renderer.renderBorders(calculateBorders(borders, bounds, borderPoints, radius));
|
|
|
+ if (container.node.checked) {
|
|
|
+ this.renderer.font(new Color('#424242'), 'normal', 'normal', 'bold', (size - 3) + "px", 'arial');
|
|
|
+ this.renderer.text("\u2714", bounds.left + size / 6, bounds.top + size - 1);
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.paintRadio = function(container) {
|
|
|
+ var bounds = container.parseBounds();
|
|
|
+
|
|
|
+ var size = Math.min(bounds.width, bounds.height) - 2;
|
|
|
+
|
|
|
+ this.renderer.clip(container.backgroundClip, function() {
|
|
|
+ this.renderer.circleStroke(bounds.left + 1, bounds.top + 1, size, new Color('#DEDEDE'), 1, new Color('#A5A5A5'));
|
|
|
+ if (container.node.checked) {
|
|
|
+ this.renderer.circle(Math.ceil(bounds.left + size / 4) + 1, Math.ceil(bounds.top + size / 4) + 1, Math.floor(size / 2), new Color('#424242'));
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.paintFormValue = function(container) {
|
|
|
+ var value = container.getValue();
|
|
|
+ if (value.length > 0) {
|
|
|
+ var document = container.node.ownerDocument;
|
|
|
+ var wrapper = document.createElement('html2canvaswrapper');
|
|
|
+ var properties = ['lineHeight', 'textAlign', 'fontFamily', 'fontWeight', 'fontSize', 'color',
|
|
|
+ 'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom',
|
|
|
+ 'width', 'height', 'borderLeftStyle', 'borderTopStyle', 'borderLeftWidth', 'borderTopWidth',
|
|
|
+ 'boxSizing', 'whiteSpace', 'wordWrap'];
|
|
|
+
|
|
|
+ properties.forEach(function(property) {
|
|
|
+ try {
|
|
|
+ wrapper.style[property] = container.css(property);
|
|
|
+ } catch(e) {
|
|
|
+
|
|
|
+ log("html2canvas: Parse: Exception caught in renderFormValue: " + e.message);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var bounds = container.parseBounds();
|
|
|
+ wrapper.style.position = "fixed";
|
|
|
+ wrapper.style.left = bounds.left + "px";
|
|
|
+ wrapper.style.top = bounds.top + "px";
|
|
|
+ wrapper.textContent = value;
|
|
|
+ document.body.appendChild(wrapper);
|
|
|
+ this.paintText(new TextContainer(wrapper.firstChild, container));
|
|
|
+ document.body.removeChild(wrapper);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.paintText = function(container) {
|
|
|
+ container.applyTextTransform();
|
|
|
+ var characters = punycode.ucs2.decode(container.node.data);
|
|
|
+ var textList = (!this.options.letterRendering || noLetterSpacing(container)) && !hasUnicode(container.node.data) ? getWords(characters) : characters.map(function(character) {
|
|
|
+ return punycode.ucs2.encode([character]);
|
|
|
+ });
|
|
|
+
|
|
|
+ var weight = container.parent.fontWeight();
|
|
|
+ var size = container.parent.css('fontSize');
|
|
|
+ var family = container.parent.css('fontFamily');
|
|
|
+ var shadows = container.parent.parseTextShadows();
|
|
|
+
|
|
|
+ this.renderer.font(container.parent.color('color'), container.parent.css('fontStyle'), container.parent.css('fontVariant'), weight, size, family);
|
|
|
+ if (shadows.length) {
|
|
|
+
|
|
|
+ this.renderer.fontShadow(shadows[0].color, shadows[0].offsetX, shadows[0].offsetY, shadows[0].blur);
|
|
|
+ } else {
|
|
|
+ this.renderer.clearShadow();
|
|
|
+ }
|
|
|
+
|
|
|
+ this.renderer.clip(container.parent.clip, function() {
|
|
|
+ textList.map(this.parseTextBounds(container), this).forEach(function(bounds, index) {
|
|
|
+ if (bounds) {
|
|
|
+ this.renderer.text(textList[index], bounds.left, bounds.bottom);
|
|
|
+ this.renderTextDecoration(container.parent, bounds, this.fontMetrics.getMetrics(family, size));
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.renderTextDecoration = function(container, bounds, metrics) {
|
|
|
+ switch(container.css("textDecoration").split(" ")[0]) {
|
|
|
+ case "underline":
|
|
|
+
|
|
|
+
|
|
|
+ this.renderer.rectangle(bounds.left, Math.round(bounds.top + metrics.baseline + metrics.lineWidth), bounds.width, 1, container.color("color"));
|
|
|
+ break;
|
|
|
+ case "overline":
|
|
|
+ this.renderer.rectangle(bounds.left, Math.round(bounds.top), bounds.width, 1, container.color("color"));
|
|
|
+ break;
|
|
|
+ case "line-through":
|
|
|
+
|
|
|
+ this.renderer.rectangle(bounds.left, Math.ceil(bounds.top + metrics.middle + metrics.lineWidth), bounds.width, 1, container.color("color"));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+var borderColorTransforms = {
|
|
|
+ inset: [
|
|
|
+ ["darken", 0.60],
|
|
|
+ ["darken", 0.10],
|
|
|
+ ["darken", 0.10],
|
|
|
+ ["darken", 0.60]
|
|
|
+ ]
|
|
|
+};
|
|
|
+
|
|
|
+NodeParser.prototype.parseBorders = function(container) {
|
|
|
+ var nodeBounds = container.parseBounds();
|
|
|
+ var radius = getBorderRadiusData(container);
|
|
|
+ var borders = ["Top", "Right", "Bottom", "Left"].map(function(side, index) {
|
|
|
+ var style = container.css('border' + side + 'Style');
|
|
|
+ var color = container.color('border' + side + 'Color');
|
|
|
+ if (style === "inset" && color.isBlack()) {
|
|
|
+ color = new Color([255, 255, 255, color.a]);
|
|
|
+ }
|
|
|
+ var colorTransform = borderColorTransforms[style] ? borderColorTransforms[style][index] : null;
|
|
|
+ return {
|
|
|
+ width: container.cssInt('border' + side + 'Width'),
|
|
|
+ color: colorTransform ? color[colorTransform[0]](colorTransform[1]) : color,
|
|
|
+ args: null
|
|
|
+ };
|
|
|
+ });
|
|
|
+ var borderPoints = calculateCurvePoints(nodeBounds, radius, borders);
|
|
|
+
|
|
|
+ return {
|
|
|
+ clip: this.parseBackgroundClip(container, borderPoints, borders, radius, nodeBounds),
|
|
|
+ borders: calculateBorders(borders, nodeBounds, borderPoints, radius)
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+function calculateBorders(borders, nodeBounds, borderPoints, radius) {
|
|
|
+ return borders.map(function(border, borderSide) {
|
|
|
+ if (border.width > 0) {
|
|
|
+ var bx = nodeBounds.left;
|
|
|
+ var by = nodeBounds.top;
|
|
|
+ var bw = nodeBounds.width;
|
|
|
+ var bh = nodeBounds.height - (borders[2].width);
|
|
|
+
|
|
|
+ switch(borderSide) {
|
|
|
+ case 0:
|
|
|
+
|
|
|
+ bh = borders[0].width;
|
|
|
+ border.args = drawSide({
|
|
|
+ c1: [bx, by],
|
|
|
+ c2: [bx + bw, by],
|
|
|
+ c3: [bx + bw - borders[1].width, by + bh],
|
|
|
+ c4: [bx + borders[3].width, by + bh]
|
|
|
+ }, radius[0], radius[1],
|
|
|
+ borderPoints.topLeftOuter, borderPoints.topLeftInner, borderPoints.topRightOuter, borderPoints.topRightInner);
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+
|
|
|
+ bx = nodeBounds.left + nodeBounds.width - (borders[1].width);
|
|
|
+ bw = borders[1].width;
|
|
|
+
|
|
|
+ border.args = drawSide({
|
|
|
+ c1: [bx + bw, by],
|
|
|
+ c2: [bx + bw, by + bh + borders[2].width],
|
|
|
+ c3: [bx, by + bh],
|
|
|
+ c4: [bx, by + borders[0].width]
|
|
|
+ }, radius[1], radius[2],
|
|
|
+ borderPoints.topRightOuter, borderPoints.topRightInner, borderPoints.bottomRightOuter, borderPoints.bottomRightInner);
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+
|
|
|
+ by = (by + nodeBounds.height) - (borders[2].width);
|
|
|
+ bh = borders[2].width;
|
|
|
+ border.args = drawSide({
|
|
|
+ c1: [bx + bw, by + bh],
|
|
|
+ c2: [bx, by + bh],
|
|
|
+ c3: [bx + borders[3].width, by],
|
|
|
+ c4: [bx + bw - borders[3].width, by]
|
|
|
+ }, radius[2], radius[3],
|
|
|
+ borderPoints.bottomRightOuter, borderPoints.bottomRightInner, borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner);
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+
|
|
|
+ bw = borders[3].width;
|
|
|
+ border.args = drawSide({
|
|
|
+ c1: [bx, by + bh + borders[2].width],
|
|
|
+ c2: [bx, by],
|
|
|
+ c3: [bx + bw, by + borders[0].width],
|
|
|
+ c4: [bx + bw, by + bh]
|
|
|
+ }, radius[3], radius[0],
|
|
|
+ borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner, borderPoints.topLeftOuter, borderPoints.topLeftInner);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return border;
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+NodeParser.prototype.parseBackgroundClip = function(container, borderPoints, borders, radius, bounds) {
|
|
|
+ var backgroundClip = container.css('backgroundClip'),
|
|
|
+ borderArgs = [];
|
|
|
+
|
|
|
+ switch(backgroundClip) {
|
|
|
+ case "content-box":
|
|
|
+ case "padding-box":
|
|
|
+ parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftInner, borderPoints.topRightInner, bounds.left + borders[3].width, bounds.top + borders[0].width);
|
|
|
+ parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightInner, borderPoints.bottomRightInner, bounds.left + bounds.width - borders[1].width, bounds.top + borders[0].width);
|
|
|
+ parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightInner, borderPoints.bottomLeftInner, bounds.left + bounds.width - borders[1].width, bounds.top + bounds.height - borders[2].width);
|
|
|
+ parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftInner, borderPoints.topLeftInner, bounds.left + borders[3].width, bounds.top + bounds.height - borders[2].width);
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftOuter, borderPoints.topRightOuter, bounds.left, bounds.top);
|
|
|
+ parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightOuter, borderPoints.bottomRightOuter, bounds.left + bounds.width, bounds.top);
|
|
|
+ parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightOuter, borderPoints.bottomLeftOuter, bounds.left + bounds.width, bounds.top + bounds.height);
|
|
|
+ parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftOuter, borderPoints.topLeftOuter, bounds.left, bounds.top + bounds.height);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return borderArgs;
|
|
|
+};
|
|
|
+
|
|
|
+function getCurvePoints(x, y, r1, r2) {
|
|
|
+ var kappa = 4 * ((Math.sqrt(2) - 1) / 3);
|
|
|
+ var ox = (r1) * kappa,
|
|
|
+ oy = (r2) * kappa,
|
|
|
+ xm = x + r1,
|
|
|
+ ym = y + r2;
|
|
|
+ return {
|
|
|
+ topLeft: bezierCurve({x: x, y: ym}, {x: x, y: ym - oy}, {x: xm - ox, y: y}, {x: xm, y: y}),
|
|
|
+ topRight: bezierCurve({x: x, y: y}, {x: x + ox,y: y}, {x: xm, y: ym - oy}, {x: xm, y: ym}),
|
|
|
+ bottomRight: bezierCurve({x: xm, y: y}, {x: xm, y: y + oy}, {x: x + ox, y: ym}, {x: x, y: ym}),
|
|
|
+ bottomLeft: bezierCurve({x: xm, y: ym}, {x: xm - ox, y: ym}, {x: x, y: y + oy}, {x: x, y:y})
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+function calculateCurvePoints(bounds, borderRadius, borders) {
|
|
|
+ var x = bounds.left,
|
|
|
+ y = bounds.top,
|
|
|
+ width = bounds.width,
|
|
|
+ height = bounds.height,
|
|
|
+
|
|
|
+ tlh = borderRadius[0][0] < width / 2 ? borderRadius[0][0] : width / 2,
|
|
|
+ tlv = borderRadius[0][1] < height / 2 ? borderRadius[0][1] : height / 2,
|
|
|
+ trh = borderRadius[1][0] < width / 2 ? borderRadius[1][0] : width / 2,
|
|
|
+ trv = borderRadius[1][1] < height / 2 ? borderRadius[1][1] : height / 2,
|
|
|
+ brh = borderRadius[2][0] < width / 2 ? borderRadius[2][0] : width / 2,
|
|
|
+ brv = borderRadius[2][1] < height / 2 ? borderRadius[2][1] : height / 2,
|
|
|
+ blh = borderRadius[3][0] < width / 2 ? borderRadius[3][0] : width / 2,
|
|
|
+ blv = borderRadius[3][1] < height / 2 ? borderRadius[3][1] : height / 2;
|
|
|
+
|
|
|
+ var topWidth = width - trh,
|
|
|
+ rightHeight = height - brv,
|
|
|
+ bottomWidth = width - brh,
|
|
|
+ leftHeight = height - blv;
|
|
|
+
|
|
|
+ return {
|
|
|
+ topLeftOuter: getCurvePoints(x, y, tlh, tlv).topLeft.subdivide(0.5),
|
|
|
+ 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),
|
|
|
+ topRightOuter: getCurvePoints(x + topWidth, y, trh, trv).topRight.subdivide(0.5),
|
|
|
+ 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),
|
|
|
+ bottomRightOuter: getCurvePoints(x + bottomWidth, y + rightHeight, brh, brv).bottomRight.subdivide(0.5),
|
|
|
+ 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),
|
|
|
+ bottomLeftOuter: getCurvePoints(x, y + leftHeight, blh, blv).bottomLeft.subdivide(0.5),
|
|
|
+ bottomLeftInner: getCurvePoints(x + borders[3].width, y + leftHeight, Math.max(0, blh - borders[3].width), blv - borders[2].width).bottomLeft.subdivide(0.5)
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+function bezierCurve(start, startControl, endControl, end) {
|
|
|
+ var lerp = function (a, b, t) {
|
|
|
+ return {
|
|
|
+ x: a.x + (b.x - a.x) * t,
|
|
|
+ y: a.y + (b.y - a.y) * t
|
|
|
+ };
|
|
|
+ };
|
|
|
+
|
|
|
+ return {
|
|
|
+ start: start,
|
|
|
+ startControl: startControl,
|
|
|
+ endControl: endControl,
|
|
|
+ end: end,
|
|
|
+ subdivide: function(t) {
|
|
|
+ var ab = lerp(start, startControl, t),
|
|
|
+ bc = lerp(startControl, endControl, t),
|
|
|
+ cd = lerp(endControl, end, t),
|
|
|
+ abbc = lerp(ab, bc, t),
|
|
|
+ bccd = lerp(bc, cd, t),
|
|
|
+ dest = lerp(abbc, bccd, t);
|
|
|
+ return [bezierCurve(start, ab, abbc, dest), bezierCurve(dest, bccd, cd, end)];
|
|
|
+ },
|
|
|
+ curveTo: function(borderArgs) {
|
|
|
+ borderArgs.push(["bezierCurve", startControl.x, startControl.y, endControl.x, endControl.y, end.x, end.y]);
|
|
|
+ },
|
|
|
+ curveToReversed: function(borderArgs) {
|
|
|
+ borderArgs.push(["bezierCurve", endControl.x, endControl.y, startControl.x, startControl.y, start.x, start.y]);
|
|
|
+ }
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+function drawSide(borderData, radius1, radius2, outer1, inner1, outer2, inner2) {
|
|
|
+ var borderArgs = [];
|
|
|
+
|
|
|
+ if (radius1[0] > 0 || radius1[1] > 0) {
|
|
|
+ borderArgs.push(["line", outer1[1].start.x, outer1[1].start.y]);
|
|
|
+ outer1[1].curveTo(borderArgs);
|
|
|
+ } else {
|
|
|
+ borderArgs.push([ "line", borderData.c1[0], borderData.c1[1]]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (radius2[0] > 0 || radius2[1] > 0) {
|
|
|
+ borderArgs.push(["line", outer2[0].start.x, outer2[0].start.y]);
|
|
|
+ outer2[0].curveTo(borderArgs);
|
|
|
+ borderArgs.push(["line", inner2[0].end.x, inner2[0].end.y]);
|
|
|
+ inner2[0].curveToReversed(borderArgs);
|
|
|
+ } else {
|
|
|
+ borderArgs.push(["line", borderData.c2[0], borderData.c2[1]]);
|
|
|
+ borderArgs.push(["line", borderData.c3[0], borderData.c3[1]]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (radius1[0] > 0 || radius1[1] > 0) {
|
|
|
+ borderArgs.push(["line", inner1[1].end.x, inner1[1].end.y]);
|
|
|
+ inner1[1].curveToReversed(borderArgs);
|
|
|
+ } else {
|
|
|
+ borderArgs.push(["line", borderData.c4[0], borderData.c4[1]]);
|
|
|
+ }
|
|
|
+
|
|
|
+ return borderArgs;
|
|
|
+}
|
|
|
+
|
|
|
+function parseCorner(borderArgs, radius1, radius2, corner1, corner2, x, y) {
|
|
|
+ if (radius1[0] > 0 || radius1[1] > 0) {
|
|
|
+ borderArgs.push(["line", corner1[0].start.x, corner1[0].start.y]);
|
|
|
+ corner1[0].curveTo(borderArgs);
|
|
|
+ corner1[1].curveTo(borderArgs);
|
|
|
+ } else {
|
|
|
+ borderArgs.push(["line", x, y]);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (radius2[0] > 0 || radius2[1] > 0) {
|
|
|
+ borderArgs.push(["line", corner2[0].start.x, corner2[0].start.y]);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function negativeZIndex(container) {
|
|
|
+ return container.cssInt("zIndex") < 0;
|
|
|
+}
|
|
|
+
|
|
|
+function positiveZIndex(container) {
|
|
|
+ return container.cssInt("zIndex") > 0;
|
|
|
+}
|
|
|
+
|
|
|
+function zIndex0(container) {
|
|
|
+ return container.cssInt("zIndex") === 0;
|
|
|
+}
|
|
|
+
|
|
|
+function inlineLevel(container) {
|
|
|
+ return ["inline", "inline-block", "inline-table"].indexOf(container.css("display")) !== -1;
|
|
|
+}
|
|
|
+
|
|
|
+function isStackingContext(container) {
|
|
|
+ return (container instanceof StackingContext);
|
|
|
+}
|
|
|
+
|
|
|
+function hasText(container) {
|
|
|
+ return container.node.data.trim().length > 0;
|
|
|
+}
|
|
|
+
|
|
|
+function noLetterSpacing(container) {
|
|
|
+ return (/^(normal|none|0px)$/.test(container.parent.css("letterSpacing")));
|
|
|
+}
|
|
|
+
|
|
|
+function getBorderRadiusData(container) {
|
|
|
+ return ["TopLeft", "TopRight", "BottomRight", "BottomLeft"].map(function(side) {
|
|
|
+ var value = container.css('border' + side + 'Radius');
|
|
|
+ var arr = value.split(" ");
|
|
|
+ if (arr.length <= 1) {
|
|
|
+ arr[1] = arr[0];
|
|
|
+ }
|
|
|
+ return arr.map(asInt);
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+function renderableNode(node) {
|
|
|
+ return (node.nodeType === Node.TEXT_NODE || node.nodeType === Node.ELEMENT_NODE);
|
|
|
+}
|
|
|
+
|
|
|
+function isPositionedForStacking(container) {
|
|
|
+ var position = container.css("position");
|
|
|
+ var zIndex = (["absolute", "relative", "fixed"].indexOf(position) !== -1) ? container.css("zIndex") : "auto";
|
|
|
+ return zIndex !== "auto";
|
|
|
+}
|
|
|
+
|
|
|
+function isPositioned(container) {
|
|
|
+ return container.css("position") !== "static";
|
|
|
+}
|
|
|
+
|
|
|
+function isFloating(container) {
|
|
|
+ return container.css("float") !== "none";
|
|
|
+}
|
|
|
+
|
|
|
+function isInlineBlock(container) {
|
|
|
+ return ["inline-block", "inline-table"].indexOf(container.css("display")) !== -1;
|
|
|
+}
|
|
|
+
|
|
|
+function not(callback) {
|
|
|
+ var context = this;
|
|
|
+ return function() {
|
|
|
+ return !callback.apply(context, arguments);
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+function isElement(container) {
|
|
|
+ return container.node.nodeType === Node.ELEMENT_NODE;
|
|
|
+}
|
|
|
+
|
|
|
+function isPseudoElement(container) {
|
|
|
+ return container.isPseudoElement === true;
|
|
|
+}
|
|
|
+
|
|
|
+function isTextNode(container) {
|
|
|
+ return container.node.nodeType === Node.TEXT_NODE;
|
|
|
+}
|
|
|
+
|
|
|
+function zIndexSort(contexts) {
|
|
|
+ return function(a, b) {
|
|
|
+ return (a.cssInt("zIndex") + (contexts.indexOf(a) / contexts.length)) - (b.cssInt("zIndex") + (contexts.indexOf(b) / contexts.length));
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+function hasOpacity(container) {
|
|
|
+ return container.getOpacity() < 1;
|
|
|
+}
|
|
|
+
|
|
|
+function asInt(value) {
|
|
|
+ return parseInt(value, 10);
|
|
|
+}
|
|
|
+
|
|
|
+function getWidth(border) {
|
|
|
+ return border.width;
|
|
|
+}
|
|
|
+
|
|
|
+function nonIgnoredElement(nodeContainer) {
|
|
|
+ return (nodeContainer.node.nodeType !== Node.ELEMENT_NODE || ["SCRIPT", "HEAD", "TITLE", "OBJECT", "BR", "OPTION"].indexOf(nodeContainer.node.nodeName) === -1);
|
|
|
+}
|
|
|
+
|
|
|
+function flatten(arrays) {
|
|
|
+ return [].concat.apply([], arrays);
|
|
|
+}
|
|
|
+
|
|
|
+function stripQuotes(content) {
|
|
|
+ var first = content.substr(0, 1);
|
|
|
+ return (first === content.substr(content.length - 1) && first.match(/'|"/)) ? content.substr(1, content.length - 2) : content;
|
|
|
+}
|
|
|
+
|
|
|
+function getWords(characters) {
|
|
|
+ var words = [], i = 0, onWordBoundary = false, word;
|
|
|
+ while(characters.length) {
|
|
|
+ if (isWordBoundary(characters[i]) === onWordBoundary) {
|
|
|
+ word = characters.splice(0, i);
|
|
|
+ if (word.length) {
|
|
|
+ words.push(punycode.ucs2.encode(word));
|
|
|
+ }
|
|
|
+ onWordBoundary =! onWordBoundary;
|
|
|
+ i = 0;
|
|
|
+ } else {
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (i >= characters.length) {
|
|
|
+ word = characters.splice(0, i);
|
|
|
+ if (word.length) {
|
|
|
+ words.push(punycode.ucs2.encode(word));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return words;
|
|
|
+}
|
|
|
+
|
|
|
+function isWordBoundary(characterCode) {
|
|
|
+ return [
|
|
|
+ 32,
|
|
|
+ 13,
|
|
|
+ 10,
|
|
|
+ 9,
|
|
|
+ 45
|
|
|
+ ].indexOf(characterCode) !== -1;
|
|
|
+}
|
|
|
+
|
|
|
+function hasUnicode(string) {
|
|
|
+ return (/[^\u0000-\u00ff]/).test(string);
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = NodeParser;
|
|
|
+
|
|
|
+},{"./color":3,"./fontmetrics":7,"./log":13,"./nodecontainer":14,"./pseudoelementcontainer":18,"./stackingcontext":21,"./textcontainer":25,"./utils":26,"punycode":1}],16:[function(_dereq_,module,exports){
|
|
|
+var XHR = _dereq_('./xhr');
|
|
|
+var utils = _dereq_('./utils');
|
|
|
+var log = _dereq_('./log');
|
|
|
+var createWindowClone = _dereq_('./clone');
|
|
|
+var decode64 = utils.decode64;
|
|
|
+
|
|
|
+function Proxy(src, proxyUrl, document) {
|
|
|
+ var supportsCORS = ('withCredentials' in new XMLHttpRequest());
|
|
|
+ if (!proxyUrl) {
|
|
|
+ return Promise.reject("No proxy configured");
|
|
|
+ }
|
|
|
+ var callback = createCallback(supportsCORS);
|
|
|
+ var url = createProxyUrl(proxyUrl, src, callback);
|
|
|
+
|
|
|
+ return supportsCORS ? XHR(url) : (jsonp(document, url, callback).then(function(response) {
|
|
|
+ return decode64(response.content);
|
|
|
+ }));
|
|
|
+}
|
|
|
+var proxyCount = 0;
|
|
|
+
|
|
|
+function ProxyURL(src, proxyUrl, document) {
|
|
|
+ var supportsCORSImage = ('crossOrigin' in new Image());
|
|
|
+ var callback = createCallback(supportsCORSImage);
|
|
|
+ var url = createProxyUrl(proxyUrl, src, callback);
|
|
|
+ return (supportsCORSImage ? Promise.resolve(url) : jsonp(document, url, callback).then(function(response) {
|
|
|
+ return "data:" + response.type + ";base64," + response.content;
|
|
|
+ }));
|
|
|
+}
|
|
|
+
|
|
|
+function jsonp(document, url, callback) {
|
|
|
+ return new Promise(function(resolve, reject) {
|
|
|
+ var s = document.createElement("script");
|
|
|
+ var cleanup = function() {
|
|
|
+ delete window.html2canvas.proxy[callback];
|
|
|
+ document.body.removeChild(s);
|
|
|
+ };
|
|
|
+ window.html2canvas.proxy[callback] = function(response) {
|
|
|
+ cleanup();
|
|
|
+ resolve(response);
|
|
|
+ };
|
|
|
+ s.src = url;
|
|
|
+ s.onerror = function(e) {
|
|
|
+ cleanup();
|
|
|
+ reject(e);
|
|
|
+ };
|
|
|
+ document.body.appendChild(s);
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+function createCallback(useCORS) {
|
|
|
+ return !useCORS ? "html2canvas_" + Date.now() + "_" + (++proxyCount) + "_" + Math.round(Math.random() * 100000) : "";
|
|
|
+}
|
|
|
+
|
|
|
+function createProxyUrl(proxyUrl, src, callback) {
|
|
|
+ return proxyUrl + "?url=" + encodeURIComponent(src) + (callback.length ? "&callback=html2canvas.proxy." + callback : "");
|
|
|
+}
|
|
|
+
|
|
|
+function documentFromHTML(src) {
|
|
|
+ return function(html) {
|
|
|
+ var parser = new DOMParser(), doc;
|
|
|
+ try {
|
|
|
+ doc = parser.parseFromString(html, "text/html");
|
|
|
+ } catch(e) {
|
|
|
+ log("DOMParser not supported, falling back to createHTMLDocument");
|
|
|
+ doc = document.implementation.createHTMLDocument("");
|
|
|
+ try {
|
|
|
+ doc.open();
|
|
|
+ doc.write(html);
|
|
|
+ doc.close();
|
|
|
+ } catch(ee) {
|
|
|
+ log("createHTMLDocument write not supported, falling back to document.body.innerHTML");
|
|
|
+ doc.body.innerHTML = html;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var b = doc.querySelector("base");
|
|
|
+ if (!b || !b.href.host) {
|
|
|
+ var base = doc.createElement("base");
|
|
|
+ base.href = src;
|
|
|
+ doc.head.insertBefore(base, doc.head.firstChild);
|
|
|
+ }
|
|
|
+
|
|
|
+ return doc;
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+function loadUrlDocument(src, proxy, document, width, height, options) {
|
|
|
+ return new Proxy(src, proxy, window.document).then(documentFromHTML(src)).then(function(doc) {
|
|
|
+ return createWindowClone(doc, document, width, height, options, 0, 0);
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+exports.Proxy = Proxy;
|
|
|
+exports.ProxyURL = ProxyURL;
|
|
|
+exports.loadUrlDocument = loadUrlDocument;
|
|
|
+
|
|
|
+},{"./clone":2,"./log":13,"./utils":26,"./xhr":28}],17:[function(_dereq_,module,exports){
|
|
|
+var ProxyURL = _dereq_('./proxy').ProxyURL;
|
|
|
+
|
|
|
+function ProxyImageContainer(src, proxy) {
|
|
|
+ var link = document.createElement("a");
|
|
|
+ link.href = src;
|
|
|
+ src = link.href;
|
|
|
+ this.src = src;
|
|
|
+ this.image = new Image();
|
|
|
+ var self = this;
|
|
|
+ this.promise = new Promise(function(resolve, reject) {
|
|
|
+ self.image.crossOrigin = "Anonymous";
|
|
|
+ self.image.onload = resolve;
|
|
|
+ self.image.onerror = reject;
|
|
|
+
|
|
|
+ new ProxyURL(src, proxy, document).then(function(url) {
|
|
|
+ self.image.src = url;
|
|
|
+ })['catch'](reject);
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = ProxyImageContainer;
|
|
|
+
|
|
|
+},{"./proxy":16}],18:[function(_dereq_,module,exports){
|
|
|
+var NodeContainer = _dereq_('./nodecontainer');
|
|
|
+
|
|
|
+function PseudoElementContainer(node, parent, type) {
|
|
|
+ NodeContainer.call(this, node, parent);
|
|
|
+ this.isPseudoElement = true;
|
|
|
+ this.before = type === ":before";
|
|
|
+}
|
|
|
+
|
|
|
+PseudoElementContainer.prototype.cloneTo = function(stack) {
|
|
|
+ PseudoElementContainer.prototype.cloneTo.call(this, stack);
|
|
|
+ stack.isPseudoElement = true;
|
|
|
+ stack.before = this.before;
|
|
|
+};
|
|
|
+
|
|
|
+PseudoElementContainer.prototype = Object.create(NodeContainer.prototype);
|
|
|
+
|
|
|
+PseudoElementContainer.prototype.appendToDOM = function() {
|
|
|
+ if (this.before) {
|
|
|
+ this.parent.node.insertBefore(this.node, this.parent.node.firstChild);
|
|
|
+ } else {
|
|
|
+ this.parent.node.appendChild(this.node);
|
|
|
+ }
|
|
|
+ this.parent.node.className += " " + this.getHideClass();
|
|
|
+};
|
|
|
+
|
|
|
+PseudoElementContainer.prototype.cleanDOM = function() {
|
|
|
+ this.node.parentNode.removeChild(this.node);
|
|
|
+ this.parent.node.className = this.parent.node.className.replace(this.getHideClass(), "");
|
|
|
+};
|
|
|
+
|
|
|
+PseudoElementContainer.prototype.getHideClass = function() {
|
|
|
+ return this["PSEUDO_HIDE_ELEMENT_CLASS_" + (this.before ? "BEFORE" : "AFTER")];
|
|
|
+};
|
|
|
+
|
|
|
+PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE = "___html2canvas___pseudoelement_before";
|
|
|
+PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER = "___html2canvas___pseudoelement_after";
|
|
|
+
|
|
|
+module.exports = PseudoElementContainer;
|
|
|
+
|
|
|
+},{"./nodecontainer":14}],19:[function(_dereq_,module,exports){
|
|
|
+var log = _dereq_('./log');
|
|
|
+
|
|
|
+function Renderer(width, height, images, options, document) {
|
|
|
+ this.width = width;
|
|
|
+ this.height = height;
|
|
|
+ this.images = images;
|
|
|
+ this.options = options;
|
|
|
+ this.document = document;
|
|
|
+}
|
|
|
+
|
|
|
+Renderer.prototype.renderImage = function(container, bounds, borderData, imageContainer) {
|
|
|
+ var paddingLeft = container.cssInt('paddingLeft'),
|
|
|
+ paddingTop = container.cssInt('paddingTop'),
|
|
|
+ paddingRight = container.cssInt('paddingRight'),
|
|
|
+ paddingBottom = container.cssInt('paddingBottom'),
|
|
|
+ borders = borderData.borders;
|
|
|
+
|
|
|
+ var width = bounds.width - (borders[1].width + borders[3].width + paddingLeft + paddingRight);
|
|
|
+ var height = bounds.height - (borders[0].width + borders[2].width + paddingTop + paddingBottom);
|
|
|
+ this.drawImage(
|
|
|
+ imageContainer,
|
|
|
+ 0,
|
|
|
+ 0,
|
|
|
+ imageContainer.image.width || width,
|
|
|
+ imageContainer.image.height || height,
|
|
|
+ bounds.left + paddingLeft + borders[3].width,
|
|
|
+ bounds.top + paddingTop + borders[0].width,
|
|
|
+ width,
|
|
|
+ height
|
|
|
+ );
|
|
|
+};
|
|
|
+
|
|
|
+Renderer.prototype.renderBackground = function(container, bounds, borderData) {
|
|
|
+ if (bounds.height > 0 && bounds.width > 0) {
|
|
|
+ this.renderBackgroundColor(container, bounds);
|
|
|
+ this.renderBackgroundImage(container, bounds, borderData);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+Renderer.prototype.renderBackgroundColor = function(container, bounds) {
|
|
|
+ var color = container.color("backgroundColor");
|
|
|
+ if (!color.isTransparent()) {
|
|
|
+ this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, color);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+Renderer.prototype.renderBorders = function(borders) {
|
|
|
+ borders.forEach(this.renderBorder, this);
|
|
|
+};
|
|
|
+
|
|
|
+Renderer.prototype.renderBorder = function(data) {
|
|
|
+ if (!data.color.isTransparent() && data.args !== null) {
|
|
|
+ this.drawShape(data.args, data.color);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+Renderer.prototype.renderBackgroundImage = function(container, bounds, borderData) {
|
|
|
+ var backgroundImages = container.parseBackgroundImages();
|
|
|
+ backgroundImages.reverse().forEach(function(backgroundImage, index, arr) {
|
|
|
+ switch(backgroundImage.method) {
|
|
|
+ case "url":
|
|
|
+ var image = this.images.get(backgroundImage.args[0]);
|
|
|
+ if (image) {
|
|
|
+ this.renderBackgroundRepeating(container, bounds, image, arr.length - (index+1), borderData);
|
|
|
+ } else {
|
|
|
+ log("Error loading background-image", backgroundImage.args[0]);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case "linear-gradient":
|
|
|
+ case "gradient":
|
|
|
+ var gradientImage = this.images.get(backgroundImage.value);
|
|
|
+ if (gradientImage) {
|
|
|
+ this.renderBackgroundGradient(gradientImage, bounds, borderData);
|
|
|
+ } else {
|
|
|
+ log("Error loading background-image", backgroundImage.args[0]);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case "none":
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ log("Unknown background-image type", backgroundImage.args[0]);
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+Renderer.prototype.renderBackgroundRepeating = function(container, bounds, imageContainer, index, borderData) {
|
|
|
+ var size = container.parseBackgroundSize(bounds, imageContainer.image, index);
|
|
|
+ var position = container.parseBackgroundPosition(bounds, imageContainer.image, index, size);
|
|
|
+ var repeat = container.parseBackgroundRepeat(index);
|
|
|
+ switch (repeat) {
|
|
|
+ case "repeat-x":
|
|
|
+ case "repeat no-repeat":
|
|
|
+ this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + borderData[3], bounds.top + position.top + borderData[0], 99999, size.height, borderData);
|
|
|
+ break;
|
|
|
+ case "repeat-y":
|
|
|
+ case "no-repeat repeat":
|
|
|
+ this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + borderData[0], size.width, 99999, borderData);
|
|
|
+ break;
|
|
|
+ case "no-repeat":
|
|
|
+ this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + position.top + borderData[0], size.width, size.height, borderData);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ this.renderBackgroundRepeat(imageContainer, position, size, {top: bounds.top, left: bounds.left}, borderData[3], borderData[0]);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = Renderer;
|
|
|
+
|
|
|
+},{"./log":13}],20:[function(_dereq_,module,exports){
|
|
|
+var Renderer = _dereq_('../renderer');
|
|
|
+var LinearGradientContainer = _dereq_('../lineargradientcontainer');
|
|
|
+var log = _dereq_('../log');
|
|
|
+
|
|
|
+function CanvasRenderer(width, height) {
|
|
|
+ Renderer.apply(this, arguments);
|
|
|
+ this.canvas = this.options.canvas || this.document.createElement("canvas");
|
|
|
+ if (!this.options.canvas) {
|
|
|
+ this.canvas.width = width;
|
|
|
+ this.canvas.height = height;
|
|
|
+ }
|
|
|
+ this.ctx = this.canvas.getContext("2d");
|
|
|
+ this.taintCtx = this.document.createElement("canvas").getContext("2d");
|
|
|
+ this.ctx.textBaseline = "bottom";
|
|
|
+ this.variables = {};
|
|
|
+ log("Initialized CanvasRenderer with size", width, "x", height);
|
|
|
+}
|
|
|
+
|
|
|
+CanvasRenderer.prototype = Object.create(Renderer.prototype);
|
|
|
+
|
|
|
+CanvasRenderer.prototype.setFillStyle = function(fillStyle) {
|
|
|
+ this.ctx.fillStyle = typeof(fillStyle) === "object" && !!fillStyle.isColor ? fillStyle.toString() : fillStyle;
|
|
|
+ return this.ctx;
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.rectangle = function(left, top, width, height, color) {
|
|
|
+ this.setFillStyle(color).fillRect(left, top, width, height);
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.circle = function(left, top, size, color) {
|
|
|
+ this.setFillStyle(color);
|
|
|
+ this.ctx.beginPath();
|
|
|
+ this.ctx.arc(left + size / 2, top + size / 2, size / 2, 0, Math.PI*2, true);
|
|
|
+ this.ctx.closePath();
|
|
|
+ this.ctx.fill();
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.circleStroke = function(left, top, size, color, stroke, strokeColor) {
|
|
|
+ this.circle(left, top, size, color);
|
|
|
+ this.ctx.strokeStyle = strokeColor.toString();
|
|
|
+ this.ctx.stroke();
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.drawShape = function(shape, color) {
|
|
|
+ this.shape(shape);
|
|
|
+ this.setFillStyle(color).fill();
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.taints = function(imageContainer) {
|
|
|
+ if (imageContainer.tainted === null) {
|
|
|
+ this.taintCtx.drawImage(imageContainer.image, 0, 0);
|
|
|
+ try {
|
|
|
+ this.taintCtx.getImageData(0, 0, 1, 1);
|
|
|
+ imageContainer.tainted = false;
|
|
|
+ } catch(e) {
|
|
|
+ this.taintCtx = document.createElement("canvas").getContext("2d");
|
|
|
+ imageContainer.tainted = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return imageContainer.tainted;
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.drawImage = function(imageContainer, sx, sy, sw, sh, dx, dy, dw, dh) {
|
|
|
+ if (!this.taints(imageContainer) || this.options.allowTaint) {
|
|
|
+ this.ctx.drawImage(imageContainer.image, sx, sy, sw, sh, dx, dy, dw, dh);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.clip = function(shapes, callback, context) {
|
|
|
+ this.ctx.save();
|
|
|
+ shapes.filter(hasEntries).forEach(function(shape) {
|
|
|
+ this.shape(shape).clip();
|
|
|
+ }, this);
|
|
|
+ callback.call(context);
|
|
|
+ this.ctx.restore();
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.shape = function(shape) {
|
|
|
+ this.ctx.beginPath();
|
|
|
+ shape.forEach(function(point, index) {
|
|
|
+ if (point[0] === "rect") {
|
|
|
+ this.ctx.rect.apply(this.ctx, point.slice(1));
|
|
|
+ } else {
|
|
|
+ this.ctx[(index === 0) ? "moveTo" : point[0] + "To" ].apply(this.ctx, point.slice(1));
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+ this.ctx.closePath();
|
|
|
+ return this.ctx;
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.font = function(color, style, variant, weight, size, family) {
|
|
|
+ this.setFillStyle(color).font = [style, variant, weight, size, family].join(" ").split(",")[0];
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.fontShadow = function(color, offsetX, offsetY, blur) {
|
|
|
+ this.setVariable("shadowColor", color.toString())
|
|
|
+ .setVariable("shadowOffsetY", offsetX)
|
|
|
+ .setVariable("shadowOffsetX", offsetY)
|
|
|
+ .setVariable("shadowBlur", blur);
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.clearShadow = function() {
|
|
|
+ this.setVariable("shadowColor", "rgba(0,0,0,0)");
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.setOpacity = function(opacity) {
|
|
|
+ this.ctx.globalAlpha = opacity;
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.setTransform = function(transform) {
|
|
|
+ this.ctx.translate(transform.origin[0], transform.origin[1]);
|
|
|
+ this.ctx.transform.apply(this.ctx, transform.matrix);
|
|
|
+ this.ctx.translate(-transform.origin[0], -transform.origin[1]);
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.setVariable = function(property, value) {
|
|
|
+ if (this.variables[property] !== value) {
|
|
|
+ this.variables[property] = this.ctx[property] = value;
|
|
|
+ }
|
|
|
+
|
|
|
+ return this;
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.text = function(text, left, bottom) {
|
|
|
+ this.ctx.fillText(text, left, bottom);
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.backgroundRepeatShape = function(imageContainer, backgroundPosition, size, bounds, left, top, width, height, borderData) {
|
|
|
+ var shape = [
|
|
|
+ ["line", Math.round(left), Math.round(top)],
|
|
|
+ ["line", Math.round(left + width), Math.round(top)],
|
|
|
+ ["line", Math.round(left + width), Math.round(height + top)],
|
|
|
+ ["line", Math.round(left), Math.round(height + top)]
|
|
|
+ ];
|
|
|
+ this.clip([shape], function() {
|
|
|
+ this.renderBackgroundRepeat(imageContainer, backgroundPosition, size, bounds, borderData[3], borderData[0]);
|
|
|
+ }, this);
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.renderBackgroundRepeat = function(imageContainer, backgroundPosition, size, bounds, borderLeft, borderTop) {
|
|
|
+ var offsetX = Math.round(bounds.left + backgroundPosition.left + borderLeft), offsetY = Math.round(bounds.top + backgroundPosition.top + borderTop);
|
|
|
+ this.setFillStyle(this.ctx.createPattern(this.resizeImage(imageContainer, size), "repeat"));
|
|
|
+ this.ctx.translate(offsetX, offsetY);
|
|
|
+ this.ctx.fill();
|
|
|
+ this.ctx.translate(-offsetX, -offsetY);
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.renderBackgroundGradient = function(gradientImage, bounds) {
|
|
|
+ if (gradientImage instanceof LinearGradientContainer) {
|
|
|
+ var gradient = this.ctx.createLinearGradient(
|
|
|
+ bounds.left + bounds.width * gradientImage.x0,
|
|
|
+ bounds.top + bounds.height * gradientImage.y0,
|
|
|
+ bounds.left + bounds.width * gradientImage.x1,
|
|
|
+ bounds.top + bounds.height * gradientImage.y1);
|
|
|
+ gradientImage.colorStops.forEach(function(colorStop) {
|
|
|
+ gradient.addColorStop(colorStop.stop, colorStop.color.toString());
|
|
|
+ });
|
|
|
+ this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, gradient);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+CanvasRenderer.prototype.resizeImage = function(imageContainer, size) {
|
|
|
+ var image = imageContainer.image;
|
|
|
+ if(image.width === size.width && image.height === size.height) {
|
|
|
+ return image;
|
|
|
+ }
|
|
|
+
|
|
|
+ var ctx, canvas = document.createElement('canvas');
|
|
|
+ canvas.width = size.width;
|
|
|
+ canvas.height = size.height;
|
|
|
+ ctx = canvas.getContext("2d");
|
|
|
+ ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, size.width, size.height );
|
|
|
+ return canvas;
|
|
|
+};
|
|
|
+
|
|
|
+function hasEntries(array) {
|
|
|
+ return array.length > 0;
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = CanvasRenderer;
|
|
|
+
|
|
|
+},{"../lineargradientcontainer":12,"../log":13,"../renderer":19}],21:[function(_dereq_,module,exports){
|
|
|
+var NodeContainer = _dereq_('./nodecontainer');
|
|
|
+
|
|
|
+function StackingContext(hasOwnStacking, opacity, element, parent) {
|
|
|
+ NodeContainer.call(this, element, parent);
|
|
|
+ this.ownStacking = hasOwnStacking;
|
|
|
+ this.contexts = [];
|
|
|
+ this.children = [];
|
|
|
+ this.opacity = (this.parent ? this.parent.stack.opacity : 1) * opacity;
|
|
|
+}
|
|
|
+
|
|
|
+StackingContext.prototype = Object.create(NodeContainer.prototype);
|
|
|
+
|
|
|
+StackingContext.prototype.getParentStack = function(context) {
|
|
|
+ var parentStack = (this.parent) ? this.parent.stack : null;
|
|
|
+ return parentStack ? (parentStack.ownStacking ? parentStack : parentStack.getParentStack(context)) : context.stack;
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = StackingContext;
|
|
|
+
|
|
|
+},{"./nodecontainer":14}],22:[function(_dereq_,module,exports){
|
|
|
+function Support(document) {
|
|
|
+ this.rangeBounds = this.testRangeBounds(document);
|
|
|
+ this.cors = this.testCORS();
|
|
|
+ this.svg = this.testSVG();
|
|
|
+}
|
|
|
+
|
|
|
+Support.prototype.testRangeBounds = function(document) {
|
|
|
+ var range, testElement, rangeBounds, rangeHeight, support = false;
|
|
|
+
|
|
|
+ if (document.createRange) {
|
|
|
+ range = document.createRange();
|
|
|
+ if (range.getBoundingClientRect) {
|
|
|
+ testElement = document.createElement('boundtest');
|
|
|
+ testElement.style.height = "123px";
|
|
|
+ testElement.style.display = "block";
|
|
|
+ document.body.appendChild(testElement);
|
|
|
+
|
|
|
+ range.selectNode(testElement);
|
|
|
+ rangeBounds = range.getBoundingClientRect();
|
|
|
+ rangeHeight = rangeBounds.height;
|
|
|
+
|
|
|
+ if (rangeHeight === 123) {
|
|
|
+ support = true;
|
|
|
+ }
|
|
|
+ document.body.removeChild(testElement);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return support;
|
|
|
+};
|
|
|
+
|
|
|
+Support.prototype.testCORS = function() {
|
|
|
+ return typeof((new Image()).crossOrigin) !== "undefined";
|
|
|
+};
|
|
|
+
|
|
|
+Support.prototype.testSVG = function() {
|
|
|
+ var img = new Image();
|
|
|
+ var canvas = document.createElement("canvas");
|
|
|
+ var ctx = canvas.getContext("2d");
|
|
|
+ img.src = "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>";
|
|
|
+
|
|
|
+ try {
|
|
|
+ ctx.drawImage(img, 0, 0);
|
|
|
+ canvas.toDataURL();
|
|
|
+ } catch(e) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = Support;
|
|
|
+
|
|
|
+},{}],23:[function(_dereq_,module,exports){
|
|
|
+var XHR = _dereq_('./xhr');
|
|
|
+var decode64 = _dereq_('./utils').decode64;
|
|
|
+
|
|
|
+function SVGContainer(src) {
|
|
|
+ this.src = src;
|
|
|
+ this.image = null;
|
|
|
+ var self = this;
|
|
|
+
|
|
|
+ this.promise = this.hasFabric().then(function() {
|
|
|
+ return (self.isInline(src) ? Promise.resolve(self.inlineFormatting(src)) : XHR(src));
|
|
|
+ }).then(function(svg) {
|
|
|
+ return new Promise(function(resolve) {
|
|
|
+ window.html2canvas.svg.fabric.loadSVGFromString(svg, self.createCanvas.call(self, resolve));
|
|
|
+ });
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+SVGContainer.prototype.hasFabric = function() {
|
|
|
+ return !window.html2canvas.svg || !window.html2canvas.svg.fabric ? Promise.reject(new Error("html2canvas.svg.js is not loaded, cannot render svg")) : Promise.resolve();
|
|
|
+};
|
|
|
+
|
|
|
+SVGContainer.prototype.inlineFormatting = function(src) {
|
|
|
+ return (/^data:image\/svg\+xml;base64,/.test(src)) ? this.decode64(this.removeContentType(src)) : this.removeContentType(src);
|
|
|
+};
|
|
|
+
|
|
|
+SVGContainer.prototype.removeContentType = function(src) {
|
|
|
+ return src.replace(/^data:image\/svg\+xml(;base64)?,/,'');
|
|
|
+};
|
|
|
+
|
|
|
+SVGContainer.prototype.isInline = function(src) {
|
|
|
+ return (/^data:image\/svg\+xml/i.test(src));
|
|
|
+};
|
|
|
+
|
|
|
+SVGContainer.prototype.createCanvas = function(resolve) {
|
|
|
+ var self = this;
|
|
|
+ return function (objects, options) {
|
|
|
+ var canvas = new window.html2canvas.svg.fabric.StaticCanvas('c');
|
|
|
+ self.image = canvas.lowerCanvasEl;
|
|
|
+ canvas
|
|
|
+ .setWidth(options.width)
|
|
|
+ .setHeight(options.height)
|
|
|
+ .add(window.html2canvas.svg.fabric.util.groupSVGElements(objects, options))
|
|
|
+ .renderAll();
|
|
|
+ resolve(canvas.lowerCanvasEl);
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+SVGContainer.prototype.decode64 = function(str) {
|
|
|
+ return (typeof(window.atob) === "function") ? window.atob(str) : decode64(str);
|
|
|
+};
|
|
|
+
|
|
|
+module.exports = SVGContainer;
|
|
|
+
|
|
|
+},{"./utils":26,"./xhr":28}],24:[function(_dereq_,module,exports){
|
|
|
+var SVGContainer = _dereq_('./svgcontainer');
|
|
|
+
|
|
|
+function SVGNodeContainer(node, _native) {
|
|
|
+ this.src = node;
|
|
|
+ this.image = null;
|
|
|
+ var self = this;
|
|
|
+
|
|
|
+ this.promise = _native ? new Promise(function(resolve, reject) {
|
|
|
+ self.image = new Image();
|
|
|
+ self.image.onload = resolve;
|
|
|
+ self.image.onerror = reject;
|
|
|
+ self.image.src = "data:image/svg+xml," + (new XMLSerializer()).serializeToString(node);
|
|
|
+ if (self.image.complete === true) {
|
|
|
+ resolve(self.image);
|
|
|
+ }
|
|
|
+ }) : this.hasFabric().then(function() {
|
|
|
+ return new Promise(function(resolve) {
|
|
|
+ window.html2canvas.svg.fabric.parseSVGDocument(node, self.createCanvas.call(self, resolve));
|
|
|
+ });
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+SVGNodeContainer.prototype = Object.create(SVGContainer.prototype);
|
|
|
+
|
|
|
+module.exports = SVGNodeContainer;
|
|
|
+
|
|
|
+},{"./svgcontainer":23}],25:[function(_dereq_,module,exports){
|
|
|
+var NodeContainer = _dereq_('./nodecontainer');
|
|
|
+
|
|
|
+function TextContainer(node, parent) {
|
|
|
+ NodeContainer.call(this, node, parent);
|
|
|
+}
|
|
|
+
|
|
|
+TextContainer.prototype = Object.create(NodeContainer.prototype);
|
|
|
+
|
|
|
+TextContainer.prototype.applyTextTransform = function() {
|
|
|
+ this.node.data = this.transform(this.parent.css("textTransform"));
|
|
|
+};
|
|
|
+
|
|
|
+TextContainer.prototype.transform = function(transform) {
|
|
|
+ var text = this.node.data;
|
|
|
+ switch(transform){
|
|
|
+ case "lowercase":
|
|
|
+ return text.toLowerCase();
|
|
|
+ case "capitalize":
|
|
|
+ return text.replace(/(^|\s|:|-|\(|\))([a-z])/g, capitalize);
|
|
|
+ case "uppercase":
|
|
|
+ return text.toUpperCase();
|
|
|
+ default:
|
|
|
+ return text;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function capitalize(m, p1, p2) {
|
|
|
+ if (m.length > 0) {
|
|
|
+ return p1 + p2.toUpperCase();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = TextContainer;
|
|
|
+
|
|
|
+},{"./nodecontainer":14}],26:[function(_dereq_,module,exports){
|
|
|
+exports.smallImage = function smallImage() {
|
|
|
+ return "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
|
|
|
+};
|
|
|
+
|
|
|
+exports.bind = function(callback, context) {
|
|
|
+ return function() {
|
|
|
+ return callback.apply(context, arguments);
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+ * base64-arraybuffer
|
|
|
+ * https:
|
|
|
+ *
|
|
|
+ * Copyright (c) 2012 Niklas von Hertzen
|
|
|
+ * Licensed under the MIT license.
|
|
|
+ */
|
|
|
+
|
|
|
+exports.decode64 = function(base64) {
|
|
|
+ var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
+ var len = base64.length, i, encoded1, encoded2, encoded3, encoded4, byte1, byte2, byte3;
|
|
|
+
|
|
|
+ var output = "";
|
|
|
+
|
|
|
+ for (i = 0; i < len; i+=4) {
|
|
|
+ encoded1 = chars.indexOf(base64[i]);
|
|
|
+ encoded2 = chars.indexOf(base64[i+1]);
|
|
|
+ encoded3 = chars.indexOf(base64[i+2]);
|
|
|
+ encoded4 = chars.indexOf(base64[i+3]);
|
|
|
+
|
|
|
+ byte1 = (encoded1 << 2) | (encoded2 >> 4);
|
|
|
+ byte2 = ((encoded2 & 15) << 4) | (encoded3 >> 2);
|
|
|
+ byte3 = ((encoded3 & 3) << 6) | encoded4;
|
|
|
+ if (encoded3 === 64) {
|
|
|
+ output += String.fromCharCode(byte1);
|
|
|
+ } else if (encoded4 === 64 || encoded4 === -1) {
|
|
|
+ output += String.fromCharCode(byte1, byte2);
|
|
|
+ } else{
|
|
|
+ output += String.fromCharCode(byte1, byte2, byte3);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return output;
|
|
|
+};
|
|
|
+
|
|
|
+exports.getBounds = function(node) {
|
|
|
+ if (node.getBoundingClientRect) {
|
|
|
+ var clientRect = node.getBoundingClientRect();
|
|
|
+ var width = node.offsetWidth == null ? clientRect.width : node.offsetWidth;
|
|
|
+ return {
|
|
|
+ top: clientRect.top,
|
|
|
+ bottom: clientRect.bottom || (clientRect.top + clientRect.height),
|
|
|
+ right: clientRect.left + width,
|
|
|
+ left: clientRect.left,
|
|
|
+ width: width,
|
|
|
+ height: node.offsetHeight == null ? clientRect.height : node.offsetHeight
|
|
|
+ };
|
|
|
+ }
|
|
|
+ return {};
|
|
|
+};
|
|
|
+
|
|
|
+exports.offsetBounds = function(node) {
|
|
|
+ var parent = node.offsetParent ? exports.offsetBounds(node.offsetParent) : {top: 0, left: 0};
|
|
|
+
|
|
|
+ return {
|
|
|
+ top: node.offsetTop + parent.top,
|
|
|
+ bottom: node.offsetTop + node.offsetHeight + parent.top,
|
|
|
+ right: node.offsetLeft + parent.left + node.offsetWidth,
|
|
|
+ left: node.offsetLeft + parent.left,
|
|
|
+ width: node.offsetWidth,
|
|
|
+ height: node.offsetHeight
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+exports.parseBackgrounds = function(backgroundImage) {
|
|
|
+ var whitespace = ' \r\n\t',
|
|
|
+ method, definition, prefix, prefix_i, block, results = [],
|
|
|
+ mode = 0, numParen = 0, quote, args;
|
|
|
+ var appendResult = function() {
|
|
|
+ if(method) {
|
|
|
+ if (definition.substr(0, 1) === '"') {
|
|
|
+ definition = definition.substr(1, definition.length - 2);
|
|
|
+ }
|
|
|
+ if (definition) {
|
|
|
+ args.push(definition);
|
|
|
+ }
|
|
|
+ if (method.substr(0, 1) === '-' && (prefix_i = method.indexOf('-', 1 ) + 1) > 0) {
|
|
|
+ prefix = method.substr(0, prefix_i);
|
|
|
+ method = method.substr(prefix_i);
|
|
|
+ }
|
|
|
+ results.push({
|
|
|
+ prefix: prefix,
|
|
|
+ method: method.toLowerCase(),
|
|
|
+ value: block,
|
|
|
+ args: args,
|
|
|
+ image: null
|
|
|
+ });
|
|
|
+ }
|
|
|
+ args = [];
|
|
|
+ method = prefix = definition = block = '';
|
|
|
+ };
|
|
|
+ args = [];
|
|
|
+ method = prefix = definition = block = '';
|
|
|
+ backgroundImage.split("").forEach(function(c) {
|
|
|
+ if (mode === 0 && whitespace.indexOf(c) > -1) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ switch(c) {
|
|
|
+ case '"':
|
|
|
+ if(!quote) {
|
|
|
+ quote = c;
|
|
|
+ } else if(quote === c) {
|
|
|
+ quote = null;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case '(':
|
|
|
+ if(quote) {
|
|
|
+ break;
|
|
|
+ } else if(mode === 0) {
|
|
|
+ mode = 1;
|
|
|
+ block += c;
|
|
|
+ return;
|
|
|
+ } else {
|
|
|
+ numParen++;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case ')':
|
|
|
+ if (quote) {
|
|
|
+ break;
|
|
|
+ } else if(mode === 1) {
|
|
|
+ if(numParen === 0) {
|
|
|
+ mode = 0;
|
|
|
+ block += c;
|
|
|
+ appendResult();
|
|
|
+ return;
|
|
|
+ } else {
|
|
|
+ numParen--;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ',':
|
|
|
+ if (quote) {
|
|
|
+ break;
|
|
|
+ } else if(mode === 0) {
|
|
|
+ appendResult();
|
|
|
+ return;
|
|
|
+ } else if (mode === 1) {
|
|
|
+ if (numParen === 0 && !method.match(/^url$/i)) {
|
|
|
+ args.push(definition);
|
|
|
+ definition = '';
|
|
|
+ block += c;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ block += c;
|
|
|
+ if (mode === 0) {
|
|
|
+ method += c;
|
|
|
+ } else {
|
|
|
+ definition += c;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ appendResult();
|
|
|
+ return results;
|
|
|
+};
|
|
|
+
|
|
|
+},{}],27:[function(_dereq_,module,exports){
|
|
|
+var GradientContainer = _dereq_('./gradientcontainer');
|
|
|
+
|
|
|
+function WebkitGradientContainer(imageData) {
|
|
|
+ GradientContainer.apply(this, arguments);
|
|
|
+ this.type = imageData.args[0] === "linear" ? GradientContainer.TYPES.LINEAR : GradientContainer.TYPES.RADIAL;
|
|
|
+}
|
|
|
+
|
|
|
+WebkitGradientContainer.prototype = Object.create(GradientContainer.prototype);
|
|
|
+
|
|
|
+module.exports = WebkitGradientContainer;
|
|
|
+
|
|
|
+},{"./gradientcontainer":9}],28:[function(_dereq_,module,exports){
|
|
|
+function XHR(url) {
|
|
|
+ return new Promise(function(resolve, reject) {
|
|
|
+ var xhr = new XMLHttpRequest();
|
|
|
+ xhr.open('GET', url);
|
|
|
+
|
|
|
+ xhr.onload = function() {
|
|
|
+ if (xhr.status === 200) {
|
|
|
+ resolve(xhr.responseText);
|
|
|
+ } else {
|
|
|
+ reject(new Error(xhr.statusText));
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ xhr.onerror = function() {
|
|
|
+ reject(new Error("Network Error"));
|
|
|
+ };
|
|
|
+
|
|
|
+ xhr.send();
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+module.exports = XHR;
|
|
|
+
|
|
|
+},{}]},{},[4])(4)
|
|
|
+});
|
