let LetData = {
	sqlServer: null,
	fofsqlite3: null,
	fofmysql: null,
	crypto: null,
	sharp: null,
	email: null,
	compress: null,
	ftp: null,
	fileFOF: null,
	DecoderAPI: null,
	SendHttp: null,
	dnsFOF: null,
	EXEAPI: null,
	PlatAPI: null,
	ReadAPI: null,
	ProcessAPI: null,
	HttpServer: null,
	TcpServer: null,
	UdpServer: null,
	IPData: null,
	BufferClass: null,
	DataPackaging: null,
	websocket: null,
	sms: null,
	excel: null,
	word: null,
	docxObj: null,
	wordPath: null,
	nodeRsa: null,
	ffiNapi: null,
	HttpProxy: null,
	TxCdn: null,
	SerialPortNode: null,
	mqttServer: null,
	modbus: null,
	printWindows: null,
	postgres: null,
	BaiDuOpencv: null,
	Alioss: null
}
//electronPreloadBegin
const { ipcRenderer } = require('electron')
window.addEventListener('DOMContentLoaded', () => {
	const replaceText = (selector, text) => {
		const element = document.getElementById(selector)
		if (element) element.innerText = text
	}
	for (const type of ['chrome', 'node', 'electron']) {
		replaceText(`${type}-version`, process.versions[type])
	}
})
ipcRenderer.on('SET_SOURCE', async (event, sizeObj) => {
	try {
		sizeObj = JSON.parse(sizeObj)
		let mandatory_ = {
			chromeMediaSource: 'desktop',
			minWidth: sizeObj["minWidth"],
			maxWidth: sizeObj["maxWidth"],
			minHeight: sizeObj["minHeight"],
			maxHeight: sizeObj["maxHeight"]
		}
		const stream = await navigator.mediaDevices.getUserMedia({
			audio: false,
			video: {
				mandatory: mandatory_
			}
		})
		try {
			if (sizeObj["图片格式"] = true) {
				const video = document.createElement('video');
				video.autoplay = true;
				video.muted = true;
				document.body.appendChild(video);
				video.srcObject = stream;
				video.style.display = 'none';
				video.onloadedmetadata = function () {
					video.play();
					setTimeout(function () {
						const canvas = document.createElement('canvas');
						canvas.width = video.videoWidth;
						canvas.height = video.videoHeight;
						const ctx = canvas.getContext('2d');
						ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
						const base64Image = canvas.toDataURL('image/png');
						系统快照事件({ "状态": "成功", "数据": stream, "图片BASE64数据": base64Image })
						document.body.removeChild(video);
					}, 10);
				};
				video.onerror = function (error) {
					document.body.removeChild(video);
					try {
						系统快照事件({ "状态": "失败", "数据": error })
					} catch (error) {

					}
				};
			} else {
				系统快照事件({ "状态": "成功", "数据": stream })
			}

		} catch (error) {

		}
	} catch (e) {
		try {
			系统快照事件({ "状态": "失败", "数据": e })
		} catch (error) {

		}
	}
})
window.electronAPI = {
	openWindows: (data) => { ipcRenderer.invoke('openWindows', data) },
	doMinWindow: (WindowsID = "") => { ipcRenderer.invoke('doMinWindow', WindowsID) },
	doCloseWindow: (WindowsID = "") => { ipcRenderer.invoke('doCloseWindow', WindowsID) },
	domaxWindow: (ifdomaxWindow = false, WindowsID = "") => { ipcRenderer.invoke('domaxWindow', ifdomaxWindow, WindowsID) },
	destroy: (WindowsID = "") => { ipcRenderer.invoke('destroy', WindowsID) },
	focus: (WindowsID = "") => { ipcRenderer.invoke('focus', WindowsID) },
	isFocused: async (WindowsID = "") => {
		let RetData = true;
		await ipcRenderer.invoke('isFocused', WindowsID).then(res => RetData = res)
		return RetData;
	},
	show: (WindowsID = "") => { ipcRenderer.invoke('show', WindowsID) },
	hide: (WindowsID = "") => { ipcRenderer.invoke('hide', WindowsID) },
	isVisible: async (WindowsID = "") => {
		let RetData = true;
		await ipcRenderer.invoke('isVisible', WindowsID).then(res => RetData = res)
		return RetData;
	},
	maximize: (WindowsID = "") => { ipcRenderer.invoke('maximize', WindowsID) },
	unmaximize: (WindowsID = "") => { ipcRenderer.invoke('unmaximize', WindowsID) },
	isMaximized: async (WindowsID = "") => {
		let RetData = false;
		await ipcRenderer.invoke('isMaximized', WindowsID).then(res => RetData = res)
		return RetData;
	},
	minimize: (WindowsID = "") => { ipcRenderer.invoke('minimize', WindowsID) },
	restore: (WindowsID = "") => { ipcRenderer.invoke('restore', WindowsID) },
	isMinimized: async (WindowsID = "") => {
		let RetData = false;
		await ipcRenderer.invoke('isMinimized', WindowsID).then(res => RetData = res)
		return RetData;
	},
	setFullScreen: (ifsetFullScreen, WindowsID = "") => { ipcRenderer.invoke('setFullScreen', ifsetFullScreen, WindowsID) },
	isFullScreen: async (WindowsID = "") => {
		let RetData = false;
		await ipcRenderer.invoke('isFullScreen', WindowsID).then(res => RetData = res)
		return RetData;
	},
	setBounds: (setBoundsData, WindowsID = "") => { ipcRenderer.invoke('setBounds', setBoundsData, WindowsID) },
	getBounds: async (WindowsID = "") => {
		let RetData = {};
		await ipcRenderer.invoke('getBounds', WindowsID).then(res => RetData = res)
		return RetData;
	},
	setWidthHeight: (setsetWidthHeight, WindowsID = "") => { ipcRenderer.invoke('setWidthHeight', setsetWidthHeight, WindowsID) },
	getWidthHeight: async (WindowsID = "") => {
		let RetData = {};
		await ipcRenderer.invoke('getWidthHeight', WindowsID).then(res => RetData = res)
		return RetData;
	},
	setResizable: (ifsetResizable, WindowsID = "") => { ipcRenderer.invoke('setResizable', ifsetResizable, WindowsID) },
	isResizable: async (WindowsID = "") => {
		let RetData = false;
		await ipcRenderer.invoke('isResizable', WindowsID).then(res => RetData = res)
		return RetData;
	},
	setMovable: (ifsetMovable, WindowsID = "") => { ipcRenderer.invoke('setMovable', ifsetMovable, WindowsID) },
	isMovable: async (WindowsID = "") => {
		let RetData = false;
		await ipcRenderer.invoke('isMovable', WindowsID).then(res => RetData = res)
		return RetData;
	},
	setMinimizable: (ifsetMinimizable, WindowsID = "") => { ipcRenderer.invoke('setMinimizable', ifsetMinimizable, WindowsID) },
	isMinimizable: async (WindowsID = "") => {
		let RetData = false;
		await ipcRenderer.invoke('isMinimizable', WindowsID).then(res => RetData = res)
		return RetData;
	},
	setMaximizable: (ifsetMaximizable, WindowsID = "") => { ipcRenderer.invoke('setMaximizable', ifsetMaximizable, WindowsID) },
	isMaximizable: async () => {
		let RetData = false;
		await ipcRenderer.invoke('isMaximizable').then(res => RetData = res)
		return RetData;
	},
	setAlwaysOnTop: (ifsetAlwaysOnTop, WindowsID = "") => { ipcRenderer.invoke('setAlwaysOnTop', ifsetAlwaysOnTop, WindowsID) },
	center: (WindowsID = "") => { ipcRenderer.invoke('center', WindowsID) },
	setSkipTaskbar: (ifsetSkipTaskbar, WindowsID = "") => { ipcRenderer.invoke('setSkipTaskbar', ifsetSkipTaskbar, WindowsID) },
	tray: (data, funEv1 = "", funEv2 = "") => {
		ipcRenderer.invoke('tray', data, funEv1, funEv2)
	},
	destroyTray: () => {
		ipcRenderer.invoke('destroyTray')
	},
	DestroyWindowID: (IndexWindowsID, WindowDependentTitleLength) => {
		//主动非主窗口销毁窗口标识，内部使用，在窗口是否可关闭代码处触发
		ipcRenderer.invoke('DestroyWindowID', IndexWindowsID, WindowDependentTitleLength)
	},
	MainDestroyWindow: () => {
		//主动销毁所有窗口，当主窗口允许关闭时使用，内部使用，在窗口是否可关闭代码处触发
		ipcRenderer.invoke('MainDestroyWindow')
	},
	initDownload: (path, ifOpen, WindowsID = "") => {
		//设置下载路径
		ipcRenderer.invoke('initDownload', path, ifOpen, WindowsID)
	},
	DownloadPause: (FileID, WindowsID = "") => {
		//暂停下载
		ipcRenderer.invoke('DownloadPause', FileID, WindowsID)
	},
	DownloadResume: (FileID, WindowsID = "") => {
		//恢复下载
		ipcRenderer.invoke('DownloadResume', FileID, WindowsID)
	},
	DownloadCancel: (FileID, WindowsID = "") => {
		//恢复下载
		ipcRenderer.invoke('DownloadCancel', FileID, WindowsID)
	},
	DownloadType: async (FileID, WindowsID = "") => {
		//获取下载状态
		let RetData = false;
		await ipcRenderer.invoke('DownloadType', FileID, WindowsID).then(res => RetData = res)
		return RetData;
	},
}
window.electronDebugAPI = {
	openDebug: (WindowsID = "") => { ipcRenderer.invoke('openDebug', WindowsID) },
	closeDevTools: (WindowsID = "") => { ipcRenderer.invoke('closeDevTools', WindowsID) },
	openDebug1: (WindowsID = "") => { ipcRenderer.invoke('openDebug1', WindowsID) },
	openDebug2: (WindowsID = "") => { ipcRenderer.invoke('openDebug2', WindowsID) },
	openDebug4: (WindowsID = "") => { ipcRenderer.invoke('openDebug4', WindowsID) },
	openDebug3: (WindowsID = "") => { ipcRenderer.invoke('openDebug3', WindowsID) },
	GetDebugOfCom: async () => {
		let RetData = "0";
		await ipcRenderer.invoke('DebugOfCom').then(res => RetData = res)
		return RetData;
	},
}
window.electronLoadAPI = {
	loadURL: (url, WindowsID = "") => { ipcRenderer.invoke('loadURL', url, WindowsID) },
	loadFile: (url, WindowsID = "") => { ipcRenderer.invoke('loadFile', url, WindowsID) },
	setCookie: (url, name, value) => {
		// Query all cookies.
		ipcRenderer.invoke('setCookie', url, name, value)
	},
	removeCookie: (url, name) => {
		// Query all cookies.
		ipcRenderer.invoke('removeCookie', url, name)
	},
}
window.electronDialogAPI = {
	showOpenDialogSync: (title, TextPath = "", funEv = undefined) => {
		ipcRenderer.invoke('showOpenDialogSync', { "名称": title, "路径": TextPath }).then(res => {
			if (funEv != undefined) {
				funEv(res);
			}
		});
	},
	showOpenDialogSyncFile: (data, funEv = undefined) => {
		ipcRenderer.invoke('showOpenDialogSyncFile', data).then(res => {
			if (funEv != undefined) {
				funEv(res);
			}
		});
	},
}
window.silentPrinting = {
	SetPrintFile: (File, data = {}) => {
		if (data["等待时间"] == undefined) {
			data["等待时间"] = 500
		}
		ipcRenderer.invoke('SetPrintFile', File)
		let Time_int = 0;
		let TimeID = setInterval(async () => {
			Time_int++;
			let RetData = await ipcRenderer.invoke('GetUrlType')
			if (RetData != "NO") {
				if (data["执行结果"] != undefined) {
					setTimeout(() => {
						data["执行结果"]({ "访问状态": "成功", "访问地址": RetData })
					}, data["等待时间"])
				}
				clearInterval(TimeID)
				return;
			}
			if (Time_int >= 600) {
				clearInterval(TimeID)
				if (data["执行结果"] != undefined) {
					data["执行结果"]({ "访问状态": "失败" })
				}
			}
		}, 100)
	},
	SetPrintHttp: async (http_, data = {}) => {
		let Time_int = 0;
		if (data["等待时间"] == undefined) {
			data["等待时间"] = 1000
		}
		ipcRenderer.invoke('SetPrintHttp', http_)
		let TimeID = setInterval(async () => {
			Time_int++;
			let RetData = await ipcRenderer.invoke('GetUrlType')
			if (RetData != "NO") {
				if (data["执行结果"] != undefined) {
					data["执行结果"]({ "访问状态": "成功", "访问地址": RetData })
				}
				clearInterval(TimeID)
				return;
			}
			if (Time_int >= 60) {
				clearInterval(TimeID)
				if (data["执行结果"] != undefined) {
					data["执行结果"]({ "访问状态": "失败" })
				}
			}
		}, data["等待时间"])
	},
	startPrintSend: (data, Fun_ = undefined) => {
		let Time_int = 0;
		let SetData = {};
		for (let key in data) {
			if (key != "执行结果") {
				SetData[key] = data[key]
			}
		}
		ipcRenderer.invoke('startPrintSend', SetData)
		if (data["打印标识"] == undefined) {
			data["超时时间"] = 600;
		}
		if (data["打印标识"]) {
			let TimeID = setInterval(async () => {
				Time_int++;
				let RetData = await ipcRenderer.invoke('GetPrintType', data["打印标识"])
				if (RetData != "NO") {
					if (data["执行结果"] != undefined) {
						if (JSON.stringify(SetData).indexOf("保存PDF") != -1 && JSON.stringify(SetData).indexOf("保存路径") != -1) {
							data["执行结果"]({ "保存状态": "成功", "状态": "打印成功", "打印标识": RetData })
						} else {
							data["执行结果"]({ "状态": "打印成功", "打印标识": RetData })
						}
					}
					if (Fun_ != undefined) {
						Fun_({ "状态": "打印成功", "打印标识": RetData })
					}
					clearInterval(TimeID)
					return;
				}
				if (Time_int >= data["超时时间"]) {
					clearInterval(TimeID)
					if (data["执行结果"] != undefined) {
						if (JSON.stringify(SetData).indexOf("保存PDF") != -1 && JSON.stringify(SetData).indexOf("保存路径") != -1) {
							data["执行结果"]({ "保存状态": "失败", "打印标识": RetData })
						} else {
							data["执行结果"]({ "状态": "打印失败", "打印标识": RetData })
						}
					}
					if (Fun_ != undefined) {
						Fun_({ "状态": "打印失败", "打印标识": RetData })
					}
				}
			}, 100)
		}
	},
	getPrintAll: async (FunName) => {
		let PrintAll = [];
		let RetData = [];
		RetData = await ipcRenderer.invoke('getPrintAll', FunName)
		RetData.forEach(ele => {
			PrintAll[PrintAll.length] = ele.name
		});
		return PrintAll;
	},
	GetPrintType: async (DataID) => {
		return ipcRenderer.invoke('GetPrintType', DataID)
	},
}
window.electronStartLogAPI = {
	startLog: (url) => { ipcRenderer.invoke('startLog', url) },
}
window.electronMultimedia = {
	Screenshot: (DataObj) => {
		ipcRenderer.invoke('Screenshot', JSON.stringify(DataObj))
	},
	mediaRecorder: [],
	audioStart: (fun_) => {
		navigator.mediaDevices.getUserMedia({ audio: true })
			.then(stream => {
				let audioID = electronMultimedia.mediaRecorder.length;
				electronMultimedia.mediaRecorder[audioID] = new MediaRecorder(stream);
				electronMultimedia.mediaRecorder[audioID].ondataavailable = (event) => {
					if (event.data.size > 0) {
						const reader = new FileReader();
						reader.onload = (e) => {
							try {
								const arrayBuffer = e.target.result;
								const buffer = Buffer.from(arrayBuffer);
								fun_({
									"状态": "录音数据输出",
									"数据": buffer
								})
							} catch (error) {

							}
						};
						try {
							reader.readAsArrayBuffer(event.data);
						} catch (error) {

						}
					}
				};
				electronMultimedia.mediaRecorder[audioID].start();
				fun_({
					"状态": "创建录音器成功",
					"录音器ID": audioID
				})
			})
			.catch(err => {
				fun_({
					"状态": "录音失败",
					"数据": err
				})
			});
	},
	audioStop: (audioID, fun_) => {
		electronMultimedia.mediaRecorder[audioID].stop();
		fun_({
			"状态": "停止成功"
		})
	},
}
//electronPreloadEnd
window.electronProcessAPI = {
	runExec: (Path, cmdCode, SetProcessYesMsg = undefined, SetProcessNoMsg = undefined, SetProcessEndMsg = undefined, encoding_ = "GBK", env = undefined, ifArr = false) => {
		if (LetData.ProcessAPI == null) {
			LetData.ProcessAPI = require('./modules/ProcessAPI.js');
		}
		LetData.ProcessAPI.runExec({ "路径": Path, "code": cmdCode }, SetProcessYesMsg, SetProcessNoMsg, SetProcessEndMsg, encoding_, env, ifArr)
	},
	runExeckill: () => {
		if (LetData.ProcessAPI == null) {
			LetData.ProcessAPI = require('./modules/ProcessAPI.js');
		}
		LetData.ProcessAPI.runExeckill()
	},

}
window.electronReadAPI = {
	readText: () => {
		if (LetData.ReadAPI == null) {
			LetData.ReadAPI = require('./modules/ReadAPI.js');
		}
		return LetData.ReadAPI.readText();
	},
	writeText: (text) => {
		if (LetData.ReadAPI == null) {
			LetData.ReadAPI = require('./modules/ReadAPI.js');
		}
		return LetData.ReadAPI.writeText(text);
	},
	readHTML: () => {
		if (LetData.ReadAPI == null) {
			LetData.ReadAPI = require('./modules/ReadAPI.js');
		}
		return LetData.ReadAPI.readHTML();
	},
	writeHTML: (text) => {
		if (LetData.ReadAPI == null) {
			LetData.ReadAPI = require('./modules/ReadAPI.js');
		}
		return LetData.ReadAPI.writeHTML(text);
	},
	readRTF: () => {
		if (LetData.ReadAPI == null) {
			LetData.ReadAPI = require('./modules/ReadAPI.js');
		}
		return LetData.ReadAPI.readRTF();
	},
	writeRTF: (text) => {
		if (LetData.ReadAPI == null) {
			LetData.ReadAPI = require('./modules/ReadAPI.js');
		}
		return LetData.ReadAPI.writeRTF(text);
	},
}
window.electronPlatAPI = {
	getPlatform: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.getPlatform();
	},
	globalShortcut: (key) => {
		//全局快捷键绑定
		try {
			//只在electron中生效
			ipcRenderer.invoke('globalShortcut', key)
		} catch (error) {

		}
	},
	Notification: (data) => {
		try {
			//只在electron中生效
			ipcRenderer.invoke('Notification', data)
		} catch (error) {

		}
	},
	openAtLogin: (true_) => {
		try {
			//只在electron中生效
			ipcRenderer.invoke('openAtLogin', true_)
		} catch (error) {

		}
	},
	powerSaveBlocker: () => {
		try {
			//只在electron中生效
			ipcRenderer.invoke('powerSaveBlocker')
		} catch (error) {

		}
	},
	processArgv: () => {
		return process.argv;
	},
	getCursorScreenPoint: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.getCursorScreenPoint()
	},
	dipToScreenPoint: (data) => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.dipToScreenPoint(data)
	},
	networkInterfaces: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.networkInterfaces()
	},
	getLocalIP: () => {
		if (LetData.IPData == null) {
			LetData.IPData = require('./modules/IP.js');
		}
		return LetData.IPData.getLocalIP()
	},
	cpus: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.cpus()
	},
	tmpDir: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.tmpDir()
	},
	arch: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.arch()
	},
	totalmem: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.totalmem()
	},
	freemem: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.freemem()
	},
	OStype: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.OStype()
	},
	hostname: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.hostname()
	},
	release: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.release()
	},
	uptime: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.uptime()
	},
	loadavg: () => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		return LetData.PlatAPI.loadavg()
	},
	showItemInFolder: (fullPath) => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		LetData.PlatAPI.showItemInFolder(fullPath)
	},
	openPath: (fullPath) => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		LetData.PlatAPI.openPath(fullPath)
	},
	openExternal: (url) => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		LetData.PlatAPI.openExternal(url)
	},
	trashItem: (fullPath) => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		LetData.PlatAPI.trashItem(fullPath)
	},
	openItem: (fullPath) => {
		if (LetData.PlatAPI == null) {
			LetData.PlatAPI = require('./modules/PlatAPI.js');
		}
		LetData.PlatAPI.openItem(fullPath)
	},
}
window.electronEXEAPI = {
	OpenEXE: (path) => {
		if (LetData.EXEAPI == null) {
			LetData.EXEAPI = require('./modules/EXEAPI.js');
		}
		return LetData.EXEAPI.OpenEXE(path)
	},
	KillEXE: (pid) => {
		if (LetData.EXEAPI == null) {
			LetData.EXEAPI = require('./modules/EXEAPI.js');
		}
		return LetData.EXEAPI.KillEXE(pid)
	},
	DoesTheProcessExist: (query, cb, encoding = "GBK") => {
		if (LetData.EXEAPI == null) {
			LetData.EXEAPI = require('./modules/EXEAPI.js');
		}
		return LetData.EXEAPI.DoesTheProcessExist(query, cb, encoding)
	},

}
window.electronDnsAPI = {
	lookup: (url, funStr = undefined) => {
		if (LetData.dnsFOF == null) {
			LetData.dnsFOF = require('./modules/dns.js');
		}
		LetData.dnsFOF.lookup(url, funStr)
	},
	lookupService: (address, family, funStr = undefined) => {
		if (LetData.dnsFOF == null) {
			LetData.dnsFOF = require('./modules/dns.js');
		}
		LetData.dnsFOF.lookupService(address, family, funStr)
	},
	resolve4: (url, funStr = undefined) => {
		if (LetData.dnsFOF == null) {
			LetData.dnsFOF = require('./modules/dns.js');
		}
		LetData.dnsFOF.resolve4(url, funStr)
	},
	resolve6: (url, funStr) => {
		if (LetData.dnsFOF == null) {
			LetData.dnsFOF = require('./modules/dns.js');
		}
		LetData.dnsFOF.resolve6(url, funStr)
	},
	reverse: (ip, funStr) => {
		if (LetData.dnsFOF == null) {
			LetData.dnsFOF = require('./modules/dns.js');
		}
		LetData.dnsFOF.reverse(ip, funStr)
	},
}
window.electronFileAPI = {
	getAppPath: () => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.getAppPath();
	},
	getDesktop: () => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.getDesktop();
	},
	getPathAll: () => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.getPathAll();
	},

	listFile: (path, funEv = undefined) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		LetData.fileFOF.listFile(path, funEv);
	},
	watch: (path, funEv = undefined) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		LetData.fileFOF.watch(path, funEv);
	},
	getExe: () => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.getExe();
	},
	existsSync: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.existsSync(path);
	},
	writeFileSync: (path, data) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.writeFileSync({ "路径": path, "数据": data });
	},
	writeFileBase64Sync: (path, data) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.writeFileBase64Sync({ "路径": path, "数据": data });
	},
	writeFileHexSync: (path, data) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.writeFileHexSync({ "路径": path, "数据": data });
	},
	readFileSync: (path, unicode = "utf8") => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.readFileSync({ "路径": path, "编码": unicode });
	},
	readFileBase64Sync: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.readFileBase64Sync({ "路径": path });
	},
	readFileHexSync: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.readFileHexSync({ "路径": path });
	},
	mkdirSync: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.mkdirSync(path);
	},
	cp: (path, path2, funEv = undefined) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.cp(path, path2, funEv);
	},
	renameSync: (path, newPath) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.renameSync({ "路径": path, "路径2": newPath });
	},
	unlink: (path, funEv = undefined) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.unlink(path, funEv);
	},
	appendFile: (path, data) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.appendFile({ "路径": path, "数据": data });
	},
	basename: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.basename(path);
	},
	dirname: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.dirname(path);
	},
	extname: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.extname(path);
	},
	isAbsolute: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.isAbsolute(path);
	},
	normalize: (path) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.normalize(path);
	},
	FileMsg: (path, EVFun) => {
		if (LetData.fileFOF == null) {
			LetData.fileFOF = require('./modules/File.js');
		}
		return LetData.fileFOF.FileMsg(path, EVFun);
	},
}
window.electronDecoderAPI = {
	TextDecoder: (Decoder, Code, hexTrue = false, hexCode = "hex") => {
		if (LetData.DecoderAPI == null) {
			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
		}
		return LetData.DecoderAPI.TextDecoder(Decoder, Code, hexTrue, hexCode);
	},
	TextDecoderBase64: (Decoder, Code) => {
		if (LetData.DecoderAPI == null) {
			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
		}
		return LetData.DecoderAPI.TextDecoderBase64(Decoder, Code);
	},
	TextToBase64: (Code) => {
		if (LetData.DecoderAPI == null) {
			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
		}
		return LetData.DecoderAPI.TextToBase64(Code);
	},
	Base64ToText: (Code) => {
		if (LetData.DecoderAPI == null) {
			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
		}
		return LetData.DecoderAPI.Base64ToText(Code);
	},
	TextTo16: (Code) => {
		if (LetData.DecoderAPI == null) {
			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
		}
		return LetData.DecoderAPI.TextTo16(Code);
	},
	HexToText: (Code) => {
		if (LetData.DecoderAPI == null) {
			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
		}
		return LetData.DecoderAPI.HexToText(Code);
	},
}
window.electronHTTPAPI = {
	httpSend: (url, RetFun = undefined, method_ = "GET", POSTDATA = "", headers_ = {}) => {
		if (LetData.SendHttp == null) {
			LetData.SendHttp = require('./modules/SendHttp.js');
		}
		LetData.SendHttp.httpSend(url, RetFun, method_, POSTDATA, headers_);
	},
	httpsSend: (url, RetFun = undefined, method_ = "GET", POSTDATA = "", headers_ = {}) => {
		if (LetData.SendHttp == null) {
			LetData.SendHttp = require('./modules/SendHttp.js');
		}
		LetData.SendHttp.httpsSend(url, RetFun, method_, POSTDATA, headers_);
	},
}
window.electronSqlServer = {
	sendsqlserver: (funStr, host, user, password, database, port = 1433, max = 20, if2000 = false, obj = undefined) => {
		if (LetData.sqlServer == null) {
			LetData.sqlServer = require('./modules/sqlServer.js');
		}
		return LetData.sqlServer.sendsqlserver(funStr, host, user, password, database, port, max, if2000, obj);
	},
	exec: (funStr, sqltXet, values, poolID = 0) => {
		if (LetData.sqlServer == null) {
			LetData.sqlServer = require('./modules/sqlServer.js');
		}
		LetData.sqlServer.exec(sqltXet, values, poolID, funStr)
	},
	exec2: async (sqltXet, values, poolID = 0) => {
		if (LetData.sqlServer == null) {
			LetData.sqlServer = require('./modules/sqlServer.js');
		}
		let RetExec = await LetData.sqlServer.exec(sqltXet, values, poolID, undefined)
		return RetExec;
	},
	execTransaction: (funStr, sqltXet, poolID = 0, TransactionType = {}) => {
		if (LetData.sqlServer == null) {
			LetData.sqlServer = require('./modules/sqlServer.js');
		}
		LetData.sqlServer.execTransaction(sqltXet, poolID, funStr, TransactionType);
	},
	execTransaction2: async (sqltXet, poolID = 0, TransactionType = {}) => {
		if (LetData.sqlServer == null) {
			LetData.sqlServer = require('./modules/sqlServer.js');
		}
		let RetData = {};
		await LetData.sqlServer.execTransaction(sqltXet, poolID, undefined, TransactionType)
			.then(res => {
				RetData = res;
			})
			.catch(err => RetData = { "状态": "失败", "数据": err });
		return RetData;
	},
	endPool: (poolID = 0) => {
		if (LetData.sqlServer == null) {
			LetData.sqlServer = require('./modules/sqlServer.js');
		}
		LetData.sqlServer.endPool(poolID);
	},
}
window.electronMysql = {
	sendmysql: (funStr, host, user, password, database, port = 3306, connectionLimit = 20, Obj = {}) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		return LetData.fofmysql.sendmysql(funStr, host, user, password, database, port, connectionLimit, Obj)
	},
	query: (funStr, sqltXet, params = [], poolID = 0) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		LetData.fofmysql.query(sqltXet, params, poolID, funStr)
	},
	query2: async (sqltXet, params = [], poolID = 0) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		let RetData = {};
		await LetData.fofmysql.query(sqltXet, params, poolID).then(res => {
			RetData = { "状态": "成功", "数据": res }
		}).catch(err => RetData = { "状态": "失败", "数据": err })
		try {
			if (RetData["数据"] == false) {
				if (Array.isArray(RetData["数据"]) == false) {
					RetData["数据"] = [];
					RetData["状态"] == "失败"
				}
			}
		} catch (error) {

		}
		return RetData;
	},
	exec: (funStr, sqltXet, values = [], poolID = 0) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		LetData.fofmysql.exec(sqltXet, values, poolID, funStr)
	},
	exec2: async (sqltXet, values = [], poolID = 0) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		let RetData = {};
		await LetData.fofmysql.exec(sqltXet, values, poolID).then(res => {
			RetData = { "状态": "成功", "数据": res && res.affectedRows > 0, "数据2": res }
		}).catch(err => RetData = { "状态": "失败", "数据": err, "数据2": {} });
		return RetData;

	},
	execTransaction: (funStr, sqlArr, poolID = 0, TransactionType = {}) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		if (sqlArr.length <= 0) {
			LetData.fofmysql.execTransaction(sqlArr, poolID, funStr, TransactionType);
		} else {
			LetData.fofmysql.execTransaction(sqlArr, poolID)
				.then(res => funStr({ "状态": "成功", "事务状态": "成功", "数据": res }))
				.catch(err => funStr({ "状态": "失败", "事务状态": "无状态", "数据": err }));
		}
	},
	execTransaction2: async (sqlArr, poolID = 0, TransactionType = {}) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		let RetData = {};
		if (sqlArr.length <= 0) {
			RetData = await LetData.fofmysql.execTransaction(sqlArr, poolID, undefined, TransactionType);
			return RetData;
		} else {
			await LetData.fofmysql.execTransaction(sqlArr, poolID)
				.then(res => RetData = { "状态": "成功", "事务状态": "成功", "数据": res })
				.catch(err => RetData = { "状态": "失败", "事务状态": "无状态", "数据": err });
			return RetData;
		}
	},
	endPool: (poolID = 0) => {
		if (LetData.fofmysql == null) {
			LetData.fofmysql = require('./modules/mysql.js');
		}
		LetData.fofmysql.endPool(poolID);
	},
}
window.electronCrypto = {
	md5: (data) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.md5(data);
	},
	sha1: (data) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.sha1(data);
	},
	md5hmac: (data, password) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.md5hmac(data, password);
	},
	sha256: (data) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.sha256(data);
	},
	sha256hmac: (data, password) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.sha256hmac(data, password);
	},
	shaSet: (type, data) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.shaSet(type, data);
	},
	shaSethmac: (type, data, password) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.shaSethmac(type, data, password);
	},
	encryptBase64: (data) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.encryptBase64(data);
	},
	decryptBase64: (data) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.decryptBase64(data);
	},
	encryptDes: (str, key, iv = null, destype = 'des-ecb') => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.encryptDes(str, key, iv, destype);
	},
	decryptDes: (str, key, iv = null, destype = 'des-ecb') => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.decryptDes(str, key, iv, destype);
	},
	encryptAes: (str, key, iv = null, destype = 'aes-128-ecb') => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.encryptAes(str, key, iv, destype);
	},
	decryptAes: (str, key, iv = null, destype = 'aes-128-ecb') => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.decryptAes(str, key, iv, destype);
	},
	generateRSAKey: (size = 1024) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.generateRSAKey(size);
	},
	encryptRSAByPrivateKey: (str, privateKey) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.encryptRSAByPrivateKey(str, privateKey);
	},
	decryptRSAByPublicKey: (str, privateKey) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.decryptRSAByPublicKey(str, privateKey);
	},
	encryptRSAByPublicKey: (str, privateKey) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.encryptRSAByPublicKey(str, privateKey);
	},
	decryptRSAByPrivateKey: (str, privateKey) => {
		if (LetData.crypto == null) {
			LetData.crypto = require('./modules/crypto.js');
		}
		return LetData.crypto.decryptRSAByPrivateKey(str, privateKey);
	},
}
window.electronSharp = {
	metadata: (img, funStr) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.metadata(img).then(res => funStr({ "宽度": res.width, "高度": res.height, "格式": res.format }))
	},
	resize: (img, options, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.resize(img, options, savePath, funStr);
	},
	border: (img, options, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.border(img, options, savePath, funStr);
	},
	crop: (img, options, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.crop(img, options, savePath, funStr);
	},
	format: (img, type, quality = 80, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.format(img, type, quality, savePath, funStr);
	},
	rotate: (img, angle, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.rotate(img, angle, savePath, funStr);
	},
	rotateBlur: (img, sigma, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.rotateBlur(img, sigma, savePath, funStr);
	},
	greyscale: (img, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.greyscale(img, savePath, funStr);
	},
	watermark: (img, text, options = {}, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.watermark(img, text, options, savePath, funStr);
	},
	watermarkFun: (img, text, options = {}, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.watermarkFun(img, text, options, savePath, funStr);
	},
	tint: (img, rgb, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.tint(img, rgb, savePath, funStr);
	},
	compose: (img, options, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.compose(img, options, savePath, funStr);
	},
	sharpen: (img, options, savePath, funStr = undefined) => {
		if (LetData.sharp == null) {
			LetData.sharp = require('./modules/sharp.js');
		}
		LetData.sharp.sharpen(img, options, savePath, funStr);
	},
}
window.electronEmailAPI = {
	sendMail: (host, port, name, user, pass, sendto, title, contents, attachments_ = [], funStr = undefined) => {
		if (LetData.email == null) {
			LetData.email = require('./modules/email.js');
		}
		LetData.email.sendMail(host, port, name, user, pass, sendto, title, contents, attachments_, funStr);
	},
}
window.electronCompressAPI = {
	compressDir: (dirPath, output, format, funStr = undefined) => {
		if (LetData.compress == null) {
			LetData.compress = require('./modules/compress.js');
		}
		LetData.compress.compressDir(dirPath, output, format, funStr);
	},
	compressFile: (filePath, output, format, funStr = undefined) => {
		if (LetData.compress == null) {
			LetData.compress = require('./modules/compress.js');
		}
		LetData.compress.compressFile(filePath, output, format, funStr);
	},
	compressFileBatch: (filePathArr, output, format, funStr = undefined) => {
		if (LetData.compress == null) {
			LetData.compress = require('./modules/compress.js');
		}
		LetData.compress.compressFileBatch(filePathArr, output, format, funStr);
	},
	unCompress: (filePath, output, funStr = undefined) => {
		if (LetData.compress == null) {
			LetData.compress = require('./modules/compress.js');
		}
		LetData.compress.unCompress(filePath, output, funStr);
	},
}
window.electronFtpAPI = {
	config: (host_, port_, user_, password_) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.config(host_, port_ + "", user_, password_);
	},
	list: (funStr = undefined, path = "") => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.list(funStr, path);
	},
	download: (targetPath, savePath, funStr = undefined) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.download(targetPath, savePath, funStr);
	},
	upload: (filePath, savePath, funStr = undefined) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.upload(savePath, filePath, funStr);
	},
	delete: (filePath, funStr = undefined) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.delete(filePath, funStr);
	},
	rename: (oldPath, newPath, funStr = undefined) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.rename(oldPath, newPath, funStr);
	},
	mkDir: (dirPath, funStr = undefined) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.mkDir(dirPath, funStr);
	},
	rmDir: (dirPath, funStr = undefined) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.rmDir(dirPath, funStr);
	},
	size: (filePath, funStr = undefined) => {
		if (LetData.ftp == null) {
			LetData.ftp = require('./modules/ftp.js');
		}
		LetData.ftp.size(filePath, funStr);
	},

}
window.electronHttpServerAPI = {
	initServer: (Data, MsgFun = undefined, funGet = undefined, funPost = undefined, funPut = undefined) => {
		if (LetData.HttpServer == null) {
			LetData.HttpServer = require('./modules/HttpServer.js');
		}
		return LetData.HttpServer.initServer(Data, MsgFun, funGet, funPost, funPut);
	},
	getTypeMime: (extname) => {
		if (LetData.HttpServer == null) {
			LetData.HttpServer = require('./modules/HttpServer.js');
		}
		return LetData.HttpServer.getTypeMime(extname);
	},
	serverClose: (IntID) => {
		if (LetData.HttpServer == null) {
			LetData.HttpServer = require('./modules/HttpServer.js');
		}
		LetData.HttpServer.serverClose(IntID);
	},

}
window.electronTcpServerAPI = {
	NewServer: (ServerData, MsgFun = undefined) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.NewServer(ServerData, MsgFun);
	},
	InsertIPBlacklist: (ip) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.InsertIPBlacklist(ip);
	},
	ServerClose: (server) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.ServerClose(server);
	},
	send: (ServerIDInt, id, data) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		LetData.TcpServer.send(ServerIDInt, id, data);
	},
	Disconnect: (ServerIDInt, id) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		LetData.TcpServer.Disconnect(ServerIDInt, id);
	},
	socketList: (ServerIDInt) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.socketList(ServerIDInt);
	}
}
window.electronTcpSocketAPI = {
	NewSocket: (ServerData, MsgFun = undefined) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.NewSocket(ServerData, MsgFun);
	},
	SocketWrite: (IntServer, Data) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.SocketWrite(IntServer, Data);
	},
	SocketReadyState: (IntServer) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.SocketReadyState(IntServer);
	},
	SocketDestroy: (IntServer) => {
		if (LetData.TcpServer == null) {
			LetData.TcpServer = require('./modules/FOFTcp.js');
		}
		return LetData.TcpServer.SocketDestroy(IntServer);
	},

}
window.electronUdpServerAPI = {
	NewServer: (port = 22333, MsgFun = undefined) => {
		if (LetData.UdpServer == null) {
			LetData.UdpServer = require('./modules/FOFUDP.js');
		}
		return LetData.UdpServer.NewServer(port, MsgFun);
	},
	ServerClose: (IntServer) => {
		if (LetData.UdpServer == null) {
			LetData.UdpServer = require('./modules/FOFUDP.js');
		}
		return LetData.UdpServer.ServerClose(IntServer);
	},
	ServerSend: (IntServer, data, address, port) => {
		if (LetData.UdpServer == null) {
			LetData.UdpServer = require('./modules/FOFUDP.js');
		}
		return LetData.UdpServer.ServerSend(IntServer, data, address, port);
	}
}
window.electronUdpClientAPI = {
	NewClient: (MsgFun = undefined) => {
		if (LetData.UdpServer == null) {
			LetData.UdpServer = require('./modules/FOFUDP.js');
		}
		return LetData.UdpServer.NewClient(MsgFun);
	},
	ClientClose: (IntServer) => {
		if (LetData.UdpServer == null) {
			LetData.UdpServer = require('./modules/FOFUDP.js');
		}
		return LetData.UdpServer.ClientClose(IntServer);
	},
	ClientSend: (IntServer, message, address, port) => {
		if (LetData.UdpServer == null) {
			LetData.UdpServer = require('./modules/FOFUDP.js');
		}
		return LetData.UdpServer.ClientSend(IntServer, message, address, port);
	}
}
window.BufferClass = {
	BufferClassToArrar: (data) => {
		if (LetData.BufferClass == null) {
			LetData.BufferClass = require('./modules/BufferClass.js');
		}
		return LetData.BufferClass.BufferClassToArrar(data);
	},
	ArrarToBufferClass: (data) => {
		if (LetData.BufferClass == null) {
			LetData.BufferClass = require('./modules/BufferClass.js');
		}
		return LetData.BufferClass.ArrarToBufferClass(data);
	}
}
window.DataPackaging = {
	NewID: (ID, dataHead, dataEnd) => {
		if (LetData.DataPackaging == null) {
			LetData.DataPackaging = require('./modules/DataPackaging.js');
		}
		return LetData.DataPackaging.NewID(ID, dataHead, dataEnd);
	},
	InsertData: (ID, Data) => {
		if (LetData.DataPackaging == null) {
			LetData.DataPackaging = require('./modules/DataPackaging.js');
		}
		return LetData.DataPackaging.InsertData(ID, Data);
	},
	SelectData: (ID) => {
		if (LetData.DataPackaging == null) {
			LetData.DataPackaging = require('./modules/DataPackaging.js');
		}
		return LetData.DataPackaging.SelectData(ID);
	},
	IFDataLength: (ID) => {
		if (LetData.DataPackaging == null) {
			LetData.DataPackaging = require('./modules/DataPackaging.js');
		}
		return LetData.DataPackaging.IFDataLength(ID);
	},
	DeleteData: (ID) => {
		if (LetData.DataPackaging == null) {
			LetData.DataPackaging = require('./modules/DataPackaging.js');
		}
		return LetData.DataPackaging.DeleteData(ID);
	}
}
window.websocketServer = {
	initWebSocketServer: (port_ = 8080, fun = undefined) => {
		if (LetData.websocket == null) {
			LetData.websocket = require('./modules/WebSocKet.js');
		}
		return LetData.websocket.initWebSocketServer(port_, fun);
	},
	send: (ServerIDInt, id, data) => {
		if (LetData.websocket == null) {
			LetData.websocket = require('./modules/WebSocKet.js');
		}
		LetData.websocket.send(ServerIDInt, id, data);
	},
	Disconnect: (ServerIDInt, id) => {
		if (LetData.websocket == null) {
			LetData.websocket = require('./modules/WebSocKet.js');
		}
		LetData.websocket.Disconnect(ServerIDInt, id);
	},
	socketList: (ServerIDInt) => {
		if (LetData.websocket == null) {
			LetData.websocket = require('./modules/WebSocKet.js');
		}
		return LetData.websocket.socketList(ServerIDInt);
	}

}
window.electronSqlite3 = {
	SetDatabase: (dbpath, password) => {
		if (LetData.fofsqlite3 == null) {
			LetData.fofsqlite3 = require('./modules/sqlite3.js');
		}
		return LetData.fofsqlite3.SetDatabase(dbpath, password)
	},
	query: (funStr, sqltXet, params, DBID = null) => {
		if (LetData.fofsqlite3 == null) {
			LetData.fofsqlite3 = require('./modules/sqlite3.js');
		}
		LetData.fofsqlite3.query(sqltXet, params, DBID).then(res => {
			funStr({ "状态": "成功", "数据": res })
		}).catch(err => funStr({ "状态": "失败", "数据": err }))
	},
	query2: async (sqltXet, params, DBID = null) => {
		if (LetData.fofsqlite3 == null) {
			LetData.fofsqlite3 = require('./modules/sqlite3.js');
		}
		let RetData = {};
		await LetData.fofsqlite3.query(sqltXet, params, DBID).then(res => {
			RetData = { "状态": "成功", "数据": res }
		}).catch(err => RetData = { "状态": "失败", "数据": err })
		return RetData;
	},
	exec: (funStr, sqltXet, values = [], DBID = null) => {
		if (LetData.fofsqlite3 == null) {
			LetData.fofsqlite3 = require('./modules/sqlite3.js');
		}
		LetData.fofsqlite3.exec(sqltXet, values, DBID).then(res => res ? funStr({ "状态": "成功", "数据": res }) : funStr({ "状态": "失败", "数据": res })).catch(err => funStr({ "状态": "失败", "数据": err }));
	},
	exec2: async (sqltXet, values = [], DBID = null) => {
		if (LetData.fofsqlite3 == null) {
			LetData.fofsqlite3 = require('./modules/sqlite3.js');
		}
		let RetData = {};
		await LetData.fofsqlite3.exec(sqltXet, values, DBID).then(res => res ? RetData = { "状态": "成功", "数据": res } : RetData = { "状态": "失败", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
		return RetData;
	},
	execTransaction: (funStr, sqlArr) => {
		if (LetData.fofsqlite3 == null) {
			LetData.fofsqlite3 = require('./modules/sqlite3.js');
		}
		LetData.fofsqlite3.execTransaction(sqlArr)
			.then(res => res ? funStr({ "状态": "成功", "事务状态": "成功", "数据": res }) : funStr({ "状态": "失败", "事务状态": "失败并回滚", "数据": res }))
			.catch(err => funStr({ "状态": "失败", "事务状态": "无状态", "数据": err }));
	},
	execTransaction2: async (sqlArr) => {
		if (LetData.fofsqlite3 == null) {
			LetData.fofsqlite3 = require('./modules/sqlite3.js');
		}
		let RetData = {};
		await LetData.fofsqlite3.execTransaction(sqlArr)
			.then(res => res ? RetData = { "状态": "成功", "事务状态": "成功", "数据": res } : RetData = { "状态": "失败", "事务状态": "失败并回滚", "数据": res })
			.catch(err => RetData = { "状态": "失败", "事务状态": "无状态", "数据": err });
		return RetData;
	},
}
window.electronSms = {
	generateCode: (bit = 6, onlyNumber = true) => {
		if (LetData.sms == null) {
			LetData.sms = require('./modules/sms.js');
		}
		return LetData.sms.generateCode(bit, onlyNumber)
	},
	sendAliSMS: (fun = undefined, config = {}, phone, params = {}) => {
		if (LetData.sms == null) {
			LetData.sms = require('./modules/sms.js');
		}
		LetData.sms.sendAliSMS(config, phone, params).then(res => res ? fun({ "状态": "成功" }) : fun({ "状态": "失败", "数据": res })).catch(err => fun({ "状态": "失败", "数据": err }));
	},
	sendTencentSMS: (fun = undefined, config = {}, phone, params = []) => {
		if (LetData.sms == null) {
			LetData.sms = require('./modules/sms.js');
		}
		LetData.sms.sendTencentSMS(config, phone, params).then(res => res ? fun({ "状态": "成功" }) : fun({ "状态": "失败", "数据": res })).catch(err => fun({ "状态": "失败", "数据": err }));
	},
	sendAliSMS2: async (config = {}, phone, params = {}) => {
		if (LetData.sms == null) {
			LetData.sms = require('./modules/sms.js');
		}
		let RetData = {};
		await LetData.sms.sendAliSMS(config, phone, params).then(res => RetData = { "状态": "成功", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
		return RetData;
	},
	sendTencentSMS2: async (config = {}, phone, params = []) => {
		if (LetData.sms == null) {
			LetData.sms = require('./modules/sms.js');
		}
		let RetData = {};
		await LetData.sms.sendTencentSMS(config, phone, params).then(res => RetData = { "状态": "成功", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
		return RetData;
	}
}
window.electronExcel = {
	readFileSheet: (filePath, sheetName) => {
		if (LetData.excel == null) {
			LetData.excel = require('./modules/excel.js');
		}
		return LetData.excel.readFileSheet(filePath, sheetName)
	},
	readFileToJson: (filePath, sheetName) => {
		if (LetData.excel == null) {
			LetData.excel = require('./modules/excel.js');
		}
		return LetData.excel.readFileToJson(filePath, sheetName)
	},
	readFileToHtml: (filePath, sheetName) => {
		if (LetData.excel == null) {
			LetData.excel = require('./modules/excel.js');
		}
		return LetData.excel.readFileToHtml(filePath, sheetName)
	},
	readFileToCsv: (filePath, sheetName) => {
		if (LetData.excel == null) {
			LetData.excel = require('./modules/excel.js');
		}
		return LetData.excel.readFileToCsv(filePath, sheetName)
	},
	createFileFrom: (data, savePath = "", sheetName = 'sheet1') => {
		if (LetData.excel == null) {
			LetData.excel = require('./modules/excel.js');
		}
		LetData.excel.createFileFrom(data, savePath, sheetName)
	},
	createFileFromArray: (data, savePath = "", sheetName = 'sheet1') => {
		if (LetData.excel == null) {
			LetData.excel = require('./modules/excel.js');
		}
		LetData.excel.createFileFromArray(data, savePath, sheetName)
	},
	createFileFromJsonArray: (data, savePath = "", sheetName = 'sheet1') => {
		if (LetData.excel == null) {
			LetData.excel = require('./modules/excel.js');
		}
		LetData.excel.createFileFromJsonArray(data, savePath, sheetName)
	},
}
window.electronWrod = {
	insertWordText: (content, paragraphStyle = 0, textStyle) => {
		LetData.docxObj.insertWordText(content, paragraphStyle, textStyle)
	},
	insertWordImage: (imagePath, paragraphStyle = 0, imageStyle) => {
		LetData.docxObj.insertWordImage(imagePath, paragraphStyle, imageStyle)
	},
	insertWordTable: (tableArray, tableStyle) => {
		LetData.docxObj.insertWordTable(tableArray, tableStyle)
	},
	insertWordHeader: (content, paragraphStyle, textStyle) => {
		LetData.docxObj.insertWordHeader(content, paragraphStyle, textStyle)
	},
	insertWordFooter: (content, paragraphStyle, textStyle) => {
		LetData.docxObj.insertWordFooter(content, paragraphStyle, textStyle)
	},
	insertHorizontalLine: () => {
		LetData.docxObj.insertHorizontalLine()
	},
	insertSoftEnter: () => {
		LetData.docxObj.insertSoftEnter()
	},
	insertPageBreak: () => {
		LetData.docxObj.insertPageBreak()
	},
	insertListItem: (content, style, dots = true, level) => {
		LetData.docxObj.insertListItem(content, style, dots, level)
	},
	output: (fun = undefined) => {
		LetData.docxObj.output(LetData.wordPath, fun)
	},
	NewWord: (filePath) => {
		if (LetData.word == null) {
			LetData.word = require('./modules/word.js');
		}
		LetData.docxObj = LetData.word.createWord({
			creator: 'MrJiang',
			description: 'This is Through NodeJS Operate Microsoft Office Word Library Demo.',
			title: 'Microsoft Office Word Demo For NodeJS',
			subject: 'Microsoft Office Word Library',
		})
		LetData.wordPath = filePath;
	},
}
window.FOFnodeRsa = {
	RsaSign: (Str, RsaKey, KeyLengTh = 1024, signingScheme = "sha256", userPrivateKey = 'pkcs8-private') => {
		if (LetData.nodeRsa == null) {
			LetData.nodeRsa = require('./modules/NodeRsa.js');
		}
		return LetData.nodeRsa.RsaSign(Str, RsaKey, KeyLengTh, signingScheme, userPrivateKey)
	}
}
window.FOFffiNapi = {
	insertCode: (file, code) => {
		if (LetData.ffiNapi == null) {
			LetData.ffiNapi = require('./modules/ffiNapi.js');
		}
		return LetData.ffiNapi.insertCode(file, code)
	},
	GetCallback: (name, int_ = 0) => {
		if (LetData.ffiNapi == null) {
			LetData.ffiNapi = require('./modules/ffiNapi.js');
		}
		return LetData.ffiNapi.GetCallback(name, int_)
	},
	RetCodeList: (name, int_ = 0) => {
		if (LetData.ffiNapi == null) {
			LetData.ffiNapi = require('./modules/ffiNapi.js');
		}
		return LetData.ffiNapi.RetCodeList(name, int_)
	},
	struct: (name, struct_) => {
		if (LetData.ffiNapi == null) {
			LetData.ffiNapi = require('./modules/ffiNapi.js');
		}
		return LetData.ffiNapi.struct(name, struct_)
	},

}
window.electronHttpProxy = {
	httpProxyServer: (serverPort = 1234, pathname = [], setHeader = [], serverFun, pathnameFun) => {
		if (LetData.HttpProxy == null) {
			LetData.HttpProxy = require('./modules/HttpProxy.js');
		}
		return LetData.HttpProxy.httpProxyServer(serverPort, pathname, setHeader, serverFun, pathnameFun)
	}
}
window.electronTxCdn = {
	initialization: (secretId, secretKey) => {
		if (LetData.TxCdn == null) {
			LetData.TxCdn = require('./modules/TxCdn.js');
		}
		return LetData.TxCdn.initialization(secretId, secretKey)
	},
	Deactivate: (Domain, funEv) => {
		if (LetData.TxCdn == null) {
			LetData.TxCdn = require('./modules/TxCdn.js');
		}
		return LetData.TxCdn.Deactivate(Domain, funEv)
	},
	Enable: (Domain, funEv) => {
		if (LetData.TxCdn == null) {
			LetData.TxCdn = require('./modules/TxCdn.js');
		}
		return LetData.TxCdn.Enable(Domain, funEv)
	}
}
window.electronSerialPortNode = {
	SerialPort: (Fun, path, baudRate, Data_ = {}) => {
		if (LetData.SerialPortNode == null) {
			LetData.SerialPortNode = require('./modules/SerialPortNode.js');
		}
		return LetData.SerialPortNode.SerialPort(Fun, path, baudRate, Data_)
	},
	GetSerialPort: (Fun = undefined) => {
		if (LetData.SerialPortNode == null) {
			LetData.SerialPortNode = require('./modules/SerialPortNode.js');
		}
		return LetData.SerialPortNode.GetSerialPort(Fun)
	},
	SetWrite: (Data, DataType = 1, Point = 0, Fun = undefined) => {
		if (LetData.SerialPortNode == null) {
			LetData.SerialPortNode = require('./modules/SerialPortNode.js');
		}
		return LetData.SerialPortNode.SetWrite(Data, DataType, Point, Fun)
	}
}
window.electronMqttServer = {
	NewMqttServer: (port_ = 1883, http_port = 8082, UserPass = [], ready = undefined, clientConnected = undefined, published = undefined, clientDisconnected = undefined, MqttErr = undefined, clientError = undefined) => {
		if (LetData.mqttServer == null) {
			LetData.mqttServer = require('./modules/mqttServer.js');
		}
		return LetData.mqttServer.NewMqttServer(port_, http_port, UserPass, ready, clientConnected, published, clientDisconnected, MqttErr, clientError)
	},
	publish: (ServerID = 0, topic_, Msg, qos_ = 0, retain_ = false, msgFun = undefined) => {
		if (LetData.mqttServer == null) {
			LetData.mqttServer = require('./modules/mqttServer.js');
		}
		return LetData.mqttServer.publish(ServerID, topic_, Msg, qos_, retain_, msgFun)
	},
	close: (ServerID = 0) => {
		if (LetData.mqttServer == null) {
			LetData.mqttServer = require('./modules/mqttServer.js');
		}
		return LetData.mqttServer.close(ServerID)
	},
}
window.modbusClient = {
	NewClientTcp: (link = "127.0.0.1", port_ = 8502, MsgFun = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.NewClientTcp(link, port_, MsgFun)
	},
	NewClientUdp: (link = "127.0.0.1", port_ = 8502, MsgFun = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.NewClientUdp(link, port_, MsgFun)
	},
	NewClientBuffered: (SerialPortPath = "/dev/ttyUSB0", options = { baudRate: 9600 }, MsgFun = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.NewClientBuffered(SerialPortPath, options, MsgFun)
	},
	setID: (clientID, ID) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.setID(clientID, ID)
	},
	getID: (clientID) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.getID(clientID)
	},
	setTimeout: (clientID, Time) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.setTimeout(clientID, Time)
	},
	getTimeout: (clientID) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.getTimeout(clientID)
	},
	isOpen: (clientID) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.isOpen(clientID)
	},
	writeRegisters: (clientID, address, arg = [0, 0xffff], Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.writeRegisters(clientID, address, arg, Fun_)
	},
	writeCoil: (clientID, address, arg = 1, Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.writeCoil(clientID, address, arg, Fun_)
	},
	writeCoils: (clientID, address, arg = [], Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.writeCoils(clientID, address, arg, Fun_)
	},
	readCoils: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.readCoils(clientID, beginaddress, endaddress, Fun_)
	},
	readHoldingRegisters: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.readHoldingRegisters(clientID, beginaddress, endaddress, Fun_)
	},
	readInputRegisters: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.readInputRegisters(clientID, beginaddress, endaddress, Fun_)
	},
	readRegistersEnron: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		LetData.modbus.readRegistersEnron(clientID, beginaddress, endaddress, Fun_)
	},
}
window.modbusTCPServer = {
	NewServer: (host_ = "0.0.0.0", port_ = 8502, debug_ = true, unitID_ = 1, Fun_ = undefined, setRegister_ = undefined, getHoldingRegister_ = undefined, getInputRegister_ = undefined, getCoil_ = undefined, setCoil_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.NewServer(host_, port_, debug_, unitID_, Fun_, setRegister_, getHoldingRegister_, getInputRegister_, getCoil_, setCoil_)
	},
	close: (ServerID, Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.close(ServerID, Fun_)
	},
	getConnections: (ServerID, Fun_ = undefined) => {
		if (LetData.modbus == null) {
			LetData.modbus = require('./modules/modbus.js');
		}
		return LetData.modbus.getConnections(ServerID, Fun_)
	},
}
window.electronPostgres = {
	sendPostgres: (funStr, host, user, password, database, port = 3306, connectionLimit = 20) => {
		if (LetData.postgres == null) {
			LetData.postgres = require('./modules/postgres.js');
		}
		return LetData.postgres.sendPostgres(funStr, host, user, password, database, port, connectionLimit)
	},
	exec: (funStr, sqltXet, params = [], poolID = 0) => {
		if (LetData.postgres == null) {
			LetData.postgres = require('./modules/postgres.js');
		}
		LetData.postgres.query(funStr, sqltXet, params, poolID)
	},
	exec2: async (sqltXet, params = [], poolID = 0) => {
		if (LetData.postgres == null) {
			LetData.postgres = require('./modules/postgres.js');
		}
		return await LetData.postgres.query2(sqltXet, params, poolID);
	},
	close: (poolID = 0) => {
		if (LetData.postgres == null) {
			LetData.postgres = require('./modules/postgres.js');
		}
		LetData.postgres.close(poolID);
	},
}
window.electronBaiDuOpencv = {
	newAccessTokenAs: (AK_, SK_) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.newAccessTokenAs(AK_, SK_)
	},
	setFacialInformation: (c1, c2, c3, c4) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.setFacialInformation(c1, c2, c3, c4)
	},
	updateFacialInformation: (c1, c2, c3, c4) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.updateFacialInformation(c1, c2, c3, c4)
	},
	faceSearch: (c1, c2, c3, c4) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.faceSearch(c1, c2, c3, c4)
	},
	faceSearch2: (c1, c2, c3, c4, c5) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.faceSearch(c1, c2, c3, c4, c5)
	},
	doesTheUserExist: (c1, c2, c3) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.doesTheUserExist(c1, c2, c3)
	},
	deleteUser: (c1, c2, c3) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.deleteUser(c1, c2, c3)
	},
	selectUserList: (c1, c2, c3, c4) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.selectUserList(c1, c2, c3, c4)
	},
	insertGroup: (c1, c2) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.faceSearch(c1, c2)
	},
	deleteGroup: (c1, c2) => {
		if (LetData.BaiDuOpencv == null) {
			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
		}
		return LetData.BaiDuOpencv.deleteGroup(c1, c2)
	}
}
window.electronAlioss = {
	newAliOss: (c1) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return LetData.Alioss.newAliOss(c1)
	},
	sendFile: (c1, c2, c3) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return LetData.Alioss.sendFile(c1, c2, c3)
	},
	getFile: (c1, c2, c3) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return LetData.Alioss.getFile(c1, c2, c3)
	},
	getFileUrl: (c1, c2) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return LetData.Alioss.getFileUrl(c1, c2)
	},
	getFileIf: (c1, c2) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return LetData.Alioss.getFileIf(c1, c2)
	},
	getFileList: (c1, c2) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return LetData.Alioss.getFileList(c1, c2)
	},
	fileCopy: async (c1, c2) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return await LetData.Alioss.fileCopy(c1, c2)
	},
	delete: (c1, c2) => {
		if (LetData.Alioss == null) {
			LetData.Alioss = require('./modules/Alioss.js');
		}
		return LetData.Alioss.delete(c1, c2)
	}
}


window.快捷方式类 = {
    设置快捷方式: (程序名称, 快捷方式说明, 图标路径) => {
        console.log(程序名称, 快捷方式说明, 图标路径)
        ipcRenderer.invoke("设置快捷方式", 程序名称, 快捷方式说明, 图标路径);
    }
};
