js将某个div节点转存成照片

创建html页面

div to img demo

ces

测试保存为图片

})

    // edited from https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob#Polyfill
   var dataURIToBlob =  function (imgName, dataURI, callback) {
        var binStr = atob(dataURI.split(',')[1]),
            len = binStr.length,
            arr = new Uint8Array(len);

        for (var i = 0; i < len; i++) {
            arr[i] = binStr.charCodeAt(i);
        }

        callback(imgName, new Blob([arr]));
    }

    var callback = function (imgName, blob) {
        var triggerDownload = $("<a>").attr("href", URL.createObjectURL(blob)).attr("download", imgName).appendTo("body").on("click", function () {
            if (navigator.msSaveBlob) {
                return navigator.msSaveBlob(blob, imgName);
            }
        });
        triggerDownload[0].click();
        triggerDownload.remove();
    };

bluebird.js文件
/* @preserve

The MIT License (MIT)
Copyright © 2013-2017 Petka Antonov
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

/
/*

bluebird build version 3.5.0
Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
*/
!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.Promise=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 dereq"function”&&dereq;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 dereq"function”&&dereq;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(dereq,module,exports){
“use strict”;
module.exports = function(Promise) {
var SomePromiseArray = Promise._SomePromiseArray;
function any(promises) {
var ret = new SomePromiseArray(promises);
var promise = ret.promise();
ret.setHowMany(1);
ret.setUnwrap();
ret.init();
return promise;
}

Promise.any = function (promises) {
return any(promises);
};

Promise.prototype.any = function () {
return any(this);
};

};

},{}],2:[function(dereq,module,exports){
“use strict”;
var firstLineError;
try {throw new Error(); } catch (e) {firstLineError = e;}
var schedule = dereq("./schedule");
var Queue = dereq("./queue");
var util = dereq("./util");

function Async() {
this._customScheduler = false;
this._isTickUsed = false;
this._lateQueue = new Queue(16);
this._normalQueue = new Queue(16);
this._haveDrainedQueues = false;
this._trampolineEnabled = true;
var self = this;
this.drainQueues = function () {
self._drainQueues();
};
this._schedule = schedule;
}

Async.prototype.setScheduler = function(fn) {
var prev = this._schedule;
this._schedule = fn;
this._customScheduler = true;
return prev;
};

Async.prototype.hasCustomScheduler = function() {
return this._customScheduler;
};

Async.prototype.enableTrampoline = function() {
this._trampolineEnabled = true;
};

Async.prototype.disableTrampolineIfNecessary = function() {
if (util.hasDevTools) {
this._trampolineEnabled = false;
}
};

Async.prototype.haveItemsQueued = function () {
return this._isTickUsed || this._haveDrainedQueues;
};

Async.prototype.fatalError = function(e, isNode) {
if (isNode) {
process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
“\n”);
process.exit(2);
} else {
this.throwLater(e);
}
};

Async.prototype.throwLater = function(fn, arg) {
if (arguments.length === 1) {
arg = fn;
fn = function () { throw arg; };
}
if (typeof setTimeout !== “undefined”) {
setTimeout(function() {
fn(arg);
}, 0);
} else try {
this._schedule(function() {
fn(arg);
});
} catch (e) {
throw new Error(“No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a”);
}
};

function AsyncInvokeLater(fn, receiver, arg) {
this._lateQueue.push(fn, receiver, arg);
this._queueTick();
}

function AsyncInvoke(fn, receiver, arg) {
this._normalQueue.push(fn, receiver, arg);
this._queueTick();
}

function AsyncSettlePromises(promise) {
this._normalQueue._pushOne(promise);
this._queueTick();
}

if (!util.hasDevTools) {
Async.prototype.invokeLater = AsyncInvokeLater;
Async.prototype.invoke = AsyncInvoke;
Async.prototype.settlePromises = AsyncSettlePromises;
} else {
Async.prototype.invokeLater = function (fn, receiver, arg) {
if (this._trampolineEnabled) {
AsyncInvokeLater.call(this, fn, receiver, arg);
} else {
this._schedule(function() {
setTimeout(function() {
fn.call(receiver, arg);
}, 100);
});
}
};

Async.prototype.invoke = function (fn, receiver, arg) {
    if (this._trampolineEnabled) {
        AsyncInvoke.call(this, fn, receiver, arg);
    } else {
        this._schedule(function() {
            fn.call(receiver, arg);
        });
    }
};

Async.prototype.settlePromises = function(promise) {
    if (this._trampolineEnabled) {
        AsyncSettlePromises.call(this, promise);
    } else {
        this._schedule(function() {
            promise._settlePromises();
        });
    }
};

}

Async.prototype._drainQueue = function(queue) {
while (queue.length() > 0) {
var fn = queue.shift();
if (typeof fn !== “function”) {
fn._settlePromises();
continue;
}
var receiver = queue.shift();
var arg = queue.shift();
fn.call(receiver, arg);
}
};

Async.prototype._drainQueues = function () {
this._drainQueue(this._normalQueue);
this._reset();
this._haveDrainedQueues = true;
this._drainQueue(this._lateQueue);
};

Async.prototype._queueTick = function () {
if (!this._isTickUsed) {
this._isTickUsed = true;
this._schedule(this.drainQueues);
}
};

Async.prototype._reset = function () {
this._isTickUsed = false;
};

module.exports = Async;
module.exports.firstLineError = firstLineError;

},{"./queue":26,"./schedule":29,"./util":36}],3:[function(dereq,module,exports){
“use strict”;
module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
var calledBind = false;
var rejectThis = function(_, e) {
this._reject(e);
};

var targetRejected = function(e, context) {
context.promiseRejectionQueued = true;
context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
};

var bindingResolved = function(thisArg, context) {
if (((this._bitField & 50397184) === 0)) {
this._resolveCallback(context.target);
}
};

var bindingRejected = function(e, context) {
if (!context.promiseRejectionQueued) this._reject(e);
};

Promise.prototype.bind = function (thisArg) {
if (!calledBind) {
calledBind = true;
Promise.prototype._propagateFrom = debug.propagateFromFunction();
Promise.prototype._boundValue = debug.boundValueFunction();
}
var maybePromise = tryConvertToPromise(thisArg);
var ret = new Promise(INTERNAL);
ret._propagateFrom(this, 1);
var target = this._target();
ret._setBoundTo(maybePromise);
if (maybePromise instanceof Promise) {
var context = {
promiseRejectionQueued: false,
promise: ret,
target: target,
bindingPromise: maybePromise
};
target._then(INTERNAL, targetRejected, undefined, ret, context);
maybePromise._then(
bindingResolved, bindingRejected, undefined, ret, context);
ret._setOnCancel(maybePromise);
} else {
ret._resolveCallback(target);
}
return ret;
};

Promise.prototype._setBoundTo = function (obj) {
if (obj !== undefined) {
this._bitField = this._bitField | 2097152;
this._boundTo = obj;
} else {
this._bitField = this._bitField & (~2097152);
}
};

Promise.prototype._isBound = function () {
return (this._bitField & 2097152) === 2097152;
};

Promise.bind = function (thisArg, value) {
return Promise.resolve(value).bind(thisArg);
};
};

},{}],4:[function(dereq,module,exports){
“use strict”;
var old;
if (typeof Promise !== “undefined”) old = Promise;
function noConflict() {
try { if (Promise === bluebird) Promise = old; }
catch (e) {}
return bluebird;
}
var bluebird = dereq("./promise")();
bluebird.noConflict = noConflict;
module.exports = bluebird;

},{"./promise":22}],5:[function(dereq,module,exports){
“use strict”;
var cr = Object.create;
if (cr) {
var callerCache = cr(null);
var getterCache = cr(null);
callerCache[" size"] = getterCache[" size"] = 0;
}

module.exports = function(Promise) {
var util = dereq("./util");
var canEvaluate = util.canEvaluate;
var isIdentifier = util.isIdentifier;

var getMethodCaller;
var getGetter;
if (!true) {
var makeMethodCaller = function (methodName) {
return new Function(“ensureMethod”, " \n
return function(obj) { \n
‘use strict’ \n
var len = this.length; \n
ensureMethod(obj, ‘methodName’); \n
switch(len) { \n
case 1: return obj.methodName(this[0]); \n
case 2: return obj.methodName(this[0], this[1]); \n
case 3: return obj.methodName(this[0], this[1], this[2]); \n
case 0: return obj.methodName(); \n
default: \n
return obj.methodName.apply(obj, this); \n
} \n
}; \n
".replace(/methodName/g, methodName))(ensureMethod);
};

var makeGetter = function (propertyName) {
return new Function(“obj”, " \n
‘use strict’; \n
return obj.propertyName; \n
".replace(“propertyName”, propertyName));
};

getMethodCaller = function(name) {
return getCompiled(name, makeMethodCaller, callerCache);
};

getGetter = function(name) {
return getCompiled(name, makeGetter, getterCache);
};
}

function ensureMethod(obj, methodName) {
var fn;
if (obj != null) fn = obj[methodName];
if (typeof fn !== “function”) {
var message = “Object " + util.classString(obj) + " has no method '” +
util.toString(methodName) + “’”;
throw new Promise.TypeError(message);
}
return fn;
}

},{"./util":36}],6:[function(dereq,module,exports){
“use strict”;
module.exports = function(Promise, PromiseArray, apiRejection, debug) {
var util = dereq("./util");
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;
var async = Promise._async;

Promise.prototype[“break”] = Promise.prototype.cancel = function() {
if (!debug.cancellation()) return this._warn(“cancellation is disabled”);

var promise = this;
var child = promise;
while (promise._isCancellable()) {
    if (!promise._cancelBy(child)) {
        if (child._isFollowing()) {
            child._followee().cancel();
        } else {
            child._cancelBranched();
        }
        break;
    }

    var parent = promise._cancellationParent;
    if (parent == null || !parent._isCancellable()) {
        if (promise._isFollowing()) {
            promise._followee().cancel();
        } else {
            promise._cancelBranched();
        }
        break;
    } else {
        if (promise._isFollowing()) promise._followee().cancel();
        promise._setWillBeCancelled();
        child = promise;
        promise = parent;
    }
}

};

Promise.prototype._branchHasCancelled = function() {
this._branchesRemainingToCancel–;
};

Promise.prototype._enoughBranchesHaveCancelled = function() {
return this._branchesRemainingToCancel === undefined ||
this._branchesRemainingToCancel <= 0;
};

Promise.prototype._cancelBy = function(canceller) {
if (canceller === this) {
this._branchesRemainingToCancel = 0;
this._invokeOnCancel();
return true;
} else {
this._branchHasCancelled();
if (this._enoughBranchesHaveCancelled()) {
this._invokeOnCancel();
return true;
}
}
return false;
};

Promise.prototype._cancelBranched = function() {
if (this._enoughBranchesHaveCancelled()) {
this._cancel();
}
};

Promise.prototype._cancel = function() {
if (!this._isCancellable()) return;
this._setCancelled();
async.invoke(this._cancelPromises, this, undefined);
};

Promise.prototype._cancelPromises = function() {
if (this._length() > 0) this._settlePromises();
};

Promise.prototype._unsetOnCancel = function() {
this._onCancelField = undefined;
};

Promise.prototype._isCancellable = function() {
return this.isPending() && !this._isCancelled();
};

Promise.prototype.isCancellable = function() {
return this.isPending() && !this.isCancelled();
};

Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
if (util.isArray(onCancelCallback)) {
for (var i = 0; i < onCancelCallback.length; ++i) {
this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
}
} else if (onCancelCallback !== undefined) {
if (typeof onCancelCallback === “function”) {
if (!internalOnly) {
var e = tryCatch(onCancelCallback).call(this._boundValue());
if (e === errorObj) {
this._attachExtraTrace(e.e);
async.throwLater(e.e);
}
}
} else {
onCancelCallback._resultCancelled(this);
}
}
};

Promise.prototype._invokeOnCancel = function() {
var onCancelCallback = this._onCancel();
this._unsetOnCancel();
async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
};

Promise.prototype._invokeInternalOnCancel = function() {
if (this._isCancellable()) {
this._doInvokeOnCancel(this._onCancel(), true);
this._unsetOnCancel();
}
};

Promise.prototype._resultCancelled = function() {
this.cancel();
};

};

},{"./util":36}],7:[function(dereq,module,exports){
“use strict”;
module.exports = function(NEXT_FILTER) {
var util = dereq("./util");
var getKeys = dereq("./es5").keys;
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;

function catchFilter(instances, cb, promise) {
return function(e) {
var boundTo = promise._boundValue();
predicateLoop: for (var i = 0; i < instances.length; ++i) {
var item = instances[i];

        if (item === Error ||
            (item != null && item.prototype instanceof Error)) {
            if (e instanceof item) {
                return tryCatch(cb).call(boundTo, e);
            }
        } else if (typeof item === "function") {
            var matchesPredicate = tryCatch(item).call(boundTo, e);
            if (matchesPredicate === errorObj) {
                return matchesPredicate;
            } else if (matchesPredicate) {
                return tryCatch(cb).call(boundTo, e);
            }
        } else if (util.isObject(e)) {
            var keys = getKeys(item);
            for (var j = 0; j < keys.length; ++j) {
                var key = keys[j];
                if (item[key] != e[key]) {
                    continue predicateLoop;
                }
            }
            return tryCatch(cb).call(boundTo, e);
        }
    }
    return NEXT_FILTER;
};

}

return catchFilter;
};

},{"./es5":13,"./util":36}],8:[function(dereq,module,exports){
“use strict”;
module.exports = function(Promise) {
var longStackTraces = false;
var contextStack = [];

Promise.prototype._promiseCreated = function() {};
Promise.prototype._pushContext = function() {};
Promise.prototype._popContext = function() {return null;};
Promise._peekContext = Promise.prototype._peekContext = function() {};

Context.prototype._popContext = function () {
if (this._trace !== undefined) {
var trace = contextStack.pop();
var ret = trace._promiseCreated;
trace._promiseCreated = null;
return ret;
}
return null;
};

function createContext() {
if (longStackTraces) return new Context();
}

},{}],9:[function(dereq,module,exports){
“use strict”;
module.exports = function(Promise, Context) {
var getDomain = Promise._getDomain;
var async = Promise._async;
var Warning = dereq("./errors").Warning;
var util = dereq("./util");
var canAttachTrace = util.canAttachTrace;
var unhandledRejectionHandled;
var possiblyUnhandledRejection;
var bluebirdFramePattern =
/[\/]bluebird[\/]js\//;
var nodeFramePattern = /((?:timers.js):\d+:\d+)/;
var parseLinePattern = //<(

相关推荐