;var MXI_DEBUG = true;
/**
* mOxie - multi-runtime File API & XMLHttpRequest L2 Polyfill
* v1.5.8
*
* Copyright 2013, Moxiecode Systems AB
* Released under GPL License.
*
* License: http://www.plupload.com/license
* Contributing: http://www.plupload.com/contributing
*
* Date: 2018-02-19
*/
;(function (global, factory) {
var extract = function() {
var ctx = {};
factory.apply(ctx, arguments);
return ctx.moxie;
};
if (typeof define === "function" && define.amd) {
define("moxie", [], extract);
} else if (typeof module === "object" && module.exports) {
module.exports = extract();
} else {
global.moxie = extract();
}
}(this || window, function() {
/**
* Compiled inline version. (Library mode)
*/
/*jshint smarttabs:true, undef:true, latedef:true, curly:true, bitwise:true, camelcase:true */
/*globals $code */
(function(exports, undefined) {
"use strict";
var modules = {};
function require(ids, callback) {
var module, defs = [];
for (var i = 0; i < ids.length; ++i) {
module = modules[ids[i]] || resolve(ids[i]);
if (!module) {
throw 'module definition dependecy not found: ' + ids[i];
}
defs.push(module);
}
callback.apply(null, defs);
}
function define(id, dependencies, definition) {
if (typeof id !== 'string') {
throw 'invalid module definition, module id must be defined and be a string';
}
if (dependencies === undefined) {
throw 'invalid module definition, dependencies must be specified';
}
if (definition === undefined) {
throw 'invalid module definition, definition function must be specified';
}
require(dependencies, function() {
modules[id] = definition.apply(null, arguments);
});
}
function defined(id) {
return !!modules[id];
}
function resolve(id) {
var target = exports;
var fragments = id.split(/[.\/]/);
for (var fi = 0; fi < fragments.length; ++fi) {
if (!target[fragments[fi]]) {
return;
}
target = target[fragments[fi]];
}
return target;
}
function expose(ids) {
for (var i = 0; i < ids.length; i++) {
var target = exports;
var id = ids[i];
var fragments = id.split(/[.\/]/);
for (var fi = 0; fi < fragments.length - 1; ++fi) {
if (target[fragments[fi]] === undefined) {
target[fragments[fi]] = {};
}
target = target[fragments[fi]];
}
target[fragments[fragments.length - 1]] = modules[id];
}
}
// Included from: src/javascript/core/utils/Basic.js
/**
* Basic.js
*
* Copyright 2013, Moxiecode Systems AB
* Released under GPL License.
*
* License: http://www.plupload.com/license
* Contributing: http://www.plupload.com/contributing
*/
/**
@class moxie/core/utils/Basic
@public
@static
*/
define('moxie/core/utils/Basic', [], function() {
/**
Gets the true type of the built-in object (better version of typeof).
@author Angus Croll (http://javascriptweblog.wordpress.com/)
@method typeOf
@static
@param {Object} o Object to check.
@return {String} Object [[Class]]
*/
function typeOf(o) {
var undef;
if (o === undef) {
return 'undefined';
} else if (o === null) {
return 'null';
} else if (o.nodeType) {
return 'node';
}
// the snippet below is awesome, however it fails to detect null, undefined and arguments types in IE lte 8
return ({}).toString.call(o).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
/**
Extends the specified object with another object(s).
@method extend
@static
@param {Object} target Object to extend.
@param {Object} [obj]* Multiple objects to extend with.
@return {Object} Same as target, the extended object.
*/
function extend() {
return merge(false, false, arguments);
}
/**
Extends the specified object with another object(s), but only if the property exists in the target.
@method extendIf
@static
@param {Object} target Object to extend.
@param {Object} [obj]* Multiple objects to extend with.
@return {Object} Same as target, the extended object.
*/
function extendIf() {
return merge(true, false, arguments);
}
function extendImmutable() {
return merge(false, true, arguments);
}
function extendImmutableIf() {
return merge(true, true, arguments);
}
function clone(value) {
switch (typeOf(value)) {
case 'array':
return merge(false, true, [[], value]);
case 'object':
return merge(false, true, [{}, value]);
default:
return value;
}
}
function shallowCopy(obj) {
switch (typeOf(obj)) {
case 'array':
return Array.prototype.slice.call(obj);
case 'object':
return extend({}, obj);
}
return obj;
}
function merge(strict, immutable, args) {
var undef;
var target = args[0];
each(args, function(arg, i) {
if (i > 0) {
each(arg, function(value, key) {
var isComplex = inArray(typeOf(value), ['array', 'object']) !== -1;
if (value === undef || strict && target[key] === undef) {
return true;
}
if (isComplex && immutable) {
value = shallowCopy(value);
}
if (typeOf(target[key]) === typeOf(value) && isComplex) {
merge(strict, immutable, [target[key], value]);
} else {
target[key] = value;
}
});
}
});
return target;
}
/**
A way to inherit one `class` from another in a consisstent way (more or less)
@method inherit
@static
@since >1.4.1
@param {Function} child
@param {Function} parent
@return {Function} Prepared constructor
*/
function inherit(child, parent) {
// copy over all parent properties
for (var key in parent) {
if ({}.hasOwnProperty.call(parent, key)) {
child[key] = parent[key];
}
}
// give child `class` a place to define its own methods
function ctor() {
this.constructor = child;
if (MXI_DEBUG) {
var getCtorName = function(fn) {
var m = fn.toString().match(/^function\s([^\(\s]+)/);
return m ? m[1] : false;
};
this.ctorName = getCtorName(child);
}
}
ctor.prototype = parent.prototype;
child.prototype = new ctor();
// keep a way to reference parent methods
child.parent = parent.prototype;
return child;
}
/**
Executes the callback function for each item in array/object. If you return false in the
callback it will break the loop.
@method each
@static
@param {Object} obj Object to iterate.
@param {function} callback Callback function to execute for each item.
*/
function each(obj, callback) {
var length, key, i, undef;
if (obj) {
try {
length = obj.length;
} catch(ex) {
length = undef;
}
if (length === undef || typeof(length) !== 'number') {
// Loop object items
for (key in obj) {
if (obj.hasOwnProperty(key)) {
if (callback(obj[key], key) === false) {
return;
}
}
}
} else {
// Loop array items
for (i = 0; i < length; i++) {
if (callback(obj[i], i) === false) {
return;
}
}
}
}
}
/**
Checks if object is empty.
@method isEmptyObj
@static
@param {Object} o Object to check.
@return {Boolean}
*/
function isEmptyObj(obj) {
var prop;
if (!obj || typeOf(obj) !== 'object') {
return true;
}
for (prop in obj) {
return false;
}
return true;
}
/**
Recieve an array of functions (usually async) to call in sequence, each function
receives a callback as first argument that it should call, when it completes. Finally,
after everything is complete, main callback is called. Passing truthy value to the
callback as a first argument will interrupt the sequence and invoke main callback
immediately.
@method inSeries
@static
@param {Array} queue Array of functions to call in sequence
@param {Function} cb Ma
没有合适的资源?快使用搜索试试~ 我知道了~
资源推荐
资源详情
资源评论
收起资源包目录
vue.zip (27个子文件)
vue
static
images
js
plupload
plupload.full.min.js 106KB
i18n
zh_CN.js 2KB
moxie.min.js 91KB
plupload.dev.js 65KB
jquery.plupload.queue
jquery.plupload.queue.min.js 7KB
jquery.plupload.queue.js 16KB
img
transp50.png 399B
delete.gif 180B
backgrounds.gif 3KB
buttons.png 1KB
throbber.gif 2KB
done.gif 1024B
buttons-disabled.png 1KB
error.gif 994B
css
jquery.plupload.queue.css 4KB
Moxie.swf 28KB
Moxie.xap 61KB
moxie.js 303KB
jquery.ui.plupload
jquery.ui.plupload.min.js 17KB
img
plupload.png 6KB
loading.gif 4KB
jquery.ui.plupload.js 38KB
css
jquery.ui.plupload.css 6KB
plupload.min.js 15KB
qiniu
qiniu.js 60KB
.gitkeep 0B
css
reset.css 2KB
共 27 条
- 1
资源评论
show_code
- 粉丝: 268
- 资源: 46
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功