;var MXI_DEBUG = false;

/**

 * mOxie - multi-runtime File API & XMLHttpRequest L2 Polyfill

 * v1.3.5

 *

 * Copyright 2013, Moxiecode Systems AB

 * Released under GPL License.

 *

 * License: http://www.plupload.com/license

 * Contributing: http://www.plupload.com/contributing

 *

 * Date: 2016-05-15

 */

/**

 * Compiled inline version. (Library mode)

 */

/**

 * Modified for WordPress, Silverlight and Flash runtimes support was removed.

 * See https://core.trac.wordpress.org/ticket/41755.

 */

/*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

 */

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

	@for Utils

	@static

	@param {Object} o Object to check.

	@return {String} Object [[Class]]

	*/

	var typeOf = function(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.

	@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.

	*/

	var extend = function(target) {

		var undef;

		each(arguments, function(arg, i) {

			if (i > 0) {

				each(arg, function(value, key) {

					if (value !== undef) {

						if (typeOf(target[key]) === typeOf(value) && !!~inArray(typeOf(value), ['array', 'object'])) {

							extend(target[key], value);

						} else {

							target[key] = value;

						}

					}

				});

			}

		});

		return target;

	};

	/**

	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.

	*/

	var each = function(obj, callback) {

		var length, key, i, undef;

		if (obj) {

			if (typeOf(obj.length) === 'number') { // it might be Array, FileList or even arguments object

				// Loop array items

				for (i = 0, length = obj.length; i < length; i++) {

					if (callback(obj[i], i) === false) {

						return;

					}

				}

			} else if (typeOf(obj) === 'object') {

				// Loop object items

				for (key in obj) {

					if (obj.hasOwnProperty(key)) {

						if (callback(obj[key], key) === false) {

							return;

						}

					}

				}

			}

		}

	};

	/**

	Checks if object is empty.

	@method isEmptyObj

	@static

	@param {Object} o Object to check.

	@return {Boolean}

	*/

	var isEmptyObj = function(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 Main callback that is called in the end, or in case of error

	*/

	var inSeries = function(queue, cb) {

		var i = 0, length = queue.length;

		if (typeOf(cb) !== 'function') {

			cb = function() {};

		}

		if (!queue || !queue.length) {

			cb();

		}

		function callNext(i) {

			if (typeOf(queue[i]) === 'function') {

				queue[i](function(error) {

					/*jshint expr:true */

					++i < length && !error ? callNext(i) : cb(error);

				});

			}

		}

		callNext(i);

	};

	/**

	Recieve an array of functions (usually async) to call in parallel, each  function

	receives a callback as first argument that it should call, when it completes. After 

	everything is complete, main callback is called. Passing truthy value to the

	callback as a first argument will interrupt the process and invoke main callback

	immediately.

	@method inParallel

	@static

	@param {Array} queue Array of functions to call in sequence

	@param {Function} cb Main callback that is called in the end, or in case of error

	*/

	var inParallel = function(queue, cb) {

		var count = 0, num = queue.length, cbArgs = new Array(num);

		each(queue, function(fn, i) {

			fn(function(error) {

				if (error) {

					return cb(error);

				}

				var args = [].slice.call(arguments);

				args.shift(); // strip error - undefined or not

				cbArgs[i] = args;

				count++;

				if (count === num) {

					cbArgs.unshift(null);

					cb.apply(this, cbArgs);

				} 

			});

		});

	};

	/**

	Find an element in array and return it's index if present, otherwise return -1.

	@method inArray

	@static

	@param {Mixed} needle Element to find

	@param {Array} array

	@return {Int} Index of the element, or -1 if not found

	*/

	var inArray = function(needle, array) {

		if (array) {

			if (Array.prototype.indexOf) {

				return Array.prototype.indexOf.call(array, needle);

			}

			for (var i = 0, length = array.length; i < length; i++) {

				if (array[i] === needle) {

					return i;

				}

			}

		}

		return -1;

	};

	/**

	Returns elements of first array if they are not present in second. And false - otherwise.

	@private

	@method arrayDiff

	@param {Array} needles

	@param {Array} array

	@return {Array|Boolean}

	*/

	var arrayDiff = function(needles, array) {

		var diff = [];

		if (typeOf(needles) !== 'array') {

			needles = [needles];

		}

		if (typeOf(array) !== 'array') {

			array = [array];

		}

		for (var i in needles) {

			if (inArray(needles[i], array) === -1) {

				diff.push(needles[i]);

			}	

		}

		return diff.length ? diff : false;

	};

	/**

	Find intersection of two arrays.

	@private

	@method arrayIntersect

	@param {Array} array1

	@param {Array} array2

	@return {Array} Intersection of two arrays or null if there is none

	*/

	var arrayIntersect = function(array1, array2) {

		var result = [];

		each(array1, function(item) {

			if (inArray(item, array2) !== -1) {

				result.push(item);

			}

		});

		return result.length ? result : null;

	};

	/**

	Forces anything into an array.

	@method toArray

	@static

	@param {Object} obj Object with length field.

	@return {Array} Array object containing all items.

	*/

	var toArray = function(obj) {

		var i, arr = [];

		for (i = 0; i < obj.length; i++) {

			arr[i] = obj[i];

		}

		return arr;

	};

	/**

	Generates an unique ID. The only way a user would be able to get the same ID is if the two persons

	at the same exact millisecond manage to get the same 5 random numbers between 0-65535; it also uses 

	a counter so each ID is guaranteed to be unique for the given page. It is more probable for the earth 

	to be hit with an asteroid.

	@method guid

	@static

	@param {String} prefix to prepend (by default 'o' will be prepended).

	@method guid

	@return {String} Virtually unique id.

	*/

	var guid = (function() {

		var counter = 0;

		return function(prefix) {

			var guid = new Date().getTime().toString(32), i;

			for (i = 0; i < 5; i++) {

				guid += Math.floor(Math.random() * 65535).toString(32);

			}

			return (prefix || 'o_') + guid + (counter++).toString(32);

		};

	}());

	/**

	Trims white spaces around the string

	@method trim

	@static

	@param {String} str

	@return {String}

	*/

	var trim = function(str) {

		if (!str) {

			return str;

		}

		return String.prototype.trim ? String.prototype.trim.call(str) : str.toString().replace(/^\s*/, '').replace(/\s*$/, '');

	};

	/**

	Parses the specified size string into a byte value. For example 10kb becomes 10240.

	@method parseSizeStr

	@static

	@param {String/Number} size String to parse or number to just pass through.

	@return {Number} Size in bytes.

	*/

	var parseSizeStr = function(size) {

		if (typeof(size) !== 'string') {

			return size;

		}

		var muls = {

				t: 1099511627776,

				g: 1073741824,

				m: 1048576,

				k: 1024

			},

			mul;

		size = /^([0-9\.]+)([tmgk]?)$/.exec(size.toLowerCase().replace(/[^0-9\.tmkg]/g, ''));

		mul = size[2];

		size = +size[1];

		if (muls.hasOwnProperty(mul)) {

			size *= muls[mul];

		}

		return Math.floor(size);

	};

	/**

	 * Pseudo sprintf implementation - simple way to replace tokens with specified values.

	 *

	 * @param {String} str String with tokens

	 * @return {String} String with replaced tokens

	 */

	var sprintf = function(str) {

		var args = [].slice.call(arguments, 1);

		return str.replace(/%[a-z]/g, function() {

			var value = args.shift();

			return typeOf(value) !== 'undefined' ? value : '';

		});

	};

	return {

		guid: guid,

		typeOf: typeOf,

		extend: extend,

		each: each,

		isEmptyObj: isEmptyObj,

		inSeries: inSeries,

		inParallel: inParallel,

		inArray: inArray,

		arrayDiff: arrayDiff,

		arrayIntersect: arrayIntersect,

		toArray: toArray,

		trim: trim,

		sprintf: sprintf,

		parseSizeStr: parseSizeStr

	};

});

// Included from: src/javascript/core/utils/Env.js

/**

 * Env.js

 *

 * Copyright 2013, Moxiecode Systems AB

 * Released under GPL License.

 *

 * License: http://www.plupload.com/license

 * Contributing: http://www.plupload.com/contributing

 */

define("moxie/core/utils/Env", [

	"moxie/core/utils/Basic"

], function(Basic) {

	/**

	 * UAParser.js v0.7.7

	 * Lightweight JavaScript-based User-Agent string parser

	 * https://github.com/faisalman/ua-parser-js

	 *

	 * Copyright © 2012-2015 Faisal Salman <fyzlman@gmail.com>

	 * Dual licensed under GPLv2 & MIT

	 */

	var UAParser = (function (undefined) {

	    //////////////

	    // Constants

	    /////////////

	    var EMPTY       = '',

	        UNKNOWN     = '?',