dyqc_hdapp/utils/weCropper.js

/**
 * we-cropper v1.3.9
 * (c) 2020 dlhandsome
 * @license MIT
 */
(function(global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
		typeof define === 'function' && define.amd ? define(factory) :
		(global.WeCropper = factory());
}(this, (function() {
	'use strict';
 
	var device = void 0;
	var TOUCH_STATE = ['touchstarted', 'touchmoved', 'touchended'];
 
	function firstLetterUpper(str) {
		return str.charAt(0).toUpperCase() + str.slice(1)
	}
 
	function setTouchState(instance) {
		var arg = [],
			len = arguments.length - 1;
		while (len-- > 0) arg[len] = arguments[len + 1];
 
		TOUCH_STATE.forEach(function(key, i) {
			if (arg[i] !== undefined) {
				instance[key] = arg[i];
			}
		});
	}
 
	function validator(instance, o) {
		Object.defineProperties(instance, o);
	}
 
	function getDevice() {
		if (!device) {
			device = uni.getSystemInfoSync();
		}
		return device
	}
 
	var tmp = {};
 
	var ref = getDevice();
	var pixelRatio = ref.pixelRatio;
 
	var DEFAULT = {
		id: {
			default: 'cropper',
			get: function get() {
				return tmp.id
			},
			set: function set(value) {
				if (typeof(value) !== 'string') {
					console.error(("id：" + value + " is invalid"));
				}
				tmp.id = value;
			}
		},
		width: {
			default: 750,
			get: function get() {
				return tmp.width
			},
			set: function set(value) {
				if (typeof(value) !== 'number') {
					console.error(("width：" + value + " is invalid"));
				}
				tmp.width = value;
			}
		},
		height: {
			default: 750,
			get: function get() {
				return tmp.height
			},
			set: function set(value) {
				if (typeof(value) !== 'number') {
					console.error(("height：" + value + " is invalid"));
				}
				tmp.height = value;
			}
		},
		pixelRatio: {
			default: pixelRatio,
			get: function get() {
				return tmp.pixelRatio
			},
			set: function set(value) {
				if (typeof(value) !== 'number') {
					console.error(("pixelRatio：" + value + " is invalid"));
				}
				tmp.pixelRatio = value;
			}
		},
		scale: {
			default: 2.5,
			get: function get() {
				return tmp.scale
			},
			set: function set(value) {
				if (typeof(value) !== 'number') {
					console.error(("scale：" + value + " is invalid"));
				}
				tmp.scale = value;
			}
		},
		zoom: {
			default: 5,
			get: function get() {
				return tmp.zoom
			},
			set: function set(value) {
				if (typeof(value) !== 'number') {
					console.error(("zoom：" + value + " is invalid"));
				} else if (value < 0 || value > 10) {
					console.error("zoom should be ranged in 0 ~ 10");
				}
				tmp.zoom = value;
			}
		},
		src: {
			default: '',
			get: function get() {
				return tmp.src
			},
			set: function set(value) {
				if (typeof(value) !== 'string') {
					console.error(("src：" + value + " is invalid"));
				}
				tmp.src = value;
			}
		},
		cut: {
			default: {},
			get: function get() {
				return tmp.cut
			},
			set: function set(value) {
				if (typeof(value) !== 'object') {
					console.error(("cut：" + value + " is invalid"));
				}
				tmp.cut = value;
			}
		},
		boundStyle: {
			default: {},
			get: function get() {
				return tmp.boundStyle
			},
			set: function set(value) {
				if (typeof(value) !== 'object') {
					console.error(("boundStyle：" + value + " is invalid"));
				}
				tmp.boundStyle = value;
			}
		},
		onReady: {
			default: null,
			get: function get() {
				return tmp.ready
			},
			set: function set(value) {
				tmp.ready = value;
			}
		},
		onBeforeImageLoad: {
			default: null,
			get: function get() {
				return tmp.beforeImageLoad
			},
			set: function set(value) {
				tmp.beforeImageLoad = value;
			}
		},
		onImageLoad: {
			default: null,
			get: function get() {
				return tmp.imageLoad
			},
			set: function set(value) {
				tmp.imageLoad = value;
			}
		},
		onBeforeDraw: {
			default: null,
			get: function get() {
				return tmp.beforeDraw
			},
			set: function set(value) {
				tmp.beforeDraw = value;
			}
		}
	};
 
	var ref$1 = getDevice();
	var windowWidth = ref$1.windowWidth;
 
	function prepare() {
		var self = this;
 
		// v1.4.0 版本中将不再自动绑定we-cropper实例
		self.attachPage = function() {
			var pages = getCurrentPages();
			// 获取到当前page上下文
			var pageContext = pages[pages.length - 1];
			// 把this依附在Page上下文的wecropper属性上，便于在page钩子函数中访问
			Object.defineProperty(pageContext, 'wecropper', {
				get: function get() {
					console.warn(
						'Instance will not be automatically bound to the page after v1.4.0\n\n' +
						'Please use a custom instance name instead\n\n' +
						'Example: \n' +
						'this.mycropper = new WeCropper(options)\n\n' +
						'// ...\n' +
						'this.mycropper.getCropperImage()'
					);
					return self
				},
				configurable: true
			});
		};
 
		self.createCtx = function() {
			var id = self.id;
			var targetId = self.targetId;
 
			if (id) {
				self.ctx = self.ctx || uni.createCanvasContext(id);
				self.targetCtx = self.targetCtx || uni.createCanvasContext(targetId);
			} else {
				console.error("constructor: create canvas context failed, 'id' must be valuable");
			}
		};
 
		self.deviceRadio = windowWidth / 750;
	}
 
	var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !==
		'undefined' ? self : {};
 
 
 
 
 
	function createCommonjsModule(fn, module) {
		return module = {
			exports: {}
		}, fn(module, module.exports), module.exports;
	}
 
	var tools = createCommonjsModule(function(module, exports) {
		/**
		 * String type check
		 */
		exports.isStr = function(v) {
			return typeof v === 'string';
		};
		/**
		 * Number type check
		 */
		exports.isNum = function(v) {
			return typeof v === 'number';
		};
		/**
		 * Array type check
		 */
		exports.isArr = Array.isArray;
		/**
		 * undefined type check
		 */
		exports.isUndef = function(v) {
			return v === undefined;
		};
 
		exports.isTrue = function(v) {
			return v === true;
		};
 
		exports.isFalse = function(v) {
			return v === false;
		};
		/**
		 * Function type check
		 */
		exports.isFunc = function(v) {
			return typeof v === 'function';
		};
		/**
		 * Quick object check - this is primarily used to tell
		 * Objects from primitive values when we know the value
		 * is a JSON-compliant type.
		 */
		exports.isObj = exports.isObject = function(obj) {
			return obj !== null && typeof obj === 'object'
		};
 
		/**
		 * Strict object type check. Only returns true
		 * for plain JavaScript objects.
		 */
		var _toString = Object.prototype.toString;
		exports.isPlainObject = function(obj) {
			return _toString.call(obj) === '[object Object]'
		};
 
		/**
		 * Check whether the object has the property.
		 */
		var hasOwnProperty = Object.prototype.hasOwnProperty;
		exports.hasOwn = function(obj, key) {
			return hasOwnProperty.call(obj, key)
		};
 
		/**
		 * Perform no operation.
		 * Stubbing args to make Flow happy without leaving useless transpiled code
		 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
		 */
		exports.noop = function(a, b, c) {};
 
		/**
		 * Check if val is a valid array index.
		 */
		exports.isValidArrayIndex = function(val) {
			var n = parseFloat(String(val));
			return n >= 0 && Math.floor(n) === n && isFinite(val)
		};
	});
 
	var tools_7 = tools.isFunc;
	var tools_10 = tools.isPlainObject;
 
	var EVENT_TYPE = ['ready', 'beforeImageLoad', 'beforeDraw', 'imageLoad'];
 
	function observer() {
		var self = this;
 
		self.on = function(event, fn) {
			if (EVENT_TYPE.indexOf(event) > -1) {
				if (tools_7(fn)) {
					event === 'ready' ?
						fn(self) :
						self[("on" + (firstLetterUpper(event)))] = fn;
				}
			} else {
				console.error(("event: " + event + " is invalid"));
			}
			return self
		};
	}
 
	function wxPromise(fn) {
		return function(obj) {
			var args = [],
				len = arguments.length - 1;
			while (len-- > 0) args[len] = arguments[len + 1];
 
			if (obj === void 0) obj = {};
			console.log('wxPromise 调用:', fn.name || '未知函数', '参数:', JSON.stringify(obj));
			return new Promise(function(resolve, reject) {
				obj.success = function(res) {
					console.log('wxPromise 成功:', fn.name || '未知函数', '结果:', res);
					resolve(res);
				};
				obj.fail = function(err) {
					console.error('wxPromise 失败:', fn.name || '未知函数', '错误:', err);
					reject(err);
				};
				obj.complete = function() {
					console.log('wxPromise 完成:', fn.name || '未知函数');
				};
				try {
					fn.apply(void 0, [obj].concat(args));
				} catch (error) {
					console.error('wxPromise 执行异常:', fn.name || '未知函数', '错误:', error);
					reject(error);
				}
			})
		}
	}
 
	function draw(ctx, reserve) {
		if (reserve === void 0) reserve = false;
 
		console.log('开始绘制 canvas');
		return new Promise(function(resolve, reject) {
			try {
				if (!ctx) {
					console.error('绘制失败: ctx 为空');
					reject(new Error('绘制失败: ctx 为空'));
					return;
				}
				
				// 直接绘制，不使用延时，避免额外问题
				ctx.draw(reserve, function(res) {
					console.log('绘制完成', res);
					// 给一点时间让绘制完成
					setTimeout(function() {
						resolve(res);
					}, 200);
				});
			} catch (error) {
				console.error('绘制出错:', error);
				reject(error);
			}
		})
	}
 
	var getImageInfo = wxPromise(uni.getImageInfo);
 
	var canvasToTempFilePath = wxPromise(uni.canvasToTempFilePath);
 
	var base64 = createCommonjsModule(function(module, exports) {
		/*! http://mths.be/base64 v0.1.0 by @mathias | MIT license */
		(function(root) {
 
			// Detect free variables `exports`.
			var freeExports = 'object' == 'object' && exports;
 
			// Detect free variable `module`.
			var freeModule = 'object' == 'object' && module &&
				module.exports == freeExports && module;
 
			// Detect free variable `global`, from Node.js or Browserified code, and use
			// it as `root`.
			var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
			if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
				root = freeGlobal;
			}
 
			/*--------------------------------------------------------------------------*/
 
			var InvalidCharacterError = function(message) {
				this.message = message;
			};
			InvalidCharacterError.prototype = new Error;
			InvalidCharacterError.prototype.name = 'InvalidCharacterError';
 
			var error = function(message) {
				// Note: the error messages used throughout this file match those used by
				// the native `atob`/`btoa` implementation in Chromium.
				throw new InvalidCharacterError(message);
			};
 
			var TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
			// http://whatwg.org/html/common-microsyntaxes.html#space-character
			var REGEX_SPACE_CHARACTERS = /[\t\n\f\r ]/g;
 
			// `decode` is designed to be fully compatible with `atob` as described in the
			// HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob
			// The optimized base64-decoding algorithm used is based on @atk's excellent
			// implementation. https://gist.github.com/atk/1020396
			var decode = function(input) {
				input = String(input)
					.replace(REGEX_SPACE_CHARACTERS, '');
				var length = input.length;
				if (length % 4 == 0) {
					input = input.replace(/==?$/, '');
					length = input.length;
				}
				if (
					length % 4 == 1 ||
					// http://whatwg.org/C#alphanumeric-ascii-characters
					/[^+a-zA-Z0-9/]/.test(input)
				) {
					error(
						'Invalid character: the string to be decoded is not correctly encoded.'
					);
				}
				var bitCounter = 0;
				var bitStorage;
				var buffer;
				var output = '';
				var position = -1;
				while (++position < length) {
					buffer = TABLE.indexOf(input.charAt(position));
					bitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;
					// Unless this is the first of a group of 4 characters…
					if (bitCounter++ % 4) {
						// …convert the first 8 bits to a single ASCII character.
						output += String.fromCharCode(
							0xFF & bitStorage >> (-2 * bitCounter & 6)
						);
					}
				}
				return output;
			};
 
			// `encode` is designed to be fully compatible with `btoa` as described in the
			// HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa
			var encode = function(input) {
				input = String(input);
				if (/[^\0-\xFF]/.test(input)) {
					// Note: no need to special-case astral symbols here, as surrogates are
					// matched, and the input is supposed to only contain ASCII anyway.
					error(
						'The string to be encoded contains characters outside of the ' +
						'Latin1 range.'
					);
				}
				var padding = input.length % 3;
				var output = '';
				var position = -1;
				var a;
				var b;
				var c;
				var buffer;
				// Make sure any padding is handled outside of the loop.
				var length = input.length - padding;
 
				while (++position < length) {
					// Read three bytes, i.e. 24 bits.
					a = input.charCodeAt(position) << 16;
					b = input.charCodeAt(++position) << 8;
					c = input.charCodeAt(++position);
					buffer = a + b + c;
					// Turn the 24 bits into four chunks of 6 bits each, and append the
					// matching character for each of them to the output.
					output += (
						TABLE.charAt(buffer >> 18 & 0x3F) +
						TABLE.charAt(buffer >> 12 & 0x3F) +
						TABLE.charAt(buffer >> 6 & 0x3F) +
						TABLE.charAt(buffer & 0x3F)
					);
				}
 
				if (padding == 2) {
					a = input.charCodeAt(position) << 8;
					b = input.charCodeAt(++position);
					buffer = a + b;
					output += (
						TABLE.charAt(buffer >> 10) +
						TABLE.charAt((buffer >> 4) & 0x3F) +
						TABLE.charAt((buffer << 2) & 0x3F) +
						'='
					);
				} else if (padding == 1) {
					buffer = input.charCodeAt(position);
					output += (
						TABLE.charAt(buffer >> 2) +
						TABLE.charAt((buffer << 4) & 0x3F) +
						'=='
					);
				}
 
				return output;
			};
 
			var base64 = {
				'encode': encode,
				'decode': decode,
				'version': '0.1.0'
			};
 
			// Some AMD build optimizers, like r.js, check for specific condition patterns
			// like the following:
			if (
				typeof undefined == 'function' &&
				typeof undefined.amd == 'object' &&
				undefined.amd
			) {
				undefined(function() {
					return base64;
				});
			} else if (freeExports && !freeExports.nodeType) {
				if (freeModule) { // in Node.js or RingoJS v0.8.0+
					freeModule.exports = base64;
				} else { // in Narwhal or RingoJS v0.7.0-
					for (var key in base64) {
						base64.hasOwnProperty(key) && (freeExports[key] = base64[key]);
					}
				}
			} else { // in Rhino or a web browser
				root.base64 = base64;
			}
 
		}(commonjsGlobal));
	});
 
	function makeURI(strData, type) {
		return 'data:' + type + ';base64,' + strData
	}
 
	function fixType(type) {
		type = type.toLowerCase().replace(/jpg/i, 'jpeg');
		var r = type.match(/png|jpeg|bmp|gif/)[0];
		return 'image/' + r
	}
 
	function encodeData(data) {
		var str = '';
		if (typeof data === 'string') {
			str = data;
		} else {
			for (var i = 0; i < data.length; i++) {
				str += String.fromCharCode(data[i]);
			}
		}
		return base64.encode(str)
	}
 
	/**
	 * 获取图像区域隐含的像素数据
	 * @param canvasId canvas标识
	 * @param x 将要被提取的图像数据矩形区域的左上角 x 坐标
	 * @param y 将要被提取的图像数据矩形区域的左上角 y 坐标
	 * @param width 将要被提取的图像数据矩形区域的宽度
	 * @param height 将要被提取的图像数据矩形区域的高度
	 * @param done 完成回调
	 */
	function getImageData(canvasId, x, y, width, height, done) {
		uni.canvasGetImageData({
			canvasId: canvasId,
			x: x,
			y: y,
			width: width,
			height: height,
			success: function success(res) {
				done(res, null);
			},
			fail: function fail(res) {
				done(null, res);
			}
		});
	}
 
	/**
	 * 生成bmp格式图片
	 * 按照规则生成图片响应头和响应体
	 * @param oData 用来描述 canvas 区域隐含的像素数据 { data, width, height } = oData
	 * @returns {*} base64字符串
	 */
	function genBitmapImage(oData) {
		//
		// BITMAPFILEHEADER: http://msdn.microsoft.com/en-us/library/windows/desktop/dd183374(v=vs.85).aspx
		// BITMAPINFOHEADER: http://msdn.microsoft.com/en-us/library/dd183376.aspx
		//
		var biWidth = oData.width;
		var biHeight = oData.height;
		var biSizeImage = biWidth * biHeight * 3;
		var bfSize = biSizeImage + 54; // total header size = 54 bytes
 
		//
		//  typedef struct tagBITMAPFILEHEADER {
		//  	WORD bfType;
		//  	DWORD bfSize;
		//  	WORD bfReserved1;
		//  	WORD bfReserved2;
		//  	DWORD bfOffBits;
		//  } BITMAPFILEHEADER;
		//
		var BITMAPFILEHEADER = [
			// WORD bfType -- The file type signature; must be "BM"
			0x42, 0x4D,
			// DWORD bfSize -- The size, in bytes, of the bitmap file
			bfSize & 0xff, bfSize >> 8 & 0xff, bfSize >> 16 & 0xff, bfSize >> 24 & 0xff,
			// WORD bfReserved1 -- Reserved; must be zero
			0, 0,
			// WORD bfReserved2 -- Reserved; must be zero
			0, 0,
			// DWORD bfOffBits -- The offset, in bytes, from the beginning of the BITMAPFILEHEADER structure to the bitmap bits.
			54, 0, 0, 0
		];
 
		//
		//  typedef struct tagBITMAPINFOHEADER {
		//  	DWORD biSize;
		//  	LONG  biWidth;
		//  	LONG  biHeight;
		//  	WORD  biPlanes;
		//  	WORD  biBitCount;
		//  	DWORD biCompression;
		//  	DWORD biSizeImage;
		//  	LONG  biXPelsPerMeter;
		//  	LONG  biYPelsPerMeter;
		//  	DWORD biClrUsed;
		//  	DWORD biClrImportant;
		//  } BITMAPINFOHEADER, *PBITMAPINFOHEADER;
		//
		var BITMAPINFOHEADER = [
			// DWORD biSize -- The number of bytes required by the structure
			40, 0, 0, 0,
			// LONG biWidth -- The width of the bitmap, in pixels
			biWidth & 0xff, biWidth >> 8 & 0xff, biWidth >> 16 & 0xff, biWidth >> 24 & 0xff,
			// LONG biHeight -- The height of the bitmap, in pixels
			biHeight & 0xff, biHeight >> 8 & 0xff, biHeight >> 16 & 0xff, biHeight >> 24 & 0xff,
			// WORD biPlanes -- The number of planes for the target device. This value must be set to 1
			1, 0,
			// WORD biBitCount -- The number of bits-per-pixel, 24 bits-per-pixel -- the bitmap
			// has a maximum of 2^24 colors (16777216, Truecolor)
			24, 0,
			// DWORD biCompression -- The type of compression, BI_RGB (code 0) -- uncompressed
			0, 0, 0, 0,
			// DWORD biSizeImage -- The size, in bytes, of the image. This may be set to zero for BI_RGB bitmaps
			biSizeImage & 0xff, biSizeImage >> 8 & 0xff, biSizeImage >> 16 & 0xff, biSizeImage >> 24 & 0xff,
			// LONG biXPelsPerMeter, unused
			0, 0, 0, 0,
			// LONG biYPelsPerMeter, unused
			0, 0, 0, 0,
			// DWORD biClrUsed, the number of color indexes of palette, unused
			0, 0, 0, 0,
			// DWORD biClrImportant, unused
			0, 0, 0, 0
		];
 
		var iPadding = (4 - ((biWidth * 3) % 4)) % 4;
 
		var aImgData = oData.data;
 
		var strPixelData = '';
		var biWidth4 = biWidth << 2;
		var y = biHeight;
		var fromCharCode = String.fromCharCode;
 
		do {
			var iOffsetY = biWidth4 * (y - 1);
			var strPixelRow = '';
			for (var x = 0; x < biWidth; x++) {
				var iOffsetX = x << 2;
				strPixelRow += fromCharCode(aImgData[iOffsetY + iOffsetX + 2]) +
					fromCharCode(aImgData[iOffsetY + iOffsetX + 1]) +
					fromCharCode(aImgData[iOffsetY + iOffsetX]);
			}
 
			for (var c = 0; c < iPadding; c++) {
				strPixelRow += String.fromCharCode(0);
			}
 
			strPixelData += strPixelRow;
		} while (--y)
 
		var strEncoded = encodeData(BITMAPFILEHEADER.concat(BITMAPINFOHEADER)) + encodeData(strPixelData);
 
		return strEncoded
	}
 
	/**
	 * 转换为图片base64
	 * @param canvasId canvas标识
	 * @param x 将要被提取的图像数据矩形区域的左上角 x 坐标
	 * @param y 将要被提取的图像数据矩形区域的左上角 y 坐标
	 * @param width 将要被提取的图像数据矩形区域的宽度
	 * @param height 将要被提取的图像数据矩形区域的高度
	 * @param type 转换图片类型
	 * @param done 完成回调
	 */
	function convertToImage(canvasId, x, y, width, height, type, done) {
		if (done === void 0) done = function() {};
 
		if (type === undefined) {
			type = 'png';
		}
		type = fixType(type);
		if (/bmp/.test(type)) {
			getImageData(canvasId, x, y, width, height, function(data, err) {
				var strData = genBitmapImage(data);
				tools_7(done) && done(makeURI(strData, 'image/' + type), err);
			});
		} else {
			console.error('暂不支持生成\'' + type + '\'类型的base64图片');
		}
	}
 
	var CanvasToBase64 = {
		convertToImage: convertToImage,
		// convertToPNG: function (width, height, done) {
		//   return convertToImage(width, height, 'png', done)
		// },
		// convertToJPEG: function (width, height, done) {
		//   return convertToImage(width, height, 'jpeg', done)
		// },
		// convertToGIF: function (width, height, done) {
		//   return convertToImage(width, height, 'gif', done)
		// },
		convertToBMP: function(ref, done) {
			if (ref === void 0) ref = {};
			var canvasId = ref.canvasId;
			var x = ref.x;
			var y = ref.y;
			var width = ref.width;
			var height = ref.height;
			if (done === void 0) done = function() {};
 
			return convertToImage(canvasId, x, y, width, height, 'bmp', done)
		}
	};
 
	function methods() {
		var self = this;
 
		var boundWidth = self.width; // 裁剪框默认宽度，即整个画布宽度
		var boundHeight = self.height; // 裁剪框默认高度，即整个画布高度
 
		var id = self.id;
		var targetId = self.targetId;
		var pixelRatio = self.pixelRatio;
 
		var ref = self.cut;
		var x = ref.x;
		if (x === void 0) x = 0;
		var y = ref.y;
		if (y === void 0) y = 0;
		var width = ref.width;
		if (width === void 0) width = boundWidth;
		var height = ref.height;
		if (height === void 0) height = boundHeight;
 
		self.updateCanvas = function(done) {
			if (self.croperTarget) {
				//  画布绘制图片
				self.ctx.drawImage(
					self.croperTarget,
					self.imgLeft,
					self.imgTop,
					self.scaleWidth,
					self.scaleHeight
				);
			}
			tools_7(self.onBeforeDraw) && self.onBeforeDraw(self.ctx, self);
 
			self.setBoundStyle(self.boundStyle); //	设置边界样式
 
			self.ctx.draw(false, done);
			return self
		};
 
		self.pushOrign = function(src) {
			self.src = src;
 
			tools_7(self.onBeforeImageLoad) && self.onBeforeImageLoad(self.ctx, self);
 
			return getImageInfo({
					src: src
				})
				.then(function(res) {
					var innerAspectRadio = res.width / res.height;
					var customAspectRadio = width / height;
 
					self.croperTarget = res.path;
 
					if (innerAspectRadio < customAspectRadio) {
						self.rectX = x;
						self.baseWidth = width;
						self.baseHeight = width / innerAspectRadio;
						self.rectY = y - Math.abs((height - self.baseHeight) / 2);
					} else {
						self.rectY = y;
						self.baseWidth = height * innerAspectRadio;
						self.baseHeight = height;
						self.rectX = x - Math.abs((width - self.baseWidth) / 2);
					}
 
					self.imgLeft = self.rectX;
					self.imgTop = self.rectY;
					self.scaleWidth = self.baseWidth;
					self.scaleHeight = self.baseHeight;
 
					self.update();
 
					return new Promise(function(resolve) {
						self.updateCanvas(resolve);
					})
				})
				.then(function() {
					tools_7(self.onImageLoad) && self.onImageLoad(self.ctx, self);
				})
		};
 
		self.removeImage = function() {
			self.src = '';
			self.croperTarget = '';
			return draw(self.ctx)
		};
 
		self.getCropperBase64 = function(done) {
			if (done === void 0) done = function() {};
 
			CanvasToBase64.convertToBMP({
				canvasId: id,
				x: x,
				y: y,
				width: width,
				height: height
			}, done);
		};
 
		self.getCropperImage = function(opt, fn) {
			var customOptions = opt;
 
			var canvasOptions = {
				canvasId: id,
				x: x,
				y: y,
				width: width,
				height: height
			};
 
			var task = function() {
				return Promise.resolve();
			};
 
			if (
				tools_10(customOptions) &&
				customOptions.original
			) {
				// original mode
				task = function() {
					self.targetCtx.drawImage(
						self.croperTarget,
						self.imgLeft * pixelRatio,
						self.imgTop * pixelRatio,
						self.scaleWidth * pixelRatio,
						self.scaleHeight * pixelRatio
					);
 
					canvasOptions = {
						canvasId: targetId,
						x: x * pixelRatio,
						y: y * pixelRatio,
						width: width * pixelRatio,
						height: height * pixelRatio
					};
 
					return draw(self.targetCtx)
				};
			}
 
			return task()
				.then(function() {
					if (tools_10(customOptions)) {
						canvasOptions = Object.assign({}, canvasOptions, customOptions);
					}
 
					if (tools_7(customOptions)) {
						fn = customOptions;
					}
 
					// Check if circular crop is requested
					var isCircular = customOptions && customOptions.shape === 'circle';
					
					if (isCircular) {
						// 使用更简单的方法实现圆形裁剪
						console.log('使用简化方法进行圆形裁剪');
						
						// 先使用普通方式裁剪出矩形
						var rectOptions = Object.assign({}, canvasOptions);
						
						// 确保有正确的输出尺寸
						var destWidth = customOptions.destWidth || width;
						var destHeight = customOptions.destHeight || height;
						
						// 先获取矩形裁剪的临时文件
						return canvasToTempFilePath.apply(null, [rectOptions])
							.then(function(res) {
								console.log('矩形裁剪完成，开始圆形处理');
								var rectPath = res.tempFilePath;
								
								// 创建新的画布进行圆形裁剪
								var circleCanvas = self.targetCtx;
								
								// 清空画布
								circleCanvas.clearRect(0, 0, destWidth, destHeight);
								
								// 创建圆形路径
								circleCanvas.save();
								circleCanvas.beginPath();
								var centerX = destWidth / 2;
								var centerY = destHeight / 2;
								var radius = Math.min(destWidth, destHeight) / 2;
								circleCanvas.arc(centerX, centerY, radius, 0, 2 * Math.PI);
								circleCanvas.clip();
								
								// 加载裁剪后的图片
								return getImageInfo({ src: rectPath })
									.then(function(imgInfo) {
										console.log('加载裁剪图片信息:', imgInfo);
										
										// 绘制到圆形区域
										circleCanvas.drawImage(
											rectPath,
											0,
											0,
											imgInfo.width,
											imgInfo.height,
											0,
											0,
											destWidth,
											destHeight
										);
										
										circleCanvas.restore();
										
										// 绘制并导出 - 不再绘制边框
										return draw(circleCanvas)
											.then(function() {
												var circleOptions = {
													canvasId: targetId,
													x: 0,
													y: 0,
													width: destWidth,
													height: destHeight,
													destWidth: destWidth,
													destHeight: destHeight,
													fileType: customOptions.fileType || 'png'
												};
												
												return canvasToTempFilePath.apply(null, [circleOptions]);
											});
									});
							});
					}

					var arg = canvasOptions.componentContext ?
						[canvasOptions, canvasOptions.componentContext] :
						[canvasOptions];

					return canvasToTempFilePath.apply(null, arg)
				})
				.then(function(res) {
					var tempFilePath = res.tempFilePath;

					return tools_7(fn) ?
						fn.call(self, tempFilePath, null) :
						tempFilePath
				})
				.catch(function(err) {
					if (tools_7(fn)) {
						fn.call(self, null, err);
					} else {
						throw err
					}
				})
		};
	}
 
	/**
	 * 获取最新缩放值
	 * @param oldScale 上一次触摸结束后的缩放值
	 * @param oldDistance 上一次触摸结束后的双指距离
	 * @param zoom 缩放系数
	 * @param touch0 第一指touch对象
	 * @param touch1 第二指touch对象
	 * @returns {*}
	 */
	var getNewScale = function(oldScale, oldDistance, zoom, touch0, touch1) {
		var xMove, yMove, newDistance;
		// 计算二指最新距离
		xMove = Math.round(touch1.x - touch0.x);
		yMove = Math.round(touch1.y - touch0.y);
		newDistance = Math.round(Math.sqrt(xMove * xMove + yMove * yMove));
 
		return oldScale + 0.001 * zoom * (newDistance - oldDistance)
	};
 
	function update() {
		var self = this;
 
		if (!self.src) {
			return
		}
 
		self.__oneTouchStart = function(touch) {
			self.touchX0 = Math.round(touch.x);
			self.touchY0 = Math.round(touch.y);
		};
 
		self.__oneTouchMove = function(touch) {
			var xMove, yMove;
			// 计算单指移动的距离
			if (self.touchended) {
				return self.updateCanvas()
			}
			xMove = Math.round(touch.x - self.touchX0);
			yMove = Math.round(touch.y - self.touchY0);
 
			var imgLeft = Math.round(self.rectX + xMove);
			var imgTop = Math.round(self.rectY + yMove);
 
			self.outsideBound(imgLeft, imgTop);
 
			self.updateCanvas();
		};
 
		self.__twoTouchStart = function(touch0, touch1) {
			var xMove, yMove, oldDistance;
 
			self.touchX1 = Math.round(self.rectX + self.scaleWidth / 2);
			self.touchY1 = Math.round(self.rectY + self.scaleHeight / 2);
 
			// 计算两指距离
			xMove = Math.round(touch1.x - touch0.x);
			yMove = Math.round(touch1.y - touch0.y);
			oldDistance = Math.round(Math.sqrt(xMove * xMove + yMove * yMove));
 
			self.oldDistance = oldDistance;
		};
 
		self.__twoTouchMove = function(touch0, touch1) {
			var oldScale = self.oldScale;
			var oldDistance = self.oldDistance;
			var scale = self.scale;
			var zoom = self.zoom;
 
			self.newScale = getNewScale(oldScale, oldDistance, zoom, touch0, touch1);
 
			//  设定缩放范围
			self.newScale <= 1 && (self.newScale = 1);
			self.newScale >= scale && (self.newScale = scale);
 
			self.scaleWidth = Math.round(self.newScale * self.baseWidth);
			self.scaleHeight = Math.round(self.newScale * self.baseHeight);
			var imgLeft = Math.round(self.touchX1 - self.scaleWidth / 2);
			var imgTop = Math.round(self.touchY1 - self.scaleHeight / 2);
 
			self.outsideBound(imgLeft, imgTop);
 
			self.updateCanvas();
		};
 
		self.__xtouchEnd = function() {
			self.oldScale = self.newScale;
			self.rectX = self.imgLeft;
			self.rectY = self.imgTop;
		};
	}
 
	var handle = {
		//  图片手势初始监测
		touchStart: function touchStart(e) {
			var self = this;
			var ref = e.touches;
			var touch0 = ref[0];
			var touch1 = ref[1];
 
			if (!self.src) {
				return
			}
 
			setTouchState(self, true, null, null);
 
			// 计算第一个触摸点的位置，并参照改点进行缩放
			self.__oneTouchStart(touch0);
 
			// 两指手势触发
			if (e.touches.length >= 2) {
				self.__twoTouchStart(touch0, touch1);
			}
		},
 
		//  图片手势动态缩放
		touchMove: function touchMove(e) {
			var self = this;
			var ref = e.touches;
			var touch0 = ref[0];
			var touch1 = ref[1];
 
			if (!self.src) {
				return
			}
 
			setTouchState(self, null, true);
 
			// 单指手势时触发
			if (e.touches.length === 1) {
				self.__oneTouchMove(touch0);
			}
			// 两指手势触发
			if (e.touches.length >= 2) {
				self.__twoTouchMove(touch0, touch1);
			}
		},
 
		touchEnd: function touchEnd(e) {
			var self = this;
 
			if (!self.src) {
				return
			}
 
			setTouchState(self, false, false, true);
			self.__xtouchEnd();
		}
	};
 
	function cut() {
		var self = this;
		var boundWidth = self.width; // 裁剪框默认宽度，即整个画布宽度
		var boundHeight = self.height;
		// 裁剪框默认高度，即整个画布高度
		var ref = self.cut;
		var x = ref.x;
		if (x === void 0) x = 0;
		var y = ref.y;
		if (y === void 0) y = 0;
		var width = ref.width;
		if (width === void 0) width = boundWidth;
		var height = ref.height;
		if (height === void 0) height = boundHeight;
 
		/**
		 * 设置边界
		 * @param imgLeft 图片左上角横坐标值
		 * @param imgTop 图片左上角纵坐标值
		 */
		self.outsideBound = function(imgLeft, imgTop) {
			self.imgLeft = imgLeft >= x ?
				x :
				self.scaleWidth + imgLeft - x <= width ?
				x + width - self.scaleWidth :
				imgLeft;
 
			self.imgTop = imgTop >= y ?
				y :
				self.scaleHeight + imgTop - y <= height ?
				y + height - self.scaleHeight :
				imgTop;
		};
 
		/**
		 * 设置边界样式
		 * @param color	边界颜色
		 */
		self.setBoundStyle = function(ref) {
			if (ref === void 0) ref = {};
			var color = ref.color;
			if (color === void 0) color = '#ffffff';
			var mask = ref.mask;
			if (mask === void 0) mask = 'rgba(0, 0, 0, 0)';
			var lineWidth = ref.lineWidth;
			if (lineWidth === void 0) lineWidth = 1;
			var isCircle = ref.isCircle;
			if (isCircle === void 0) isCircle = true;  // 默认使用圆形边框

			var half = lineWidth / 2;
			
			// Check if we want a circular boundary instead of rectangular
			if (isCircle) {
				// Calculate center and radius
				var centerX = x + width / 2;
				var centerY = y + height / 2;
				var radius = width / 2; // Assuming width = height for a circle
				
				// Draw the mask (everything outside the circle)
				self.ctx.beginPath();
				self.ctx.setFillStyle(mask);
				// Draw a rectangle covering the entire canvas
				self.ctx.fillRect(0, 0, boundWidth, boundHeight);
				
				// Create a circular hole in the mask
				self.ctx.beginPath();
				self.ctx.arc(centerX, centerY, radius, 0, 2 * Math.PI);
				self.ctx.setFillStyle('transparent');
				self.ctx.fill();
				
				// Draw the border circle
				self.ctx.beginPath();
				self.ctx.arc(centerX, centerY, radius, 0, 2 * Math.PI);
				self.ctx.setStrokeStyle(color);
				self.ctx.setLineWidth(lineWidth);
				self.ctx.stroke();
			} else {
				// Original rectangular boundary code
				var boundOption = [{
						start: {
							x: x - half,
							y: y + 10 - half
						},
						step1: {
							x: x - half,
							y: y - half
						},
						step2: {
							x: x + 10 - half,
							y: y - half
						}
					},
					{
						start: {
							x: x - half,
							y: y + height - 10 + half
						},
						step1: {
							x: x - half,
							y: y + height + half
						},
						step2: {
							x: x + 10 - half,
							y: y + height + half
						}
					},
					{
						start: {
							x: x + width - 10 + half,
							y: y - half
						},
						step1: {
							x: x + width + half,
							y: y - half
						},
						step2: {
							x: x + width + half,
							y: y + 10 - half
						}
					},
					{
						start: {
							x: x + width + half,
							y: y + height - 10 + half
						},
						step1: {
							x: x + width + half,
							y: y + height + half
						},
						step2: {
							x: x + width - 10 + half,
							y: y + height + half
						}
					}
				];

				// 绘制半透明层
				self.ctx.beginPath();
				self.ctx.setFillStyle(mask);
				self.ctx.fillRect(0, 0, x, boundHeight);
				self.ctx.fillRect(x, 0, width, y);
				self.ctx.fillRect(x, y + height, width, boundHeight - y - height);
				self.ctx.fillRect(x + width, 0, boundWidth - x - width, boundHeight);
				self.ctx.fill();

				boundOption.forEach(function(op) {
					self.ctx.beginPath();
					self.ctx.setStrokeStyle(color);
					self.ctx.setLineWidth(lineWidth);
					self.ctx.moveTo(op.start.x, op.start.y);
					self.ctx.lineTo(op.step1.x, op.step1.y);
					self.ctx.lineTo(op.step2.x, op.step2.y);
					self.ctx.stroke();
				});
			}
		};
	}
 
	var version = "1.3.9";
 
	var WeCropper = function WeCropper(params) {
		var self = this;
		var _default = {};
 
		validator(self, DEFAULT);
 
		Object.keys(DEFAULT).forEach(function(key) {
			_default[key] = DEFAULT[key].default;
		});
		Object.assign(self, _default, params);
 
		self.prepare();
		self.attachPage();
		self.createCtx();
		self.observer();
		self.cutt();
		self.methods();
		self.init();
		self.update();
 
		return self
	};
 
	WeCropper.prototype.init = function init() {
		var self = this;
		var src = self.src;
 
		self.version = version;
 
		typeof self.onReady === 'function' && self.onReady(self.ctx, self);
 
		if (src) {
			self.pushOrign(src);
		} else {
			self.updateCanvas();
		}
		setTouchState(self, false, false, false);
 
		self.oldScale = 1;
		self.newScale = 1;
 
		return self
	};
 
	Object.assign(WeCropper.prototype, handle);
 
	WeCropper.prototype.prepare = prepare;
	WeCropper.prototype.observer = observer;
	WeCropper.prototype.methods = methods;
	WeCropper.prototype.cutt = cut;
	WeCropper.prototype.update = update;
 
	return WeCropper;
 
})));