diff --git a/app.json b/app.json index 093dc2a..67554c1 100644 --- a/app.json +++ b/app.json @@ -8,12 +8,18 @@ "pages": [ "index" ] + }, + { + "root": "package_lesson2", + "pages": [ + "index" + ] } ], "window": { "backgroundTextStyle": "light", "navigationBarBackgroundColor": "#fff", - "navigationBarTitleText": "微信小程序运行Go", + "navigationBarTitleText": "运行WASM", "navigationBarTextStyle": "black" }, "sitemapLocation": "sitemap.json" diff --git a/opencv_dev/assets/app.css b/opencv_dev/assets/app.css new file mode 100644 index 0000000..be30681 --- /dev/null +++ b/opencv_dev/assets/app.css @@ -0,0 +1,71 @@ +.page{ + background-color: #F8F8F8; + font-size: 16px; +} +.page__hd { + padding: 40px; +} +.page__bd { + padding-bottom: 40px; +} +.page__bd_spacing { + padding-left: 15px; + padding-right: 15px; +} + +.page__ft{ + padding-bottom: 10px; + text-align: center; +} + +.page__title { + text-align: left; + font-size: 20px; + font-weight: 400; +} + +.page__desc { + margin-top: 5px; + color: #888888; + text-align: left; + font-size: 14px; +} + +.marginTop10{ + margin-top: 10px; +} + +.loading{ + text-align: center; +} + +.button-sp-area{ + margin: 0 auto; + padding-top: 15px; + width: 60%; +} +.mini-btn{ + margin-right: 5px; +} +.weui-panel__hd{ + font-weight:bold; + color:#333; +} + +.visibleCanvas{ + margin:10px auto; + display: block; +} + +.hiddenCanvas{ + position:fixed; + left:1000px; + width:800%; + height:400%; +} + +.inputImage{ + width:375px; + display: block; + margin: auto; +} \ No newline at end of file diff --git a/opencv_dev/assets/opencv_exec.js b/opencv_dev/assets/opencv_exec.js new file mode 100644 index 0000000..6855bca --- /dev/null +++ b/opencv_dev/assets/opencv_exec.js @@ -0,0 +1,9652 @@ +(function (root, factory) { + if (typeof define === 'function' && define.amd) { + // AMD. Register as an anonymous module. + define(function () { + return (root.cv = factory()); + }); + } else if (typeof module === 'object' && module.exports) { + // Node. Does not work with strict CommonJS, but + // only CommonJS-like environments that support module.exports, + // like Node. + module.exports = factory(); + } else if (typeof window === 'object') { + // Browser globals + root.cv = factory(); + } else if (typeof importScripts === 'function') { + // Web worker + root.cv = factory(); + } else { + // Other shells, e.g. d8 + root.cv = factory(); + } +}(this, function () { + const IsWechat = false; + var cv = (function () { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + return (function (cv) { + cv = cv || {}; + + // IsWechat + var wasmBinaryFile; + if (IsWechat) { + wasmBinaryFile = global.wasm_url + } else { + wasmBinaryFile = window.wasm_url; + } + + var Module = typeof cv !== "undefined" ? cv : {}; + var moduleOverrides = {}; + var key; + for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key] + } + } + var arguments_ = []; + var thisProgram = "./this.program"; + var quit_ = function (status, toThrow) { + throw toThrow + }; + var ENVIRONMENT_IS_WEB = false; + var ENVIRONMENT_IS_WORKER = false; + var ENVIRONMENT_IS_NODE = false; + var ENVIRONMENT_HAS_NODE = false; + var ENVIRONMENT_IS_SHELL = false; + ENVIRONMENT_IS_WEB = typeof window === "object"; + ENVIRONMENT_IS_WORKER = typeof importScripts === "function"; + ENVIRONMENT_HAS_NODE = typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string"; + ENVIRONMENT_IS_NODE = ENVIRONMENT_HAS_NODE && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; + ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + var scriptDirectory = ""; + function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory) + } + return scriptDirectory + path + } + var read_, readAsync, readBinary, setWindowTitle; + if (ENVIRONMENT_IS_NODE) { + scriptDirectory = __dirname + "/"; + var nodeFS; + var nodePath; + read_ = function shell_read(filename, binary) { + var ret; + ret = tryParseAsDataURI(filename); + if (!ret) { + if (!nodeFS) + nodeFS = require("fs"); + if (!nodePath) + nodePath = require("path"); + filename = nodePath["normalize"](filename); + ret = nodeFS["readFileSync"](filename) + } + return binary ? ret : ret.toString() + } + ; + readBinary = function readBinary(filename) { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret) + } + assert(ret.buffer); + return ret + } + ; + if (process["argv"].length > 1) { + thisProgram = process["argv"][1].replace(/\\/g, "/") + } + arguments_ = process["argv"].slice(2); + process["on"]("uncaughtException", function (ex) { + if (!(ex instanceof ExitStatus)) { + throw ex + } + }); + process["on"]("unhandledRejection", abort); + quit_ = function (status) { + process["exit"](status) + } + ; + Module["inspect"] = function () { + return "[Emscripten Module object]" + } + } else if (!IsWechat && ENVIRONMENT_IS_SHELL) { + if (typeof read != "undefined") { + read_ = function shell_read(f) { + var data = tryParseAsDataURI(f); + if (data) { + return intArrayToString(data) + } + return read(f) + } + } + readBinary = function readBinary(f) { + var data; + data = tryParseAsDataURI(f); + if (data) { + return data + } + if (typeof readbuffer === "function") { + return new Uint8Array(readbuffer(f)) + } + data = read(f, "binary"); + assert(typeof data === "object"); + return data + } + ; + if (typeof scriptArgs != "undefined") { + arguments_ = scriptArgs + } else if (typeof arguments != "undefined") { + arguments_ = arguments + } + if (typeof quit === "function") { + quit_ = function (status) { + quit(status) + } + } + if (typeof print !== "undefined") { + if (typeof console === "undefined") + console = {}; + console.log = print; + console.warn = console.error = typeof printErr !== "undefined" ? printErr : print + } + // } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + } else if (IsWechat || ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href + } else if (!IsWechat && document.currentScript) { + scriptDirectory = document.currentScript.src + } + if (_scriptDir) { + scriptDirectory = _scriptDir + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1) + } else { + scriptDirectory = "" + } + read_ = function shell_read(url) { + try { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.send(null); + return xhr.responseText + } catch (err) { + var data = tryParseAsDataURI(url); + if (data) { + return intArrayToString(data) + } + throw err + } + } + ; + if (ENVIRONMENT_IS_WORKER) { + readBinary = function readBinary(url) { + try { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(xhr.response) + } catch (err) { + var data = tryParseAsDataURI(url); + if (data) { + return data + } + throw err + } + } + } + readAsync = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || xhr.status == 0 && xhr.response) { + onload(xhr.response); + return + } + var data = tryParseAsDataURI(url); + if (data) { + onload(data.buffer); + return + } + onerror() + } + ; + xhr.onerror = onerror; + xhr.send(null) + } + ; + setWindowTitle = function (title) { + document.title = title + } + } else { } + + var out = Module["print"] || console.log.bind(console); + var err = Module["printErr"] || console.warn.bind(console); + for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key] + } + } + moduleOverrides = null; + if (Module["arguments"]) + arguments_ = Module["arguments"]; + if (Module["thisProgram"]) + thisProgram = Module["thisProgram"]; + if (Module["quit"]) + quit_ = Module["quit"]; + var STACK_ALIGN = 16; + function dynamicAlloc(size) { + var ret = HEAP32[DYNAMICTOP_PTR >> 2]; + var end = ret + size + 15 & -16; + if (end > _emscripten_get_heap_size()) { + abort() + } + HEAP32[DYNAMICTOP_PTR >> 2] = end; + return ret + } + function getNativeTypeSize(type) { + switch (type) { + case "i1": + case "i8": + return 1; + case "i16": + return 2; + case "i32": + return 4; + case "i64": + return 8; + case "float": + return 4; + case "double": + return 8; + default: + { + if (type[type.length - 1] === "*") { + return 4 + } else if (type[0] === "i") { + var bits = parseInt(type.substr(1)); + assert(bits % 8 === 0, "getNativeTypeSize invalid bits " + bits + ", type " + type); + return bits / 8 + } else { + return 0 + } + } + } + } + function warnOnce(text) { + if (!warnOnce.shown) + warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text) + } + } + function convertJsFunctionToWasm(func, sig) { + var typeSection = [1, 0, 1, 96]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + "i": 127, + "j": 126, + "f": 125, + "d": 124 + }; + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]) + } + if (sigRet == "v") { + typeSection.push(0) + } else { + typeSection = typeSection.concat([1, typeCodes[sigRet]]) + } + typeSection[1] = typeSection.length - 2; + var bytes = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0].concat(typeSection, [2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0])); + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + e: { + f: func + } + }); + var wrappedFunc = instance.exports.f; + return wrappedFunc + } + function addFunctionWasm(func, sig) { + var table = wasmTable; + var ret = table.length; + try { + table.grow(1) + } catch (err) { + if (!err instanceof RangeError) { + throw err + } + throw "Unable to grow wasm table. Use a higher value for RESERVED_FUNCTION_POINTERS or set ALLOW_TABLE_GROWTH." + } + try { + table.set(ret, func) + } catch (err) { + if (!err instanceof TypeError) { + throw err + } + assert(typeof sig !== "undefined", "Missing signature argument to addFunction"); + var wrapped = convertJsFunctionToWasm(func, sig); + table.set(ret, wrapped) + } + return ret + } + function removeFunctionWasm(index) { } + var funcWrappers = {}; + function dynCall(sig, ptr, args) { + if (args && args.length) { + return Module["dynCall_" + sig].apply(null, [ptr].concat(args)) + } else { + return Module["dynCall_" + sig].call(null, ptr) + } + } + var tempRet0 = 0; + var setTempRet0 = function (value) { + tempRet0 = value + }; + var wasmBinary; + if (Module["wasmBinary"]) + wasmBinary = Module["wasmBinary"]; + var noExitRuntime; + if (Module["noExitRuntime"]) + noExitRuntime = Module["noExitRuntime"]; + if (typeof WebAssembly !== "object") { + err("no native wasm support detected") + } + function setValue(ptr, value, type, noSafe) { + type = type || "i8"; + if (type.charAt(type.length - 1) === "*") + type = "i32"; + switch (type) { + case "i1": + HEAP8[ptr >> 0] = value; + break; + case "i8": + HEAP8[ptr >> 0] = value; + break; + case "i16": + HEAP16[ptr >> 1] = value; + break; + case "i32": + HEAP32[ptr >> 2] = value; + break; + case "i64": + tempI64 = [value >>> 0, (tempDouble = value, + +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], + HEAP32[ptr >> 2] = tempI64[0], + HEAP32[ptr + 4 >> 2] = tempI64[1]; + break; + case "float": + HEAPF32[ptr >> 2] = value; + break; + case "double": + HEAPF64[ptr >> 3] = value; + break; + default: + abort("invalid type for setValue: " + type) + } + } + var wasmMemory; + var wasmTable = new WebAssembly.Table({ + "initial": 8039, + "maximum": 8039 + 0, + "element": "anyfunc" + }); + var ABORT = false; + var EXITSTATUS = 0; + function assert(condition, text) { + if (!condition) { + abort("Assertion failed: " + text) + } + } + function getCFunc(ident) { + var func = Module["_" + ident]; + assert(func, "Cannot call unknown function " + ident + ", make sure it is exported"); + return func + } + function ccall(ident, returnType, argTypes, args, opts) { + var toC = { + "string": function (str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len) + } + return ret + }, + "array": function (arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret + } + }; + function convertReturnValue(ret) { + if (returnType === "string") + return UTF8ToString(ret); + if (returnType === "boolean") + return Boolean(ret); + return ret + } + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) + stack = stackSave(); + cArgs[i] = converter(args[i]) + } else { + cArgs[i] = args[i] + } + } + } + var ret = func.apply(null, cArgs); + ret = convertReturnValue(ret); + if (stack !== 0) + stackRestore(stack); + return ret + } + var ALLOC_NONE = 3; + function allocate(slab, types, allocator, ptr) { + var zeroinit, size; + if (typeof slab === "number") { + zeroinit = true; + size = slab + } else { + zeroinit = false; + size = slab.length + } + var singleType = typeof types === "string" ? types : null; + var ret; + if (allocator == ALLOC_NONE) { + ret = ptr + } else { + ret = [_malloc, stackAlloc, dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length)) + } + if (zeroinit) { + var stop; + ptr = ret; + assert((ret & 3) == 0); + stop = ret + (size & ~3); + for (; ptr < stop; ptr += 4) { + HEAP32[ptr >> 2] = 0 + } + stop = ret + size; + while (ptr < stop) { + HEAP8[ptr++ >> 0] = 0 + } + return ret + } + if (singleType === "i8") { + if (slab.subarray || slab.slice) { + HEAPU8.set(slab, ret) + } else { + HEAPU8.set(new Uint8Array(slab), ret) + } + return ret + } + var i = 0, type, typeSize, previousType; + while (i < size) { + var curr = slab[i]; + type = singleType || types[i]; + if (type === 0) { + i++; + continue + } + if (type == "i64") + type = "i32"; + setValue(ret + i, curr, type); + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type + } + i += typeSize + } + return ret + } + function getMemory(size) { + if (!runtimeInitialized) + return dynamicAlloc(size); + return _malloc(size) + } + var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined; + function UTF8ArrayToString(u8Array, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + while (u8Array[endPtr] && !(endPtr >= endIdx)) + ++endPtr; + if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { + return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)) + } else { + var str = ""; + while (idx < endPtr) { + var u0 = u8Array[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue + } + var u1 = u8Array[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode((u0 & 31) << 6 | u1); + continue + } + var u2 = u8Array[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = (u0 & 15) << 12 | u1 << 6 | u2 + } else { + u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u8Array[idx++] & 63 + } + if (u0 < 65536) { + str += String.fromCharCode(u0) + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023) + } + } + } + return str + } + function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "" + } + function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) + return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | u1 & 1023 + } + if (u <= 127) { + if (outIdx >= endIdx) + break; + outU8Array[outIdx++] = u + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) + break; + outU8Array[outIdx++] = 192 | u >> 6; + outU8Array[outIdx++] = 128 | u & 63 + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) + break; + outU8Array[outIdx++] = 224 | u >> 12; + outU8Array[outIdx++] = 128 | u >> 6 & 63; + outU8Array[outIdx++] = 128 | u & 63 + } else { + if (outIdx + 3 >= endIdx) + break; + outU8Array[outIdx++] = 240 | u >> 18; + outU8Array[outIdx++] = 128 | u >> 12 & 63; + outU8Array[outIdx++] = 128 | u >> 6 & 63; + outU8Array[outIdx++] = 128 | u & 63 + } + } + outU8Array[outIdx] = 0; + return outIdx - startIdx + } + function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite) + } + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) + u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023; + if (u <= 127) + ++len; + else if (u <= 2047) + len += 2; + else if (u <= 65535) + len += 3; + else + len += 4 + } + return len + } + var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined; + function writeArrayToMemory(array, buffer) { + HEAP8.set(array, buffer) + } + function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[buffer++ >> 0] = str.charCodeAt(i) + } + if (!dontAddNull) + HEAP8[buffer >> 0] = 0 + } + var PAGE_SIZE = 16384; + var WASM_PAGE_SIZE = 65536; + function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - x % multiple + } + return x + } + var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module["HEAP8"] = HEAP8 = new Int8Array(buf); + Module["HEAP16"] = HEAP16 = new Int16Array(buf); + Module["HEAP32"] = HEAP32 = new Int32Array(buf); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf); + Module["HEAPF32"] = HEAPF32 = new Float32Array(buf); + Module["HEAPF64"] = HEAPF64 = new Float64Array(buf) + } + var STACK_BASE = 6518496 + , DYNAMIC_BASE = 6518496 + , DYNAMICTOP_PTR = 1275456; + var INITIAL_TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 134217728; + if (Module["wasmMemory"]) { + wasmMemory = Module["wasmMemory"] + } else { + wasmMemory = new WebAssembly.Memory({ + "initial": INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE, + "maximum": 1073741824 / WASM_PAGE_SIZE + }) + } + if (wasmMemory) { + buffer = wasmMemory.buffer + } + INITIAL_TOTAL_MEMORY = buffer.byteLength; + updateGlobalBufferAndViews(buffer); + HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE; + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == "function") { + callback(); + continue + } + var func = callback.func; + if (typeof func === "number") { + if (callback.arg === undefined) { + Module["dynCall_v"](func) + } else { + Module["dynCall_vi"](func, callback.arg) + } + } else { + func(callback.arg === undefined ? null : callback.arg) + } + } + } + var __ATPRERUN__ = []; + var __ATINIT__ = []; + var __ATMAIN__ = []; + var __ATEXIT__ = []; + var __ATPOSTRUN__ = []; + var runtimeInitialized = false; + var runtimeExited = false; + function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") + Module["preRun"] = [Module["preRun"]]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()) + } + } + callRuntimeCallbacks(__ATPRERUN__) + } + function initRuntime() { + runtimeInitialized = true; + if (!Module["noFSInit"] && !FS.init.initialized) + FS.init(); + TTY.init(); + callRuntimeCallbacks(__ATINIT__) + } + function preMain() { + FS.ignorePermissions = false; + callRuntimeCallbacks(__ATMAIN__) + } + function exitRuntime() { + runtimeExited = true + } + function postRun() { + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") + Module["postRun"] = [Module["postRun"]]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()) + } + } + callRuntimeCallbacks(__ATPOSTRUN__) + } + function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb) + } + function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb) + } + var Math_abs = Math.abs; + var Math_ceil = Math.ceil; + var Math_floor = Math.floor; + var Math_min = Math.min; + var runDependencies = 0; + var runDependencyWatcher = null; + var dependenciesFulfilled = null; + function getUniqueRunDependency(id) { + return id + } + function addRunDependency(id) { + runDependencies++; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies) + } + } + function removeRunDependency(id) { + runDependencies--; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies) + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback() + } + } + } + Module["preloadedImages"] = {}; + Module["preloadedAudios"] = {}; + function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what) + } + what += ""; + out(what); + err(what); + ABORT = true; + EXITSTATUS = 1; + throw "abort(" + what + "). Build with -s ASSERTIONS=1 for more info." + } + var dataURIPrefix = "data:application/octet-stream;base64,"; + function isDataURI(filename) { + return String.prototype.startsWith ? filename.startsWith(dataURIPrefix) : filename.indexOf(dataURIPrefix) === 0 + } + + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile) + } + function getBinary() { + try { + if (wasmBinary) { + return new Uint8Array(wasmBinary) + } + var binary = tryParseAsDataURI(wasmBinaryFile); + if (binary) { + return binary + } + if (readBinary) { + return readBinary(wasmBinaryFile) + } else { + throw "both async and sync fetching of the wasm failed" + } + } catch (err) { + abort(err) + } + } + function getBinaryPromise() { + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function") { + return fetch(wasmBinaryFile, { + credentials: "same-origin" + }).then(function (response) { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'" + } + return response["arrayBuffer"]() + }).catch(function () { + return getBinary() + }) + } + return new Promise(function (resolve, reject) { + resolve(getBinary()) + } + ) + } + function createWasm() { + var info = { + "env": asmLibraryArg, + "wasi_unstable": asmLibraryArg + }; + function receiveInstance(instance, module) { + var exports = instance.exports; + Module["asm"] = exports; + removeRunDependency("wasm-instantiate") + } + addRunDependency("wasm-instantiate"); + function receiveInstantiatedSource(output) { + receiveInstance(output["instance"]) + } + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function (binary) { + + return WebAssembly.instantiate(binary, info) + }).then(receiver, function (reason) { + err("failed to asynchronously prepare wasm: " + reason); + abort(reason) + }) + } + function instantiateAsync() { + if (IsWechat) { + var result = WXWebAssembly.instantiate(wasmBinaryFile, info) + return result.then(receiveInstantiatedSource, function (reason) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + instantiateArrayBuffer(receiveInstantiatedSource) + }) + + } else { + if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") { + fetch(wasmBinaryFile, { + credentials: "same-origin" + }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + + return result.then(receiveInstantiatedSource, function (reason) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + instantiateArrayBuffer(receiveInstantiatedSource) + }) + }) + } else { + return instantiateArrayBuffer(receiveInstantiatedSource) + } + + } + + + } + if (Module["instantiateWasm"]) { + try { + var exports = Module["instantiateWasm"](info, receiveInstance); + return exports + } catch (e) { + err("Module.instantiateWasm callback failed with error: " + e); + return false + } + } + instantiateAsync(); + return {} + } + var tempDouble; + var tempI64; + __ATINIT__.push({ + func: function () { + ___wasm_call_ctors() + } + }); + function _emscripten_set_main_loop_timing(mode, value) { + Browser.mainLoop.timingMode = mode; + Browser.mainLoop.timingValue = value; + if (!Browser.mainLoop.func) { + return 1 + } + if (mode == 0) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() { + var timeUntilNextTick = Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0; + setTimeout(Browser.mainLoop.runner, timeUntilNextTick) + } + ; + Browser.mainLoop.method = "timeout" + } else if (mode == 1) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() { + Browser.requestAnimationFrame(Browser.mainLoop.runner) + } + ; + Browser.mainLoop.method = "rAF" + } else if (mode == 2) { + if (typeof setImmediate === "undefined") { + var setImmediates = []; + var emscriptenMainLoopMessageId = "setimmediate"; + var Browser_setImmediate_messageHandler = function (event) { + if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) { + event.stopPropagation(); + setImmediates.shift()() + } + }; + addEventListener("message", Browser_setImmediate_messageHandler, true); + setImmediate = function Browser_emulated_setImmediate(func) { + setImmediates.push(func); + if (ENVIRONMENT_IS_WORKER) { + if (Module["setImmediates"] === undefined) + Module["setImmediates"] = []; + Module["setImmediates"].push(func); + postMessage({ + target: emscriptenMainLoopMessageId + }) + } else + postMessage(emscriptenMainLoopMessageId, "*") + } + } + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() { + setImmediate(Browser.mainLoop.runner) + } + ; + Browser.mainLoop.method = "immediate" + } + return 0 + } + function _emscripten_get_now() { + abort() + } + function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop, arg, noSetTiming) { + noExitRuntime = true; + assert(!Browser.mainLoop.func, "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters."); + Browser.mainLoop.func = func; + Browser.mainLoop.arg = arg; + var browserIterationFunc; + if (typeof arg !== "undefined") { + browserIterationFunc = function () { + Module["dynCall_vi"](func, arg) + } + } else { + browserIterationFunc = function () { + Module["dynCall_v"](func) + } + } + var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop; + Browser.mainLoop.runner = function Browser_mainLoop_runner() { + if (ABORT) + return; + if (Browser.mainLoop.queue.length > 0) { + var start = Date.now(); + var blocker = Browser.mainLoop.queue.shift(); + blocker.func(blocker.arg); + if (Browser.mainLoop.remainingBlockers) { + var remaining = Browser.mainLoop.remainingBlockers; + var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining); + if (blocker.counted) { + Browser.mainLoop.remainingBlockers = next + } else { + next = next + .5; + Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9 + } + } + console.log('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms"); + Browser.mainLoop.updateStatus(); + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) + return; + setTimeout(Browser.mainLoop.runner, 0); + return + } + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) + return; + Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0; + if (Browser.mainLoop.timingMode == 1 && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) { + Browser.mainLoop.scheduler(); + return + } else if (Browser.mainLoop.timingMode == 0) { + Browser.mainLoop.tickStartTime = _emscripten_get_now() + } + if (Browser.mainLoop.method === "timeout" && Module.ctx) { + err("Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!"); + Browser.mainLoop.method = "" + } + Browser.mainLoop.runIter(browserIterationFunc); + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) + return; + if (typeof SDL === "object" && SDL.audio && SDL.audio.queueNewAudioData) + SDL.audio.queueNewAudioData(); + Browser.mainLoop.scheduler() + } + ; + if (!noSetTiming) { + if (fps && fps > 0) + _emscripten_set_main_loop_timing(0, 1e3 / fps); + else + _emscripten_set_main_loop_timing(1, 1); + Browser.mainLoop.scheduler() + } + if (simulateInfiniteLoop) { + throw "SimulateInfiniteLoop" + } + } + var Browser = { + mainLoop: { + scheduler: null, + method: "", + currentlyRunningMainloop: 0, + func: null, + arg: 0, + timingMode: 0, + timingValue: 0, + currentFrameNumber: 0, + queue: [], + pause: function () { + Browser.mainLoop.scheduler = null; + Browser.mainLoop.currentlyRunningMainloop++ + }, + resume: function () { + Browser.mainLoop.currentlyRunningMainloop++; + var timingMode = Browser.mainLoop.timingMode; + var timingValue = Browser.mainLoop.timingValue; + var func = Browser.mainLoop.func; + Browser.mainLoop.func = null; + _emscripten_set_main_loop(func, 0, false, Browser.mainLoop.arg, true); + _emscripten_set_main_loop_timing(timingMode, timingValue); + Browser.mainLoop.scheduler() + }, + updateStatus: function () { + if (Module["setStatus"]) { + var message = Module["statusMessage"] || "Please wait..."; + var remaining = Browser.mainLoop.remainingBlockers; + var expected = Browser.mainLoop.expectedBlockers; + if (remaining) { + if (remaining < expected) { + Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")") + } else { + Module["setStatus"](message) + } + } else { + Module["setStatus"]("") + } + } + }, + runIter: function (func) { + if (ABORT) + return; + if (Module["preMainLoop"]) { + var preRet = Module["preMainLoop"](); + if (preRet === false) { + return + } + } + try { + func() + } catch (e) { + if (e instanceof ExitStatus) { + return + } else { + if (e && typeof e === "object" && e.stack) + err("exception thrown: " + [e, e.stack]); + throw e + } + } + if (Module["postMainLoop"]) + Module["postMainLoop"]() + } + }, + isFullscreen: false, + pointerLock: false, + moduleContextCreatedCallbacks: [], + workers: [], + init: function () { + if (!Module["preloadPlugins"]) + Module["preloadPlugins"] = []; + if (Browser.initted) + return; + Browser.initted = true; + try { + new Blob; + Browser.hasBlobConstructor = true + } catch (e) { + Browser.hasBlobConstructor = false; + console.log("warning: no blob constructor, cannot create blobs with mimetypes") + } + Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : !Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null; + Browser.URLObject = typeof window != "undefined" ? window.URL ? window.URL : window.webkitURL : undefined; + if (!Module.noImageDecoding && typeof Browser.URLObject === "undefined") { + console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available."); + Module.noImageDecoding = true + } + var imagePlugin = {}; + imagePlugin["canHandle"] = function imagePlugin_canHandle(name) { + return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name) + } + ; + imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) { + var b = null; + if (Browser.hasBlobConstructor) { + try { + b = new Blob([byteArray], { + type: Browser.getMimetype(name) + }); + if (b.size !== byteArray.length) { + b = new Blob([new Uint8Array(byteArray).buffer], { + type: Browser.getMimetype(name) + }) + } + } catch (e) { + warnOnce("Blob constructor present but fails: " + e + "; falling back to blob builder") + } + } + if (!b) { + var bb = new Browser.BlobBuilder; + bb.append(new Uint8Array(byteArray).buffer); + b = bb.getBlob() + } + var url = Browser.URLObject.createObjectURL(b); + var img = new Image; + img.onload = function img_onload() { + assert(img.complete, "Image " + name + " could not be decoded"); + var canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + var ctx = canvas.getContext("2d"); + ctx.drawImage(img, 0, 0); + Module["preloadedImages"][name] = canvas; + Browser.URLObject.revokeObjectURL(url); + if (onload) + onload(byteArray) + } + ; + img.onerror = function img_onerror(event) { + console.log("Image " + url + " could not be decoded"); + if (onerror) + onerror() + } + ; + img.src = url + } + ; + Module["preloadPlugins"].push(imagePlugin); + var audioPlugin = {}; + audioPlugin["canHandle"] = function audioPlugin_canHandle(name) { + return !Module.noAudioDecoding && name.substr(-4) in { + ".ogg": 1, + ".wav": 1, + ".mp3": 1 + } + } + ; + audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) { + var done = false; + function finish(audio) { + if (done) + return; + done = true; + Module["preloadedAudios"][name] = audio; + if (onload) + onload(byteArray) + } + function fail() { + if (done) + return; + done = true; + Module["preloadedAudios"][name] = new Audio; + if (onerror) + onerror() + } + if (Browser.hasBlobConstructor) { + try { + var b = new Blob([byteArray], { + type: Browser.getMimetype(name) + }) + } catch (e) { + return fail() + } + var url = Browser.URLObject.createObjectURL(b); + var audio = new Audio; + audio.addEventListener("canplaythrough", function () { + finish(audio) + }, false); + audio.onerror = function audio_onerror(event) { + if (done) + return; + console.log("warning: browser could not fully decode audio " + name + ", trying slower base64 approach"); + function encode64(data) { + var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var PAD = "="; + var ret = ""; + var leftchar = 0; + var leftbits = 0; + for (var i = 0; i < data.length; i++) { + leftchar = leftchar << 8 | data[i]; + leftbits += 8; + while (leftbits >= 6) { + var curr = leftchar >> leftbits - 6 & 63; + leftbits -= 6; + ret += BASE[curr] + } + } + if (leftbits == 2) { + ret += BASE[(leftchar & 3) << 4]; + ret += PAD + PAD + } else if (leftbits == 4) { + ret += BASE[(leftchar & 15) << 2]; + ret += PAD + } + return ret + } + audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray); + finish(audio) + } + ; + audio.src = url; + Browser.safeSetTimeout(function () { + finish(audio) + }, 1e4) + } else { + return fail() + } + } + ; + Module["preloadPlugins"].push(audioPlugin); + function pointerLockChange() { + Browser.pointerLock = document["pointerLockElement"] === Module["canvas"] || document["mozPointerLockElement"] === Module["canvas"] || document["webkitPointerLockElement"] === Module["canvas"] || document["msPointerLockElement"] === Module["canvas"] + } + var canvas = Module["canvas"]; + if (canvas) { + canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || function () { } + ; + canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] || function () { } + ; + canvas.exitPointerLock = canvas.exitPointerLock.bind(document); + document.addEventListener("pointerlockchange", pointerLockChange, false); + document.addEventListener("mozpointerlockchange", pointerLockChange, false); + document.addEventListener("webkitpointerlockchange", pointerLockChange, false); + document.addEventListener("mspointerlockchange", pointerLockChange, false); + if (Module["elementPointerLock"]) { + canvas.addEventListener("click", function (ev) { + if (!Browser.pointerLock && Module["canvas"].requestPointerLock) { + Module["canvas"].requestPointerLock(); + ev.preventDefault() + } + }, false) + } + } + }, + createContext: function (canvas, useWebGL, setInModule, webGLContextAttributes) { + if (useWebGL && Module.ctx && canvas == Module.canvas) + return Module.ctx; + var ctx; + var contextHandle; + if (useWebGL) { + var contextAttributes = { + antialias: false, + alpha: false, + majorVersion: 1 + }; + if (webGLContextAttributes) { + for (var attribute in webGLContextAttributes) { + contextAttributes[attribute] = webGLContextAttributes[attribute] + } + } + if (typeof GL !== "undefined") { + contextHandle = GL.createContext(canvas, contextAttributes); + if (contextHandle) { + ctx = GL.getContext(contextHandle).GLctx + } + } + } else { + ctx = canvas.getContext("2d") + } + if (!ctx) + return null; + if (setInModule) { + if (!useWebGL) + assert(typeof GLctx === "undefined", "cannot set in module if GLctx is used, but we are a non-GL context that would replace it"); + Module.ctx = ctx; + if (useWebGL) + GL.makeContextCurrent(contextHandle); + Module.useWebGL = useWebGL; + Browser.moduleContextCreatedCallbacks.forEach(function (callback) { + callback() + }); + Browser.init() + } + return ctx + }, + destroyContext: function (canvas, useWebGL, setInModule) { }, + fullscreenHandlersInstalled: false, + lockPointer: undefined, + resizeCanvas: undefined, + requestFullscreen: function (lockPointer, resizeCanvas, vrDevice) { + Browser.lockPointer = lockPointer; + Browser.resizeCanvas = resizeCanvas; + Browser.vrDevice = vrDevice; + if (typeof Browser.lockPointer === "undefined") + Browser.lockPointer = true; + if (typeof Browser.resizeCanvas === "undefined") + Browser.resizeCanvas = false; + if (typeof Browser.vrDevice === "undefined") + Browser.vrDevice = null; + var canvas = Module["canvas"]; + function fullscreenChange() { + Browser.isFullscreen = false; + var canvasContainer = canvas.parentNode; + if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvasContainer) { + canvas.exitFullscreen = Browser.exitFullscreen; + if (Browser.lockPointer) + canvas.requestPointerLock(); + Browser.isFullscreen = true; + if (Browser.resizeCanvas) { + Browser.setFullscreenCanvasSize() + } else { + Browser.updateCanvasDimensions(canvas) + } + } else { + canvasContainer.parentNode.insertBefore(canvas, canvasContainer); + canvasContainer.parentNode.removeChild(canvasContainer); + if (Browser.resizeCanvas) { + Browser.setWindowedCanvasSize() + } else { + Browser.updateCanvasDimensions(canvas) + } + } + if (Module["onFullScreen"]) + Module["onFullScreen"](Browser.isFullscreen); + if (Module["onFullscreen"]) + Module["onFullscreen"](Browser.isFullscreen) + } + if (!Browser.fullscreenHandlersInstalled) { + Browser.fullscreenHandlersInstalled = true; + document.addEventListener("fullscreenchange", fullscreenChange, false); + document.addEventListener("mozfullscreenchange", fullscreenChange, false); + document.addEventListener("webkitfullscreenchange", fullscreenChange, false); + document.addEventListener("MSFullscreenChange", fullscreenChange, false) + } + var canvasContainer = document.createElement("div"); + canvas.parentNode.insertBefore(canvasContainer, canvas); + canvasContainer.appendChild(canvas); + canvasContainer.requestFullscreen = canvasContainer["requestFullscreen"] || canvasContainer["mozRequestFullScreen"] || canvasContainer["msRequestFullscreen"] || (canvasContainer["webkitRequestFullscreen"] ? function () { + canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]) + } + : null) || (canvasContainer["webkitRequestFullScreen"] ? function () { + canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]) + } + : null); + if (vrDevice) { + canvasContainer.requestFullscreen({ + vrDisplay: vrDevice + }) + } else { + canvasContainer.requestFullscreen() + } + }, + requestFullScreen: function (lockPointer, resizeCanvas, vrDevice) { + err("Browser.requestFullScreen() is deprecated. Please call Browser.requestFullscreen instead."); + Browser.requestFullScreen = function (lockPointer, resizeCanvas, vrDevice) { + return Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice) + } + ; + return Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice) + }, + exitFullscreen: function () { + if (!Browser.isFullscreen) { + return false + } + var CFS = document["exitFullscreen"] || document["cancelFullScreen"] || document["mozCancelFullScreen"] || document["msExitFullscreen"] || document["webkitCancelFullScreen"] || function () { } + ; + CFS.apply(document, []); + return true + }, + nextRAF: 0, + fakeRequestAnimationFrame: function (func) { + var now = Date.now(); + if (Browser.nextRAF === 0) { + Browser.nextRAF = now + 1e3 / 60 + } else { + while (now + 2 >= Browser.nextRAF) { + Browser.nextRAF += 1e3 / 60 + } + } + var delay = Math.max(Browser.nextRAF - now, 0); + setTimeout(func, delay) + }, + requestAnimationFrame: function (func) { + if (typeof requestAnimationFrame === "function") { + requestAnimationFrame(func); + return + } + var RAF = Browser.fakeRequestAnimationFrame; + RAF(func) + }, + safeCallback: function (func) { + return function () { + if (!ABORT) + return func.apply(null, arguments) + } + }, + allowAsyncCallbacks: true, + queuedAsyncCallbacks: [], + pauseAsyncCallbacks: function () { + Browser.allowAsyncCallbacks = false + }, + resumeAsyncCallbacks: function () { + Browser.allowAsyncCallbacks = true; + if (Browser.queuedAsyncCallbacks.length > 0) { + var callbacks = Browser.queuedAsyncCallbacks; + Browser.queuedAsyncCallbacks = []; + callbacks.forEach(function (func) { + func() + }) + } + }, + safeRequestAnimationFrame: function (func) { + return Browser.requestAnimationFrame(function () { + if (ABORT) + return; + if (Browser.allowAsyncCallbacks) { + func() + } else { + Browser.queuedAsyncCallbacks.push(func) + } + }) + }, + safeSetTimeout: function (func, timeout) { + noExitRuntime = true; + return setTimeout(function () { + if (ABORT) + return; + if (Browser.allowAsyncCallbacks) { + func() + } else { + Browser.queuedAsyncCallbacks.push(func) + } + }, timeout) + }, + safeSetInterval: function (func, timeout) { + noExitRuntime = true; + return setInterval(function () { + if (ABORT) + return; + if (Browser.allowAsyncCallbacks) { + func() + } + }, timeout) + }, + getMimetype: function (name) { + return { + "jpg": "image/jpeg", + "jpeg": "image/jpeg", + "png": "image/png", + "bmp": "image/bmp", + "ogg": "audio/ogg", + "wav": "audio/wav", + "mp3": "audio/mpeg" + }[name.substr(name.lastIndexOf(".") + 1)] + }, + getUserMedia: function (func) { + if (!window.getUserMedia) { + window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"] + } + window.getUserMedia(func) + }, + getMovementX: function (event) { + return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0 + }, + getMovementY: function (event) { + return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0 + }, + getMouseWheelDelta: function (event) { + var delta = 0; + switch (event.type) { + case "DOMMouseScroll": + delta = event.detail / 3; + break; + case "mousewheel": + delta = event.wheelDelta / 120; + break; + case "wheel": + delta = event.deltaY; + switch (event.deltaMode) { + case 0: + delta /= 100; + break; + case 1: + delta /= 3; + break; + case 2: + delta *= 80; + break; + default: + throw "unrecognized mouse wheel delta mode: " + event.deltaMode + } + break; + default: + throw "unrecognized mouse wheel event: " + event.type + } + return delta + }, + mouseX: 0, + mouseY: 0, + mouseMovementX: 0, + mouseMovementY: 0, + touches: {}, + lastTouches: {}, + calculateMouseEvent: function (event) { + if (Browser.pointerLock) { + if (event.type != "mousemove" && "mozMovementX" in event) { + Browser.mouseMovementX = Browser.mouseMovementY = 0 + } else { + Browser.mouseMovementX = Browser.getMovementX(event); + Browser.mouseMovementY = Browser.getMovementY(event) + } + if (typeof SDL != "undefined") { + Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; + Browser.mouseY = SDL.mouseY + Browser.mouseMovementY + } else { + Browser.mouseX += Browser.mouseMovementX; + Browser.mouseY += Browser.mouseMovementY + } + } else { + var rect = Module["canvas"].getBoundingClientRect(); + var cw = Module["canvas"].width; + var ch = Module["canvas"].height; + var scrollX = typeof window.scrollX !== "undefined" ? window.scrollX : window.pageXOffset; + var scrollY = typeof window.scrollY !== "undefined" ? window.scrollY : window.pageYOffset; + if (event.type === "touchstart" || event.type === "touchend" || event.type === "touchmove") { + var touch = event.touch; + if (touch === undefined) { + return + } + var adjustedX = touch.pageX - (scrollX + rect.left); + var adjustedY = touch.pageY - (scrollY + rect.top); + adjustedX = adjustedX * (cw / rect.width); + adjustedY = adjustedY * (ch / rect.height); + var coords = { + x: adjustedX, + y: adjustedY + }; + if (event.type === "touchstart") { + Browser.lastTouches[touch.identifier] = coords; + Browser.touches[touch.identifier] = coords + } else if (event.type === "touchend" || event.type === "touchmove") { + var last = Browser.touches[touch.identifier]; + if (!last) + last = coords; + Browser.lastTouches[touch.identifier] = last; + Browser.touches[touch.identifier] = coords + } + return + } + var x = event.pageX - (scrollX + rect.left); + var y = event.pageY - (scrollY + rect.top); + x = x * (cw / rect.width); + y = y * (ch / rect.height); + Browser.mouseMovementX = x - Browser.mouseX; + Browser.mouseMovementY = y - Browser.mouseY; + Browser.mouseX = x; + Browser.mouseY = y + } + }, + asyncLoad: function (url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency("al " + url) : ""; + readAsync(url, function (arrayBuffer) { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) + removeRunDependency(dep) + }, function (event) { + if (onerror) { + onerror() + } else { + throw 'Loading data file "' + url + '" failed.' + } + }); + if (dep) + addRunDependency(dep) + }, + resizeListeners: [], + updateResizeListeners: function () { + var canvas = Module["canvas"]; + Browser.resizeListeners.forEach(function (listener) { + listener(canvas.width, canvas.height) + }) + }, + setCanvasSize: function (width, height, noUpdates) { + var canvas = Module["canvas"]; + Browser.updateCanvasDimensions(canvas, width, height); + if (!noUpdates) + Browser.updateResizeListeners() + }, + windowedWidth: 0, + windowedHeight: 0, + setFullscreenCanvasSize: function () { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags | 8388608; + HEAP32[SDL.screen >> 2] = flags + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners() + }, + setWindowedCanvasSize: function () { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags & ~8388608; + HEAP32[SDL.screen >> 2] = flags + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners() + }, + updateCanvasDimensions: function (canvas, wNative, hNative) { + if (wNative && hNative) { + canvas.widthNative = wNative; + canvas.heightNative = hNative + } else { + wNative = canvas.widthNative; + hNative = canvas.heightNative + } + var w = wNative; + var h = hNative; + if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) { + if (w / h < Module["forcedAspectRatio"]) { + w = Math.round(h * Module["forcedAspectRatio"]) + } else { + h = Math.round(w / Module["forcedAspectRatio"]) + } + } + if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvas.parentNode && typeof screen != "undefined") { + var factor = Math.min(screen.width / w, screen.height / h); + w = Math.round(w * factor); + h = Math.round(h * factor) + } + if (Browser.resizeCanvas) { + if (canvas.width != w) + canvas.width = w; + if (canvas.height != h) + canvas.height = h; + if (typeof canvas.style != "undefined") { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height") + } + } else { + if (canvas.width != wNative) + canvas.width = wNative; + if (canvas.height != hNative) + canvas.height = hNative; + if (typeof canvas.style != "undefined") { + if (w != wNative || h != hNative) { + canvas.style.setProperty("width", w + "px", "important"); + canvas.style.setProperty("height", h + "px", "important") + } else { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height") + } + } + } + }, + wgetRequests: {}, + nextWgetRequestHandle: 0, + getNextWgetRequestHandle: function () { + var handle = Browser.nextWgetRequestHandle; + Browser.nextWgetRequestHandle++; + return handle + } + }; + function demangle(func) { + var __cxa_demangle_func = Module["___cxa_demangle"] || Module["__cxa_demangle"]; + assert(__cxa_demangle_func); + try { + var s = func; + if (s.startsWith("__Z")) + s = s.substr(1); + var len = lengthBytesUTF8(s) + 1; + var buf = _malloc(len); + stringToUTF8(s, buf, len); + var status = _malloc(4); + var ret = __cxa_demangle_func(buf, 0, 0, status); + if (HEAP32[status >> 2] === 0 && ret) { + return UTF8ToString(ret) + } + } catch (e) { } finally { + if (buf) + _free(buf); + if (status) + _free(status); + if (ret) + _free(ret) + } + return func + } + function demangleAll(text) { + var regex = /\b_Z[\w\d_]+/g; + return text.replace(regex, function (x) { + var y = demangle(x); + return x === y ? x : y + " [" + x + "]" + }) + } + function jsStackTrace() { + var err = new Error; + if (!err.stack) { + try { + throw new Error(0) + } catch (e) { + err = e + } + if (!err.stack) { + return "(no stack trace available)" + } + } + return err.stack.toString() + } + function stackTrace() { + var js = jsStackTrace(); + if (Module["extraStackTrace"]) + js += "\n" + Module["extraStackTrace"](); + return demangleAll(js) + } + function ___cxa_allocate_exception(size) { + return _malloc(size) + } + function _atexit(func, arg) { + __ATEXIT__.unshift({ + func: func, + arg: arg + }) + } + function ___cxa_atexit() { + return _atexit.apply(null, arguments) + } + var ___exception_infos = {}; + var ___exception_last = 0; + function ___cxa_throw(ptr, type, destructor) { + ___exception_infos[ptr] = { + ptr: ptr, + adjusted: [ptr], + type: type, + destructor: destructor, + refcount: 0, + caught: false, + rethrown: false + }; + ___exception_last = ptr; + if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) { + __ZSt18uncaught_exceptionv.uncaught_exceptions = 1 + } else { + __ZSt18uncaught_exceptionv.uncaught_exceptions++ + } + throw ptr + } + function ___lock() { } + function ___setErrNo(value) { + if (Module["___errno_location"]) + HEAP32[Module["___errno_location"]() >> 2] = value; + return value + } + function ___map_file(pathname, size) { + ___setErrNo(63); + return -1 + } + var PATH = { + splitPath: function (filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1) + }, + normalizeArray: function (parts, allowAboveRoot) { + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === ".") { + parts.splice(i, 1) + } else if (last === "..") { + parts.splice(i, 1); + up++ + } else if (up) { + parts.splice(i, 1); + up-- + } + } + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift("..") + } + } + return parts + }, + normalize: function (path) { + var isAbsolute = path.charAt(0) === "/" + , trailingSlash = path.substr(-1) === "/"; + path = PATH.normalizeArray(path.split("/").filter(function (p) { + return !!p + }), !isAbsolute).join("/"); + if (!path && !isAbsolute) { + path = "." + } + if (path && trailingSlash) { + path += "/" + } + return (isAbsolute ? "/" : "") + path + }, + dirname: function (path) { + var result = PATH.splitPath(path) + , root = result[0] + , dir = result[1]; + if (!root && !dir) { + return "." + } + if (dir) { + dir = dir.substr(0, dir.length - 1) + } + return root + dir + }, + basename: function (path) { + if (path === "/") + return "/"; + var lastSlash = path.lastIndexOf("/"); + if (lastSlash === -1) + return path; + return path.substr(lastSlash + 1) + }, + extname: function (path) { + return PATH.splitPath(path)[3] + }, + join: function () { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join("/")) + }, + join2: function (l, r) { + return PATH.normalize(l + "/" + r) + } + }; + var PATH_FS = { + resolve: function () { + var resolvedPath = "" + , resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = i >= 0 ? arguments[i] : FS.cwd(); + if (typeof path !== "string") { + throw new TypeError("Arguments to path.resolve must be strings") + } else if (!path) { + return "" + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = path.charAt(0) === "/" + } + resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(function (p) { + return !!p + }), !resolvedAbsolute).join("/"); + return (resolvedAbsolute ? "/" : "") + resolvedPath || "." + }, + relative: function (from, to) { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== "") + break + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== "") + break + } + if (start > end) + return []; + return arr.slice(start, end - start + 1) + } + var fromParts = trim(from.split("/")); + var toParts = trim(to.split("/")); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push("..") + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join("/") + } + }; + var TTY = { + ttys: [], + init: function () { }, + shutdown: function () { }, + register: function (dev, ops) { + TTY.ttys[dev] = { + input: [], + output: [], + ops: ops + }; + FS.registerDevice(dev, TTY.stream_ops) + }, + stream_ops: { + open: function (stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43) + } + stream.tty = tty; + stream.seekable = false + }, + close: function (stream) { + stream.tty.ops.flush(stream.tty) + }, + flush: function (stream) { + stream.tty.ops.flush(stream.tty) + }, + read: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60) + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty) + } catch (e) { + throw new FS.ErrnoError(29) + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6) + } + if (result === null || result === undefined) + break; + bytesRead++; + buffer[offset + i] = result + } + if (bytesRead) { + stream.node.timestamp = Date.now() + } + return bytesRead + }, + write: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60) + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset + i]) + } + } catch (e) { + throw new FS.ErrnoError(29) + } + if (length) { + stream.node.timestamp = Date.now() + } + return i + } + }, + default_tty_ops: { + get_char: function (tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + var BUFSIZE = 256; + var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE); + var bytesRead = 0; + try { + bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, null) + } catch (e) { + if (e.toString().indexOf("EOF") != -1) + bytesRead = 0; + else + throw e + } + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString("utf-8") + } else { + result = null + } + } else if (typeof window != "undefined" && typeof window.prompt == "function") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n" + } + } else if (typeof readline == "function") { + result = readline(); + if (result !== null) { + result += "\n" + } + } + if (!result) { + return null + } + tty.input = intArrayFromString(result, true) + } + return tty.input.shift() + }, + put_char: function (tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } else { + if (val != 0) + tty.output.push(val) + } + }, + flush: function (tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } + } + }, + default_tty1_ops: { + put_char: function (tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } else { + if (val != 0) + tty.output.push(val) + } + }, + flush: function (tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } + } + } + }; + var MEMFS = { + ops_table: null, + mount: function (mount) { + return MEMFS.createNode(null, "/", 16384 | 511, 0) + }, + createNode: function (parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + throw new FS.ErrnoError(63) + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink + }, + stream: { + llseek: MEMFS.stream_ops.llseek + } + }, + file: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync + } + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink + }, + stream: {} + }, + chrdev: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: FS.chrdev_stream_ops + } + } + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {} + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; + node.contents = null + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream + } + node.timestamp = Date.now(); + if (parent) { + parent.contents[name] = node + } + return node + }, + getFileDataAsRegularArray: function (node) { + if (node.contents && node.contents.subarray) { + var arr = []; + for (var i = 0; i < node.usedBytes; ++i) + arr.push(node.contents[i]); + return arr + } + return node.contents + }, + getFileDataAsTypedArray: function (node) { + if (!node.contents) + return new Uint8Array; + if (node.contents.subarray) + return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents) + }, + expandFileStorage: function (node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) + return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) | 0); + if (prevCapacity != 0) + newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) + node.contents.set(oldContents.subarray(0, node.usedBytes), 0); + return + }, + resizeFileStorage: function (node, newSize) { + if (node.usedBytes == newSize) + return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0; + return + } + if (!node.contents || node.contents.subarray) { + var oldContents = node.contents; + node.contents = new Uint8Array(new ArrayBuffer(newSize)); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))) + } + node.usedBytes = newSize; + return + } + if (!node.contents) + node.contents = []; + if (node.contents.length > newSize) + node.contents.length = newSize; + else + while (node.contents.length < newSize) + node.contents.push(0); + node.usedBytes = newSize + }, + node_ops: { + getattr: function (node) { + var attr = {}; + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096 + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length + } else { + attr.size = 0 + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr + }, + setattr: function (node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size) + } + }, + lookup: function (parent, name) { + throw FS.genericErrors[44] + }, + mknod: function (parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev) + }, + rename: function (old_node, new_dir, new_name) { + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name) + } catch (e) { } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55) + } + } + } + delete old_node.parent.contents[old_node.name]; + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + old_node.parent = new_dir + }, + unlink: function (parent, name) { + delete parent.contents[name] + }, + rmdir: function (parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55) + } + delete parent.contents[name] + }, + readdir: function (node) { + var entries = [".", ".."]; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue + } + entries.push(key) + } + return entries + }, + symlink: function (parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); + node.link = oldpath; + return node + }, + readlink: function (node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28) + } + return node.link + } + }, + stream_ops: { + read: function (stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) + return 0; + var size = Math.min(stream.node.usedBytes - position, length); + if (size > 8 && contents.subarray) { + buffer.set(contents.subarray(position, position + size), offset) + } else { + for (var i = 0; i < size; i++) + buffer[offset + i] = contents[position + i] + } + return size + }, + write: function (stream, buffer, offset, length, position, canOwn) { + canOwn = false; + if (!length) + return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + if (canOwn) { + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length + } else if (node.usedBytes === 0 && position === 0) { + node.contents = new Uint8Array(buffer.subarray(offset, offset + length)); + node.usedBytes = length; + return length + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) + node.contents.set(buffer.subarray(offset, offset + length), position); + else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i] + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length + }, + llseek: function (stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes + } + } + if (position < 0) { + throw new FS.ErrnoError(28) + } + return position + }, + allocate: function (stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length) + }, + mmap: function (stream, buffer, offset, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43) + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && (contents.buffer === buffer || contents.buffer === buffer.buffer)) { + allocated = false; + ptr = contents.byteOffset + } else { + if (position > 0 || position + length < stream.node.usedBytes) { + if (contents.subarray) { + contents = contents.subarray(position, position + length) + } else { + contents = Array.prototype.slice.call(contents, position, position + length) + } + } + allocated = true; + var fromHeap = buffer.buffer == HEAP8.buffer; + ptr = _malloc(length); + if (!ptr) { + throw new FS.ErrnoError(48) + } + (fromHeap ? HEAP8 : buffer).set(contents, ptr) + } + return { + ptr: ptr, + allocated: allocated + } + }, + msync: function (stream, buffer, offset, length, mmapFlags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43) + } + if (mmapFlags & 2) { + return 0 + } + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + return 0 + } + } + }; + var IDBFS = { + dbs: {}, + indexedDB: function () { + if (typeof indexedDB !== "undefined") + return indexedDB; + var ret = null; + if (typeof window === "object") + ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + assert(ret, "IDBFS used, but indexedDB not supported"); + return ret + }, + DB_VERSION: 21, + DB_STORE_NAME: "FILE_DATA", + mount: function (mount) { + return MEMFS.mount.apply(null, arguments) + }, + syncfs: function (mount, populate, callback) { + IDBFS.getLocalSet(mount, function (err, local) { + if (err) + return callback(err); + IDBFS.getRemoteSet(mount, function (err, remote) { + if (err) + return callback(err); + var src = populate ? remote : local; + var dst = populate ? local : remote; + IDBFS.reconcile(src, dst, callback) + }) + }) + }, + getDB: function (name, callback) { + var db = IDBFS.dbs[name]; + if (db) { + return callback(null, db) + } + var req; + try { + req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION) + } catch (e) { + return callback(e) + } + if (!req) { + return callback("Unable to connect to IndexedDB") + } + req.onupgradeneeded = function (e) { + var db = e.target.result; + var transaction = e.target.transaction; + var fileStore; + if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) { + fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME) + } else { + fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME) + } + if (!fileStore.indexNames.contains("timestamp")) { + fileStore.createIndex("timestamp", "timestamp", { + unique: false + }) + } + } + ; + req.onsuccess = function () { + db = req.result; + IDBFS.dbs[name] = db; + callback(null, db) + } + ; + req.onerror = function (e) { + callback(this.error); + e.preventDefault() + } + }, + getLocalSet: function (mount, callback) { + var entries = {}; + function isRealDir(p) { + return p !== "." && p !== ".." + } + function toAbsolute(root) { + return function (p) { + return PATH.join2(root, p) + } + } + var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint)); + while (check.length) { + var path = check.pop(); + var stat; + try { + stat = FS.stat(path) + } catch (e) { + return callback(e) + } + if (FS.isDir(stat.mode)) { + check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path))) + } + entries[path] = { + timestamp: stat.mtime + } + } + return callback(null, { + type: "local", + entries: entries + }) + }, + getRemoteSet: function (mount, callback) { + var entries = {}; + IDBFS.getDB(mount.mountpoint, function (err, db) { + if (err) + return callback(err); + try { + var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly"); + transaction.onerror = function (e) { + callback(this.error); + e.preventDefault() + } + ; + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + var index = store.index("timestamp"); + index.openKeyCursor().onsuccess = function (event) { + var cursor = event.target.result; + if (!cursor) { + return callback(null, { + type: "remote", + db: db, + entries: entries + }) + } + entries[cursor.primaryKey] = { + timestamp: cursor.key + }; + cursor.continue() + } + } catch (e) { + return callback(e) + } + }) + }, + loadLocalEntry: function (path, callback) { + var stat, node; + try { + var lookup = FS.lookupPath(path); + node = lookup.node; + stat = FS.stat(path) + } catch (e) { + return callback(e) + } + if (FS.isDir(stat.mode)) { + return callback(null, { + timestamp: stat.mtime, + mode: stat.mode + }) + } else if (FS.isFile(stat.mode)) { + node.contents = MEMFS.getFileDataAsTypedArray(node); + return callback(null, { + timestamp: stat.mtime, + mode: stat.mode, + contents: node.contents + }) + } else { + return callback(new Error("node type not supported")) + } + }, + storeLocalEntry: function (path, entry, callback) { + try { + if (FS.isDir(entry.mode)) { + FS.mkdir(path, entry.mode) + } else if (FS.isFile(entry.mode)) { + FS.writeFile(path, entry.contents, { + canOwn: true + }) + } else { + return callback(new Error("node type not supported")) + } + FS.chmod(path, entry.mode); + FS.utime(path, entry.timestamp, entry.timestamp) + } catch (e) { + return callback(e) + } + callback(null) + }, + removeLocalEntry: function (path, callback) { + try { + var lookup = FS.lookupPath(path); + var stat = FS.stat(path); + if (FS.isDir(stat.mode)) { + FS.rmdir(path) + } else if (FS.isFile(stat.mode)) { + FS.unlink(path) + } + } catch (e) { + return callback(e) + } + callback(null) + }, + loadRemoteEntry: function (store, path, callback) { + var req = store.get(path); + req.onsuccess = function (event) { + callback(null, event.target.result) + } + ; + req.onerror = function (e) { + callback(this.error); + e.preventDefault() + } + }, + storeRemoteEntry: function (store, path, entry, callback) { + var req = store.put(entry, path); + req.onsuccess = function () { + callback(null) + } + ; + req.onerror = function (e) { + callback(this.error); + e.preventDefault() + } + }, + removeRemoteEntry: function (store, path, callback) { + var req = store.delete(path); + req.onsuccess = function () { + callback(null) + } + ; + req.onerror = function (e) { + callback(this.error); + e.preventDefault() + } + }, + reconcile: function (src, dst, callback) { + var total = 0; + var create = []; + Object.keys(src.entries).forEach(function (key) { + var e = src.entries[key]; + var e2 = dst.entries[key]; + if (!e2 || e.timestamp > e2.timestamp) { + create.push(key); + total++ + } + }); + var remove = []; + Object.keys(dst.entries).forEach(function (key) { + var e = dst.entries[key]; + var e2 = src.entries[key]; + if (!e2) { + remove.push(key); + total++ + } + }); + if (!total) { + return callback(null) + } + var errored = false; + var db = src.type === "remote" ? src.db : dst.db; + var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readwrite"); + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + function done(err) { + if (err && !errored) { + errored = true; + return callback(err) + } + } + transaction.onerror = function (e) { + done(this.error); + e.preventDefault() + } + ; + transaction.oncomplete = function (e) { + if (!errored) { + callback(null) + } + } + ; + create.sort().forEach(function (path) { + if (dst.type === "local") { + IDBFS.loadRemoteEntry(store, path, function (err, entry) { + if (err) + return done(err); + IDBFS.storeLocalEntry(path, entry, done) + }) + } else { + IDBFS.loadLocalEntry(path, function (err, entry) { + if (err) + return done(err); + IDBFS.storeRemoteEntry(store, path, entry, done) + }) + } + }); + remove.sort().reverse().forEach(function (path) { + if (dst.type === "local") { + IDBFS.removeLocalEntry(path, done) + } else { + IDBFS.removeRemoteEntry(store, path, done) + } + }) + } + }; + var ERRNO_CODES = { + EPERM: 63, + ENOENT: 44, + ESRCH: 71, + EINTR: 27, + EIO: 29, + ENXIO: 60, + E2BIG: 1, + ENOEXEC: 45, + EBADF: 8, + ECHILD: 12, + EAGAIN: 6, + EWOULDBLOCK: 6, + ENOMEM: 48, + EACCES: 2, + EFAULT: 21, + ENOTBLK: 105, + EBUSY: 10, + EEXIST: 20, + EXDEV: 75, + ENODEV: 43, + ENOTDIR: 54, + EISDIR: 31, + EINVAL: 28, + ENFILE: 41, + EMFILE: 33, + ENOTTY: 59, + ETXTBSY: 74, + EFBIG: 22, + ENOSPC: 51, + ESPIPE: 70, + EROFS: 69, + EMLINK: 34, + EPIPE: 64, + EDOM: 18, + ERANGE: 68, + ENOMSG: 49, + EIDRM: 24, + ECHRNG: 106, + EL2NSYNC: 156, + EL3HLT: 107, + EL3RST: 108, + ELNRNG: 109, + EUNATCH: 110, + ENOCSI: 111, + EL2HLT: 112, + EDEADLK: 16, + ENOLCK: 46, + EBADE: 113, + EBADR: 114, + EXFULL: 115, + ENOANO: 104, + EBADRQC: 103, + EBADSLT: 102, + EDEADLOCK: 16, + EBFONT: 101, + ENOSTR: 100, + ENODATA: 116, + ETIME: 117, + ENOSR: 118, + ENONET: 119, + ENOPKG: 120, + EREMOTE: 121, + ENOLINK: 47, + EADV: 122, + ESRMNT: 123, + ECOMM: 124, + EPROTO: 65, + EMULTIHOP: 36, + EDOTDOT: 125, + EBADMSG: 9, + ENOTUNIQ: 126, + EBADFD: 127, + EREMCHG: 128, + ELIBACC: 129, + ELIBBAD: 130, + ELIBSCN: 131, + ELIBMAX: 132, + ELIBEXEC: 133, + ENOSYS: 52, + ENOTEMPTY: 55, + ENAMETOOLONG: 37, + ELOOP: 32, + EOPNOTSUPP: 138, + EPFNOSUPPORT: 139, + ECONNRESET: 15, + ENOBUFS: 42, + EAFNOSUPPORT: 5, + EPROTOTYPE: 67, + ENOTSOCK: 57, + ENOPROTOOPT: 50, + ESHUTDOWN: 140, + ECONNREFUSED: 14, + EADDRINUSE: 3, + ECONNABORTED: 13, + ENETUNREACH: 40, + ENETDOWN: 38, + ETIMEDOUT: 73, + EHOSTDOWN: 142, + EHOSTUNREACH: 23, + EINPROGRESS: 26, + EALREADY: 7, + EDESTADDRREQ: 17, + EMSGSIZE: 35, + EPROTONOSUPPORT: 66, + ESOCKTNOSUPPORT: 137, + EADDRNOTAVAIL: 4, + ENETRESET: 39, + EISCONN: 30, + ENOTCONN: 53, + ETOOMANYREFS: 141, + EUSERS: 136, + EDQUOT: 19, + ESTALE: 72, + ENOTSUP: 138, + ENOMEDIUM: 148, + EILSEQ: 25, + EOVERFLOW: 61, + ECANCELED: 11, + ENOTRECOVERABLE: 56, + EOWNERDEAD: 62, + ESTRPIPE: 135 + }; + var NODEFS = { + isWindows: false, + staticInit: function () { + NODEFS.isWindows = !!process.platform.match(/^win/); + var flags = process["binding"]("constants"); + if (flags["fs"]) { + flags = flags["fs"] + } + NODEFS.flagsForNodeMap = { + 1024: flags["O_APPEND"], + 64: flags["O_CREAT"], + 128: flags["O_EXCL"], + 0: flags["O_RDONLY"], + 2: flags["O_RDWR"], + 4096: flags["O_SYNC"], + 512: flags["O_TRUNC"], + 1: flags["O_WRONLY"] + } + }, + bufferFrom: function (arrayBuffer) { + return Buffer["alloc"] ? Buffer.from(arrayBuffer) : new Buffer(arrayBuffer) + }, + convertNodeCode: function (e) { + var code = e.code; + assert(code in ERRNO_CODES); + return ERRNO_CODES[code] + }, + mount: function (mount) { + assert(ENVIRONMENT_HAS_NODE); + return NODEFS.createNode(null, "/", NODEFS.getMode(mount.opts.root), 0) + }, + createNode: function (parent, name, mode, dev) { + if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) { + throw new FS.ErrnoError(28) + } + var node = FS.createNode(parent, name, mode); + node.node_ops = NODEFS.node_ops; + node.stream_ops = NODEFS.stream_ops; + return node + }, + getMode: function (path) { + var stat; + try { + stat = fs.lstatSync(path); + if (NODEFS.isWindows) { + stat.mode = stat.mode | (stat.mode & 292) >> 2 + } + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + return stat.mode + }, + realPath: function (node) { + var parts = []; + while (node.parent !== node) { + parts.push(node.name); + node = node.parent + } + parts.push(node.mount.opts.root); + parts.reverse(); + return PATH.join.apply(null, parts) + }, + flagsForNode: function (flags) { + flags &= ~2097152; + flags &= ~2048; + flags &= ~32768; + flags &= ~524288; + var newFlags = 0; + for (var k in NODEFS.flagsForNodeMap) { + if (flags & k) { + newFlags |= NODEFS.flagsForNodeMap[k]; + flags ^= k + } + } + if (!flags) { + return newFlags + } else { + throw new FS.ErrnoError(28) + } + }, + node_ops: { + getattr: function (node) { + var path = NODEFS.realPath(node); + var stat; + try { + stat = fs.lstatSync(path) + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + if (NODEFS.isWindows && !stat.blksize) { + stat.blksize = 4096 + } + if (NODEFS.isWindows && !stat.blocks) { + stat.blocks = (stat.size + stat.blksize - 1) / stat.blksize | 0 + } + return { + dev: stat.dev, + ino: stat.ino, + mode: stat.mode, + nlink: stat.nlink, + uid: stat.uid, + gid: stat.gid, + rdev: stat.rdev, + size: stat.size, + atime: stat.atime, + mtime: stat.mtime, + ctime: stat.ctime, + blksize: stat.blksize, + blocks: stat.blocks + } + }, + setattr: function (node, attr) { + var path = NODEFS.realPath(node); + try { + if (attr.mode !== undefined) { + fs.chmodSync(path, attr.mode); + node.mode = attr.mode + } + if (attr.timestamp !== undefined) { + var date = new Date(attr.timestamp); + fs.utimesSync(path, date, date) + } + if (attr.size !== undefined) { + fs.truncateSync(path, attr.size) + } + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + lookup: function (parent, name) { + var path = PATH.join2(NODEFS.realPath(parent), name); + var mode = NODEFS.getMode(path); + return NODEFS.createNode(parent, name, mode) + }, + mknod: function (parent, name, mode, dev) { + var node = NODEFS.createNode(parent, name, mode, dev); + var path = NODEFS.realPath(node); + try { + if (FS.isDir(node.mode)) { + fs.mkdirSync(path, node.mode) + } else { + fs.writeFileSync(path, "", { + mode: node.mode + }) + } + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + return node + }, + rename: function (oldNode, newDir, newName) { + var oldPath = NODEFS.realPath(oldNode); + var newPath = PATH.join2(NODEFS.realPath(newDir), newName); + try { + fs.renameSync(oldPath, newPath) + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + unlink: function (parent, name) { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.unlinkSync(path) + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + rmdir: function (parent, name) { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.rmdirSync(path) + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + readdir: function (node) { + var path = NODEFS.realPath(node); + try { + return fs.readdirSync(path) + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + symlink: function (parent, newName, oldPath) { + var newPath = PATH.join2(NODEFS.realPath(parent), newName); + try { + fs.symlinkSync(oldPath, newPath) + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + readlink: function (node) { + var path = NODEFS.realPath(node); + try { + path = fs.readlinkSync(path); + path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path); + return path + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + } + }, + stream_ops: { + open: function (stream) { + var path = NODEFS.realPath(stream.node); + try { + if (FS.isFile(stream.node.mode)) { + stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags)) + } + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + close: function (stream) { + try { + if (FS.isFile(stream.node.mode) && stream.nfd) { + fs.closeSync(stream.nfd) + } + } catch (e) { + if (!e.code) + throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + read: function (stream, buffer, offset, length, position) { + if (length === 0) + return 0; + try { + return fs.readSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position) + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + write: function (stream, buffer, offset, length, position) { + try { + return fs.writeSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position) + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + }, + llseek: function (stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + try { + var stat = fs.fstatSync(stream.nfd); + position += stat.size + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)) + } + } + } + if (position < 0) { + throw new FS.ErrnoError(28) + } + return position + } + } + }; + var WORKERFS = { + DIR_MODE: 16895, + FILE_MODE: 33279, + reader: null, + mount: function (mount) { + assert(ENVIRONMENT_IS_WORKER); + if (!WORKERFS.reader) + WORKERFS.reader = new FileReaderSync; + var root = WORKERFS.createNode(null, "/", WORKERFS.DIR_MODE, 0); + var createdParents = {}; + function ensureParent(path) { + var parts = path.split("/"); + var parent = root; + for (var i = 0; i < parts.length - 1; i++) { + var curr = parts.slice(0, i + 1).join("/"); + if (!createdParents[curr]) { + createdParents[curr] = WORKERFS.createNode(parent, parts[i], WORKERFS.DIR_MODE, 0) + } + parent = createdParents[curr] + } + return parent + } + function base(path) { + var parts = path.split("/"); + return parts[parts.length - 1] + } + Array.prototype.forEach.call(mount.opts["files"] || [], function (file) { + WORKERFS.createNode(ensureParent(file.name), base(file.name), WORKERFS.FILE_MODE, 0, file, file.lastModifiedDate) + }); + (mount.opts["blobs"] || []).forEach(function (obj) { + WORKERFS.createNode(ensureParent(obj["name"]), base(obj["name"]), WORKERFS.FILE_MODE, 0, obj["data"]) + }); + (mount.opts["packages"] || []).forEach(function (pack) { + pack["metadata"].files.forEach(function (file) { + var name = file.filename.substr(1); + WORKERFS.createNode(ensureParent(name), base(name), WORKERFS.FILE_MODE, 0, pack["blob"].slice(file.start, file.end)) + }) + }); + return root + }, + createNode: function (parent, name, mode, dev, contents, mtime) { + var node = FS.createNode(parent, name, mode); + node.mode = mode; + node.node_ops = WORKERFS.node_ops; + node.stream_ops = WORKERFS.stream_ops; + node.timestamp = (mtime || new Date).getTime(); + assert(WORKERFS.FILE_MODE !== WORKERFS.DIR_MODE); + if (mode === WORKERFS.FILE_MODE) { + node.size = contents.size; + node.contents = contents + } else { + node.size = 4096; + node.contents = {} + } + if (parent) { + parent.contents[name] = node + } + return node + }, + node_ops: { + getattr: function (node) { + return { + dev: 1, + ino: undefined, + mode: node.mode, + nlink: 1, + uid: 0, + gid: 0, + rdev: undefined, + size: node.size, + atime: new Date(node.timestamp), + mtime: new Date(node.timestamp), + ctime: new Date(node.timestamp), + blksize: 4096, + blocks: Math.ceil(node.size / 4096) + } + }, + setattr: function (node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp + } + }, + lookup: function (parent, name) { + throw new FS.ErrnoError(44) + }, + mknod: function (parent, name, mode, dev) { + throw new FS.ErrnoError(63) + }, + rename: function (oldNode, newDir, newName) { + throw new FS.ErrnoError(63) + }, + unlink: function (parent, name) { + throw new FS.ErrnoError(63) + }, + rmdir: function (parent, name) { + throw new FS.ErrnoError(63) + }, + readdir: function (node) { + var entries = [".", ".."]; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue + } + entries.push(key) + } + return entries + }, + symlink: function (parent, newName, oldPath) { + throw new FS.ErrnoError(63) + }, + readlink: function (node) { + throw new FS.ErrnoError(63) + } + }, + stream_ops: { + read: function (stream, buffer, offset, length, position) { + if (position >= stream.node.size) + return 0; + var chunk = stream.node.contents.slice(position, position + length); + var ab = WORKERFS.reader.readAsArrayBuffer(chunk); + buffer.set(new Uint8Array(ab), offset); + return chunk.size + }, + write: function (stream, buffer, offset, length, position) { + throw new FS.ErrnoError(29) + }, + llseek: function (stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.size + } + } + if (position < 0) { + throw new FS.ErrnoError(28) + } + return position + } + } + }; + var FS = { + root: null, + mounts: [], + devices: {}, + streams: [], + nextInode: 1, + nameTable: null, + currentPath: "/", + initialized: false, + ignorePermissions: true, + trackingDelegate: {}, + tracking: { + openFlags: { + READ: 1, + WRITE: 2 + } + }, + ErrnoError: null, + genericErrors: {}, + filesystems: null, + syncFSRequests: 0, + handleFSError: function (e) { + if (!(e instanceof FS.ErrnoError)) + throw e + " : " + stackTrace(); + return ___setErrNo(e.errno) + }, + lookupPath: function (path, opts) { + path = PATH_FS.resolve(FS.cwd(), path); + opts = opts || {}; + if (!path) + return { + path: "", + node: null + }; + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + for (var key in defaults) { + if (opts[key] === undefined) { + opts[key] = defaults[key] + } + } + if (opts.recurse_count > 8) { + throw new FS.ErrnoError(32) + } + var parts = PATH.normalizeArray(path.split("/").filter(function (p) { + return !!p + }), false); + var current = FS.root; + var current_path = "/"; + for (var i = 0; i < parts.length; i++) { + var islast = i === parts.length - 1; + if (islast && opts.parent) { + break + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || islast && opts.follow_mount) { + current = current.mounted.root + } + } + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + var lookup = FS.lookupPath(current_path, { + recurse_count: opts.recurse_count + }); + current = lookup.node; + if (count++ > 40) { + throw new FS.ErrnoError(32) + } + } + } + } + return { + path: current_path, + node: current + } + }, + getPath: function (node) { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) + return mount; + return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path + } + path = path ? node.name + "/" + path : node.name; + node = node.parent + } + }, + hashName: function (parentid, name) { + var hash = 0; + for (var i = 0; i < name.length; i++) { + hash = (hash << 5) - hash + name.charCodeAt(i) | 0 + } + return (parentid + hash >>> 0) % FS.nameTable.length + }, + hashAddNode: function (node) { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node + }, + hashRemoveNode: function (node) { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break + } + current = current.name_next + } + } + }, + lookupNode: function (parent, name) { + var err = FS.mayLookup(parent); + if (err) { + throw new FS.ErrnoError(err, parent) + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node + } + } + return FS.lookup(parent, name) + }, + createNode: function (parent, name, mode, rdev) { + if (!FS.FSNode) { + FS.FSNode = function (parent, name, mode, rdev) { + if (!parent) { + parent = this + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev + } + ; + FS.FSNode.prototype = {}; + var readMode = 292 | 73; + var writeMode = 146; + Object.defineProperties(FS.FSNode.prototype, { + read: { + get: function () { + return (this.mode & readMode) === readMode + }, + set: function (val) { + val ? this.mode |= readMode : this.mode &= ~readMode + } + }, + write: { + get: function () { + return (this.mode & writeMode) === writeMode + }, + set: function (val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode + } + }, + isFolder: { + get: function () { + return FS.isDir(this.mode) + } + }, + isDevice: { + get: function () { + return FS.isChrdev(this.mode) + } + } + }) + } + var node = new FS.FSNode(parent, name, mode, rdev); + FS.hashAddNode(node); + return node + }, + destroyNode: function (node) { + FS.hashRemoveNode(node) + }, + isRoot: function (node) { + return node === node.parent + }, + isMountpoint: function (node) { + return !!node.mounted + }, + isFile: function (mode) { + return (mode & 61440) === 32768 + }, + isDir: function (mode) { + return (mode & 61440) === 16384 + }, + isLink: function (mode) { + return (mode & 61440) === 40960 + }, + isChrdev: function (mode) { + return (mode & 61440) === 8192 + }, + isBlkdev: function (mode) { + return (mode & 61440) === 24576 + }, + isFIFO: function (mode) { + return (mode & 61440) === 4096 + }, + isSocket: function (mode) { + return (mode & 49152) === 49152 + }, + flagModes: { + "r": 0, + "rs": 1052672, + "r+": 2, + "w": 577, + "wx": 705, + "xw": 705, + "w+": 578, + "wx+": 706, + "xw+": 706, + "a": 1089, + "ax": 1217, + "xa": 1217, + "a+": 1090, + "ax+": 1218, + "xa+": 1218 + }, + modeStringToFlags: function (str) { + var flags = FS.flagModes[str]; + if (typeof flags === "undefined") { + throw new Error("Unknown file open mode: " + str) + } + return flags + }, + flagsToPermissionString: function (flag) { + var perms = ["r", "w", "rw"][flag & 3]; + if (flag & 512) { + perms += "w" + } + return perms + }, + nodePermissions: function (node, perms) { + if (FS.ignorePermissions) { + return 0 + } + if (perms.indexOf("r") !== -1 && !(node.mode & 292)) { + return 2 + } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) { + return 2 + } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) { + return 2 + } + return 0 + }, + mayLookup: function (dir) { + var err = FS.nodePermissions(dir, "x"); + if (err) + return err; + if (!dir.node_ops.lookup) + return 2; + return 0 + }, + mayCreate: function (dir, name) { + try { + var node = FS.lookupNode(dir, name); + return 20 + } catch (e) { } + return FS.nodePermissions(dir, "wx") + }, + mayDelete: function (dir, name, isdir) { + var node; + try { + node = FS.lookupNode(dir, name) + } catch (e) { + return e.errno + } + var err = FS.nodePermissions(dir, "wx"); + if (err) { + return err + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54 + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10 + } + } else { + if (FS.isDir(node.mode)) { + return 31 + } + } + return 0 + }, + mayOpen: function (node, flags) { + if (!node) { + return 44 + } + if (FS.isLink(node.mode)) { + return 32 + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { + return 31 + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)) + }, + MAX_OPEN_FDS: 4096, + nextfd: function (fd_start, fd_end) { + fd_start = fd_start || 0; + fd_end = fd_end || FS.MAX_OPEN_FDS; + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd + } + } + throw new FS.ErrnoError(33) + }, + getStream: function (fd) { + return FS.streams[fd] + }, + createStream: function (stream, fd_start, fd_end) { + if (!FS.FSStream) { + FS.FSStream = function () { } + ; + FS.FSStream.prototype = {}; + Object.defineProperties(FS.FSStream.prototype, { + object: { + get: function () { + return this.node + }, + set: function (val) { + this.node = val + } + }, + isRead: { + get: function () { + return (this.flags & 2097155) !== 1 + } + }, + isWrite: { + get: function () { + return (this.flags & 2097155) !== 0 + } + }, + isAppend: { + get: function () { + return this.flags & 1024 + } + } + }) + } + var newStream = new FS.FSStream; + for (var p in stream) { + newStream[p] = stream[p] + } + stream = newStream; + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream + }, + closeStream: function (fd) { + FS.streams[fd] = null + }, + chrdev_stream_ops: { + open: function (stream) { + var device = FS.getDevice(stream.node.rdev); + stream.stream_ops = device.stream_ops; + if (stream.stream_ops.open) { + stream.stream_ops.open(stream) + } + }, + llseek: function () { + throw new FS.ErrnoError(70) + } + }, + major: function (dev) { + return dev >> 8 + }, + minor: function (dev) { + return dev & 255 + }, + makedev: function (ma, mi) { + return ma << 8 | mi + }, + registerDevice: function (dev, ops) { + FS.devices[dev] = { + stream_ops: ops + } + }, + getDevice: function (dev) { + return FS.devices[dev] + }, + getMounts: function (mount) { + var mounts = []; + var check = [mount]; + while (check.length) { + var m = check.pop(); + mounts.push(m); + check.push.apply(check, m.mounts) + } + return mounts + }, + syncfs: function (populate, callback) { + if (typeof populate === "function") { + callback = populate; + populate = false + } + FS.syncFSRequests++; + if (FS.syncFSRequests > 1) { + console.log("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work") + } + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + function doCallback(err) { + FS.syncFSRequests--; + return callback(err) + } + function done(err) { + if (err) { + if (!done.errored) { + done.errored = true; + return doCallback(err) + } + return + } + if (++completed >= mounts.length) { + doCallback(null) + } + } + mounts.forEach(function (mount) { + if (!mount.type.syncfs) { + return done(null) + } + mount.type.syncfs(mount, populate, done) + }) + }, + mount: function (type, opts, mountpoint) { + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(10) + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + mountpoint = lookup.path; + node = lookup.node; + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10) + } + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54) + } + } + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot + } else if (node) { + node.mounted = mount; + if (node.mount) { + node.mount.mounts.push(mount) + } + } + return mountRoot + }, + unmount: function (mountpoint) { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28) + } + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + Object.keys(FS.nameTable).forEach(function (hash) { + var current = FS.nameTable[hash]; + while (current) { + var next = current.name_next; + if (mounts.indexOf(current.mount) !== -1) { + FS.destroyNode(current) + } + current = next + } + }); + node.mounted = null; + var idx = node.mount.mounts.indexOf(mount); + node.mount.mounts.splice(idx, 1) + }, + lookup: function (parent, name) { + return parent.node_ops.lookup(parent, name) + }, + mknod: function (path, mode, dev) { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === "." || name === "..") { + throw new FS.ErrnoError(28) + } + var err = FS.mayCreate(parent, name); + if (err) { + throw new FS.ErrnoError(err) + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63) + } + return parent.node_ops.mknod(parent, name, mode, dev) + }, + create: function (path, mode) { + mode = mode !== undefined ? mode : 438; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0) + }, + mkdir: function (path, mode) { + mode = mode !== undefined ? mode : 511; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0) + }, + mkdirTree: function (path, mode) { + var dirs = path.split("/"); + var d = ""; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) + continue; + d += "/" + dirs[i]; + try { + FS.mkdir(d, mode) + } catch (e) { + if (e.errno != 20) + throw e + } + } + }, + mkdev: function (path, mode, dev) { + if (typeof dev === "undefined") { + dev = mode; + mode = 438 + } + mode |= 8192; + return FS.mknod(path, mode, dev) + }, + symlink: function (oldpath, newpath) { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44) + } + var lookup = FS.lookupPath(newpath, { + parent: true + }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44) + } + var newname = PATH.basename(newpath); + var err = FS.mayCreate(parent, newname); + if (err) { + throw new FS.ErrnoError(err) + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63) + } + return parent.node_ops.symlink(parent, newname, oldpath) + }, + rename: function (old_path, new_path) { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + var lookup, old_dir, new_dir; + try { + lookup = FS.lookupPath(old_path, { + parent: true + }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { + parent: true + }); + new_dir = lookup.node + } catch (e) { + throw new FS.ErrnoError(10) + } + if (!old_dir || !new_dir) + throw new FS.ErrnoError(44); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75) + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28) + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55) + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name) + } catch (e) { } + if (old_node === new_node) { + return + } + var isdir = FS.isDir(old_node.mode); + var err = FS.mayDelete(old_dir, old_name, isdir); + if (err) { + throw new FS.ErrnoError(err) + } + err = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name); + if (err) { + throw new FS.ErrnoError(err) + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63) + } + if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) { + throw new FS.ErrnoError(10) + } + if (new_dir !== old_dir) { + err = FS.nodePermissions(old_dir, "w"); + if (err) { + throw new FS.ErrnoError(err) + } + } + try { + if (FS.trackingDelegate["willMovePath"]) { + FS.trackingDelegate["willMovePath"](old_path, new_path) + } + } catch (e) { + console.log("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message) + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name) + } catch (e) { + throw e + } finally { + FS.hashAddNode(old_node) + } + try { + if (FS.trackingDelegate["onMovePath"]) + FS.trackingDelegate["onMovePath"](old_path, new_path) + } catch (e) { + console.log("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message) + } + }, + rmdir: function (path) { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var err = FS.mayDelete(parent, name, true); + if (err) { + throw new FS.ErrnoError(err) + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63) + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10) + } + try { + if (FS.trackingDelegate["willDeletePath"]) { + FS.trackingDelegate["willDeletePath"](path) + } + } catch (e) { + console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message) + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + try { + if (FS.trackingDelegate["onDeletePath"]) + FS.trackingDelegate["onDeletePath"](path) + } catch (e) { + console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message) + } + }, + readdir: function (path) { + var lookup = FS.lookupPath(path, { + follow: true + }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54) + } + return node.node_ops.readdir(node) + }, + unlink: function (path) { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var err = FS.mayDelete(parent, name, false); + if (err) { + throw new FS.ErrnoError(err) + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63) + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10) + } + try { + if (FS.trackingDelegate["willDeletePath"]) { + FS.trackingDelegate["willDeletePath"](path) + } + } catch (e) { + console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message) + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + try { + if (FS.trackingDelegate["onDeletePath"]) + FS.trackingDelegate["onDeletePath"](path) + } catch (e) { + console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message) + } + }, + readlink: function (path) { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44) + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28) + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)) + }, + stat: function (path, dontFollow) { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44) + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63) + } + return node.node_ops.getattr(node) + }, + lstat: function (path) { + return FS.stat(path, true) + }, + chmod: function (path, mode, dontFollow) { + var node; + if (typeof path === "string") { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + node = lookup.node + } else { + node = path + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63) + } + node.node_ops.setattr(node, { + mode: mode & 4095 | node.mode & ~4095, + timestamp: Date.now() + }) + }, + lchmod: function (path, mode) { + FS.chmod(path, mode, true) + }, + fchmod: function (fd, mode) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8) + } + FS.chmod(stream.node, mode) + }, + chown: function (path, uid, gid, dontFollow) { + var node; + if (typeof path === "string") { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + node = lookup.node + } else { + node = path + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63) + } + node.node_ops.setattr(node, { + timestamp: Date.now() + }) + }, + lchown: function (path, uid, gid) { + FS.chown(path, uid, gid, true) + }, + fchown: function (fd, uid, gid) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8) + } + FS.chown(stream.node, uid, gid) + }, + truncate: function (path, len) { + if (len < 0) { + throw new FS.ErrnoError(28) + } + var node; + if (typeof path === "string") { + var lookup = FS.lookupPath(path, { + follow: true + }); + node = lookup.node + } else { + node = path + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63) + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31) + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28) + } + var err = FS.nodePermissions(node, "w"); + if (err) { + throw new FS.ErrnoError(err) + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }) + }, + ftruncate: function (fd, len) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8) + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28) + } + FS.truncate(stream.node, len) + }, + utime: function (path, atime, mtime) { + var lookup = FS.lookupPath(path, { + follow: true + }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }) + }, + open: function (path, flags, mode, fd_start, fd_end) { + if (path === "") { + throw new FS.ErrnoError(44) + } + flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode === "undefined" ? 438 : mode; + if (flags & 64) { + mode = mode & 4095 | 32768 + } else { + mode = 0 + } + var node; + if (typeof path === "object") { + node = path + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node + } catch (e) { } + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20) + } + } else { + node = FS.mknod(path, mode, 0); + created = true + } + } + if (!node) { + throw new FS.ErrnoError(44) + } + if (FS.isChrdev(node.mode)) { + flags &= ~512 + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54) + } + if (!created) { + var err = FS.mayOpen(node, flags); + if (err) { + throw new FS.ErrnoError(err) + } + } + if (flags & 512) { + FS.truncate(node, 0) + } + flags &= ~(128 | 512); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false + }, fd_start, fd_end); + if (stream.stream_ops.open) { + stream.stream_ops.open(stream) + } + if (Module["logReadFiles"] && !(flags & 1)) { + if (!FS.readFiles) + FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + console.log("FS.trackingDelegate error on read file: " + path) + } + } + try { + if (FS.trackingDelegate["onOpenFile"]) { + var trackingFlags = 0; + if ((flags & 2097155) !== 1) { + trackingFlags |= FS.tracking.openFlags.READ + } + if ((flags & 2097155) !== 0) { + trackingFlags |= FS.tracking.openFlags.WRITE + } + FS.trackingDelegate["onOpenFile"](path, trackingFlags) + } + } catch (e) { + console.log("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message) + } + return stream + }, + close: function (stream) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if (stream.getdents) + stream.getdents = null; + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream) + } + } catch (e) { + throw e + } finally { + FS.closeStream(stream.fd) + } + stream.fd = null + }, + isClosed: function (stream) { + return stream.fd === null + }, + llseek: function (stream, offset, whence) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70) + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28) + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position + }, + read: function (stream, buffer, offset, length, position) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28) + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8) + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31) + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28) + } + var seeking = typeof position !== "undefined"; + if (!seeking) { + position = stream.position + } else if (!stream.seekable) { + throw new FS.ErrnoError(70) + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) + stream.position += bytesRead; + return bytesRead + }, + write: function (stream, buffer, offset, length, position, canOwn) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28) + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8) + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31) + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28) + } + if (stream.flags & 1024) { + FS.llseek(stream, 0, 2) + } + var seeking = typeof position !== "undefined"; + if (!seeking) { + position = stream.position + } else if (!stream.seekable) { + throw new FS.ErrnoError(70) + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) + stream.position += bytesWritten; + try { + if (stream.path && FS.trackingDelegate["onWriteToFile"]) + FS.trackingDelegate["onWriteToFile"](stream.path) + } catch (e) { + console.log("FS.trackingDelegate['onWriteToFile']('" + stream.path + "') threw an exception: " + e.message) + } + return bytesWritten + }, + allocate: function (stream, offset, length) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28) + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8) + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43) + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138) + } + stream.stream_ops.allocate(stream, offset, length) + }, + mmap: function (stream, buffer, offset, length, position, prot, flags) { + if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2) + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2) + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43) + } + return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags) + }, + msync: function (stream, buffer, offset, length, mmapFlags) { + if (!stream || !stream.stream_ops.msync) { + return 0 + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags) + }, + munmap: function (stream) { + return 0 + }, + ioctl: function (stream, cmd, arg) { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59) + } + return stream.stream_ops.ioctl(stream, cmd, arg) + }, + readFile: function (path, opts) { + opts = opts || {}; + opts.flags = opts.flags || "r"; + opts.encoding = opts.encoding || "binary"; + if (opts.encoding !== "utf8" && opts.encoding !== "binary") { + throw new Error('Invalid encoding type "' + opts.encoding + '"') + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === "utf8") { + ret = UTF8ArrayToString(buf, 0) + } else if (opts.encoding === "binary") { + ret = buf + } + FS.close(stream); + return ret + }, + writeFile: function (path, data, opts) { + opts = opts || {}; + opts.flags = opts.flags || "w"; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data === "string") { + var buf = new Uint8Array(lengthBytesUTF8(data) + 1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn) + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn) + } else { + throw new Error("Unsupported data type") + } + FS.close(stream) + }, + cwd: function () { + return FS.currentPath + }, + chdir: function (path) { + var lookup = FS.lookupPath(path, { + follow: true + }); + if (lookup.node === null) { + throw new FS.ErrnoError(44) + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54) + } + var err = FS.nodePermissions(lookup.node, "x"); + if (err) { + throw new FS.ErrnoError(err) + } + FS.currentPath = lookup.path + }, + createDefaultDirectories: function () { + FS.mkdir("/tmp"); + FS.mkdir("/home"); + FS.mkdir("/home/web_user") + }, + createDefaultDevices: function () { + FS.mkdir("/dev"); + FS.registerDevice(FS.makedev(1, 3), { + read: function () { + return 0 + }, + write: function (stream, buffer, offset, length, pos) { + return length + } + }); + FS.mkdev("/dev/null", FS.makedev(1, 3)); + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev("/dev/tty", FS.makedev(5, 0)); + FS.mkdev("/dev/tty1", FS.makedev(6, 0)); + var random_device; + if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") { + var randomBuffer = new Uint8Array(1); + random_device = function () { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0] + } + } else if (ENVIRONMENT_IS_NODE) { + try { + var crypto_module = require("crypto"); + random_device = function () { + return crypto_module["randomBytes"](1)[0] + } + } catch (e) { } + } else { } + if (!random_device) { + random_device = function () { + abort("random_device") + } + } + FS.createDevice("/dev", "random", random_device); + FS.createDevice("/dev", "urandom", random_device); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp") + }, + createSpecialDirectories: function () { + FS.mkdir("/proc"); + FS.mkdir("/proc/self"); + FS.mkdir("/proc/self/fd"); + FS.mount({ + mount: function () { + var node = FS.createNode("/proc/self", "fd", 16384 | 511, 73); + node.node_ops = { + lookup: function (parent, name) { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) + throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { + mountpoint: "fake" + }, + node_ops: { + readlink: function () { + return stream.path + } + } + }; + ret.parent = ret; + return ret + } + }; + return node + } + }, {}, "/proc/self/fd") + }, + createStandardStreams: function () { + if (Module["stdin"]) { + FS.createDevice("/dev", "stdin", Module["stdin"]) + } else { + FS.symlink("/dev/tty", "/dev/stdin") + } + if (Module["stdout"]) { + FS.createDevice("/dev", "stdout", null, Module["stdout"]) + } else { + FS.symlink("/dev/tty", "/dev/stdout") + } + if (Module["stderr"]) { + FS.createDevice("/dev", "stderr", null, Module["stderr"]) + } else { + FS.symlink("/dev/tty1", "/dev/stderr") + } + var stdin = FS.open("/dev/stdin", "r"); + var stdout = FS.open("/dev/stdout", "w"); + var stderr = FS.open("/dev/stderr", "w") + }, + ensureErrnoError: function () { + if (FS.ErrnoError) + return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = function (errno) { + this.errno = errno + } + ; + this.setErrno(errno); + this.message = "FS error" + } + ; + FS.ErrnoError.prototype = new Error; + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + [44].forEach(function (code) { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = "" + }) + }, + staticInit: function () { + FS.ensureErrnoError(); + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = { + "MEMFS": MEMFS, + "IDBFS": IDBFS, + "NODEFS": NODEFS, + "WORKERFS": WORKERFS + } + }, + init: function (input, output, error) { + FS.init.initialized = true; + FS.ensureErrnoError(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams() + }, + quit: function () { + FS.init.initialized = false; + var fflush = Module["_fflush"]; + if (fflush) + fflush(0); + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue + } + FS.close(stream) + } + }, + getMode: function (canRead, canWrite) { + var mode = 0; + if (canRead) + mode |= 292 | 73; + if (canWrite) + mode |= 146; + return mode + }, + joinPath: function (parts, forceRelative) { + var path = PATH.join.apply(null, parts); + if (forceRelative && path[0] == "/") + path = path.substr(1); + return path + }, + absolutePath: function (relative, base) { + return PATH_FS.resolve(base, relative) + }, + standardizePath: function (path) { + return PATH.normalize(path) + }, + findObject: function (path, dontResolveLastLink) { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object + } else { + ___setErrNo(ret.error); + return null + } + }, + analyzePath: function (path, dontResolveLastLink) { + try { + var lookup = FS.lookupPath(path, { + follow: !dontResolveLastLink + }); + path = lookup.path + } catch (e) { } + var ret = { + isRoot: false, + exists: false, + error: 0, + name: null, + path: null, + object: null, + parentExists: false, + parentPath: null, + parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { + parent: true + }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { + follow: !dontResolveLastLink + }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === "/" + } catch (e) { + ret.error = e.errno + } + return ret + }, + createFolder: function (parent, name, canRead, canWrite) { + var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.mkdir(path, mode) + }, + createPath: function (parent, path, canRead, canWrite) { + parent = typeof parent === "string" ? parent : FS.getPath(parent); + var parts = path.split("/").reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) + continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current) + } catch (e) { } + parent = current + } + return current + }, + createFile: function (parent, name, properties, canRead, canWrite) { + var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode) + }, + createDataFile: function (parent, name, data, canRead, canWrite, canOwn) { + var path = name ? PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name) : parent; + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data === "string") { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) + arr[i] = data.charCodeAt(i); + data = arr + } + FS.chmod(node, mode | 146); + var stream = FS.open(node, "w"); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode) + } + return node + }, + createDevice: function (parent, name, input, output) { + var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) + FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + FS.registerDevice(dev, { + open: function (stream) { + stream.seekable = false + }, + close: function (stream) { + if (output && output.buffer && output.buffer.length) { + output(10) + } + }, + read: function (stream, buffer, offset, length, pos) { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input() + } catch (e) { + throw new FS.ErrnoError(29) + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6) + } + if (result === null || result === undefined) + break; + bytesRead++; + buffer[offset + i] = result + } + if (bytesRead) { + stream.node.timestamp = Date.now() + } + return bytesRead + }, + write: function (stream, buffer, offset, length, pos) { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset + i]) + } catch (e) { + throw new FS.ErrnoError(29) + } + } + if (length) { + stream.node.timestamp = Date.now() + } + return i + } + }); + return FS.mkdev(path, mode, dev) + }, + createLink: function (parent, name, target, canRead, canWrite) { + var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name); + return FS.symlink(target, path) + }, + forceLoadFile: function (obj) { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) + return true; + var success = true; + if (typeof XMLHttpRequest !== "undefined") { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.") + } else if (read_) { + try { + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length + } catch (e) { + success = false + } + } else { + throw new Error("Cannot load without read() or XMLHttpRequest.") + } + if (!success) + ___setErrNo(29); + return success + }, + createLazyFile: function (parent, name, url, canRead, canWrite) { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = [] + } + LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { + if (idx > this.length - 1 || idx < 0) { + return undefined + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = idx / this.chunkSize | 0; + return this.getter(chunkNum)[chunkOffset] + } + ; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter + } + ; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + var xhr = new XMLHttpRequest; + xhr.open("HEAD", url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + var chunkSize = 1024 * 1024; + if (!hasByteServing) + chunkSize = datalength; + var doXHR = function (from, to) { + if (from > to) + throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength - 1) + throw new Error("only " + datalength + " bytes available! programmer error!"); + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + if (datalength !== chunkSize) + xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + if (typeof Uint8Array != "undefined") + xhr.responseType = "arraybuffer"; + if (xhr.overrideMimeType) { + xhr.overrideMimeType("text/plain; charset=x-user-defined") + } + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(xhr.response || []) + } else { + return intArrayFromString(xhr.responseText || "", true) + } + }; + var lazyArray = this; + lazyArray.setDataGetter(function (chunkNum) { + var start = chunkNum * chunkSize; + var end = (chunkNum + 1) * chunkSize - 1; + end = Math.min(end, datalength - 1); + if (typeof lazyArray.chunks[chunkNum] === "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end) + } + if (typeof lazyArray.chunks[chunkNum] === "undefined") + throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum] + }); + if (usesGzip || !datalength) { + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + console.log("LazyFiles on gzip forces download of the whole file when length is accessed") + } + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true + } + ; + if (typeof XMLHttpRequest !== "undefined") { + if (!ENVIRONMENT_IS_WORKER) + throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc"; + var lazyArray = new LazyUint8Array; + Object.defineProperties(lazyArray, { + length: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength() + } + return this._length + } + }, + chunkSize: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength() + } + return this._chunkSize + } + } + }); + var properties = { + isDevice: false, + contents: lazyArray + } + } else { + var properties = { + isDevice: false, + url: url + } + } + var node = FS.createFile(parent, name, properties, canRead, canWrite); + if (properties.contents) { + node.contents = properties.contents + } else if (properties.url) { + node.contents = null; + node.url = properties.url + } + Object.defineProperties(node, { + usedBytes: { + get: function () { + return this.contents.length + } + } + }); + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach(function (key) { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + if (!FS.forceLoadFile(node)) { + throw new FS.ErrnoError(29) + } + return fn.apply(null, arguments) + } + }); + stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) { + if (!FS.forceLoadFile(node)) { + throw new FS.ErrnoError(29) + } + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + if (contents.slice) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i] + } + } else { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents.get(position + i) + } + } + return size + } + ; + node.stream_ops = stream_ops; + return node + }, + createPreloadedFile: function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) { + Browser.init(); + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency("cp " + fullname); + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) + preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn) + } + if (onload) + onload(); + removeRunDependency(dep) + } + var handled = false; + Module["preloadPlugins"].forEach(function (plugin) { + if (handled) + return; + if (plugin["canHandle"](fullname)) { + plugin["handle"](byteArray, fullname, finish, function () { + if (onerror) + onerror(); + removeRunDependency(dep) + }); + handled = true + } + }); + if (!handled) + finish(byteArray) + } + addRunDependency(dep); + if (typeof url == "string") { + Browser.asyncLoad(url, function (byteArray) { + processData(byteArray) + }, onerror) + } else { + processData(url) + } + }, + indexedDB: function () { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB + }, + DB_NAME: function () { + return "EM_FS_" + window.location.pathname + }, + DB_VERSION: 20, + DB_STORE_NAME: "FILE_DATA", + saveFilesToDB: function (paths, onload, onerror) { + onload = onload || function () { } + ; + onerror = onerror || function () { } + ; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION) + } catch (e) { + return onerror(e) + } + openRequest.onupgradeneeded = function openRequest_onupgradeneeded() { + console.log("creating db"); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME) + } + ; + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite"); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0 + , fail = 0 + , total = paths.length; + function finish() { + if (fail == 0) + onload(); + else + onerror() + } + paths.forEach(function (path) { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = function putRequest_onsuccess() { + ok++; + if (ok + fail == total) + finish() + } + ; + putRequest.onerror = function putRequest_onerror() { + fail++; + if (ok + fail == total) + finish() + } + }); + transaction.onerror = onerror + } + ; + openRequest.onerror = onerror + }, + loadFilesFromDB: function (paths, onload, onerror) { + onload = onload || function () { } + ; + onerror = onerror || function () { } + ; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION) + } catch (e) { + return onerror(e) + } + openRequest.onupgradeneeded = onerror; + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], "readonly") + } catch (e) { + onerror(e); + return + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0 + , fail = 0 + , total = paths.length; + function finish() { + if (fail == 0) + onload(); + else + onerror() + } + paths.forEach(function (path) { + var getRequest = files.get(path); + getRequest.onsuccess = function getRequest_onsuccess() { + if (FS.analyzePath(path).exists) { + FS.unlink(path) + } + FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); + ok++; + if (ok + fail == total) + finish() + } + ; + getRequest.onerror = function getRequest_onerror() { + fail++; + if (ok + fail == total) + finish() + } + }); + transaction.onerror = onerror + } + ; + openRequest.onerror = onerror + } + }; + var SYSCALLS = { + DEFAULT_POLLMASK: 5, + mappings: {}, + umask: 511, + calculateAt: function (dirfd, path) { + if (path[0] !== "/") { + var dir; + if (dirfd === -100) { + dir = FS.cwd() + } else { + var dirstream = FS.getStream(dirfd); + if (!dirstream) + throw new FS.ErrnoError(8); + dir = dirstream.path + } + path = PATH.join2(dir, path) + } + return path + }, + doStat: function (func, path, buf) { + try { + var stat = func(path) + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + return -54 + } + throw e + } + HEAP32[buf >> 2] = stat.dev; + HEAP32[buf + 4 >> 2] = 0; + HEAP32[buf + 8 >> 2] = stat.ino; + HEAP32[buf + 12 >> 2] = stat.mode; + HEAP32[buf + 16 >> 2] = stat.nlink; + HEAP32[buf + 20 >> 2] = stat.uid; + HEAP32[buf + 24 >> 2] = stat.gid; + HEAP32[buf + 28 >> 2] = stat.rdev; + HEAP32[buf + 32 >> 2] = 0; + tempI64 = [stat.size >>> 0, (tempDouble = stat.size, + +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], + HEAP32[buf + 40 >> 2] = tempI64[0], + HEAP32[buf + 44 >> 2] = tempI64[1]; + HEAP32[buf + 48 >> 2] = 4096; + HEAP32[buf + 52 >> 2] = stat.blocks; + HEAP32[buf + 56 >> 2] = stat.atime.getTime() / 1e3 | 0; + HEAP32[buf + 60 >> 2] = 0; + HEAP32[buf + 64 >> 2] = stat.mtime.getTime() / 1e3 | 0; + HEAP32[buf + 68 >> 2] = 0; + HEAP32[buf + 72 >> 2] = stat.ctime.getTime() / 1e3 | 0; + HEAP32[buf + 76 >> 2] = 0; + tempI64 = [stat.ino >>> 0, (tempDouble = stat.ino, + +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], + HEAP32[buf + 80 >> 2] = tempI64[0], + HEAP32[buf + 84 >> 2] = tempI64[1]; + return 0 + }, + doMsync: function (addr, stream, len, flags) { + var buffer = new Uint8Array(HEAPU8.subarray(addr, addr + len)); + FS.msync(stream, buffer, 0, len, flags) + }, + doMkdir: function (path, mode) { + path = PATH.normalize(path); + if (path[path.length - 1] === "/") + path = path.substr(0, path.length - 1); + FS.mkdir(path, mode, 0); + return 0 + }, + doMknod: function (path, mode, dev) { + switch (mode & 61440) { + case 32768: + case 8192: + case 24576: + case 4096: + case 49152: + break; + default: + return -28 + } + FS.mknod(path, mode, dev); + return 0 + }, + doReadlink: function (path, buf, bufsize) { + if (bufsize <= 0) + return -28; + var ret = FS.readlink(path); + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf + len]; + stringToUTF8(ret, buf, bufsize + 1); + HEAP8[buf + len] = endChar; + return len + }, + doAccess: function (path, amode) { + if (amode & ~7) { + return -28 + } + var node; + var lookup = FS.lookupPath(path, { + follow: true + }); + node = lookup.node; + if (!node) { + return -44 + } + var perms = ""; + if (amode & 4) + perms += "r"; + if (amode & 2) + perms += "w"; + if (amode & 1) + perms += "x"; + if (perms && FS.nodePermissions(node, perms)) { + return -2 + } + return 0 + }, + doDup: function (path, flags, suggestFD) { + var suggest = FS.getStream(suggestFD); + if (suggest) + FS.close(suggest); + return FS.open(path, flags, 0, suggestFD, suggestFD).fd + }, + doReadv: function (stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[iov + i * 8 >> 2]; + var len = HEAP32[iov + (i * 8 + 4) >> 2]; + var curr = FS.read(stream, HEAP8, ptr, len, offset); + if (curr < 0) + return -1; + ret += curr; + if (curr < len) + break + } + return ret + }, + doWritev: function (stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[iov + i * 8 >> 2]; + var len = HEAP32[iov + (i * 8 + 4) >> 2]; + var curr = FS.write(stream, HEAP8, ptr, len, offset); + if (curr < 0) + return -1; + ret += curr + } + return ret + }, + varargs: 0, + get: function (varargs) { + SYSCALLS.varargs += 4; + var ret = HEAP32[SYSCALLS.varargs - 4 >> 2]; + return ret + }, + getStr: function () { + var ret = UTF8ToString(SYSCALLS.get()); + return ret + }, + getStreamFromFD: function (fd) { + if (fd === undefined) + fd = SYSCALLS.get(); + var stream = FS.getStream(fd); + if (!stream) + throw new FS.ErrnoError(8); + return stream + }, + get64: function () { + var low = SYSCALLS.get() + , high = SYSCALLS.get(); + return low + }, + getZero: function () { + SYSCALLS.get() + } + }; + function ___syscall221(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD() + , cmd = SYSCALLS.get(); + switch (cmd) { + case 0: + { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28 + } + var newStream; + newStream = FS.open(stream.path, stream.flags, 0, arg); + return newStream.fd + } + case 1: + case 2: + return 0; + case 3: + return stream.flags; + case 4: + { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0 + } + case 12: + { + var arg = SYSCALLS.get(); + var offset = 0; + HEAP16[arg + offset >> 1] = 2; + return 0 + } + case 13: + case 14: + return 0; + case 16: + case 8: + return -28; + case 9: + ___setErrNo(28); + return -1; + default: + { + return -28 + } + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno + } + } + function ___syscall3(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD() + , buf = SYSCALLS.get() + , count = SYSCALLS.get(); + return FS.read(stream, HEAP8, buf, count) + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno + } + } + function ___syscall4(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD() + , buf = SYSCALLS.get() + , count = SYSCALLS.get(); + return FS.write(stream, HEAP8, buf, count) + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno + } + } + function ___syscall5(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var pathname = SYSCALLS.getStr() + , flags = SYSCALLS.get() + , mode = SYSCALLS.get(); + var stream = FS.open(pathname, flags, mode); + return stream.fd + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno + } + } + function ___syscall54(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD() + , op = SYSCALLS.get(); + switch (op) { + case 21509: + case 21505: + { + if (!stream.tty) + return -59; + return 0 + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: + { + if (!stream.tty) + return -59; + return 0 + } + case 21519: + { + if (!stream.tty) + return -59; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0 + } + case 21520: + { + if (!stream.tty) + return -59; + return -28 + } + case 21531: + { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp) + } + case 21523: + { + if (!stream.tty) + return -59; + return 0 + } + case 21524: + { + if (!stream.tty) + return -59; + return 0 + } + default: + abort("bad ioctl syscall " + op) + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno + } + } + function __emscripten_syscall_munmap(addr, len) { + if (addr === -1 || len === 0) { + return -28 + } + var info = SYSCALLS.mappings[addr]; + if (!info) + return 0; + if (len === info.len) { + var stream = FS.getStream(info.fd); + SYSCALLS.doMsync(addr, stream, len, info.flags); + FS.munmap(stream); + SYSCALLS.mappings[addr] = null; + if (info.allocated) { + _free(info.malloc) + } + } + return 0 + } + function ___syscall91(which, varargs) { + SYSCALLS.varargs = varargs; + try { + var addr = SYSCALLS.get() + , len = SYSCALLS.get(); + return __emscripten_syscall_munmap(addr, len) + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno + } + } + function ___unlock() { } + var tupleRegistrations = {}; + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr) + } + } + function simpleReadValueFromPointer(pointer) { + return this["fromWireType"](HEAPU32[pointer >> 2]) + } + var awaitingDependencies = {}; + var registeredTypes = {}; + var typeDependencies = {}; + var char_0 = 48; + var char_9 = 57; + function makeLegalFunctionName(name) { + if (undefined === name) { + return "_unknown" + } + name = name.replace(/[^a-zA-Z0-9_]/g, "$"); + var f = name.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return "_" + name + } else { + return name + } + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + if (IsWechat) { + var f1 = function (body) { + return function () { + "use strict"; + return body.apply(this, arguments); + } + } + return f1(body) + } else { + return new Function("body", "return function " + name + "() {\n" + ' "use strict";' + " return body.apply(this, arguments);\n" + "};\n")(body) + } + + } + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function (message) { + this.name = errorName; + this.message = message; + var stack = new Error(message).stack; + if (stack !== undefined) { + this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "") + } + }); + + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function () { + if (this.message === undefined) { + return this.name + } else { + return this.name + ": " + this.message + } + } + ; + return errorClass + } + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message) + } + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function (type) { + typeDependencies[type] = dependentTypes + }); + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError("Mismatched type converter count") + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]) + } + } + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach(function (dt, i) { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt] + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = [] + } + awaitingDependencies[dt].push(function () { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters) + } + }) + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters) + } + } + function __embind_finalize_value_array(rawTupleType) { + var reg = tupleRegistrations[rawTupleType]; + delete tupleRegistrations[rawTupleType]; + var elements = reg.elements; + var elementsLength = elements.length; + var elementTypes = elements.map(function (elt) { + return elt.getterReturnType + }).concat(elements.map(function (elt) { + return elt.setterArgumentType + })); + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + whenDependentTypesAreResolved([rawTupleType], elementTypes, function (elementTypes) { + elements.forEach(function (elt, i) { + var getterReturnType = elementTypes[i]; + var getter = elt.getter; + var getterContext = elt.getterContext; + var setterArgumentType = elementTypes[i + elementsLength]; + var setter = elt.setter; + var setterContext = elt.setterContext; + elt.read = function (ptr) { + return getterReturnType["fromWireType"](getter(getterContext, ptr)) + } + ; + elt.write = function (ptr, o) { + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o)); + runDestructors(destructors) + } + }); + return [{ + name: reg.name, + "fromWireType": function (ptr) { + var rv = new Array(elementsLength); + for (var i = 0; i < elementsLength; ++i) { + rv[i] = elements[i].read(ptr) + } + rawDestructor(ptr); + return rv + }, + "toWireType": function (destructors, o) { + if (elementsLength !== o.length) { + throw new TypeError("Incorrect number of tuple elements for " + reg.name + ": expected=" + elementsLength + ", actual=" + o.length) + } + var ptr = rawConstructor(); + for (var i = 0; i < elementsLength; ++i) { + elements[i].write(ptr, o[i]) + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr) + } + return ptr + }, + "argPackAdvance": 8, + "readValueFromPointer": simpleReadValueFromPointer, + destructorFunction: rawDestructor + }] + }) + } + var structRegistrations = {}; + function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map(function (field) { + return field.getterReturnType + }).concat(fieldRecords.map(function (field) { + return field.setterArgumentType + })); + whenDependentTypesAreResolved([structType], fieldTypes, function (fieldTypes) { + var fields = {}; + fieldRecords.forEach(function (field, i) { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: function (ptr) { + return getterReturnType["fromWireType"](getter(getterContext, ptr)) + }, + write: function (ptr, o) { + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o)); + runDestructors(destructors) + } + } + }); + return [{ + name: reg.name, + "fromWireType": function (ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr) + } + rawDestructor(ptr); + return rv + }, + "toWireType": function (destructors, o) { + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError("Missing field") + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]) + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr) + } + return ptr + }, + "argPackAdvance": 8, + "readValueFromPointer": simpleReadValueFromPointer, + destructorFunction: rawDestructor + }] + }) + } + function getShiftFromSize(size) { + switch (size) { + case 1: + return 0; + case 2: + return 1; + case 4: + return 2; + case 8: + return 3; + default: + throw new TypeError("Unknown type size: " + size) + } + } + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i) + } + embind_charCodes = codes + } + var embind_charCodes = undefined; + function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]] + } + return ret + } + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message) + } + function registerType(rawType, registeredInstance, options) { + options = options || {}; + if (!("argPackAdvance" in registeredInstance)) { + throw new TypeError("registerType registeredInstance requires argPackAdvance") + } + var name = registeredInstance.name; + if (!rawType) { + throwBindingError('type "' + name + '" must have a positive integer typeid pointer') + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return + } else { + throwBindingError("Cannot register type '" + name + "' twice") + } + } + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach(function (cb) { + cb() + }) + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + "fromWireType": function (wt) { + return !!wt + }, + "toWireType": function (destructors, o) { + return o ? trueValue : falseValue + }, + "argPackAdvance": 8, + "readValueFromPointer": function (pointer) { + var heap; + if (size === 1) { + heap = HEAP8 + } else if (size === 2) { + heap = HEAP16 + } else if (size === 4) { + heap = HEAP32 + } else { + throw new TypeError("Unknown boolean type size: " + name) + } + return this["fromWireType"](heap[pointer >> shift]) + }, + destructorFunction: null + }) + } + function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false + } + if (!(other instanceof ClassHandle)) { + return false + } + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass + } + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass + } + return leftClass === rightClass && left === right + } + function shallowCopyInternalPointer(o) { + return { + count: o.count, + deleteScheduled: o.deleteScheduled, + preservePointerOnDelete: o.preservePointerOnDelete, + ptr: o.ptr, + ptrType: o.ptrType, + smartPtr: o.smartPtr, + smartPtrType: o.smartPtrType + } + } + function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name + } + throwBindingError(getInstanceTypeName(obj) + " instance already deleted") + } + var finalizationGroup = false; + function detachFinalizer(handle) { } + function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr) + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr) + } + } + function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = 0 === $$.count.value; + if (toDelete) { + runDestructor($$) + } + } + function attachFinalizer(handle) { + if ("undefined" === typeof FinalizationGroup) { + attachFinalizer = function (handle) { + return handle + } + ; + return handle + } + finalizationGroup = new FinalizationGroup(function (iter) { + for (var result = iter.next(); !result.done; result = iter.next()) { + var $$ = result.value; + if (!$$.ptr) { + console.warn("object already deleted: " + $$.ptr) + } else { + releaseClassHandle($$) + } + } + } + ); + attachFinalizer = function (handle) { + finalizationGroup.register(handle, handle.$$, handle.$$); + return handle + } + ; + detachFinalizer = function (handle) { + finalizationGroup.unregister(handle.$$) + } + ; + return attachFinalizer(handle) + } + function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this) + } + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this + } else { + var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { + $$: { + value: shallowCopyInternalPointer(this.$$) + } + })); + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone + } + } + function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this) + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion") + } + detachFinalizer(this); + releaseClassHandle(this.$$); + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = undefined; + this.$$.ptr = undefined + } + } + function ClassHandle_isDeleted() { + return !this.$$.ptr + } + var delayFunction = undefined; + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj["delete"]() + } + } + function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this) + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion") + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes) + } + this.$$.deleteScheduled = true; + return this + } + function init_ClassHandle() { + ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf; + ClassHandle.prototype["clone"] = ClassHandle_clone; + ClassHandle.prototype["delete"] = ClassHandle_delete; + ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted; + ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater + } + function ClassHandle() { } + var registeredPointers = {}; + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + proto[methodName] = function () { + if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) { + throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!") + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments) + } + ; + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc + } + } + function exposePublicSymbol(name, value, numArguments) { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) { + throwBindingError("Cannot register public name '" + name + "' twice") + } + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!") + } + Module[name].overloadTable[numArguments] = value + } else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments + } + } + } + function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) { + this.name = name; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = [] + } + function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError("Expected null or instance of " + desiredClass.name + ", got an instance of " + ptrClass.name) + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass + } + return ptr + } + function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name) + } + return 0 + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name) + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name) + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr + } + function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name) + } + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr) + } + return ptr + } else { + return 0 + } + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name) + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name) + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name) + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + if (this.isSmartPointer) { + if (undefined === handle.$$.smartPtr) { + throwBindingError("Passing raw pointer to smart pointer is illegal") + } + switch (this.sharingPolicy) { + case 0: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr + } else { + throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name) + } + break; + case 1: + ptr = handle.$$.smartPtr; + break; + case 2: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr + } else { + var clonedHandle = handle["clone"](); + ptr = this.rawShare(ptr, __emval_register(function () { + clonedHandle["delete"]() + })); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr) + } + } + break; + default: + throwBindingError("Unsupporting sharing policy") + } + } + return ptr + } + function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name) + } + return 0 + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name) + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name) + } + if (handle.$$.ptrType.isConst) { + throwBindingError("Cannot convert argument of type " + handle.$$.ptrType.name + " to parameter type " + this.name) + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr + } + function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr) + } + return ptr + } + function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr) + } + } + function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle["delete"]() + } + } + function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr + } + if (undefined === desiredClass.baseClass) { + return null + } + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null + } + return desiredClass.downcast(rv) + } + function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length + } + function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (registeredInstances.hasOwnProperty(k)) { + rv.push(registeredInstances[k]) + } + } + return rv + } + function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes) + } + } + function init_embind() { + Module["getInheritedInstanceCount"] = getInheritedInstanceCount; + Module["getLiveInheritedInstances"] = getLiveInheritedInstances; + Module["flushPendingDeletes"] = flushPendingDeletes; + Module["setDelayFunction"] = setDelayFunction + } + var registeredInstances = {}; + function getBasestPointer(class_, ptr) { + if (ptr === undefined) { + throwBindingError("ptr should not be undefined") + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass + } + return ptr + } + function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr] + } + function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError("makeClassHandle requires ptr and ptrType") + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError("Both smartPtrType and smartPtr must be specified") + } + record.count = { + value: 1 + }; + return attachFinalizer(Object.create(prototype, { + $$: { + value: record + } + })) + } + function RegisteredPointer_fromWireType(ptr) { + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null + } + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance["clone"]() + } else { + var rv = registeredInstance["clone"](); + this.destructor(ptr); + return rv + } + } + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this.pointeeType, + ptr: rawPointer, + smartPtrType: this, + smartPtr: ptr + }) + } else { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this, + ptr: ptr + }) + } + } + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this) + } + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType + } else { + toType = registeredPointerRecord.pointerType + } + var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this) + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + smartPtrType: this, + smartPtr: ptr + }) + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp + }) + } + } + function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype["argPackAdvance"] = 8; + RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer; + RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype["fromWireType"] = RegisteredPointer_fromWireType + } + function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + if (!isSmartPointer && registeredClass.baseClass === undefined) { + if (isConst) { + this["toWireType"] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null + } else { + this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null + } + } else { + this["toWireType"] = genericPointerToWireType + } + } + function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError("Replacing nonexistant public symbol") + } + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value + } else { + Module[name] = value; + Module[name].argCount = numArguments + } + } + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + function makeDynCaller(dynCall) { + + if (IsWechat) { + var f1 = function (dynCall, rawFunction) { + return function () { + return dynCall(rawFunction, ...arguments); + } + } + + return f1(dynCall, rawFunction) + + } else { + var args = []; + for (var i = 1; i < signature.length; ++i) { + args.push("a" + i) + } + var name = "dynCall_" + signature + "_" + rawFunction; + var body = "return function " + name + "(" + args.join(", ") + ") {\n"; + body += " return dynCall(rawFunction" + (args.length ? ", " : "") + args.join(", ") + ");\n"; + body += "};\n"; + + return new Function("dynCall", "rawFunction", body)(dynCall, rawFunction) + } + + + } + var fp; + if (Module["FUNCTION_TABLE_" + signature] !== undefined) { + fp = Module["FUNCTION_TABLE_" + signature][rawFunction] + } else if (typeof FUNCTION_TABLE !== "undefined") { + fp = FUNCTION_TABLE[rawFunction] + } else { + var dc = Module["dynCall_" + signature]; + if (dc === undefined) { + dc = Module["dynCall_" + signature.replace(/f/g, "d")]; + if (dc === undefined) { + throwBindingError("No dynCall invoker for signature: " + signature) + } + } + fp = makeDynCaller(dc) + } + if (typeof fp !== "function") { + throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction) + } + return fp + } + var UnboundTypeError = undefined; + function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv + } + function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return + } + if (registeredTypes[type]) { + return + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return + } + unboundTypes.push(type); + seen[type] = true + } + types.forEach(visit); + throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "])) + } + function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) { + name = readLatin1String(name); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast) + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast) + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name); + exposePublicSymbol(legalFunctionName, function () { + throwUnboundTypeError("Cannot construct " + name + " due to unbound types", [baseClassRawType]) + }); + whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function (base) { + base = base[0]; + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype + } else { + basePrototype = ClassHandle.prototype + } + var constructor = createNamedFunction(legalFunctionName, function () { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name) + } + if (undefined === registeredClass.constructor_body) { + throw new BindingError(name + " has no accessible constructor") + } + var body = registeredClass.constructor_body[arguments.length]; + if (undefined === body) { + throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!") + } + return body.apply(this, arguments) + }); + var instancePrototype = Object.create(basePrototype, { + constructor: { + value: constructor + } + }); + constructor.prototype = instancePrototype; + var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast); + var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false); + var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false); + var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false); + registeredPointers[rawType] = { + pointerType: pointerConverter, + constPointerType: constPointerConverter + }; + replacePublicSymbol(legalFunctionName, constructor); + return [referenceConverter, pointerConverter, constPointerConverter] + }) + } + function new_(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function") + } + var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function () { }); + dummy.prototype = constructor.prototype; + var obj = new dummy; + + var r = constructor.apply(obj, argumentList); + return r instanceof Object ? r : obj + } + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) { + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!") + } + + var isClassMethodFunc = argTypes[1] !== null && classType !== null; + var needsDestructorStack = false; + for (var i = 1; i < argTypes.length; ++i) { + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + needsDestructorStack = true; + break + } + } + var returns = argTypes[0].name !== "void"; + + if (IsWechat) { + var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]; + for (var i = 0; i < argCount - 2; ++i) { + args2.push(argTypes[i + 2]) + } + for (var i = 2; i < argCount; ++i) { + if (argTypes[i].destructorFunction !== null) { + args2.push(argTypes[i].destructorFunction) + } + } + + function f1(throwBindingError, invoker, fn, runDestructors, retType, classParam) { + // argType0,argType1,argType2 + const argsTypeOrigin = Array.prototype.slice.call(arguments, 6, 6 + argCount - 2) + // arg0Wired_dtor + const argsWired_dtorOrigin = Array.prototype.slice.call(arguments, 6 + argCount - 2) + + return function () { + // arg0, arg1, arg2 + if (arguments.length !== argCount - 2) { + throwBindingError('function ' + humanName + ' called with ' + arguments.length + ' arguments, expected 0 args!'); + } + var thisWired; + if (isClassMethodFunc) { + if (needsDestructorStack) { + var destructors = []; + thisWired = classParam.toWireType(destructors, this); + } else { + thisWired = classParam.toWireType(null, this); + } + } + + // arg0Wired,arg1Wired,arg2Wired + var argsWired = []; + for (var i = 0; i < arguments.length; i++) { + argsWired.push(argsTypeOrigin[i].toWireType(null, arguments[i])) + } + + var rv; + if (isClassMethodFunc) { + rv = invoker(fn, thisWired, ...argsWired); + } else { + rv = invoker(fn, ...argsWired); + } + + if (needsDestructorStack) { + runDestructors(destructors); + } else { + if (isClassMethodFunc) { + for (var i = 1; i < argTypes.length; ++i) { + if (argTypes[i].destructorFunction !== null) { + argsWired_dtorOrigin[i - 1](thisWired); + } + } + } else { + for (var i = 2; i < argTypes.length; ++i) { + if (argTypes[i].destructorFunction !== null) { + argsWired_dtorOrigin[i - 2](argsWired[i - 2]); + } + } + } + } + if (returns) { + var ret = retType.fromWireType(rv); + return ret; + } + } + } + return f1.apply(null, args2) + } else { + var argsList = ""; + var argsListWired = ""; + for (var i = 0; i < argCount - 2; ++i) { + argsList += (i !== 0 ? ", " : "") + "arg" + i; + argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired" + } + + var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n"; + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n" + } + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"]; + var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]; + if (isClassMethodFunc) { + invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n" + } + for (var i = 0; i < argCount - 2; ++i) { + invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n"; + args1.push("argType" + i); + args2.push(argTypes[i + 2]) + } + if (isClassMethodFunc) { + argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired + } + invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n"; + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n" + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired"; + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n"; + args1.push(paramName + "_dtor"); + args2.push(argTypes[i].destructorFunction) + } + } + } + if (returns) { + invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n" + } else { } + invokerFnBody += "}\n"; + args1.push(invokerFnBody); + var invokerFunction = new_(Function, args1).apply(null, args2); + return invokerFunction + } + + } + function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAP32[(firstElement >> 2) + i]) + } + return array + } + function __embind_register_class_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + methodName; + function unboundTypesHandler() { + throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes) + } + var proto = classType.registeredClass.constructor; + if (undefined === proto[methodName]) { + unboundTypesHandler.argCount = argCount - 1; + proto[methodName] = unboundTypesHandler + } else { + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler + } + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1)); + var func = craftInvokerFunction(humanName, invokerArgsArray, null, rawInvoker, fn); + if (undefined === proto[methodName].overloadTable) { + func.argCount = argCount - 1; + proto[methodName] = func + } else { + proto[methodName].overloadTable[argCount - 1] = func + } + return [] + }); + return [] + }) + } + function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = "constructor " + classType.name; + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = [] + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError("Cannot register multiple constructors with identical number of parameters (" + (argCount - 1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!") + } + classType.registeredClass.constructor_body[argCount - 1] = function unboundTypeHandler() { + throwUnboundTypeError("Cannot construct " + classType.name + " due to unbound types", rawArgTypes) + } + ; + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + classType.registeredClass.constructor_body[argCount - 1] = function constructor_body() { + if (arguments.length !== argCount - 1) { + throwBindingError(humanName + " called with " + arguments.length + " arguments, expected " + (argCount - 1)) + } + var destructors = []; + var args = new Array(argCount); + args[0] = rawConstructor; + for (var i = 1; i < argCount; ++i) { + args[i] = argTypes[i]["toWireType"](destructors, arguments[i - 1]) + } + var ptr = invoker.apply(null, args); + runDestructors(destructors); + return argTypes[0]["fromWireType"](ptr) + } + ; + return [] + }); + return [] + }) + } + function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + methodName; + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName) + } + function unboundTypesHandler() { + throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes) + } + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if (undefined === method || undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) { + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler + } else { + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler + } + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context); + if (undefined === proto[methodName].overloadTable) { + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction + } + return [] + }); + return [] + }) + } + function validateThis(this_, classType, humanName) { + if (!(this_ instanceof Object)) { + throwBindingError(humanName + ' with invalid "this": ' + this_) + } + if (!(this_ instanceof classType.registeredClass.constructor)) { + throwBindingError(humanName + ' incompatible with "this" of type ' + this_.constructor.name) + } + if (!this_.$$.ptr) { + throwBindingError("cannot call emscripten binding method " + humanName + " on deleted object") + } + return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass) + } + function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { + fieldName = readLatin1String(fieldName); + getter = embind__requireFunction(getterSignature, getter); + whenDependentTypesAreResolved([], [classType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + fieldName; + var desc = { + get: function () { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [getterReturnType, setterArgumentType]) + }, + enumerable: true, + configurable: true + }; + if (setter) { + desc.set = function () { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [getterReturnType, setterArgumentType]) + } + } else { + desc.set = function (v) { + throwBindingError(humanName + " is a read-only property") + } + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + whenDependentTypesAreResolved([], setter ? [getterReturnType, setterArgumentType] : [getterReturnType], function (types) { + var getterReturnType = types[0]; + var desc = { + get: function () { + var ptr = validateThis(this, classType, humanName + " getter"); + return getterReturnType["fromWireType"](getter(getterContext, ptr)) + }, + enumerable: true + }; + if (setter) { + setter = embind__requireFunction(setterSignature, setter); + var setterArgumentType = types[1]; + desc.set = function (v) { + var ptr = validateThis(this, classType, humanName + " setter"); + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, v)); + runDestructors(destructors) + } + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + return [] + }); + return [] + }) + } + function __embind_register_constant(name, type, value) { + name = readLatin1String(name); + whenDependentTypesAreResolved([], [type], function (type) { + type = type[0]; + Module[name] = type["fromWireType"](value); + return [] + }) + } + var emval_free_list = []; + var emval_handle_array = [{}, { + value: undefined + }, { + value: null + }, { + value: true + }, { + value: false + }]; + function __emval_decref(handle) { + if (handle > 4 && 0 === --emval_handle_array[handle].refcount) { + emval_handle_array[handle] = undefined; + emval_free_list.push(handle) + } + } + function count_emval_handles() { + var count = 0; + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + ++count + } + } + return count + } + function get_first_emval() { + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + return emval_handle_array[i] + } + } + return null + } + function init_emval() { + Module["count_emval_handles"] = count_emval_handles; + Module["get_first_emval"] = get_first_emval + } + function __emval_register(value) { + switch (value) { + case undefined: + { + return 1 + } + case null: + { + return 2 + } + case true: + { + return 3 + } + case false: + { + return 4 + } + default: + { + var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length; + emval_handle_array[handle] = { + refcount: 1, + value: value + }; + return handle + } + } + } + function __embind_register_emval(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + name: name, + "fromWireType": function (handle) { + var rv = emval_handle_array[handle].value; + __emval_decref(handle); + return rv + }, + "toWireType": function (destructors, value) { + return __emval_register(value) + }, + "argPackAdvance": 8, + "readValueFromPointer": simpleReadValueFromPointer, + destructorFunction: null + }) + } + function _embind_repr(v) { + if (v === null) { + return "null" + } + var t = typeof v; + if (t === "object" || t === "array" || t === "function") { + return v.toString() + } else { + return "" + v + } + } + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: + return function (pointer) { + return this["fromWireType"](HEAPF32[pointer >> 2]) + } + ; + case 3: + return function (pointer) { + return this["fromWireType"](HEAPF64[pointer >> 3]) + } + ; + default: + throw new TypeError("Unknown float type: " + name) + } + } + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + "fromWireType": function (value) { + return value + }, + "toWireType": function (destructors, value) { + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name) + } + return value + }, + "argPackAdvance": 8, + "readValueFromPointer": floatReadValueFromPointer(name, shift), + destructorFunction: null + }) + } + function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + rawInvoker = embind__requireFunction(signature, rawInvoker); + exposePublicSymbol(name, function () { + throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes) + }, argCount - 1); + whenDependentTypesAreResolved([], argTypes, function (argTypes) { + var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1)); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1); + return [] + }) + } + function integerReadValueFromPointer(name, shift, signed) { + switch (shift) { + case 0: + return signed ? function readS8FromPointer(pointer) { + return HEAP8[pointer] + } + : function readU8FromPointer(pointer) { + return HEAPU8[pointer] + } + ; + case 1: + return signed ? function readS16FromPointer(pointer) { + return HEAP16[pointer >> 1] + } + : function readU16FromPointer(pointer) { + return HEAPU16[pointer >> 1] + } + ; + case 2: + return signed ? function readS32FromPointer(pointer) { + return HEAP32[pointer >> 2] + } + : function readU32FromPointer(pointer) { + return HEAPU32[pointer >> 2] + } + ; + default: + throw new TypeError("Unknown integer type: " + name) + } + } + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + if (maxRange === -1) { + maxRange = 4294967295 + } + var shift = getShiftFromSize(size); + var fromWireType = function (value) { + return value + }; + if (minRange === 0) { + var bitshift = 32 - 8 * size; + fromWireType = function (value) { + return value << bitshift >>> bitshift + } + } + var isUnsignedType = name.indexOf("unsigned") != -1; + registerType(primitiveType, { + name: name, + "fromWireType": fromWireType, + "toWireType": function (destructors, value) { + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name) + } + if (value < minRange || value > maxRange) { + throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ", " + maxRange + "]!") + } + return isUnsignedType ? value >>> 0 : value | 0 + }, + "argPackAdvance": 8, + "readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null + }) + } + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]; + var TA = typeMapping[dataTypeIndex]; + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; + var data = heap[handle + 1]; + return new TA(heap["buffer"], data, size) + } + name = readLatin1String(name); + registerType(rawType, { + name: name, + "fromWireType": decodeMemoryView, + "argPackAdvance": 8, + "readValueFromPointer": decodeMemoryView + }, { + ignoreDuplicateRegistrations: true + }) + } + function __embind_register_smart_ptr(rawType, rawPointeeType, name, sharingPolicy, getPointeeSignature, rawGetPointee, constructorSignature, rawConstructor, shareSignature, rawShare, destructorSignature, rawDestructor) { + name = readLatin1String(name); + rawGetPointee = embind__requireFunction(getPointeeSignature, rawGetPointee); + rawConstructor = embind__requireFunction(constructorSignature, rawConstructor); + rawShare = embind__requireFunction(shareSignature, rawShare); + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + whenDependentTypesAreResolved([rawType], [rawPointeeType], function (pointeeType) { + pointeeType = pointeeType[0]; + var registeredPointer = new RegisteredPointer(name, pointeeType.registeredClass, false, false, true, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor); + return [registeredPointer] + }) + } + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 = name === "std::string"; + registerType(rawType, { + name: name, + "fromWireType": function (value) { + var length = HEAPU32[value >> 2]; + var str; + if (stdStringIsUTF8) { + var endChar = HEAPU8[value + 4 + length]; + var endCharSwap = 0; + if (endChar != 0) { + endCharSwap = endChar; + HEAPU8[value + 4 + length] = 0 + } + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i; + if (HEAPU8[currentBytePtr] == 0) { + var stringSegment = UTF8ToString(decodeStartPtr); + if (str === undefined) + str = stringSegment; + else { + str += String.fromCharCode(0); + str += stringSegment + } + decodeStartPtr = currentBytePtr + 1 + } + } + if (endCharSwap != 0) + HEAPU8[value + 4 + length] = endCharSwap + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[value + 4 + i]) + } + str = a.join("") + } + _free(value); + return str + }, + "toWireType": function (destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value) + } + var getLength; + var valueIsOfTypeString = typeof value === "string"; + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError("Cannot pass non-string to std::string") + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + getLength = function () { + return lengthBytesUTF8(value) + } + } else { + getLength = function () { + return value.length + } + } + var length = getLength(); + var ptr = _malloc(4 + length + 1); + HEAPU32[ptr >> 2] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr + 4, length + 1) + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError("String has UTF-16 code units that do not fit in 8 bits") + } + HEAPU8[ptr + 4 + i] = charCode + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + 4 + i] = value[i] + } + } + } + if (destructors !== null) { + destructors.push(_free, ptr) + } + return ptr + }, + "argPackAdvance": 8, + "readValueFromPointer": simpleReadValueFromPointer, + destructorFunction: function (ptr) { + _free(ptr) + } + }) + } + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var getHeap, shift; + if (charSize === 2) { + getHeap = function () { + return HEAPU16 + } + ; + shift = 1 + } else if (charSize === 4) { + getHeap = function () { + return HEAPU32 + } + ; + shift = 2 + } + registerType(rawType, { + name: name, + "fromWireType": function (value) { + var HEAP = getHeap(); + var length = HEAPU32[value >> 2]; + var a = new Array(length); + var start = value + 4 >> shift; + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAP[start + i]) + } + _free(value); + return a.join("") + }, + "toWireType": function (destructors, value) { + var length = value.length; + var ptr = _malloc(4 + length * charSize); + var HEAP = getHeap(); + HEAPU32[ptr >> 2] = length; + var start = ptr + 4 >> shift; + for (var i = 0; i < length; ++i) { + HEAP[start + i] = value.charCodeAt(i) + } + if (destructors !== null) { + destructors.push(_free, ptr) + } + return ptr + }, + "argPackAdvance": 8, + "readValueFromPointer": simpleReadValueFromPointer, + destructorFunction: function (ptr) { + _free(ptr) + } + }) + } + function __embind_register_value_array(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) { + tupleRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + elements: [] + } + } + function __embind_register_value_array_element(rawTupleType, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { + tupleRegistrations[rawTupleType].elements.push({ + getterReturnType: getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext: getterContext, + setterArgumentType: setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext: setterContext + }) + } + function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) { + structRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [] + } + } + function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { + structRegistrations[structType].fields.push({ + fieldName: readLatin1String(fieldName), + getterReturnType: getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext: getterContext, + setterArgumentType: setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext: setterContext + }) + } + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, + name: name, + "argPackAdvance": 0, + "fromWireType": function () { + return undefined + }, + "toWireType": function (destructors, o) { + return undefined + } + }) + } + function requireHandle(handle) { + if (!handle) { + throwBindingError("Cannot use deleted val. handle = " + handle) + } + return emval_handle_array[handle].value + } + function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)) + } + return impl + } + function __emval_as(handle, returnType, destructorsRef) { + handle = requireHandle(handle); + returnType = requireRegisteredType(returnType, "emval::as"); + var destructors = []; + var rd = __emval_register(destructors); + HEAP32[destructorsRef >> 2] = rd; + return returnType["toWireType"](destructors, handle) + } + var emval_symbols = {}; + function getStringOrSymbol(address) { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return readLatin1String(address) + } else { + return symbol + } + } + var emval_methodCallers = []; + function __emval_call_void_method(caller, handle, methodName, args) { + caller = emval_methodCallers[caller]; + handle = requireHandle(handle); + methodName = getStringOrSymbol(methodName); + caller(handle, methodName, null, args) + } + function __emval_addMethodCaller(caller) { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id + } + function __emval_lookupTypes(argCount, argTypes, argWireTypes) { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAP32[(argTypes >> 2) + i], "parameter " + i) + } + return a + } + function __emval_get_method_caller(argCount, argTypes) { + var types = __emval_lookupTypes(argCount, argTypes); + var retType = types[0]; + var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { + return t.name + }).join("_") + "$"; + var params = ["retType"]; + var args = [retType]; + var argsList = ""; + for (var i = 0; i < argCount - 1; ++i) { + argsList += (i !== 0 ? ", " : "") + "arg" + i; + params.push("argType" + i); + args.push(types[1 + i]) + } + var functionName = makeLegalFunctionName("methodCaller_" + signatureName); + var functionBody = "return function " + functionName + "(handle, name, destructors, args) {\n"; + var offset = 0; + for (var i = 0; i < argCount - 1; ++i) { + functionBody += " var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? "+" + offset : "") + ");\n"; + offset += types[i + 1]["argPackAdvance"] + } + functionBody += " var rv = handle[name](" + argsList + ");\n"; + for (var i = 0; i < argCount - 1; ++i) { + if (types[i + 1]["deleteObject"]) { + functionBody += " argType" + i + ".deleteObject(arg" + i + ");\n" + } + } + if (!retType.isVoid) { + functionBody += " return retType.toWireType(destructors, rv);\n" + } + functionBody += "};\n"; + params.push(functionBody); + var invokerFunction = new_(Function, params).apply(null, args); + return __emval_addMethodCaller(invokerFunction) + } + function __emval_get_property(handle, key) { + handle = requireHandle(handle); + key = requireHandle(key); + return __emval_register(handle[key]) + } + function __emval_incref(handle) { + if (handle > 4) { + emval_handle_array[handle].refcount += 1 + } + } + function __emval_new_array() { + return __emval_register([]) + } + function __emval_new_cstring(v) { + return __emval_register(getStringOrSymbol(v)) + } + function __emval_run_destructors(handle) { + var destructors = emval_handle_array[handle].value; + runDestructors(destructors); + __emval_decref(handle) + } + function __emval_set_property(handle, key, value) { + handle = requireHandle(handle); + key = requireHandle(key); + value = requireHandle(value); + handle[key] = value + } + function __emval_take_value(type, argv) { + type = requireRegisteredType(type, "_emval_take_value"); + var v = type["readValueFromPointer"](argv); + return __emval_register(v) + } + function _abort() { + abort() + } + function _emscripten_get_now_is_monotonic() { + return 0 || ENVIRONMENT_IS_NODE || typeof dateNow !== "undefined" || typeof performance === "object" && performance && typeof performance["now"] === "function" + } + function _clock_gettime(clk_id, tp) { + var now; + if (clk_id === 0) { + now = Date.now() + } else if (clk_id === 1 && _emscripten_get_now_is_monotonic()) { + now = _emscripten_get_now() + } else { + ___setErrNo(28); + return -1 + } + HEAP32[tp >> 2] = now / 1e3 | 0; + HEAP32[tp + 4 >> 2] = now % 1e3 * 1e3 * 1e3 | 0; + return 0 + } + function _emscripten_get_heap_size() { + return HEAP8.length + } + function _emscripten_get_sbrk_ptr() { + return 1275456 + } + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.set(HEAPU8.subarray(src, src + num), dest) + } + function emscripten_realloc_buffer(size) { + try { + wasmMemory.grow(size - buffer.byteLength + 65535 >> 16); + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1 + } catch (e) { } + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = _emscripten_get_heap_size(); + var PAGE_MULTIPLE = 65536; + var LIMIT = 2147483648 - PAGE_MULTIPLE; + if (requestedSize > LIMIT) { + return false + } + var MIN_TOTAL_MEMORY = 16777216; + var newSize = Math.max(oldSize, MIN_TOTAL_MEMORY); + while (newSize < requestedSize) { + if (newSize <= 536870912) { + newSize = alignUp(2 * newSize, PAGE_MULTIPLE) + } else { + newSize = Math.min(alignUp((3 * newSize + 2147483648) / 4, PAGE_MULTIPLE), LIMIT) + } + } + newSize = Math.min(newSize, 1073741824); + if (newSize == oldSize) { + return false + } + var replacement = emscripten_realloc_buffer(newSize); + if (!replacement) { + return false + } + return true + } + var ENV = {}; + function _emscripten_get_environ() { + if (!_emscripten_get_environ.strings) { + var env = { + "USER": "web_user", + "LOGNAME": "web_user", + "PATH": "/", + "PWD": "/", + "HOME": "/home/web_user", + "LANG": (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", + "_": thisProgram + }; + for (var x in ENV) { + env[x] = ENV[x] + } + var strings = []; + for (var x in env) { + strings.push(x + "=" + env[x]) + } + _emscripten_get_environ.strings = strings + } + return _emscripten_get_environ.strings + } + function _environ_get(__environ, environ_buf) { + var strings = _emscripten_get_environ(); + var bufSize = 0; + strings.forEach(function (string, i) { + var ptr = environ_buf + bufSize; + HEAP32[__environ + i * 4 >> 2] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1 + }); + return 0 + } + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = _emscripten_get_environ(); + HEAP32[penviron_count >> 2] = strings.length; + var bufSize = 0; + strings.forEach(function (string) { + bufSize += string.length + 1 + }); + HEAP32[penviron_buf_size >> 2] = bufSize; + return 0 + } + function _fd_close(fd) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0 + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno + } + } + function _fd_read(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doReadv(stream, iov, iovcnt); + HEAP32[pnum >> 2] = num; + return 0 + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno + } + } + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var HIGH_OFFSET = 4294967296; + var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0); + var DOUBLE_LIMIT = 9007199254740992; + if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) { + return -61 + } + FS.llseek(stream, offset, whence); + tempI64 = [stream.position >>> 0, (tempDouble = stream.position, + +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], + HEAP32[newOffset >> 2] = tempI64[0], + HEAP32[newOffset + 4 >> 2] = tempI64[1]; + if (stream.getdents && offset === 0 && whence === 0) + stream.getdents = null; + return 0 + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno + } + } + function _fd_write(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doWritev(stream, iov, iovcnt); + HEAP32[pnum >> 2] = num; + return 0 + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno + } + } + function _pthread_mutexattr_destroy() { } + function _pthread_mutexattr_init() { } + function _pthread_mutexattr_settype() { } + function _roundf(d) { + d = +d; + return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5) + } + function _sched_yield() { + return 0 + } + function _setTempRet0($i) { + setTempRet0($i | 0) + } + function __isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) + } + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) + ; + return sum + } + var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + if (days > daysInCurrentMonth - newDate.getDate()) { + days -= daysInCurrentMonth - newDate.getDate() + 1; + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth + 1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear() + 1) + } + } else { + newDate.setDate(newDate.getDate() + days); + return newDate + } + } + return newDate + } + function _strftime(s, maxsize, format, tm) { + var tm_zone = HEAP32[tm + 40 >> 2]; + var date = { + tm_sec: HEAP32[tm >> 2], + tm_min: HEAP32[tm + 4 >> 2], + tm_hour: HEAP32[tm + 8 >> 2], + tm_mday: HEAP32[tm + 12 >> 2], + tm_mon: HEAP32[tm + 16 >> 2], + tm_year: HEAP32[tm + 20 >> 2], + tm_wday: HEAP32[tm + 24 >> 2], + tm_yday: HEAP32[tm + 28 >> 2], + tm_isdst: HEAP32[tm + 32 >> 2], + tm_gmtoff: HEAP32[tm + 36 >> 2], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : "" + }; + var pattern = UTF8ToString(format); + var EXPANSION_RULES_1 = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]) + } + var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; + var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]; + function leadingSomething(value, digits, character) { + var str = typeof value === "number" ? value.toString() : value || ""; + while (str.length < digits) { + str = character[0] + str + } + return str + } + function leadingNulls(value, digits) { + return leadingSomething(value, digits, "0") + } + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : value > 0 ? 1 : 0 + } + var compare; + if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) { + compare = sgn(date1.getDate() - date2.getDate()) + } + } + return compare + } + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: + return new Date(janFourth.getFullYear() - 1, 11, 29); + case 1: + return janFourth; + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + case 6: + return new Date(janFourth.getFullYear() - 1, 11, 30) + } + } + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday); + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear() + 1 + } else { + return thisDate.getFullYear() + } + } else { + return thisDate.getFullYear() - 1 + } + } + var EXPANSION_RULES_2 = { + "%a": function (date) { + return WEEKDAYS[date.tm_wday].substring(0, 3) + }, + "%A": function (date) { + return WEEKDAYS[date.tm_wday] + }, + "%b": function (date) { + return MONTHS[date.tm_mon].substring(0, 3) + }, + "%B": function (date) { + return MONTHS[date.tm_mon] + }, + "%C": function (date) { + var year = date.tm_year + 1900; + return leadingNulls(year / 100 | 0, 2) + }, + "%d": function (date) { + return leadingNulls(date.tm_mday, 2) + }, + "%e": function (date) { + return leadingSomething(date.tm_mday, 2, " ") + }, + "%g": function (date) { + return getWeekBasedYear(date).toString().substring(2) + }, + "%G": function (date) { + return getWeekBasedYear(date) + }, + "%H": function (date) { + return leadingNulls(date.tm_hour, 2) + }, + "%I": function (date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) + twelveHour = 12; + else if (twelveHour > 12) + twelveHour -= 12; + return leadingNulls(twelveHour, 2) + }, + "%j": function (date) { + return leadingNulls(date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1), 3) + }, + "%m": function (date) { + return leadingNulls(date.tm_mon + 1, 2) + }, + "%M": function (date) { + return leadingNulls(date.tm_min, 2) + }, + "%n": function () { + return "\n" + }, + "%p": function (date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return "AM" + } else { + return "PM" + } + }, + "%S": function (date) { + return leadingNulls(date.tm_sec, 2) + }, + "%t": function () { + return "\t" + }, + "%u": function (date) { + return date.tm_wday || 7 + }, + "%U": function (date) { + var janFirst = new Date(date.tm_year + 1900, 0, 1); + var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7 - janFirst.getDay()); + var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday); + if (compareByDay(firstSunday, endDate) < 0) { + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31; + var firstSundayUntilEndJanuary = 31 - firstSunday.getDate(); + var days = firstSundayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate(); + return leadingNulls(Math.ceil(days / 7), 2) + } + return compareByDay(firstSunday, janFirst) === 0 ? "01" : "00" + }, + "%V": function (date) { + var janFourthThisYear = new Date(date.tm_year + 1900, 0, 4); + var janFourthNextYear = new Date(date.tm_year + 1901, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + var endDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday); + if (compareByDay(endDate, firstWeekStartThisYear) < 0) { + return "53" + } + if (compareByDay(firstWeekStartNextYear, endDate) <= 0) { + return "01" + } + var daysDifference; + if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) { + daysDifference = date.tm_yday + 32 - firstWeekStartThisYear.getDate() + } else { + daysDifference = date.tm_yday + 1 - firstWeekStartThisYear.getDate() + } + return leadingNulls(Math.ceil(daysDifference / 7), 2) + }, + "%w": function (date) { + return date.tm_wday + }, + "%W": function (date) { + var janFirst = new Date(date.tm_year, 0, 1); + var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7 - janFirst.getDay() + 1); + var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday); + if (compareByDay(firstMonday, endDate) < 0) { + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31; + var firstMondayUntilEndJanuary = 31 - firstMonday.getDate(); + var days = firstMondayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate(); + return leadingNulls(Math.ceil(days / 7), 2) + } + return compareByDay(firstMonday, janFirst) === 0 ? "01" : "00" + }, + "%y": function (date) { + return (date.tm_year + 1900).toString().substring(2) + }, + "%Y": function (date) { + return date.tm_year + 1900 + }, + "%z": function (date) { + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + off = off / 60 * 100 + off % 60; + return (ahead ? "+" : "-") + String("0000" + off).slice(-4) + }, + "%Z": function (date) { + return date.tm_zone + }, + "%%": function () { + return "%" + } + }; + for (var rule in EXPANSION_RULES_2) { + if (pattern.indexOf(rule) >= 0) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date)) + } + } + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0 + } + writeArrayToMemory(bytes, s); + return bytes.length - 1 + } + function _strftime_l(s, maxsize, format, tm) { + return _strftime(s, maxsize, format, tm) + } + function _sysconf(name) { + switch (name) { + case 30: + return PAGE_SIZE; + case 85: + var maxHeapSize = 2 * 1024 * 1024 * 1024 - 65536; + maxHeapSize = 1073741824; + return maxHeapSize / PAGE_SIZE; + case 132: + case 133: + case 12: + case 137: + case 138: + case 15: + case 235: + case 16: + case 17: + case 18: + case 19: + case 20: + case 149: + case 13: + case 10: + case 236: + case 153: + case 9: + case 21: + case 22: + case 159: + case 154: + case 14: + case 77: + case 78: + case 139: + case 80: + case 81: + case 82: + case 68: + case 67: + case 164: + case 11: + case 29: + case 47: + case 48: + case 95: + case 52: + case 51: + case 46: + return 200809; + case 79: + return 0; + case 27: + case 246: + case 127: + case 128: + case 23: + case 24: + case 160: + case 161: + case 181: + case 182: + case 242: + case 183: + case 184: + case 243: + case 244: + case 245: + case 165: + case 178: + case 179: + case 49: + case 50: + case 168: + case 169: + case 175: + case 170: + case 171: + case 172: + case 97: + case 76: + case 32: + case 173: + case 35: + return -1; + case 176: + case 177: + case 7: + case 155: + case 8: + case 157: + case 125: + case 126: + case 92: + case 93: + case 129: + case 130: + case 131: + case 94: + case 91: + return 1; + case 74: + case 60: + case 69: + case 70: + case 4: + return 1024; + case 31: + case 42: + case 72: + return 32; + case 87: + case 26: + case 33: + return 2147483647; + case 34: + case 1: + return 47839; + case 38: + case 36: + return 99; + case 43: + case 37: + return 2048; + case 0: + return 2097152; + case 3: + return 65536; + case 28: + return 32768; + case 44: + return 32767; + case 75: + return 16384; + case 39: + return 1e3; + case 89: + return 700; + case 71: + return 256; + case 40: + return 255; + case 2: + return 100; + case 180: + return 64; + case 25: + return 20; + case 5: + return 16; + case 6: + return 6; + case 73: + return 4; + case 84: + { + if (typeof navigator === "object") + return navigator["hardwareConcurrency"] || 1; + return 1 + } + } + ___setErrNo(28); + return -1 + } + Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas, vrDevice) { + err("Module.requestFullScreen is deprecated. Please call Module.requestFullscreen instead."); + Module["requestFullScreen"] = Module["requestFullscreen"]; + Browser.requestFullScreen(lockPointer, resizeCanvas, vrDevice) + } + ; + Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas, vrDevice) { + Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice) + } + ; + Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { + Browser.requestAnimationFrame(func) + } + ; + Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { + Browser.setCanvasSize(width, height, noUpdates) + } + ; + Module["pauseMainLoop"] = function Module_pauseMainLoop() { + Browser.mainLoop.pause() + } + ; + Module["resumeMainLoop"] = function Module_resumeMainLoop() { + Browser.mainLoop.resume() + } + ; + Module["getUserMedia"] = function Module_getUserMedia() { + Browser.getUserMedia() + } + ; + Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) { + return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes) + } + ; + if (ENVIRONMENT_IS_NODE) { + _emscripten_get_now = function _emscripten_get_now_actual() { + var t = process["hrtime"](); + return t[0] * 1e3 + t[1] / 1e6 + } + } else if (typeof dateNow !== "undefined") { + _emscripten_get_now = dateNow + } else if (typeof performance === "object" && performance && typeof performance["now"] === "function") { + _emscripten_get_now = function () { + return performance["now"]() + } + } else { + _emscripten_get_now = Date.now + } + FS.staticInit(); + Module["FS_createFolder"] = FS.createFolder; + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createLink"] = FS.createLink; + Module["FS_createDevice"] = FS.createDevice; + Module["FS_unlink"] = FS.unlink; + if (ENVIRONMENT_HAS_NODE) { + var fs = require("fs"); + var NODEJS_PATH = require("path"); + NODEFS.staticInit() + } + InternalError = Module["InternalError"] = extendError(Error, "InternalError"); + embind_init_charCodes(); + BindingError = Module["BindingError"] = extendError(Error, "BindingError"); + init_ClassHandle(); + init_RegisteredPointer(); + init_embind(); + UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError"); + init_emval(); + var ASSERTIONS = false; + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) + u8array.length = numBytesWritten; + return u8array + } + function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 255) { + if (ASSERTIONS) { + assert(false, "Character code " + chr + " (" + String.fromCharCode(chr) + ") at offset " + i + " not in 0x00-0xFF.") + } + chr &= 255 + } + ret.push(String.fromCharCode(chr)) + } + return ret.join("") + } + var decodeBase64 = typeof atob === "function" ? atob : function (input) { + var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + var output = ""; + var chr1, chr2, chr3; + var enc1, enc2, enc3, enc4; + var i = 0; + input = input.replace(/[^A-Za-z0-9\+\/\=]/g, ""); + do { + enc1 = keyStr.indexOf(input.charAt(i++)); + enc2 = keyStr.indexOf(input.charAt(i++)); + enc3 = keyStr.indexOf(input.charAt(i++)); + enc4 = keyStr.indexOf(input.charAt(i++)); + chr1 = enc1 << 2 | enc2 >> 4; + chr2 = (enc2 & 15) << 4 | enc3 >> 2; + chr3 = (enc3 & 3) << 6 | enc4; + output = output + String.fromCharCode(chr1); + if (enc3 !== 64) { + output = output + String.fromCharCode(chr2) + } + if (enc4 !== 64) { + output = output + String.fromCharCode(chr3) + } + } while (i < input.length); + return output + } + ; + function intArrayFromBase64(s) { + if (typeof ENVIRONMENT_IS_NODE === "boolean" && ENVIRONMENT_IS_NODE) { + var buf; + try { + buf = Buffer.from(s, "base64") + } catch (_) { + buf = new Buffer(s, "base64") + } + return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) + } + try { + var decoded = decodeBase64(s); + var bytes = new Uint8Array(decoded.length); + for (var i = 0; i < decoded.length; ++i) { + bytes[i] = decoded.charCodeAt(i) + } + return bytes + } catch (_) { + throw new Error("Converting base64 string to bytes failed.") + } + } + function tryParseAsDataURI(filename) { + if (!isDataURI(filename)) { + return + } + return intArrayFromBase64(filename.slice(dataURIPrefix.length)) + } + var asmLibraryArg = { + "__cxa_allocate_exception": ___cxa_allocate_exception, + "__cxa_atexit": ___cxa_atexit, + "__cxa_throw": ___cxa_throw, + "__lock": ___lock, + "__map_file": ___map_file, + "__syscall221": ___syscall221, + "__syscall3": ___syscall3, + "__syscall4": ___syscall4, + "__syscall5": ___syscall5, + "__syscall54": ___syscall54, + "__syscall91": ___syscall91, + "__unlock": ___unlock, + "_embind_finalize_value_array": __embind_finalize_value_array, + "_embind_finalize_value_object": __embind_finalize_value_object, + "_embind_register_bool": __embind_register_bool, + "_embind_register_class": __embind_register_class, + "_embind_register_class_class_function": __embind_register_class_class_function, + "_embind_register_class_constructor": __embind_register_class_constructor, + "_embind_register_class_function": __embind_register_class_function, + "_embind_register_class_property": __embind_register_class_property, + "_embind_register_constant": __embind_register_constant, + "_embind_register_emval": __embind_register_emval, + "_embind_register_float": __embind_register_float, + "_embind_register_function": __embind_register_function, + "_embind_register_integer": __embind_register_integer, + "_embind_register_memory_view": __embind_register_memory_view, + "_embind_register_smart_ptr": __embind_register_smart_ptr, + "_embind_register_std_string": __embind_register_std_string, + "_embind_register_std_wstring": __embind_register_std_wstring, + "_embind_register_value_array": __embind_register_value_array, + "_embind_register_value_array_element": __embind_register_value_array_element, + "_embind_register_value_object": __embind_register_value_object, + "_embind_register_value_object_field": __embind_register_value_object_field, + "_embind_register_void": __embind_register_void, + "_emval_as": __emval_as, + "_emval_call_void_method": __emval_call_void_method, + "_emval_decref": __emval_decref, + "_emval_get_method_caller": __emval_get_method_caller, + "_emval_get_property": __emval_get_property, + "_emval_incref": __emval_incref, + "_emval_new_array": __emval_new_array, + "_emval_new_cstring": __emval_new_cstring, + "_emval_run_destructors": __emval_run_destructors, + "_emval_set_property": __emval_set_property, + "_emval_take_value": __emval_take_value, + "abort": _abort, + "clock_gettime": _clock_gettime, + "emscripten_get_sbrk_ptr": _emscripten_get_sbrk_ptr, + "emscripten_memcpy_big": _emscripten_memcpy_big, + "emscripten_resize_heap": _emscripten_resize_heap, + "environ_get": _environ_get, + "environ_sizes_get": _environ_sizes_get, + "fd_close": _fd_close, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "memory": wasmMemory, + "pthread_mutexattr_destroy": _pthread_mutexattr_destroy, + "pthread_mutexattr_init": _pthread_mutexattr_init, + "pthread_mutexattr_settype": _pthread_mutexattr_settype, + "roundf": _roundf, + "sched_yield": _sched_yield, + "setTempRet0": _setTempRet0, + "strftime_l": _strftime_l, + "sysconf": _sysconf, + "table": wasmTable + }; + var asm = createWasm(); + Module["asm"] = asm; + var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function () { + return Module["asm"]["__wasm_call_ctors"].apply(null, arguments) + } + ; + var _malloc = Module["_malloc"] = function () { + return Module["asm"]["malloc"].apply(null, arguments) + } + ; + var _free = Module["_free"] = function () { + return Module["asm"]["free"].apply(null, arguments) + } + ; + var ___errno_location = Module["___errno_location"] = function () { + return Module["asm"]["__errno_location"].apply(null, arguments) + } + ; + var _setThrew = Module["_setThrew"] = function () { + return Module["asm"]["setThrew"].apply(null, arguments) + } + ; + var __ZSt18uncaught_exceptionv = Module["__ZSt18uncaught_exceptionv"] = function () { + return Module["asm"]["_ZSt18uncaught_exceptionv"].apply(null, arguments) + } + ; + var ___cxa_demangle = Module["___cxa_demangle"] = function () { + return Module["asm"]["__cxa_demangle"].apply(null, arguments) + } + ; + var ___getTypeName = Module["___getTypeName"] = function () { + return Module["asm"]["__getTypeName"].apply(null, arguments) + } + ; + var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = function () { + return Module["asm"]["__embind_register_native_and_builtin_types"].apply(null, arguments) + } + ; + var stackSave = Module["stackSave"] = function () { + return Module["asm"]["stackSave"].apply(null, arguments) + } + ; + var stackAlloc = Module["stackAlloc"] = function () { + return Module["asm"]["stackAlloc"].apply(null, arguments) + } + ; + var stackRestore = Module["stackRestore"] = function () { + return Module["asm"]["stackRestore"].apply(null, arguments) + } + ; + var __growWasmMemory = Module["__growWasmMemory"] = function () { + return Module["asm"]["__growWasmMemory"].apply(null, arguments) + } + ; + var dynCall_ii = Module["dynCall_ii"] = function () { + return Module["asm"]["dynCall_ii"].apply(null, arguments) + } + ; + var dynCall_vi = Module["dynCall_vi"] = function () { + return Module["asm"]["dynCall_vi"].apply(null, arguments) + } + ; + var dynCall_i = Module["dynCall_i"] = function () { + return Module["asm"]["dynCall_i"].apply(null, arguments) + } + ; + var dynCall_iii = Module["dynCall_iii"] = function () { + return Module["asm"]["dynCall_iii"].apply(null, arguments) + } + ; + var dynCall_iiii = Module["dynCall_iiii"] = function () { + return Module["asm"]["dynCall_iiii"].apply(null, arguments) + } + ; + var dynCall_iiiii = Module["dynCall_iiiii"] = function () { + return Module["asm"]["dynCall_iiiii"].apply(null, arguments) + } + ; + var dynCall_iiiiii = Module["dynCall_iiiiii"] = function () { + return Module["asm"]["dynCall_iiiiii"].apply(null, arguments) + } + ; + var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function () { + return Module["asm"]["dynCall_iiiiiii"].apply(null, arguments) + } + ; + var dynCall_viii = Module["dynCall_viii"] = function () { + return Module["asm"]["dynCall_viii"].apply(null, arguments) + } + ; + var dynCall_viiii = Module["dynCall_viiii"] = function () { + return Module["asm"]["dynCall_viiii"].apply(null, arguments) + } + ; + var dynCall_vii = Module["dynCall_vii"] = function () { + return Module["asm"]["dynCall_vii"].apply(null, arguments) + } + ; + var dynCall_viiidd = Module["dynCall_viiidd"] = function () { + return Module["asm"]["dynCall_viiidd"].apply(null, arguments) + } + ; + var dynCall_viiiidd = Module["dynCall_viiiidd"] = function () { + return Module["asm"]["dynCall_viiiidd"].apply(null, arguments) + } + ; + var dynCall_viiid = Module["dynCall_viiid"] = function () { + return Module["asm"]["dynCall_viiid"].apply(null, arguments) + } + ; + var dynCall_viiiid = Module["dynCall_viiiid"] = function () { + return Module["asm"]["dynCall_viiiid"].apply(null, arguments) + } + ; + var dynCall_viiiii = Module["dynCall_viiiii"] = function () { + return Module["asm"]["dynCall_viiiii"].apply(null, arguments) + } + ; + var dynCall_dii = Module["dynCall_dii"] = function () { + return Module["asm"]["dynCall_dii"].apply(null, arguments) + } + ; + var dynCall_diii = Module["dynCall_diii"] = function () { + return Module["asm"]["dynCall_diii"].apply(null, arguments) + } + ; + var dynCall_iiiid = Module["dynCall_iiiid"] = function () { + return Module["asm"]["dynCall_iiiid"].apply(null, arguments) + } + ; + var dynCall_fiii = Module["dynCall_fiii"] = function () { + return Module["asm"]["dynCall_fiii"].apply(null, arguments) + } + ; + var dynCall_fiiii = Module["dynCall_fiiii"] = function () { + return Module["asm"]["dynCall_fiiii"].apply(null, arguments) + } + ; + var dynCall_fiiiii = Module["dynCall_fiiiii"] = function () { + return Module["asm"]["dynCall_fiiiii"].apply(null, arguments) + } + ; + var dynCall_diiiii = Module["dynCall_diiiii"] = function () { + return Module["asm"]["dynCall_diiiii"].apply(null, arguments) + } + ; + var dynCall_diiii = Module["dynCall_diiii"] = function () { + return Module["asm"]["dynCall_diiii"].apply(null, arguments) + } + ; + var dynCall_viid = Module["dynCall_viid"] = function () { + return Module["asm"]["dynCall_viid"].apply(null, arguments) + } + ; + var dynCall_fii = Module["dynCall_fii"] = function () { + return Module["asm"]["dynCall_fii"].apply(null, arguments) + } + ; + var dynCall_viif = Module["dynCall_viif"] = function () { + return Module["asm"]["dynCall_viif"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = function () { + return Module["asm"]["dynCall_iiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = function () { + return Module["asm"]["dynCall_iiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = function () { + return Module["asm"]["dynCall_iiiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiif = Module["dynCall_viiif"] = function () { + return Module["asm"]["dynCall_viiif"].apply(null, arguments) + } + ; + var dynCall_iiiif = Module["dynCall_iiiif"] = function () { + return Module["asm"]["dynCall_iiiif"].apply(null, arguments) + } + ; + var dynCall_viiiddii = Module["dynCall_viiiddii"] = function () { + return Module["asm"]["dynCall_viiiddii"].apply(null, arguments) + } + ; + var dynCall_viiddii = Module["dynCall_viiddii"] = function () { + return Module["asm"]["dynCall_viiddii"].apply(null, arguments) + } + ; + var dynCall_viiiddi = Module["dynCall_viiiddi"] = function () { + return Module["asm"]["dynCall_viiiddi"].apply(null, arguments) + } + ; + var dynCall_viiddi = Module["dynCall_viiddi"] = function () { + return Module["asm"]["dynCall_viiddi"].apply(null, arguments) + } + ; + var dynCall_viidd = Module["dynCall_viidd"] = function () { + return Module["asm"]["dynCall_viidd"].apply(null, arguments) + } + ; + var dynCall_viiiiddi = Module["dynCall_viiiiddi"] = function () { + return Module["asm"]["dynCall_viiiiddi"].apply(null, arguments) + } + ; + var dynCall_viiiiddddii = Module["dynCall_viiiiddddii"] = function () { + return Module["asm"]["dynCall_viiiiddddii"].apply(null, arguments) + } + ; + var dynCall_viiiddddii = Module["dynCall_viiiddddii"] = function () { + return Module["asm"]["dynCall_viiiddddii"].apply(null, arguments) + } + ; + var dynCall_viiiiddddi = Module["dynCall_viiiiddddi"] = function () { + return Module["asm"]["dynCall_viiiiddddi"].apply(null, arguments) + } + ; + var dynCall_viiiddddi = Module["dynCall_viiiddddi"] = function () { + return Module["asm"]["dynCall_viiiddddi"].apply(null, arguments) + } + ; + var dynCall_viiiidddd = Module["dynCall_viiiidddd"] = function () { + return Module["asm"]["dynCall_viiiidddd"].apply(null, arguments) + } + ; + var dynCall_viiidddd = Module["dynCall_viiidddd"] = function () { + return Module["asm"]["dynCall_viiidddd"].apply(null, arguments) + } + ; + var dynCall_viiiiddd = Module["dynCall_viiiiddd"] = function () { + return Module["asm"]["dynCall_viiiiddd"].apply(null, arguments) + } + ; + var dynCall_viiiddd = Module["dynCall_viiiddd"] = function () { + return Module["asm"]["dynCall_viiiddd"].apply(null, arguments) + } + ; + var dynCall_viiiddidddd = Module["dynCall_viiiddidddd"] = function () { + return Module["asm"]["dynCall_viiiddidddd"].apply(null, arguments) + } + ; + var dynCall_viiddidddd = Module["dynCall_viiddidddd"] = function () { + return Module["asm"]["dynCall_viiddidddd"].apply(null, arguments) + } + ; + var dynCall_viiiddiddd = Module["dynCall_viiiddiddd"] = function () { + return Module["asm"]["dynCall_viiiddiddd"].apply(null, arguments) + } + ; + var dynCall_viiddiddd = Module["dynCall_viiddiddd"] = function () { + return Module["asm"]["dynCall_viiddiddd"].apply(null, arguments) + } + ; + var dynCall_viiiddidd = Module["dynCall_viiiddidd"] = function () { + return Module["asm"]["dynCall_viiiddidd"].apply(null, arguments) + } + ; + var dynCall_viiddidd = Module["dynCall_viiddidd"] = function () { + return Module["asm"]["dynCall_viiddidd"].apply(null, arguments) + } + ; + var dynCall_viiiddid = Module["dynCall_viiiddid"] = function () { + return Module["asm"]["dynCall_viiiddid"].apply(null, arguments) + } + ; + var dynCall_viiddid = Module["dynCall_viiddid"] = function () { + return Module["asm"]["dynCall_viiddid"].apply(null, arguments) + } + ; + var dynCall_viiiiiddi = Module["dynCall_viiiiiddi"] = function () { + return Module["asm"]["dynCall_viiiiiddi"].apply(null, arguments) + } + ; + var dynCall_viiiiidd = Module["dynCall_viiiiidd"] = function () { + return Module["asm"]["dynCall_viiiiidd"].apply(null, arguments) + } + ; + var dynCall_viiiiid = Module["dynCall_viiiiid"] = function () { + return Module["asm"]["dynCall_viiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiiiddi = Module["dynCall_viiiiiiddi"] = function () { + return Module["asm"]["dynCall_viiiiiiddi"].apply(null, arguments) + } + ; + var dynCall_viiiiiidd = Module["dynCall_viiiiiidd"] = function () { + return Module["asm"]["dynCall_viiiiiidd"].apply(null, arguments) + } + ; + var dynCall_viiiiiid = Module["dynCall_viiiiiid"] = function () { + return Module["asm"]["dynCall_viiiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiii = Module["dynCall_viiiiii"] = function () { + return Module["asm"]["dynCall_viiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiddi = Module["dynCall_viiiiiiiddi"] = function () { + return Module["asm"]["dynCall_viiiiiiiddi"].apply(null, arguments) + } + ; + var dynCall_viiiiiiidd = Module["dynCall_viiiiiiidd"] = function () { + return Module["asm"]["dynCall_viiiiiiidd"].apply(null, arguments) + } + ; + var dynCall_viiiiiiid = Module["dynCall_viiiiiiid"] = function () { + return Module["asm"]["dynCall_viiiiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function () { + return Module["asm"]["dynCall_viiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiidiiid = Module["dynCall_viiidiiid"] = function () { + return Module["asm"]["dynCall_viiidiiid"].apply(null, arguments) + } + ; + var dynCall_viidiiid = Module["dynCall_viidiiid"] = function () { + return Module["asm"]["dynCall_viidiiid"].apply(null, arguments) + } + ; + var dynCall_viididdii = Module["dynCall_viididdii"] = function () { + return Module["asm"]["dynCall_viididdii"].apply(null, arguments) + } + ; + var dynCall_vididdii = Module["dynCall_vididdii"] = function () { + return Module["asm"]["dynCall_vididdii"].apply(null, arguments) + } + ; + var dynCall_viididdi = Module["dynCall_viididdi"] = function () { + return Module["asm"]["dynCall_viididdi"].apply(null, arguments) + } + ; + var dynCall_vididdi = Module["dynCall_vididdi"] = function () { + return Module["asm"]["dynCall_vididdi"].apply(null, arguments) + } + ; + var dynCall_viiidi = Module["dynCall_viiidi"] = function () { + return Module["asm"]["dynCall_viiidi"].apply(null, arguments) + } + ; + var dynCall_viidi = Module["dynCall_viidi"] = function () { + return Module["asm"]["dynCall_viidi"].apply(null, arguments) + } + ; + var dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = function () { + return Module["asm"]["dynCall_viiiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiidiiiidi = Module["dynCall_viiiidiiiidi"] = function () { + return Module["asm"]["dynCall_viiiidiiiidi"].apply(null, arguments) + } + ; + var dynCall_viiidiiiidi = Module["dynCall_viiidiiiidi"] = function () { + return Module["asm"]["dynCall_viiidiiiidi"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiiiiid = Module["dynCall_viiiiiiiiiiid"] = function () { + return Module["asm"]["dynCall_viiiiiiiiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiiiid = Module["dynCall_viiiiiiiiiid"] = function () { + return Module["asm"]["dynCall_viiiiiiiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiiiii = Module["dynCall_viiiiiiiiiii"] = function () { + return Module["asm"]["dynCall_viiiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = function () { + return Module["asm"]["dynCall_viiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = function () { + return Module["asm"]["dynCall_viiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_diiiiiiiiiiiii = Module["dynCall_diiiiiiiiiiiii"] = function () { + return Module["asm"]["dynCall_diiiiiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_diiiiiiiiiiii = Module["dynCall_diiiiiiiiiiii"] = function () { + return Module["asm"]["dynCall_diiiiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_diiiiiiiiiii = Module["dynCall_diiiiiiiiiii"] = function () { + return Module["asm"]["dynCall_diiiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_diiiiiiiiii = Module["dynCall_diiiiiiiiii"] = function () { + return Module["asm"]["dynCall_diiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_di = Module["dynCall_di"] = function () { + return Module["asm"]["dynCall_di"].apply(null, arguments) + } + ; + var dynCall_viiiiidi = Module["dynCall_viiiiidi"] = function () { + return Module["asm"]["dynCall_viiiiidi"].apply(null, arguments) + } + ; + var dynCall_viiiidi = Module["dynCall_viiiidi"] = function () { + return Module["asm"]["dynCall_viiiidi"].apply(null, arguments) + } + ; + var dynCall_vidiii = Module["dynCall_vidiii"] = function () { + return Module["asm"]["dynCall_vidiii"].apply(null, arguments) + } + ; + var dynCall_vdiii = Module["dynCall_vdiii"] = function () { + return Module["asm"]["dynCall_vdiii"].apply(null, arguments) + } + ; + var dynCall_vidii = Module["dynCall_vidii"] = function () { + return Module["asm"]["dynCall_vidii"].apply(null, arguments) + } + ; + var dynCall_vdii = Module["dynCall_vdii"] = function () { + return Module["asm"]["dynCall_vdii"].apply(null, arguments) + } + ; + var dynCall_viiiiiifi = Module["dynCall_viiiiiifi"] = function () { + return Module["asm"]["dynCall_viiiiiifi"].apply(null, arguments) + } + ; + var dynCall_viiiiifi = Module["dynCall_viiiiifi"] = function () { + return Module["asm"]["dynCall_viiiiifi"].apply(null, arguments) + } + ; + var dynCall_viiiiiif = Module["dynCall_viiiiiif"] = function () { + return Module["asm"]["dynCall_viiiiiif"].apply(null, arguments) + } + ; + var dynCall_viiiiif = Module["dynCall_viiiiif"] = function () { + return Module["asm"]["dynCall_viiiiif"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiiiiii = Module["dynCall_viiiiiiiiiiii"] = function () { + return Module["asm"]["dynCall_viiiiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiidddiiii = Module["dynCall_viiiidddiiii"] = function () { + return Module["asm"]["dynCall_viiiidddiiii"].apply(null, arguments) + } + ; + var dynCall_viiidddiiii = Module["dynCall_viiidddiiii"] = function () { + return Module["asm"]["dynCall_viiidddiiii"].apply(null, arguments) + } + ; + var dynCall_viiiidddiii = Module["dynCall_viiiidddiii"] = function () { + return Module["asm"]["dynCall_viiiidddiii"].apply(null, arguments) + } + ; + var dynCall_viiidddiii = Module["dynCall_viiidddiii"] = function () { + return Module["asm"]["dynCall_viiidddiii"].apply(null, arguments) + } + ; + var dynCall_viiiidddii = Module["dynCall_viiiidddii"] = function () { + return Module["asm"]["dynCall_viiiidddii"].apply(null, arguments) + } + ; + var dynCall_viiidddii = Module["dynCall_viiidddii"] = function () { + return Module["asm"]["dynCall_viiidddii"].apply(null, arguments) + } + ; + var dynCall_viiiidddi = Module["dynCall_viiiidddi"] = function () { + return Module["asm"]["dynCall_viiiidddi"].apply(null, arguments) + } + ; + var dynCall_viiidddi = Module["dynCall_viiidddi"] = function () { + return Module["asm"]["dynCall_viiidddi"].apply(null, arguments) + } + ; + var dynCall_iiiiiididi = Module["dynCall_iiiiiididi"] = function () { + return Module["asm"]["dynCall_iiiiiididi"].apply(null, arguments) + } + ; + var dynCall_viiiiididi = Module["dynCall_viiiiididi"] = function () { + return Module["asm"]["dynCall_viiiiididi"].apply(null, arguments) + } + ; + var dynCall_iiiiiidid = Module["dynCall_iiiiiidid"] = function () { + return Module["asm"]["dynCall_iiiiiidid"].apply(null, arguments) + } + ; + var dynCall_viiiiidid = Module["dynCall_viiiiidid"] = function () { + return Module["asm"]["dynCall_viiiiidid"].apply(null, arguments) + } + ; + var dynCall_iiiiiidi = Module["dynCall_iiiiiidi"] = function () { + return Module["asm"]["dynCall_iiiiiidi"].apply(null, arguments) + } + ; + var dynCall_iiiiiid = Module["dynCall_iiiiiid"] = function () { + return Module["asm"]["dynCall_iiiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiiidi = Module["dynCall_viiiiiidi"] = function () { + return Module["asm"]["dynCall_viiiiiidi"].apply(null, arguments) + } + ; + var dynCall_iiiiidiid = Module["dynCall_iiiiidiid"] = function () { + return Module["asm"]["dynCall_iiiiidiid"].apply(null, arguments) + } + ; + var dynCall_viiiidiid = Module["dynCall_viiiidiid"] = function () { + return Module["asm"]["dynCall_viiiidiid"].apply(null, arguments) + } + ; + var dynCall_iiiiidii = Module["dynCall_iiiiidii"] = function () { + return Module["asm"]["dynCall_iiiiidii"].apply(null, arguments) + } + ; + var dynCall_viiiidii = Module["dynCall_viiiidii"] = function () { + return Module["asm"]["dynCall_viiiidii"].apply(null, arguments) + } + ; + var dynCall_iiiiidi = Module["dynCall_iiiiidi"] = function () { + return Module["asm"]["dynCall_iiiiidi"].apply(null, arguments) + } + ; + var dynCall_iiiiid = Module["dynCall_iiiiid"] = function () { + return Module["asm"]["dynCall_iiiiid"].apply(null, arguments) + } + ; + var dynCall_diiiiiiii = Module["dynCall_diiiiiiii"] = function () { + return Module["asm"]["dynCall_diiiiiiii"].apply(null, arguments) + } + ; + var dynCall_diiiiiii = Module["dynCall_diiiiiii"] = function () { + return Module["asm"]["dynCall_diiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiididii = Module["dynCall_viiididii"] = function () { + return Module["asm"]["dynCall_viiididii"].apply(null, arguments) + } + ; + var dynCall_viididii = Module["dynCall_viididii"] = function () { + return Module["asm"]["dynCall_viididii"].apply(null, arguments) + } + ; + var dynCall_viiididi = Module["dynCall_viiididi"] = function () { + return Module["asm"]["dynCall_viiididi"].apply(null, arguments) + } + ; + var dynCall_viididi = Module["dynCall_viididi"] = function () { + return Module["asm"]["dynCall_viididi"].apply(null, arguments) + } + ; + var dynCall_iiidd = Module["dynCall_iiidd"] = function () { + return Module["asm"]["dynCall_iiidd"].apply(null, arguments) + } + ; + var dynCall_viiiiddiiid = Module["dynCall_viiiiddiiid"] = function () { + return Module["asm"]["dynCall_viiiiddiiid"].apply(null, arguments) + } + ; + var dynCall_viiiddiiid = Module["dynCall_viiiddiiid"] = function () { + return Module["asm"]["dynCall_viiiddiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiddiii = Module["dynCall_viiiiddiii"] = function () { + return Module["asm"]["dynCall_viiiiddiii"].apply(null, arguments) + } + ; + var dynCall_viiiddiii = Module["dynCall_viiiddiii"] = function () { + return Module["asm"]["dynCall_viiiddiii"].apply(null, arguments) + } + ; + var dynCall_viiiiddii = Module["dynCall_viiiiddii"] = function () { + return Module["asm"]["dynCall_viiiiddii"].apply(null, arguments) + } + ; + var dynCall_viiiiddiiiid = Module["dynCall_viiiiddiiiid"] = function () { + return Module["asm"]["dynCall_viiiiddiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiddiiiid = Module["dynCall_viiiddiiiid"] = function () { + return Module["asm"]["dynCall_viiiddiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiddiiii = Module["dynCall_viiiiddiiii"] = function () { + return Module["asm"]["dynCall_viiiiddiiii"].apply(null, arguments) + } + ; + var dynCall_viiiddiiii = Module["dynCall_viiiddiiii"] = function () { + return Module["asm"]["dynCall_viiiddiiii"].apply(null, arguments) + } + ; + var dynCall_diiiiii = Module["dynCall_diiiiii"] = function () { + return Module["asm"]["dynCall_diiiiii"].apply(null, arguments) + } + ; + var dynCall_diiiid = Module["dynCall_diiiid"] = function () { + return Module["asm"]["dynCall_diiiid"].apply(null, arguments) + } + ; + var dynCall_diiid = Module["dynCall_diiid"] = function () { + return Module["asm"]["dynCall_diiid"].apply(null, arguments) + } + ; + var dynCall_viiddiii = Module["dynCall_viiddiii"] = function () { + return Module["asm"]["dynCall_viiddiii"].apply(null, arguments) + } + ; + var dynCall_vidi = Module["dynCall_vidi"] = function () { + return Module["asm"]["dynCall_vidi"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiid = Module["dynCall_viiiiiiiid"] = function () { + return Module["asm"]["dynCall_viiiiiiiid"].apply(null, arguments) + } + ; + var dynCall_viiiiidiiii = Module["dynCall_viiiiidiiii"] = function () { + return Module["asm"]["dynCall_viiiiidiiii"].apply(null, arguments) + } + ; + var dynCall_viiiidiiii = Module["dynCall_viiiidiiii"] = function () { + return Module["asm"]["dynCall_viiiidiiii"].apply(null, arguments) + } + ; + var dynCall_viiiiidiii = Module["dynCall_viiiiidiii"] = function () { + return Module["asm"]["dynCall_viiiiidiii"].apply(null, arguments) + } + ; + var dynCall_viiiidiii = Module["dynCall_viiiidiii"] = function () { + return Module["asm"]["dynCall_viiiidiii"].apply(null, arguments) + } + ; + var dynCall_viiiiidii = Module["dynCall_viiiiidii"] = function () { + return Module["asm"]["dynCall_viiiiidii"].apply(null, arguments) + } + ; + var dynCall_viiiiiiidi = Module["dynCall_viiiiiiidi"] = function () { + return Module["asm"]["dynCall_viiiiiiidi"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiiifdii = Module["dynCall_iiiiiiiiiifdii"] = function () { + return Module["asm"]["dynCall_iiiiiiiiiifdii"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiifdii = Module["dynCall_iiiiiiiiifdii"] = function () { + return Module["asm"]["dynCall_iiiiiiiiifdii"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiiifdi = Module["dynCall_iiiiiiiiiifdi"] = function () { + return Module["asm"]["dynCall_iiiiiiiiiifdi"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiifdi = Module["dynCall_iiiiiiiiifdi"] = function () { + return Module["asm"]["dynCall_iiiiiiiiifdi"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiiifd = Module["dynCall_iiiiiiiiiifd"] = function () { + return Module["asm"]["dynCall_iiiiiiiiiifd"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiifd = Module["dynCall_iiiiiiiiifd"] = function () { + return Module["asm"]["dynCall_iiiiiiiiifd"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiiif = Module["dynCall_iiiiiiiiiif"] = function () { + return Module["asm"]["dynCall_iiiiiiiiiif"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiif = Module["dynCall_iiiiiiiiif"] = function () { + return Module["asm"]["dynCall_iiiiiiiiif"].apply(null, arguments) + } + ; + var dynCall_diiiddi = Module["dynCall_diiiddi"] = function () { + return Module["asm"]["dynCall_diiiddi"].apply(null, arguments) + } + ; + var dynCall_diiddi = Module["dynCall_diiddi"] = function () { + return Module["asm"]["dynCall_diiddi"].apply(null, arguments) + } + ; + var dynCall_iiidiiiii = Module["dynCall_iiidiiiii"] = function () { + return Module["asm"]["dynCall_iiidiiiii"].apply(null, arguments) + } + ; + var dynCall_viidiiiii = Module["dynCall_viidiiiii"] = function () { + return Module["asm"]["dynCall_viidiiiii"].apply(null, arguments) + } + ; + var dynCall_iiidiiii = Module["dynCall_iiidiiii"] = function () { + return Module["asm"]["dynCall_iiidiiii"].apply(null, arguments) + } + ; + var dynCall_viidiiii = Module["dynCall_viidiiii"] = function () { + return Module["asm"]["dynCall_viidiiii"].apply(null, arguments) + } + ; + var dynCall_iiidiii = Module["dynCall_iiidiii"] = function () { + return Module["asm"]["dynCall_iiidiii"].apply(null, arguments) + } + ; + var dynCall_viidiii = Module["dynCall_viidiii"] = function () { + return Module["asm"]["dynCall_viidiii"].apply(null, arguments) + } + ; + var dynCall_iiidii = Module["dynCall_iiidii"] = function () { + return Module["asm"]["dynCall_iiidii"].apply(null, arguments) + } + ; + var dynCall_viidii = Module["dynCall_viidii"] = function () { + return Module["asm"]["dynCall_viidii"].apply(null, arguments) + } + ; + var dynCall_iiidi = Module["dynCall_iiidi"] = function () { + return Module["asm"]["dynCall_iiidi"].apply(null, arguments) + } + ; + var dynCall_iiid = Module["dynCall_iiid"] = function () { + return Module["asm"]["dynCall_iiid"].apply(null, arguments) + } + ; + var dynCall_iiiiifiii = Module["dynCall_iiiiifiii"] = function () { + return Module["asm"]["dynCall_iiiiifiii"].apply(null, arguments) + } + ; + var dynCall_viiiifiii = Module["dynCall_viiiifiii"] = function () { + return Module["asm"]["dynCall_viiiifiii"].apply(null, arguments) + } + ; + var dynCall_iiiiifii = Module["dynCall_iiiiifii"] = function () { + return Module["asm"]["dynCall_iiiiifii"].apply(null, arguments) + } + ; + var dynCall_viiiifii = Module["dynCall_viiiifii"] = function () { + return Module["asm"]["dynCall_viiiifii"].apply(null, arguments) + } + ; + var dynCall_iiiiifi = Module["dynCall_iiiiifi"] = function () { + return Module["asm"]["dynCall_iiiiifi"].apply(null, arguments) + } + ; + var dynCall_viiiifi = Module["dynCall_viiiifi"] = function () { + return Module["asm"]["dynCall_viiiifi"].apply(null, arguments) + } + ; + var dynCall_iiiiif = Module["dynCall_iiiiif"] = function () { + return Module["asm"]["dynCall_iiiiif"].apply(null, arguments) + } + ; + var dynCall_viiiif = Module["dynCall_viiiif"] = function () { + return Module["asm"]["dynCall_viiiif"].apply(null, arguments) + } + ; + var dynCall_vid = Module["dynCall_vid"] = function () { + return Module["asm"]["dynCall_vid"].apply(null, arguments) + } + ; + var dynCall_iiiiffi = Module["dynCall_iiiiffi"] = function () { + return Module["asm"]["dynCall_iiiiffi"].apply(null, arguments) + } + ; + var dynCall_viiiffi = Module["dynCall_viiiffi"] = function () { + return Module["asm"]["dynCall_viiiffi"].apply(null, arguments) + } + ; + var dynCall_iiiiff = Module["dynCall_iiiiff"] = function () { + return Module["asm"]["dynCall_iiiiff"].apply(null, arguments) + } + ; + var dynCall_viiiff = Module["dynCall_viiiff"] = function () { + return Module["asm"]["dynCall_viiiff"].apply(null, arguments) + } + ; + var dynCall_iiiiiiffi = Module["dynCall_iiiiiiffi"] = function () { + return Module["asm"]["dynCall_iiiiiiffi"].apply(null, arguments) + } + ; + var dynCall_viiiiiffi = Module["dynCall_viiiiiffi"] = function () { + return Module["asm"]["dynCall_viiiiiffi"].apply(null, arguments) + } + ; + var dynCall_iiiiiiff = Module["dynCall_iiiiiiff"] = function () { + return Module["asm"]["dynCall_iiiiiiff"].apply(null, arguments) + } + ; + var dynCall_viiiiiff = Module["dynCall_viiiiiff"] = function () { + return Module["asm"]["dynCall_viiiiiff"].apply(null, arguments) + } + ; + var dynCall_iidi = Module["dynCall_iidi"] = function () { + return Module["asm"]["dynCall_iidi"].apply(null, arguments) + } + ; + var dynCall_iid = Module["dynCall_iid"] = function () { + return Module["asm"]["dynCall_iid"].apply(null, arguments) + } + ; + var dynCall_viiidiiii = Module["dynCall_viiidiiii"] = function () { + return Module["asm"]["dynCall_viiidiiii"].apply(null, arguments) + } + ; + var dynCall_viiidiii = Module["dynCall_viiidiii"] = function () { + return Module["asm"]["dynCall_viiidiii"].apply(null, arguments) + } + ; + var dynCall_viiidii = Module["dynCall_viiidii"] = function () { + return Module["asm"]["dynCall_viiidii"].apply(null, arguments) + } + ; + var dynCall_viiiiidiiiii = Module["dynCall_viiiiidiiiii"] = function () { + return Module["asm"]["dynCall_viiiiidiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiiiidiiiii = Module["dynCall_viiiiiidiiiii"] = function () { + return Module["asm"]["dynCall_viiiiiidiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiiiidiiii = Module["dynCall_viiiiiidiiii"] = function () { + return Module["asm"]["dynCall_viiiiiidiiii"].apply(null, arguments) + } + ; + var dynCall_viiiiiidiii = Module["dynCall_viiiiiidiii"] = function () { + return Module["asm"]["dynCall_viiiiiidiii"].apply(null, arguments) + } + ; + var dynCall_viiiiiidii = Module["dynCall_viiiiiidii"] = function () { + return Module["asm"]["dynCall_viiiiiidii"].apply(null, arguments) + } + ; + var dynCall_viiiiifii = Module["dynCall_viiiiifii"] = function () { + return Module["asm"]["dynCall_viiiiifii"].apply(null, arguments) + } + ; + var dynCall_viiifii = Module["dynCall_viiifii"] = function () { + return Module["asm"]["dynCall_viiifii"].apply(null, arguments) + } + ; + var dynCall_viiifi = Module["dynCall_viiifi"] = function () { + return Module["asm"]["dynCall_viiifi"].apply(null, arguments) + } + ; + var dynCall_iiiddiid = Module["dynCall_iiiddiid"] = function () { + return Module["asm"]["dynCall_iiiddiid"].apply(null, arguments) + } + ; + var dynCall_viiddiid = Module["dynCall_viiddiid"] = function () { + return Module["asm"]["dynCall_viiddiid"].apply(null, arguments) + } + ; + var dynCall_iiiddii = Module["dynCall_iiiddii"] = function () { + return Module["asm"]["dynCall_iiiddii"].apply(null, arguments) + } + ; + var dynCall_iiiddi = Module["dynCall_iiiddi"] = function () { + return Module["asm"]["dynCall_iiiddi"].apply(null, arguments) + } + ; + var dynCall_iiiddiiid = Module["dynCall_iiiddiiid"] = function () { + return Module["asm"]["dynCall_iiiddiiid"].apply(null, arguments) + } + ; + var dynCall_viiddiiid = Module["dynCall_viiddiiid"] = function () { + return Module["asm"]["dynCall_viiddiiid"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiididiii = Module["dynCall_iiiiiiiididiii"] = function () { + return Module["asm"]["dynCall_iiiiiiiididiii"].apply(null, arguments) + } + ; + var dynCall_iiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiii"] = function () { + return Module["asm"]["dynCall_iiiiiiiiiiiii"].apply(null, arguments) + } + ; + var dynCall_viiiidiiddi = Module["dynCall_viiiidiiddi"] = function () { + return Module["asm"]["dynCall_viiiidiiddi"].apply(null, arguments) + } + ; + var dynCall_viiiiidiiddi = Module["dynCall_viiiiidiiddi"] = function () { + return Module["asm"]["dynCall_viiiiidiiddi"].apply(null, arguments) + } + ; + var dynCall_viiiidiidd = Module["dynCall_viiiidiidd"] = function () { + return Module["asm"]["dynCall_viiiidiidd"].apply(null, arguments) + } + ; + var dynCall_viiiiidiidd = Module["dynCall_viiiiidiidd"] = function () { + return Module["asm"]["dynCall_viiiiidiidd"].apply(null, arguments) + } + ; + var dynCall_viiiiidiid = Module["dynCall_viiiiidiid"] = function () { + return Module["asm"]["dynCall_viiiiidiid"].apply(null, arguments) + } + ; + var dynCall_iiiifiii = Module["dynCall_iiiifiii"] = function () { + return Module["asm"]["dynCall_iiiifiii"].apply(null, arguments) + } + ; + var dynCall_viiifiii = Module["dynCall_viiifiii"] = function () { + return Module["asm"]["dynCall_viiifiii"].apply(null, arguments) + } + ; + var dynCall_iiiifii = Module["dynCall_iiiifii"] = function () { + return Module["asm"]["dynCall_iiiifii"].apply(null, arguments) + } + ; + var dynCall_iiiifi = Module["dynCall_iiiifi"] = function () { + return Module["asm"]["dynCall_iiiifi"].apply(null, arguments) + } + ; + var dynCall_iiiiiddiddi = Module["dynCall_iiiiiddiddi"] = function () { + return Module["asm"]["dynCall_iiiiiddiddi"].apply(null, arguments) + } + ; + var dynCall_viiiiddiddi = Module["dynCall_viiiiddiddi"] = function () { + return Module["asm"]["dynCall_viiiiddiddi"].apply(null, arguments) + } + ; + var dynCall_iiiiiddidd = Module["dynCall_iiiiiddidd"] = function () { + return Module["asm"]["dynCall_iiiiiddidd"].apply(null, arguments) + } + ; + var dynCall_viiiiddidd = Module["dynCall_viiiiddidd"] = function () { + return Module["asm"]["dynCall_viiiiddidd"].apply(null, arguments) + } + ; + var dynCall_iiiiiddid = Module["dynCall_iiiiiddid"] = function () { + return Module["asm"]["dynCall_iiiiiddid"].apply(null, arguments) + } + ; + var dynCall_viiiiddid = Module["dynCall_viiiiddid"] = function () { + return Module["asm"]["dynCall_viiiiddid"].apply(null, arguments) + } + ; + var dynCall_iiiiiddi = Module["dynCall_iiiiiddi"] = function () { + return Module["asm"]["dynCall_iiiiiddi"].apply(null, arguments) + } + ; + var dynCall_iiiiidd = Module["dynCall_iiiiidd"] = function () { + return Module["asm"]["dynCall_iiiiidd"].apply(null, arguments) + } + ; + var dynCall_iiifiiiiiii = Module["dynCall_iiifiiiiiii"] = function () { + return Module["asm"]["dynCall_iiifiiiiiii"].apply(null, arguments) + } + ; + var dynCall_viifiiiiiii = Module["dynCall_viifiiiiiii"] = function () { + return Module["asm"]["dynCall_viifiiiiiii"].apply(null, arguments) + } + ; + var dynCall_iiifiiiiii = Module["dynCall_iiifiiiiii"] = function () { + return Module["asm"]["dynCall_iiifiiiiii"].apply(null, arguments) + } + ; + var dynCall_viifiiiiii = Module["dynCall_viifiiiiii"] = function () { + return Module["asm"]["dynCall_viifiiiiii"].apply(null, arguments) + } + ; + var dynCall_iiifiiiii = Module["dynCall_iiifiiiii"] = function () { + return Module["asm"]["dynCall_iiifiiiii"].apply(null, arguments) + } + ; + var dynCall_viifiiiii = Module["dynCall_viifiiiii"] = function () { + return Module["asm"]["dynCall_viifiiiii"].apply(null, arguments) + } + ; + var dynCall_iiifiiii = Module["dynCall_iiifiiii"] = function () { + return Module["asm"]["dynCall_iiifiiii"].apply(null, arguments) + } + ; + var dynCall_viifiiii = Module["dynCall_viifiiii"] = function () { + return Module["asm"]["dynCall_viifiiii"].apply(null, arguments) + } + ; + var dynCall_iiifiii = Module["dynCall_iiifiii"] = function () { + return Module["asm"]["dynCall_iiifiii"].apply(null, arguments) + } + ; + var dynCall_viifiii = Module["dynCall_viifiii"] = function () { + return Module["asm"]["dynCall_viifiii"].apply(null, arguments) + } + ; + var dynCall_iiifii = Module["dynCall_iiifii"] = function () { + return Module["asm"]["dynCall_iiifii"].apply(null, arguments) + } + ; + var dynCall_viifii = Module["dynCall_viifii"] = function () { + return Module["asm"]["dynCall_viifii"].apply(null, arguments) + } + ; + var dynCall_iiifi = Module["dynCall_iiifi"] = function () { + return Module["asm"]["dynCall_iiifi"].apply(null, arguments) + } + ; + var dynCall_viifi = Module["dynCall_viifi"] = function () { + return Module["asm"]["dynCall_viifi"].apply(null, arguments) + } + ; + var dynCall_iiif = Module["dynCall_iiif"] = function () { + return Module["asm"]["dynCall_iiif"].apply(null, arguments) + } + ; + var dynCall_viijii = Module["dynCall_viijii"] = function () { + return Module["asm"]["dynCall_viijii"].apply(null, arguments) + } + ; + var dynCall_ji = Module["dynCall_ji"] = function () { + return Module["asm"]["dynCall_ji"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiiiiddi = Module["dynCall_viiiiiiiiiiddi"] = function () { + return Module["asm"]["dynCall_viiiiiiiiiiddi"].apply(null, arguments) + } + ; + var dynCall_v = Module["dynCall_v"] = function () { + return Module["asm"]["dynCall_v"].apply(null, arguments) + } + ; + var dynCall_viiiiiiiiidd = Module["dynCall_viiiiiiiiidd"] = function () { + return Module["asm"]["dynCall_viiiiiiiiidd"].apply(null, arguments) + } + ; + var dynCall_jiii = Module["dynCall_jiii"] = function () { + return Module["asm"]["dynCall_jiii"].apply(null, arguments) + } + ; + var dynCall_vij = Module["dynCall_vij"] = function () { + return Module["asm"]["dynCall_vij"].apply(null, arguments) + } + ; + var dynCall_iiiiiifiididiii = Module["dynCall_iiiiiifiididiii"] = function () { + return Module["asm"]["dynCall_iiiiiifiididiii"].apply(null, arguments) + } + ; + var dynCall_viiidiiddi = Module["dynCall_viiidiiddi"] = function () { + return Module["asm"]["dynCall_viiidiiddi"].apply(null, arguments) + } + ; + var dynCall_viiij = Module["dynCall_viiij"] = function () { + return Module["asm"]["dynCall_viiij"].apply(null, arguments) + } + ; + var dynCall_jiiii = Module["dynCall_jiiii"] = function () { + return Module["asm"]["dynCall_jiiii"].apply(null, arguments) + } + ; + var dynCall_viiiij = Module["dynCall_viiiij"] = function () { + return Module["asm"]["dynCall_viiiij"].apply(null, arguments) + } + ; + var dynCall_jii = Module["dynCall_jii"] = function () { + return Module["asm"]["dynCall_jii"].apply(null, arguments) + } + ; + var dynCall_viji = Module["dynCall_viji"] = function () { + return Module["asm"]["dynCall_viji"].apply(null, arguments) + } + ; + var dynCall_vifi = Module["dynCall_vifi"] = function () { + return Module["asm"]["dynCall_vifi"].apply(null, arguments) + } + ; + var dynCall_jiji = Module["dynCall_jiji"] = function () { + return Module["asm"]["dynCall_jiji"].apply(null, arguments) + } + ; + var dynCall_iidiiii = Module["dynCall_iidiiii"] = function () { + return Module["asm"]["dynCall_iidiiii"].apply(null, arguments) + } + ; + var dynCall_iiiiij = Module["dynCall_iiiiij"] = function () { + return Module["asm"]["dynCall_iiiiij"].apply(null, arguments) + } + ; + var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function () { + return Module["asm"]["dynCall_iiiiijj"].apply(null, arguments) + } + ; + var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function () { + return Module["asm"]["dynCall_iiiiiijj"].apply(null, arguments) + } + ; + Module["asm"] = asm; + Module["getMemory"] = getMemory; + Module["addRunDependency"] = addRunDependency; + Module["removeRunDependency"] = removeRunDependency; + Module["FS_createFolder"] = FS.createFolder; + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createLink"] = FS.createLink; + Module["FS_createDevice"] = FS.createDevice; + Module["FS_unlink"] = FS.unlink; + Module["calledRun"] = calledRun; + var calledRun; + Module["then"] = function (func) { + if (calledRun) { + func(Module) + } else { + var old = Module["onRuntimeInitialized"]; + Module["onRuntimeInitialized"] = function () { + if (old) + old(); + func(Module) + } + } + return Module + } + ; + function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status + } + dependenciesFulfilled = function runCaller() { + if (!calledRun) + run(); + if (!calledRun) + dependenciesFulfilled = runCaller + } + ; + function run(args) { + args = args || arguments_; + if (runDependencies > 0) { + return + } + preRun(); + if (runDependencies > 0) + return; + function doRun() { + if (calledRun) + return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) + return; + initRuntime(); + preMain(); + if (Module["onRuntimeInitialized"]) + Module["onRuntimeInitialized"](); + postRun() + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function () { + setTimeout(function () { + Module["setStatus"]("") + }, 1); + doRun() + }, 1) + } else { + doRun() + } + } + Module["run"] = run; + if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") + Module["preInit"] = [Module["preInit"]]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()() + } + } + noExitRuntime = true; + run(); + if (typeof Module.FS === "undefined" && typeof FS !== "undefined") { + Module.FS = FS + } + + if (!IsWechat) { + // 在微信里不执行 + Module["imread"] = function (imageSource) { + var img = null; + if (typeof imageSource === "string") { + img = document.getElementById(imageSource) + } else { + img = imageSource + } + var canvas = null; + var ctx = null; + if (img instanceof HTMLImageElement) { + canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + ctx = canvas.getContext("2d"); + ctx.drawImage(img, 0, 0, img.width, img.height) + } else if (img instanceof HTMLCanvasElement) { + canvas = img; + ctx = canvas.getContext("2d") + } else { + throw new Error("Please input the valid canvas or img id."); + return + } + var imgData = ctx.getImageData(0, 0, canvas.width, canvas.height); + return cv.matFromImageData(imgData) + + }; + // 在微信里不执行 + Module["imshow"] = function (canvasSource, mat) { + var canvas = null; + if (typeof canvasSource === "string") { + canvas = document.getElementById(canvasSource) + } else { + canvas = canvasSource + } + if (!(canvas instanceof HTMLCanvasElement)) { + throw new Error("Please input the valid canvas element or id."); + return + } + if (!(mat instanceof cv.Mat)) { + throw new Error("Please input the valid cv.Mat instance."); + return + } + var img = new cv.Mat; + var depth = mat.type() % 8; + var scale = depth <= cv.CV_8S ? 1 : depth <= cv.CV_32S ? 1 / 256 : 255; + var shift = depth === cv.CV_8S || depth === cv.CV_16S ? 128 : 0; + mat.convertTo(img, cv.CV_8U, scale, shift); + switch (img.type()) { + case cv.CV_8UC1: + cv.cvtColor(img, img, cv.COLOR_GRAY2RGBA); + break; + case cv.CV_8UC3: + cv.cvtColor(img, img, cv.COLOR_RGB2RGBA); + break; + case cv.CV_8UC4: + break; + default: + throw new Error("Bad number of channels (Source image must have 1, 3 or 4 channels)"); + return + } + var imgData = new ImageData(new Uint8ClampedArray(img.data), img.cols, img.rows); + var ctx = canvas.getContext("2d"); + ctx.clearRect(0, 0, canvas.width, canvas.height); + canvas.width = imgData.width; + canvas.height = imgData.height; + ctx.putImageData(imgData, 0, 0); + img.delete() + + }; + } else { + Module["imread"] = function (imgData) { + return cv.matFromImageData(imgData) + } + ; + Module["imshow"] = function (canvas, mat) { + if (!(mat instanceof cv.Mat)) { + throw new Error("Please input the valid cv.Mat instance."); + return + } + var img = new cv.Mat; + var depth = mat.type() % 8; + var scale = depth <= cv.CV_8S ? 1 : depth <= cv.CV_32S ? 1 / 256 : 255; + var shift = depth === cv.CV_8S || depth === cv.CV_16S ? 128 : 0; + mat.convertTo(img, cv.CV_8U, scale, shift); + switch (img.type()) { + case cv.CV_8UC1: + cv.cvtColor(img, img, cv.COLOR_GRAY2RGBA); + break; + case cv.CV_8UC3: + cv.cvtColor(img, img, cv.COLOR_RGB2RGBA); + break; + case cv.CV_8UC4: + break; + default: + throw new Error("Bad number of channels (Source image must have 1, 3 or 4 channels)"); + return + } + + var ctx = canvas.getContext("2d"); + ctx.clearRect(0, 0, canvas.width, canvas.height); + + // 创建ImageData对象 + var imgData = ctx.createImageData(img.cols, img.rows); + // imgData.data是只读对象，但是imgData.data.set()方法可修改imgData.data。 + imgData.data.set(new Uint8ClampedArray(img.data)) + // 画布canvas的宽度和高度，不能比图像imgData小。 + canvas.width = imgData.width; + canvas.height = imgData.height; + // 需要传递ImageData类型，但小程序无法通过new ImageData()创建该类型。 + ctx.putImageData(imgData, 0, 0); + img.delete() + }; + + } + + + Module["VideoCapture"] = function (videoSource) { + var video = null; + if (typeof videoSource === "string") { + video = document.getElementById(videoSource) + } else { + video = videoSource + } + if (!(video instanceof HTMLVideoElement)) { + throw new Error("Please input the valid video element or id."); + return + } + var canvas = document.createElement("canvas"); + canvas.width = video.width; + canvas.height = video.height; + var ctx = canvas.getContext("2d"); + this.video = video; + this.read = function (frame) { + if (!(frame instanceof cv.Mat)) { + throw new Error("Please input the valid cv.Mat instance."); + return + } + if (frame.type() !== cv.CV_8UC4) { + throw new Error("Bad type of input mat: the type should be cv.CV_8UC4."); + return + } + if (frame.cols !== video.width || frame.rows !== video.height) { + throw new Error("Bad size of input mat: the size should be same as the video."); + return + } + ctx.drawImage(video, 0, 0, video.width, video.height); + frame.data.set(ctx.getImageData(0, 0, video.width, video.height).data) + } + } + ; + function Range(start, end) { + this.start = typeof start === "undefined" ? 0 : start; + this.end = typeof end === "undefined" ? 0 : end + } + Module["Range"] = Range; + function Point(x, y) { + this.x = typeof x === "undefined" ? 0 : x; + this.y = typeof y === "undefined" ? 0 : y + } + Module["Point"] = Point; + function Size(width, height) { + this.width = typeof width === "undefined" ? 0 : width; + this.height = typeof height === "undefined" ? 0 : height + } + Module["Size"] = Size; + function Rect() { + switch (arguments.length) { + case 0: + { + this.x = 0; + this.y = 0; + this.width = 0; + this.height = 0; + break + } + case 1: + { + var rect = arguments[0]; + this.x = rect.x; + this.y = rect.y; + this.width = rect.width; + this.height = rect.height; + break + } + case 2: + { + var point = arguments[0]; + var size = arguments[1]; + this.x = point.x; + this.y = point.y; + this.width = size.width; + this.height = size.height; + break + } + case 4: + { + this.x = arguments[0]; + this.y = arguments[1]; + this.width = arguments[2]; + this.height = arguments[3]; + break + } + default: + { + throw new Error("Invalid arguments") + } + } + } + Module["Rect"] = Rect; + function RotatedRect() { + switch (arguments.length) { + case 0: + { + this.center = { + x: 0, + y: 0 + }; + this.size = { + width: 0, + height: 0 + }; + this.angle = 0; + break + } + case 3: + { + this.center = arguments[0]; + this.size = arguments[1]; + this.angle = arguments[2]; + break + } + default: + { + throw new Error("Invalid arguments") + } + } + } + RotatedRect.points = function (obj) { + return Module.rotatedRectPoints(obj) + } + ; + RotatedRect.boundingRect = function (obj) { + return Module.rotatedRectBoundingRect(obj) + } + ; + RotatedRect.boundingRect2f = function (obj) { + return Module.rotatedRectBoundingRect2f(obj) + } + ; + Module["RotatedRect"] = RotatedRect; + function Scalar(v0, v1, v2, v3) { + this.push(typeof v0 === "undefined" ? 0 : v0); + this.push(typeof v1 === "undefined" ? 0 : v1); + this.push(typeof v2 === "undefined" ? 0 : v2); + this.push(typeof v3 === "undefined" ? 0 : v3) + } + Scalar.prototype = new Array; + Scalar.all = function (v) { + return new Scalar(v, v, v, v) + } + ; + Module["Scalar"] = Scalar; + function MinMaxLoc() { + switch (arguments.length) { + case 0: + { + this.minVal = 0; + this.maxVal = 0; + this.minLoc = new Point; + this.maxLoc = new Point; + break + } + case 4: + { + this.minVal = arguments[0]; + this.maxVal = arguments[1]; + this.minLoc = arguments[2]; + this.maxLoc = arguments[3]; + break + } + default: + { + throw new Error("Invalid arguments") + } + } + } + Module["MinMaxLoc"] = MinMaxLoc; + function Circle() { + switch (arguments.length) { + case 0: + { + this.center = new Point; + this.radius = 0; + break + } + case 2: + { + this.center = arguments[0]; + this.radius = arguments[1]; + break + } + default: + { + throw new Error("Invalid arguments") + } + } + } + Module["Circle"] = Circle; + function TermCriteria() { + switch (arguments.length) { + case 0: + { + this.type = 0; + this.maxCount = 0; + this.epsilon = 0; + break + } + case 3: + { + this.type = arguments[0]; + this.maxCount = arguments[1]; + this.epsilon = arguments[2]; + break + } + default: + { + throw new Error("Invalid arguments") + } + } + } + Module["TermCriteria"] = TermCriteria; + Module["matFromArray"] = function (rows, cols, type, array) { + var mat = new cv.Mat(rows, cols, type); + switch (type) { + case cv.CV_8U: + case cv.CV_8UC1: + case cv.CV_8UC2: + case cv.CV_8UC3: + case cv.CV_8UC4: + { + mat.data.set(array); + break + } + case cv.CV_8S: + case cv.CV_8SC1: + case cv.CV_8SC2: + case cv.CV_8SC3: + case cv.CV_8SC4: + { + mat.data8S.set(array); + break + } + case cv.CV_16U: + case cv.CV_16UC1: + case cv.CV_16UC2: + case cv.CV_16UC3: + case cv.CV_16UC4: + { + mat.data16U.set(array); + break + } + case cv.CV_16S: + case cv.CV_16SC1: + case cv.CV_16SC2: + case cv.CV_16SC3: + case cv.CV_16SC4: + { + mat.data16S.set(array); + break + } + case cv.CV_32S: + case cv.CV_32SC1: + case cv.CV_32SC2: + case cv.CV_32SC3: + case cv.CV_32SC4: + { + mat.data32S.set(array); + break + } + case cv.CV_32F: + case cv.CV_32FC1: + case cv.CV_32FC2: + case cv.CV_32FC3: + case cv.CV_32FC4: + { + mat.data32F.set(array); + break + } + case cv.CV_64F: + case cv.CV_64FC1: + case cv.CV_64FC2: + case cv.CV_64FC3: + case cv.CV_64FC4: + { + mat.data64F.set(array); + break + } + default: + { + throw new Error("Type is unsupported") + } + } + return mat + } + ; + Module["matFromImageData"] = function (imageData) { + var mat = new cv.Mat(imageData.height, imageData.width, cv.CV_8UC4); + mat.data.set(imageData.data); + return mat + } + ; + + return cv + } + ); + } + )(); + if (typeof exports === 'object' && typeof module === 'object') + module.exports = cv; + else if (typeof define === 'function' && define['amd']) + define([], function () { + return cv; + }); + else if (typeof exports === 'object') + exports["cv"] = cv; + + if (typeof Module === 'undefined') + Module = {}; + return cv(Module); +})); diff --git a/opencv_dev/assets/sampleImage1.jpg b/opencv_dev/assets/sampleImage1.jpg new file mode 100644 index 0000000..dcef055 Binary files /dev/null and b/opencv_dev/assets/sampleImage1.jpg differ diff --git a/opencv_dev/assets/vue.min.js b/opencv_dev/assets/vue.min.js new file mode 100644 index 0000000..37febff --- /dev/null +++ b/opencv_dev/assets/vue.min.js @@ -0,0 +1,6 @@ +/*! + * Vue.js v2.5.16 + * (c) 2014-2018 Evan You + * Released under the MIT License. + */ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Vue=t()}(this,function(){"use strict";var y=Object.freeze({});function M(e){return null==e}function D(e){return null!=e}function S(e){return!0===e}function T(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function P(e){return null!==e&&"object"==typeof e}var r=Object.prototype.toString;function l(e){return"[object Object]"===r.call(e)}function i(e){var t=parseFloat(String(e));return 0<=t&&Math.floor(t)===t&&isFinite(e)}function t(e){return null==e?"":"object"==typeof e?JSON.stringify(e,null,2):String(e)}function F(e){var t=parseFloat(e);return isNaN(t)?e:t}function s(e,t){for(var n=Object.create(null),r=e.split(","),i=0;ie.id;)n--;bt.splice(n+1,0,e)}else bt.push(e);Ct||(Ct=!0,Ze(At))}}(this)},St.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||P(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Fe(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},St.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},St.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},St.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||f(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var Tt={enumerable:!0,configurable:!0,get:$,set:$};function Et(e,t,n){Tt.get=function(){return this[t][n]},Tt.set=function(e){this[t][n]=e},Object.defineProperty(e,n,Tt)}function jt(e){e._watchers=[];var t=e.$options;t.props&&function(n,r){var i=n.$options.propsData||{},o=n._props={},a=n.$options._propKeys=[];n.$parent&&ge(!1);var e=function(e){a.push(e);var t=Ie(e,r,i,n);Ce(o,e,t),e in n||Et(n,"_props",e)};for(var t in r)e(t);ge(!0)}(e,t.props),t.methods&&function(e,t){e.$options.props;for(var n in t)e[n]=null==t[n]?$:v(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;l(t=e._data="function"==typeof t?function(e,t){se();try{return e.call(t,t)}catch(e){return Fe(e,t,"data()"),{}}finally{ce()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props,i=(e.$options.methods,n.length);for(;i--;){var o=n[i];r&&p(r,o)||(void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&Et(e,"_data",o))}var a;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=Y();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new St(e,a||$,$,Nt)),i in e||Lt(e,i,o)}}(e,t.computed),t.watch&&t.watch!==G&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;iparseInt(this.max)&&bn(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};$n=hn,Cn={get:function(){return j}},Object.defineProperty($n,"config",Cn),$n.util={warn:re,extend:m,mergeOptions:Ne,defineReactive:Ce},$n.set=xe,$n.delete=ke,$n.nextTick=Ze,$n.options=Object.create(null),k.forEach(function(e){$n.options[e+"s"]=Object.create(null)}),m(($n.options._base=$n).options.components,kn),$n.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(-1=a&&l()};setTimeout(function(){c\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,oo="[a-zA-Z_][\\w\\-\\.]*",ao="((?:"+oo+"\\:)?"+oo+")",so=new RegExp("^<"+ao),co=/^\s*(\/?)>/,lo=new RegExp("^<\\/"+ao+"[^>]*>"),uo=/^]+>/i,fo=/^",""":'"',"&":"&"," ":"\n"," ":"\t"},go=/&(?:lt|gt|quot|amp);/g,_o=/&(?:lt|gt|quot|amp|#10|#9);/g,bo=s("pre,textarea",!0),$o=function(e,t){return e&&bo(e)&&"\n"===t[0]};var wo,Co,xo,ko,Ao,Oo,So,To,Eo=/^@|^v-on:/,jo=/^v-|^@|^:/,No=/([^]*?)\s+(?:in|of)\s+([^]*)/,Lo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Io=/^\(|\)$/g,Mo=/:(.*)$/,Do=/^:|^v-bind:/,Po=/\.[^.]+/g,Fo=e(eo);function Ro(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:function(e){for(var t={},n=0,r=e.length;n]*>)","i")),n=i.replace(t,function(e,t,n){return r=n.length,ho(o)||"noscript"===o||(t=t.replace(//g,"$1").replace(//g,"$1")),$o(o,t)&&(t=t.slice(1)),d.chars&&d.chars(t),""});a+=i.length-n.length,i=n,A(o,a-r,a)}else{var s=i.indexOf("<");if(0===s){if(fo.test(i)){var c=i.indexOf("--\x3e");if(0<=c){d.shouldKeepComment&&d.comment(i.substring(4,c)),C(c+3);continue}}if(po.test(i)){var l=i.indexOf("]>");if(0<=l){C(l+2);continue}}var u=i.match(uo);if(u){C(u[0].length);continue}var f=i.match(lo);if(f){var p=a;C(f[0].length),A(f[1],p,a);continue}var _=x();if(_){k(_),$o(v,i)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(0<=s){for($=i.slice(s);!(lo.test($)||so.test($)||fo.test($)||po.test($)||(w=$.indexOf("<",1))<0);)s+=w,$=i.slice(s);b=i.substring(0,s),C(s)}s<0&&(b=i,i=""),d.chars&&b&&d.chars(b)}if(i===e){d.chars&&d.chars(i);break}}function C(e){a+=e,i=i.substring(e)}function x(){var e=i.match(so);if(e){var t,n,r={tagName:e[1],attrs:[],start:a};for(C(e[0].length);!(t=i.match(co))&&(n=i.match(io));)C(n[0].length),r.attrs.push(n);if(t)return r.unarySlash=t[1],C(t[0].length),r.end=a,r}}function k(e){var t=e.tagName,n=e.unarySlash;m&&("p"===v&&ro(t)&&A(v),g(t)&&v===t&&A(t));for(var r,i,o,a=y(t)||!!n,s=e.attrs.length,c=new Array(s),l=0;l-1"+("true"===d?":("+l+")":":_q("+l+","+d+")")),Ar(c,"change","var $$a="+l+",$$el=$event.target,$$c=$$el.checked?("+d+"):("+v+");if(Array.isArray($$a)){var $$v="+(f?"_n("+p+")":p)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Er(l,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Er(l,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Er(l,"$$c")+"}",null,!0);else if("input"===$&&"radio"===w)r=e,i=_,a=(o=b)&&o.number,s=Or(r,"value")||"null",Cr(r,"checked","_q("+i+","+(s=a?"_n("+s+")":s)+")"),Ar(r,"change",Er(i,s),null,!0);else if("input"===$||"textarea"===$)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,l=o?"change":"range"===r?Pr:"input",u="$event.target.value";s&&(u="$event.target.value.trim()"),a&&(u="_n("+u+")");var f=Er(t,u);c&&(f="if($event.target.composing)return;"+f),Cr(e,"value","("+t+")"),Ar(e,l,f,null,!0),(s||a)&&Ar(e,"blur","$forceUpdate()")}(e,_,b);else if(!j.isReservedTag($))return Tr(e,_,b),!1;return!0},text:function(e,t){t.value&&Cr(e,"textContent","_s("+t.value+")")},html:function(e,t){t.value&&Cr(e,"innerHTML","_s("+t.value+")")}},isPreTag:function(e){return"pre"===e},isUnaryTag:to,mustUseProp:Sn,canBeLeftOpenTag:no,isReservedTag:Un,getTagNamespace:Vn,staticKeys:(Go=Wo,Go.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(","))},Qo=e(function(e){return s("type,tag,attrsList,attrsMap,plain,parent,children,attrs"+(e?","+e:""))});function ea(e,t){e&&(Zo=Qo(t.staticKeys||""),Xo=t.isReservedTag||O,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||c(e.tag)||!Xo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Zo)))}(t);if(1===t.type){if(!Xo(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n|^function\s*\(/,na=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,ra={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},ia={esc:"Escape",tab:"Tab",enter:"Enter",space:" ",up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete"]},oa=function(e){return"if("+e+")return null;"},aa={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:oa("$event.target !== $event.currentTarget"),ctrl:oa("!$event.ctrlKey"),shift:oa("!$event.shiftKey"),alt:oa("!$event.altKey"),meta:oa("!$event.metaKey"),left:oa("'button' in $event && $event.button !== 0"),middle:oa("'button' in $event && $event.button !== 1"),right:oa("'button' in $event && $event.button !== 2")};function sa(e,t,n){var r=t?"nativeOn:{":"on:{";for(var i in e)r+='"'+i+'":'+ca(i,e[i])+",";return r.slice(0,-1)+"}"}function ca(t,e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return ca(t,e)}).join(",")+"]";var n=na.test(e.value),r=ta.test(e.value);if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(aa[s])o+=aa[s],ra[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=oa(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+="if(!('button' in $event)&&"+a.map(la).join("&&")+")return null;"),o&&(i+=o),"function($event){"+i+(n?"return "+e.value+"($event)":r?"return ("+e.value+")($event)":e.value)+"}"}return n||r?e.value:"function($event){"+e.value+"}"}function la(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=ra[e],r=ia[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var ua={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(t,n){t.wrapData=function(e){return"_b("+e+",'"+t.tag+"',"+n.value+","+(n.modifiers&&n.modifiers.prop?"true":"false")+(n.modifiers&&n.modifiers.sync?",true":"")+")"}},cloak:$},fa=function(e){this.options=e,this.warn=e.warn||$r,this.transforms=wr(e.modules,"transformCode"),this.dataGenFns=wr(e.modules,"genData"),this.directives=m(m({},ua),e.directives);var t=e.isReservedTag||O;this.maybeComponent=function(e){return!t(e.tag)},this.onceId=0,this.staticRenderFns=[]};function pa(e,t){var n=new fa(t);return{render:"with(this){return "+(e?da(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function da(e,t){if(e.staticRoot&&!e.staticProcessed)return va(e,t);if(e.once&&!e.onceProcessed)return ha(e,t);if(e.for&&!e.forProcessed)return f=t,v=(u=e).for,h=u.alias,m=u.iterator1?","+u.iterator1:"",y=u.iterator2?","+u.iterator2:"",u.forProcessed=!0,(d||"_l")+"(("+v+"),function("+h+m+y+"){return "+(p||da)(u,f)+"})";if(e.if&&!e.ifProcessed)return ma(e,t);if("template"!==e.tag||e.slotTarget){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=_a(e,t),i="_t("+n+(r?","+r:""),o=e.attrs&&"{"+e.attrs.map(function(e){return g(e.name)+":"+e.value}).join(",")+"}",a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)a=e.component,c=t,l=(s=e).inlineTemplate?null:_a(s,c,!0),n="_c("+a+","+ya(s,c)+(l?","+l:"")+")";else{var r=e.plain?void 0:ya(e,t),i=e.inlineTemplate?null:_a(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o':'
',0.weui-cell__bd { + position: relative; + z-index: 1; + background-color: #fff; + background-color: var(--weui-BG-2); +} + +.weui-cell_swiped>.weui-cell__ft { + position: absolute; + right: 0; + top: 0; + bottom: 0; + display: -webkit-box; + display: -webkit-flex; + display: flex; + color: #fff; +} + +.weui-swiped-btn { + display: block; + padding: 16px 1em; + line-height: 1.41176471; + color: inherit; +} + +.weui-swiped-btn_default { + background-color: #ededed; + background-color: var(--weui-BG-0); +} + +.weui-swiped-btn_warn { + background-color: #fa5151; + background-color: var(--weui-RED); +} + +.weui-cell_access { + -webkit-tap-highlight-color: rgba(0,0,0,0); + color: inherit; +} + +.weui-cell_access:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-cell_access .weui-cell__ft { + padding-right: 22px; + position: relative; +} + +.weui-cell_access .weui-cell__ft:after { + content: " "; + width: 12px; + height: 24px; + -webkit-mask-position: 0 0; + mask-position: 0 0; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + -webkit-mask-size: 100%; + mask-size: 100%; + background-color: currentColor; + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); + position: absolute; + top: 50%; + right: 0; + margin-top: -12px; +} + +.weui-cell_link { + color: #576b95; + color: var(--weui-LINK); + font-size: 17px; +} + +.weui-cell_link:first-child:before { + display: block; +} + +.weui-check__label { + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +.weui-check__label:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-check { + position: absolute; + left: -9999px; +} + +.weui-cells_radio .weui-cell__ft { + padding-left: 16px; + font-size: 0; +} + +.weui-cells_radio .weui-check+.weui-icon-checked { + min-width: 16px; + color: transparent; +} + +.weui-cells_radio .weui-check:checked+.weui-icon-checked,.weui-cells_radio .weui-check[aria-checked="true"]+.weui-icon-checked { + color: #07c160; + color: var(--weui-BRAND); + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.657%2018.435L3%2012.778l1.414-1.414%204.95%204.95L20.678%205l1.414%201.414-12.02%2012.021a1%201%200%2001-1.415%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.657%2018.435L3%2012.778l1.414-1.414%204.95%204.95L20.678%205l1.414%201.414-12.02%2012.021a1%201%200%2001-1.415%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); +} + +.weui-cells_checkbox .weui-check__label:before { + left: 55px; +} + +.weui-cells_checkbox .weui-cell__hd { + padding-right: 16px; + font-size: 0; +} + +.weui-cells_checkbox .weui-icon-checked { + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E); +} + +.weui-cells_checkbox .weui-check:checked+.weui-icon-checked,.weui-cells_checkbox .weui-check[aria-checked="true"]+.weui-icon-checked { + color: #07c160; + color: var(--weui-BRAND); + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E); +} + +.weui-label { + display: block; + width: 105px; + word-wrap: break-word; + word-break: break-all; +} + +.weui-input { + width: 100%; + border: 0; + outline: 0; + -webkit-appearance: none; + background-color: transparent; + font-size: inherit; + color: inherit; + height: 1.41176471em; + line-height: 1.41176471; +} + +.weui-input::-webkit-outer-spin-button,.weui-input::-webkit-inner-spin-button { + -webkit-appearance: none; + margin: 0; +} + +.weui-input:focus:not(:placeholder-shown)+.weui-btn_input-clear { + display: inline; +} + +.weui-textarea { + display: block; + border: 0; + resize: none; + background: transparent; + width: 100%; + color: inherit; + font-size: 1em; + line-height: inherit; + outline: 0; +} + +.weui-textarea-counter { + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + text-align: right; + font-size: 14px; +} + +.weui-cell_warn .weui-textarea-counter { + color: #fa5151; + color: var(--weui-RED); +} + +.weui-cells_form .weui-cell_switch:active,.weui-cells_form .weui-cell_vcode:active,.weui-cells_form .weui-cell_readonly:active,.weui-cells_form .weui-cell_disabled:active { + background-color: transparent; +} + +.weui-cells_form .weui-cell__ft { + font-size: 0; +} + +.weui-cells_form .weui-icon-warn { + display: none; +} + +.weui-cells_form input,.weui-cells_form textarea,.weui-cells_form label[for] { + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +.weui-cell_warn { + color: #fa5151; + color: var(--weui-RED); +} + +.weui-cell_warn .weui-icon-warn { + display: inline-block; +} + +.weui-cell_readonly .weui-input:disabled,.weui-cell_disabled .weui-input:disabled,.weui-cell_readonly .weui-textarea:disabled,.weui-cell_disabled .weui-textarea:disabled { + opacity: 1; + -webkit-text-fill-color: rgba(0,0,0,0.5); + -webkit-text-fill-color: var(--weui-FG-1); +} + +.weui-cell_readonly .weui-input[disabled],.weui-cell_disabled .weui-input[disabled],.weui-cell_readonly .weui-textarea[disabled],.weui-cell_disabled .weui-textarea[disabled],.weui-cell_readonly .weui-input[readonly],.weui-cell_disabled .weui-input[readonly],.weui-cell_readonly .weui-textarea[readonly],.weui-cell_disabled .weui-textarea[readonly] { + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); +} + +.weui-btn_input-clear { + display: none; + padding-left: 8px; +} + +.weui-btn_input-clear [class*="weui-icon-"] { + width: 18px; +} + +.weui-form-preview { + position: relative; + background-color: #fff; + background-color: var(--weui-BG-2); +} + +.weui-form-preview:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-form-preview:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-form-preview__hd { + position: relative; + padding: 16px; + text-align: right; + line-height: 2.5em; +} + +.weui-form-preview__hd:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); + left: 16px; +} + +.weui-form-preview__hd .weui-form-preview__value { + font-style: normal; + font-size: 1.6em; +} + +.weui-form-preview__bd { + padding: 16px; + font-size: 0.9em; + text-align: right; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + line-height: 2; +} + +.weui-form-preview__ft { + position: relative; + line-height: 50px; + display: -webkit-box; + display: -webkit-flex; + display: flex; +} + +.weui-form-preview__ft:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-DIALOG-LINE-COLOR); + color: rgba(0,0,0,0.1); + color: var(--weui-DIALOG-LINE-COLOR); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-form-preview__item { + overflow: hidden; +} + +.weui-form-preview__label { + float: left; + margin-right: 1em; + min-width: 4em; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + text-align: justify; + text-align-last: justify; +} + +.weui-form-preview__value { + display: block; + overflow: hidden; + word-break: normal; + word-wrap: break-word; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-form-preview__btn { + position: relative; + display: block; + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + color: #576b95; + color: var(--weui-LINK); + text-align: center; + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +button.weui-form-preview__btn { + background-color: transparent; + border: 0; + outline: 0; + line-height: inherit; + font-size: inherit; +} + +.weui-form-preview__btn:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-form-preview__btn:after { + content: " "; + position: absolute; + left: 0; + top: 0; + width: 1px; + bottom: 0; + border-left: 1px solid rgba(0,0,0,0.1); + border-left: 1px solid var(--weui-DIALOG-LINE-COLOR); + color: rgba(0,0,0,0.1); + color: var(--weui-DIALOG-LINE-COLOR); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); +} + +.weui-form-preview__btn:first-child:after { + display: none; +} + +.weui-form-preview__btn_default { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-HALF); +} + +.weui-form-preview__btn_primary { + color: #576b95; + color: var(--weui-LINK); +} + +.weui-form-preview__list { + padding-top: 24px; + padding-bottom: 24px; + line-height: 1.4; + font-size: 14px; + position: relative; +} + +.weui-form-preview__list:before { + content: ""; + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-form-preview__list:last-child { + padding-bottom: 0; +} + +.weui-form-preview__list .weui-form-preview__label { + text-align: left; + text-align-last: unset; + width: 6em; +} + +.weui-form-preview__list .weui-form-preview__value { + -webkit-hyphens: auto; + hyphens: auto; +} + +.weui-form-preview__list .weui-form-preview__item { + margin-top: 12px; +} + +.weui-form-preview__list .weui-form-preview__item:first-child { + margin-top: 0; +} + +.weui-form-preview__list>.weui-cells__title:first-child { + margin-top: 0; +} + +.weui-cell_select { + padding: 0; +} + +.weui-cell_select .weui-select { + padding-right: 30px; +} + +.weui-cell_select .weui-cell__bd:after { + content: " "; + width: 12px; + height: 24px; + -webkit-mask-position: 0 0; + mask-position: 0 0; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + -webkit-mask-size: 100%; + mask-size: 100%; + background-color: currentColor; + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); + position: absolute; + top: 50%; + right: 16px; + margin-top: -12px; +} + +.weui-select { + -webkit-appearance: none; + border: 0; + outline: 0; + background-color: transparent; + width: 100%; + font-size: inherit; + height: 56px; + line-height: 56px; + position: relative; + z-index: 1; + padding-left: 16px; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-cell_select-before { + padding-right: 16px; +} + +.weui-cell_select-before .weui-select { + width: 105px; + box-sizing: border-box; +} + +.weui-cell_select-before .weui-cell__hd { + position: relative; +} + +.weui-cell_select-before .weui-cell__hd:after { + content: " "; + position: absolute; + right: 0; + top: 0; + width: 1px; + bottom: 0; + border-right: 1px solid rgba(0,0,0,0.1); + border-right: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 100% 0; + transform-origin: 100% 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); +} + +.weui-cell_select-before .weui-cell__hd:before { + content: " "; + width: 12px; + height: 24px; + -webkit-mask-position: 0 0; + mask-position: 0 0; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + -webkit-mask-size: 100%; + mask-size: 100%; + background-color: currentColor; + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E); + position: absolute; + top: 50%; + right: 16px; + margin-top: -12px; +} + +.weui-cell_select-before .weui-cell__bd { + padding-left: 16px; +} + +.weui-cell_select-before .weui-cell__bd:after { + display: none; +} + +.weui-cell_select-before.weui-cell_access .weui-cell__hd { + line-height: 56px; + padding-left: 32px; +} + +.weui-cell_select-after { + padding-left: 16px; +} + +.weui-cell_select-after .weui-select { + padding-left: 0; +} + +.weui-cell_select-after.weui-cell_access .weui-cell__bd { + line-height: 56px; +} + +.weui-cell_vcode { + padding-top: 0; + padding-right: 0; + padding-bottom: 0; +} + +.weui-vcode-img { + margin-left: 5px; + height: 56px; + vertical-align: middle; +} + +.weui-vcode-btn { + display: inline-block; + height: 56px; + margin-left: 5px; + padding: 0 0.6em 0 0.7em; + line-height: 56px; + vertical-align: middle; + font-size: 17px; + color: #576b95; + color: var(--weui-LINK); + position: relative; +} + +.weui-vcode-btn:before { + content: " "; + position: absolute; + left: 0; + top: 0; + width: 1px; + bottom: 0; + border-left: 1px solid rgba(0,0,0,0.1); + border-left: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); +} + +button.weui-vcode-btn { + background-color: transparent; + border: 0; + outline: 0; +} + +.weui-vcode-btn:active { + color: rgba(87,107,149,0.5); + color: var(--weui-LINK-ACTIVE); +} + +.weui-gallery { + display: none; + position: fixed; + top: 0; + right: 0; + bottom: 0; + left: 0; + background-color: #000; + z-index: 1000; +} + +.weui-gallery__img,.weui-gallery__opr { + position: absolute; + left: 0; + left: constant(safe-area-inset-left); + left: env(safe-area-inset-left); + right: 0; + right: constant(safe-area-inset-right); + right: env(safe-area-inset-right); +} + +.weui-gallery__img { + top: 0; + top: constant(safe-area-inset-top); + top: env(safe-area-inset-top); + bottom: 60px; + bottom: calc(60px + constant(safe-area-inset-bottom)); + bottom: calc(60px + env(safe-area-inset-bottom)); + width: 100%; + background: center center no-repeat; + background-size: contain; +} + +.weui-gallery__opr { + position: absolute; + bottom: 0; + padding-bottom: 0; + padding-bottom: constant(safe-area-inset-bottom); + padding-bottom: env(safe-area-inset-bottom); + background-color: #0d0d0d; + color: #fff; + color: var(--weui-WHITE); + line-height: 60px; + text-align: center; +} + +.weui-gallery__del { + display: block; +} + +.weui-cell_switch { + padding-top: 12px; + padding-bottom: 12px; +} + +.weui-switch { + -webkit-appearance: none; + appearance: none; +} + +.weui-switch,.weui-switch-cp__box { + position: relative; + width: 52px; + height: 32px; + border: 2px solid rgba(0,0,0,0.1); + border: 2px solid var(--weui-FG-3); + outline: 0; + border-radius: 16px; + box-sizing: border-box; + -webkit-transition: background-color 0.1s,border 0.1s; + transition: background-color 0.1s,border 0.1s; +} + +.weui-switch:before,.weui-switch-cp__box:before { + content: " "; + position: absolute; + top: 0; + left: 0; + bottom: 0; + right: 0; + border-radius: 15px; + background-color: #f7f7f7; + background-color: var(--weui-BG-3); + -webkit-transition: -webkit-transform 0.35s cubic-bezier(0.45,1,0.4,1); + transition: -webkit-transform 0.35s cubic-bezier(0.45,1,0.4,1); + transition: transform 0.35s cubic-bezier(0.45,1,0.4,1); + transition: transform 0.35s cubic-bezier(0.45,1,0.4,1),-webkit-transform 0.35s cubic-bezier(0.45,1,0.4,1); +} + +.weui-switch:after,.weui-switch-cp__box:after { + content: " "; + position: absolute; + top: 0; + left: 0; + width: 28px; + height: 28px; + border-radius: 15px; + background-color: #fff; + box-shadow: 0 1px 3px rgba(0,0,0,0.4); + -webkit-transition: -webkit-transform 0.35s cubic-bezier(0.4,0.4,0.25,1.35); + transition: -webkit-transform 0.35s cubic-bezier(0.4,0.4,0.25,1.35); + transition: transform 0.35s cubic-bezier(0.4,0.4,0.25,1.35); + transition: transform 0.35s cubic-bezier(0.4,0.4,0.25,1.35),-webkit-transform 0.35s cubic-bezier(0.4,0.4,0.25,1.35); +} + +.weui-switch:checked,.weui-switch-cp__input:checked+.weui-switch-cp__box,.weui-switch-cp__input[aria-checked="true"]+.weui-switch-cp__box { + border-color: #07c160; + border-color: var(--weui-BRAND); + background-color: #07c160; + background-color: var(--weui-BRAND); +} + +.weui-switch:checked:before,.weui-switch-cp__input:checked+.weui-switch-cp__box:before,.weui-switch-cp__input[aria-checked="true"]+.weui-switch-cp__box:before { + -webkit-transform: scale(0); + transform: scale(0); +} + +.weui-switch:checked:after,.weui-switch-cp__input:checked+.weui-switch-cp__box:after,.weui-switch-cp__input[aria-checked="true"]+.weui-switch-cp__box:after { + -webkit-transform: translateX(20px); + transform: translateX(20px); +} + +.weui-switch-cp__input { + position: absolute; + left: -9999px; +} + +.weui-switch-cp__box { + display: block; +} + +.weui-cell_uploader { + padding-bottom: 24px; +} + +.weui-uploader { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; +} + +.weui-uploader__hd { + display: -webkit-box; + display: -webkit-flex; + display: flex; + padding-bottom: 16px; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; +} + +.weui-uploader__title { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; +} + +.weui-uploader__info { + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); +} + +.weui-uploader__bd { + margin-bottom: -8px; + margin-right: -8px; + overflow: hidden; +} + +.weui-uploader__files { + list-style: none; +} + +.weui-uploader__file { + float: left; + margin-right: 8px; + margin-bottom: 8px; + width: 96px; + height: 96px; + background: no-repeat center center; + background-size: cover; +} + +.weui-uploader__file_status { + position: relative; +} + +.weui-uploader__file_status:before { + content: " "; + position: absolute; + top: 0; + right: 0; + bottom: 0; + left: 0; + background-color: rgba(0,0,0,0.5); +} + +.weui-uploader__file_status .weui-uploader__file-content { + display: block; +} + +.weui-uploader__file-content { + display: none; + position: absolute; + top: 50%; + left: 50%; + -webkit-transform: translate(-50%,-50%); + transform: translate(-50%,-50%); + color: #fff; + color: var(--weui-WHITE); +} + +.weui-uploader__file-content .weui-icon-warn { + display: inline-block; +} + +.weui-uploader__input-box { + float: left; + position: relative; + margin-right: 8px; + margin-bottom: 8px; + width: 96px; + height: 96px; + box-sizing: border-box; + background-color: #ededed; +} + +body[data-weui-theme='dark'] .weui-uploader__input-box { + background-color: #2e2e2e; +} + +@media (prefers-color-scheme:dark) { + body:not([data-weui-theme='light']) .weui-uploader__input-box { + background-color: #2e2e2e; + } +} + +.weui-uploader__input-box:before,.weui-uploader__input-box:after { + content: " "; + position: absolute; + top: 50%; + left: 50%; + -webkit-transform: translate(-50%,-50%); + transform: translate(-50%,-50%); + background-color: #a3a3a3; +} + +body[data-weui-theme='dark'] .weui-uploader__input-box:before,body[data-weui-theme='dark'] .weui-uploader__input-box:after { + background-color: #6d6d6d; +} + +@media (prefers-color-scheme:dark) { + body:not([data-weui-theme='light']) .weui-uploader__input-box:before,body:not([data-weui-theme='light']) .weui-uploader__input-box:after { + background-color: #6d6d6d; + } +} + +.weui-uploader__input-box:before { + width: 2px; + height: 32px; +} + +.weui-uploader__input-box:after { + width: 32px; + height: 2px; +} + +.weui-uploader__input-box:active:before,.weui-uploader__input-box:active:after { + opacity: 0.7; +} + +.weui-uploader__input { + position: absolute; + z-index: 1; + top: 0; + left: 0; + width: 100%; + height: 100%; + opacity: 0; + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +.weui-msg__desc a,.weui-msg__desc-primary a,.weui-msg__tips a { + color: #576b95; + color: var(--weui-LINK); + display: inline-block; + vertical-align: baseline; +} + +.weui-msg { + padding-top: 48px; + padding: calc(48px + constant(safe-area-inset-top)) constant(safe-area-inset-right) constant(safe-area-inset-bottom) constant(safe-area-inset-left); + padding: calc(48px + env(safe-area-inset-top)) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left); + text-align: center; + line-height: 1.4; + min-height: 100%; + box-sizing: border-box; + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -webkit-flex-direction: column; + flex-direction: column; + background-color: #fff; + background-color: var(--weui-BG-2); +} + +.weui-msg__icon-area { + margin-bottom: 32px; +} + +.weui-msg__text-area { + margin-bottom: 32px; + padding: 0 32px; + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + line-height: 1.6; + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; +} + +.weui-msg__text-area:first-child { + padding-top: 96px; +} + +.weui-msg__title { + margin-bottom: 16px; + font-weight: 400; + font-size: 22px; + color: #191919; + -webkit-text-stroke: 0.02em; +} + +body[data-weui-theme='dark'] .weui-msg__title { + color: #D1D1D1; +} + +@media (prefers-color-scheme:dark) { + body:not([data-weui-theme='light']) .weui-msg__title { + color: #D1D1D1; + } +} + +@supports (-webkit-overflow-scrolling:touch) { + .weui-msg__title { + font-weight: 500; + -webkit-text-stroke: initial; + } +} + +.weui-msg__desc { + font-size: 17px; + font-weight: 400; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + margin-bottom: 16px; +} + +.weui-msg__desc-primary { + font-size: 14px; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + margin-bottom: 16px; +} + +.weui-msg__custom-area { + text-align: left; + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; + margin-bottom: 16px; +} + +.weui-msg__title+.weui-msg__custom-area { + margin-top: 48px; +} + +.weui-msg__desc+.weui-msg__custom-area,.weui-msg__desc-primary+.weui-msg__custom-area { + margin-top: 40px; +} + +.weui-msg__custom-area .weui-cells__group_form .weui-cells:before,.weui-msg__custom-area .weui-cells__group_form .weui-cells:after { + left: 0; + right: 0; +} + +.weui-msg__custom-area .weui-cells__group_form .weui-cell { + padding-left: 0; + padding-right: 0; +} + +.weui-msg__custom-area .weui-cells__group_form .weui-cell:before { + left: 0; + right: 0; +} + +.weui-msg__opr-area { + margin-bottom: 16px; +} + +.weui-msg__opr-area .weui-btn-area { + margin: 0; +} + +.weui-msg__opr-area .weui-btn+.weui-btn { + margin-bottom: 16px; +} + +.weui-msg__opr-area:last-child { + margin-bottom: 96px; +} + +.weui-msg__opr-area+.weui-msg__extra-area { + margin-top: 48px; +} + +.weui-msg__tips-area { + margin-bottom: 16px; + padding: 0 40px; + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; +} + +.weui-msg__opr-area+.weui-msg__tips-area { + margin-bottom: 48px; +} + +.weui-msg__tips-area:last-child { + margin-bottom: 64px; +} + +.weui-msg__tips { + font-size: 12px; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); +} + +.weui-msg__extra-area { + margin-bottom: 24px; + font-size: 12px; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); +} + +.weui-msg__extra-area a,.weui-msg__extra-area navigator { + color: #576b95; + color: var(--weui-LINK); +} + +.weui-msg__extra-area navigator { + display: inline; +} + +.weui-msg_align-top .weui-msg__text-area:first-child { + padding-top: 0; +} + +.weui-cells__group_form:first-child .weui-cells__title { + margin-top: 0; +} + +.weui-cells__group_form .weui-cells__title { + margin-top: 24px; + margin-bottom: 8px; + padding: 0 32px; +} + +.weui-cells__group_form .weui-cells:before,.weui-cells__group_form .weui-cell:before { + left: 32px; + right: 32px; +} + +.weui-cells__group_form .weui-cells_checkbox .weui-check__label:before { + left: 72px; +} + +.weui-cells__group_form .weui-cells:after { + left: 32px; + right: 32px; +} + +.weui-cells__group_form .weui-cell { + padding: 16px 32px; +} + +.weui-cells__group_form .weui-cell:not(.weui-cell_link) { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-cells__group_form .weui-cell__hd { + padding-right: 16px; +} + +.weui-cells__group_form .weui-cell__ft { + padding-left: 16px; +} + +.weui-cells__group_form .weui-cell_warn input { + color: #fa5151; + color: var(--weui-RED); +} + +.weui-cells__group_form .weui-label { + max-width: 5em; + margin-right: 8px; +} + +.weui-cells__group_form .weui-cells__tips { + margin-top: 8px; + padding: 0 32px; + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); +} + +.weui-cells__group_form .weui-cells__tips a { + font-weight: 700; +} + +.weui-cells__group_form .weui-cells__tips_warn { + color: #fa5151; + color: var(--weui-RED); +} + +.weui-cells__group_form .weui-cell_vcode { + padding: 12px 32px; +} + +.weui-cells__group_form .weui-vcode-btn { + font-size: 16px; + padding: 0 12px; + margin-left: 0; + height: auto; + width: auto; + line-height: 2em; + color: #06ae56; + color: var(--weui-BTN-DEFAULT-COLOR); + background-color: #f2f2f2; + background-color: var(--weui-BTN-DEFAULT-BG); +} + +.weui-cells__group_form .weui-vcode-btn:before { + display: none; +} + +.weui-cells__group_form .weui-cell_select { + padding: 0; +} + +.weui-cells__group_form .weui-cell_select .weui-select { + padding: 0 32px; +} + +.weui-cells__group_form .weui-cell_select .weui-cell__bd:after { + right: 32px; +} + +.weui-cells__group_form .weui-cell_select-before .weui-label { + margin-right: 24px; +} + +.weui-cells__group_form .weui-cell_select-before .weui-select { + padding-right: 24px; + box-sizing: initial; +} + +.weui-cells__group_form .weui-cell_select-after { + padding-left: 32px; +} + +.weui-cells__group_form .weui-cell_select-after .weui-select { + padding-left: 0; +} + +.weui-cells__group_form .weui-cell_switch { + padding: 12px 32px; +} + +.weui-form { + padding: 56px 0 0; + padding: calc(56px + constant(safe-area-inset-top)) constant(safe-area-inset-right) constant(safe-area-inset-bottom) constant(safe-area-inset-left); + padding: calc(56px + env(safe-area-inset-top)) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left); + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -webkit-flex-direction: column; + flex-direction: column; + line-height: 1.4; + min-height: 100%; + box-sizing: border-box; + background-color: #fff; + background-color: var(--weui-BG-2); +} + +.weui-form .weui-footer,.weui-form .weui-footer__link { + font-size: 14px; +} + +.weui-form .weui-agree { + padding: 0; +} + +.weui-form__text-area { + padding: 0 32px; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + text-align: center; +} + +.weui-form__control-area { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + margin: 48px 0; +} + +.weui-form__tips-area { + overflow: hidden; +} + +.weui-form__tips-area,.weui-form__extra-area { + margin-bottom: 24px; + text-align: center; +} + +.weui-form__opr-area { + margin-bottom: 64px; +} + +.weui-form__opr-area:last-child { + margin-bottom: 96px; +} + +.weui-form__title { + font-size: 22px; + font-weight: 700; + line-height: 1.36; +} + +.weui-form__desc { + font-size: 17px; + margin-top: 16px; +} + +.weui-form__tips { + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + font-size: 14px; +} + +.weui-form__tips a,.weui-form__tips navigator { + color: #576b95; + color: var(--weui-LINK); +} + +.weui-form__tips navigator { + display: inline; +} + +.weui-article { + padding: 24px 16px; + padding: 24px calc(16px + constant(safe-area-inset-right)) calc(24px + constant(safe-area-inset-bottom)) calc(16px + constant(safe-area-inset-left)); + padding: 24px calc(16px + env(safe-area-inset-right)) calc(24px + env(safe-area-inset-bottom)) calc(16px + env(safe-area-inset-left)); + font-size: 17px; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; +} + +.weui-article section { + margin-bottom: 1.5em; +} + +.weui-article h1 { + font-size: 22px; + font-weight: 700; + margin-bottom: 0.9em; + line-height: 1.4; +} + +.weui-article h2 { + font-size: 17px; + font-weight: 700; + margin-bottom: 0.34em; + line-height: 1.4; +} + +.weui-article h3 { + font-weight: 700; + font-size: 15px; + margin-bottom: 0.34em; + line-height: 1.4; +} + +.weui-article * { + max-width: 100%; + box-sizing: border-box; + word-wrap: break-word; +} + +.weui-article p { + margin: 0 0 0.8em; +} + +.weui-tabbar { + display: -webkit-box; + display: -webkit-flex; + display: flex; + position: relative; + z-index: 500; + background-color: #f7f7f7; + background-color: var(--weui-BG-1); +} + +.weui-tabbar:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-tabbar__item { + display: block; + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + padding: 8px 0; + padding-bottom: calc(8px + constant(safe-area-inset-bottom)); + padding-bottom: calc(8px + env(safe-area-inset-bottom)); + font-size: 0; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + text-align: center; + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +.weui-tabbar__item:first-child { + padding-left: constant(safe-area-inset-left); + padding-left: env(safe-area-inset-left); +} + +.weui-tabbar__item:last-child { + padding-right: constant(safe-area-inset-right); + padding-right: env(safe-area-inset-right); +} + +.weui-tabbar__item.weui-bar__item_on .weui-tabbar__icon,.weui-tabbar__item.weui-bar__item_on .weui-tabbar__icon>i,.weui-tabbar__item.weui-bar__item_on .weui-tabbar__label { + color: #07c160; + color: var(--weui-BRAND); +} + +.weui-tabbar__icon { + display: inline-block; + width: 28px; + height: 28px; + margin-bottom: 2px; +} + +i.weui-tabbar__icon,.weui-tabbar__icon>i { + font-size: 24px; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); +} + +.weui-tabbar__icon img { + width: 100%; + height: 100%; +} + +.weui-tabbar__label { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + font-size: 10px; + line-height: 1.4; +} + +.weui-navbar { + display: -webkit-box; + display: -webkit-flex; + display: flex; + position: relative; + z-index: 500; + background-color: #fff; + background-color: var(--weui-BG-2); + padding-top: constant(safe-area-inset-top); + padding-top: env(safe-area-inset-top); +} + +.weui-navbar:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-navbar+.weui-tab__panel { + padding-bottom: constant(safe-area-inset-bottom); + padding-bottom: env(safe-area-inset-bottom); +} + +.weui-navbar__item { + position: relative; + display: block; + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + padding: 16px 0; + padding-top: calc(16px + constant(safe-area-inset-top)); + padding-top: calc(16px + env(safe-area-inset-top)); + text-align: center; + font-size: 17px; + line-height: 1.41176471; + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +.weui-navbar__item:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-navbar__item.weui-bar__item_on { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-navbar__item:after { + content: " "; + position: absolute; + right: 0; + top: 0; + width: 1px; + bottom: 0; + border-right: 1px solid rgba(0,0,0,0.1); + border-right: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 100% 0; + transform-origin: 100% 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); +} + +.weui-navbar__item:first-child { + padding-left: constant(safe-area-inset-left); + padding-left: env(safe-area-inset-left); +} + +.weui-navbar__item:last-child { + padding-right: constant(safe-area-inset-right); + padding-right: env(safe-area-inset-right); +} + +.weui-navbar__item:last-child:after { + display: none; +} + +.weui-tab { + display: -webkit-box; + display: -webkit-flex; + display: flex; + height: 100%; + box-sizing: border-box; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -webkit-flex-direction: column; + flex-direction: column; +} + +.weui-tab__panel { + box-sizing: border-box; + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + overflow: auto; + -webkit-overflow-scrolling: touch; +} + +.weui-tab__content { + display: none; +} + +.weui-progress { + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; +} + +.weui-progress__bar { + background-color: #ededed; + background-color: var(--weui-BG-0); + height: 3px; + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; +} + +.weui-progress__inner-bar { + width: 0; + height: 100%; + background-color: #07c160; + background-color: var(--weui-BRAND); +} + +.weui-progress__opr { + display: block; + margin-left: 15px; + font-size: 0; +} + +.weui-panel { + background-color: #fff; + background-color: var(--weui-BG-2); + margin-top: 10px; + position: relative; + overflow: hidden; +} + +.weui-panel:first-child { + margin-top: 0; +} + +.weui-panel:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-panel:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-panel__hd { + padding: 16px 16px 13px; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + font-size: 15px; + font-weight: 700; + position: relative; +} + +.weui-panel__hd:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); + left: 15px; +} + +.weui-media-box { + padding: 16px; + position: relative; +} + +.weui-media-box:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); + left: 16px; +} + +.weui-media-box:first-child:before { + display: none; +} + +a.weui-media-box { + color: #000; + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +a.weui-media-box:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-media-box__title { + font-weight: 400; + font-size: 17px; + line-height: 1.4; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + width: auto; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + word-wrap: normal; + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; +} + +.weui-media-box__desc { + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + font-size: 14px; + line-height: 1.4; + padding-top: 4px; + overflow: hidden; + text-overflow: ellipsis; + display: -webkit-box; + -webkit-box-orient: vertical; + -webkit-line-clamp: 2; + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; +} + +.weui-media-box__info { + margin-top: 16px; + padding-bottom: 4px; + font-size: 13px; + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + line-height: 1em; + list-style: none; + overflow: hidden; +} + +.weui-media-box__info__meta { + float: left; + padding-right: 1em; +} + +.weui-media-box__info__meta_extra { + padding-left: 1em; + border-left: 1px solid rgba(0,0,0,0.3); + border-left: 1px solid var(--weui-FG-2); +} + +.weui-media-box_appmsg { + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; +} + +.weui-media-box_appmsg .weui-media-box__hd { + margin-right: 16px; + width: 60px; + height: 60px; + line-height: 60px; + text-align: center; +} + +.weui-media-box_appmsg .weui-media-box__thumb { + width: 100%; + max-height: 100%; + vertical-align: top; +} + +.weui-media-box_appmsg .weui-media-box__bd { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + min-width: 0; +} + +.weui-media-box_small-appmsg { + padding: 0; +} + +.weui-media-box_small-appmsg .weui-cells { + margin-top: 0; +} + +.weui-media-box_small-appmsg .weui-cells:before { + display: none; +} + +.weui-grids { + position: relative; + overflow: hidden; +} + +.weui-grids:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-grids:after { + content: " "; + position: absolute; + left: 0; + top: 0; + width: 1px; + bottom: 0; + border-left: 1px solid rgba(0,0,0,0.1); + border-left: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); +} + +.weui-grid { + position: relative; + float: left; + padding: 20px 10px; + width: 33.33333333%; + box-sizing: border-box; +} + +.weui-grid:before { + content: " "; + position: absolute; + right: 0; + top: 0; + width: 1px; + bottom: 0; + border-right: 1px solid rgba(0,0,0,0.1); + border-right: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 100% 0; + transform-origin: 100% 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); +} + +.weui-grid:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-grid:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-grid__icon { + width: 28px; + height: 28px; + margin: 0 auto; +} + +.weui-grid__icon img { + display: block; + width: 100%; + height: 100%; +} + +.weui-grid__icon+.weui-grid__label { + margin-top: 4px; +} + +.weui-grid__label { + display: block; + text-align: center; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + font-size: 14px; + white-space: nowrap; + text-overflow: ellipsis; + overflow: hidden; +} + +.weui-footer { + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + font-size: 14px; + line-height: 1.4; + text-align: center; +} + +.weui-footer a,.weui-footer navigator { + color: #576b95; + color: var(--weui-LINK); +} + +.weui-footer navigator { + display: inline; +} + +.weui-footer_fixed-bottom { + position: fixed; + bottom: 0; + left: 0; + right: 0; + padding-top: 16px; + padding-bottom: 16px; + padding-bottom: calc(16px + constant(safe-area-inset-bottom)); + padding-bottom: calc(16px + env(safe-area-inset-bottom)); + left: constant(safe-area-inset-left); + left: env(safe-area-inset-left); + right: constant(safe-area-inset-right); + right: env(safe-area-inset-right); +} + +.weui-footer__links { + font-size: 0; +} + +.weui-footer__link { + display: inline-block; + vertical-align: top; + margin: 0 8px; + position: relative; + font-size: 14px; +} + +.weui-footer__link:before { + content: " "; + position: absolute; + left: 0; + top: 0; + width: 1px; + bottom: 0; + border-left: 1px solid rgba(0,0,0,0.1); + border-left: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); + left: -8px; + top: 0.36em; + bottom: 0.36em; +} + +.weui-footer__link:first-child:before { + display: none; +} + +.weui-footer__text { + padding: 0 16px; + font-size: 12px; +} + +.weui-flex { + display: -webkit-box; + display: -webkit-flex; + display: flex; +} + +.weui-flex__item { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; +} + +.weui-dialog { + position: fixed; + z-index: 5000; + top: 50%; + left: 16px; + right: 16px; + -webkit-transform: translate(0,-50%); + transform: translate(0,-50%); + background-color: #fff; + background-color: var(--weui-BG-2); + text-align: center; + border-radius: 12px; + overflow: hidden; + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-flex-direction: column; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + flex-direction: column; + max-height: 90%; +} + +.weui-dialog__hd { + padding: 32px 24px 16px; +} + +.weui-dialog__title { + font-weight: 700; + font-size: 17px; + line-height: 1.4; +} + +.weui-dialog__bd { + overflow-y: auto; + -webkit-overflow-scrolling: touch; + padding: 0 24px; + margin-bottom: 32px; + font-size: 17px; + line-height: 1.4; + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); +} + +.weui-dialog__bd:first-child { + min-height: 40px; + padding: 32px 24px 0; + font-weight: 700; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-flex-direction: column; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + flex-direction: column; + -webkit-box-pack: center; + -webkit-justify-content: center; + justify-content: center; +} + +.weui-dialog__ft { + position: relative; + line-height: 56px; + min-height: 56px; + font-size: 17px; + display: -webkit-box; + display: -webkit-flex; + display: flex; +} + +.weui-dialog__ft:after { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-DIALOG-LINE-COLOR); + color: rgba(0,0,0,0.1); + color: var(--weui-DIALOG-LINE-COLOR); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-dialog__btn { + display: block; + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + color: #576b95; + color: var(--weui-LINK); + font-weight: 700; + text-decoration: none; + -webkit-tap-highlight-color: rgba(0,0,0,0); + position: relative; +} + +.weui-dialog__btn:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-dialog__btn:after { + content: " "; + position: absolute; + left: 0; + top: 0; + width: 1px; + bottom: 0; + border-left: 1px solid rgba(0,0,0,0.1); + border-left: 1px solid var(--weui-DIALOG-LINE-COLOR); + color: rgba(0,0,0,0.1); + color: var(--weui-DIALOG-LINE-COLOR); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleX(0.5); + transform: scaleX(0.5); +} + +.weui-dialog__btn:first-child:after { + display: none; +} + +.weui-dialog__btn_default { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-HALF); +} + +.weui-skin_android .weui-dialog { + text-align: left; + box-shadow: 0 6px 30px 0 rgba(0,0,0,0.1); +} + +.weui-skin_android .weui-dialog__title { + font-size: 22px; + line-height: 1.4; +} + +.weui-skin_android .weui-dialog__hd { + text-align: left; +} + +.weui-skin_android .weui-dialog__bd { + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + text-align: left; +} + +.weui-skin_android .weui-dialog__bd:first-child { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-skin_android .weui-dialog__ft { + display: block; + text-align: right; + line-height: 40px; + min-height: 40px; + padding: 0 24px 16px; +} + +.weui-skin_android .weui-dialog__ft:after { + display: none; +} + +.weui-skin_android .weui-dialog__btn { + display: inline-block; + vertical-align: top; + padding: 0 0.8em; +} + +.weui-skin_android .weui-dialog__btn:after { + display: none; +} + +.weui-skin_android .weui-dialog__btn:last-child { + margin-right: -0.8em; +} + +.weui-skin_android .weui-dialog__btn_default { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-HALF); +} + +@media screen and (min-width:352px) { + .weui-dialog { + width: 320px; + margin: 0 auto; + } +} + +.weui-half-screen-dialog { + position: fixed; + left: 0; + right: 0; + bottom: 0; + max-height: 75%; + z-index: 5000; + line-height: 1.4; + background-color: #fff; + background-color: var(--weui-BG-2); + border-top-left-radius: 12px; + border-top-right-radius: 12px; + overflow: hidden; + padding: 0 24px; + padding: 0 calc(24px + constant(safe-area-inset-right)) constant(safe-area-inset-bottom) calc(24px + constant(safe-area-inset-left)); + padding: 0 calc(24px + env(safe-area-inset-right)) env(safe-area-inset-bottom) calc(24px + env(safe-area-inset-left)); +} + +@media only screen and (max-height:558px) { + .weui-half-screen-dialog { + max-height: none; + } +} + +.weui-half-screen-dialog__hd { + font-size: 8px; + height: 8em; + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; +} + +.weui-half-screen-dialog__hd .weui-icon-btn { + position: absolute; + top: 50%; + -webkit-transform: translateY(-50%); + transform: translateY(-50%); +} + +.weui-half-screen-dialog__hd .weui-icon-btn:active { + opacity: 0.5; +} + +.weui-half-screen-dialog__hd__side { + position: relative; + left: -8px; +} + +.weui-half-screen-dialog__hd__main { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; +} + +.weui-half-screen-dialog__hd__side+.weui-half-screen-dialog__hd__main { + text-align: center; + padding: 0 40px; +} + +.weui-half-screen-dialog__hd__main+.weui-half-screen-dialog__hd__side { + right: -8px; + left: auto; +} + +.weui-half-screen-dialog__hd__main+.weui-half-screen-dialog__hd__side .weui-icon-btn { + right: 0; +} + +.weui-half-screen-dialog__title { + display: block; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + font-weight: 700; + font-size: 15px; +} + +.weui-half-screen-dialog__subtitle { + display: block; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + font-size: 10px; +} + +.weui-half-screen-dialog__bd { + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; + overflow-y: auto; + padding-top: 4px; + padding-bottom: 56px; + font-size: 14px; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-half-screen-dialog__desc { + font-size: 17px; + font-weight: 700; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + line-height: 1.4; +} + +.weui-half-screen-dialog__tips { + padding-top: 16px; + font-size: 14px; + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + line-height: 1.4; +} + +.weui-half-screen-dialog__ft { + padding: 0 0 64px; + text-align: center; +} + +.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2),.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2)+.weui-btn { + display: inline-block; + vertical-align: top; + margin: 0 8px; + width: 120px; +} + +.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2):first-child,.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2)+.weui-btn:first-child { + margin-left: 0; +} + +.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2):last-child,.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2)+.weui-btn:last-child { + margin-right: 0; +} + +.weui-half-screen-dialog__btn-area+.weui-half-screen-dialog__attachment-area { + margin-top: 24px; + margin-bottom: -44px; +} + +.weui-icon-btn { + outline: 0; + -webkit-appearance: none; + -webkit-tap-highlight-color: rgba(0,0,0,0); + border-width: 0; + background-color: transparent; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + font-size: 0; +} + +.weui-icon-more { + display: inline-block; + vertical-align: middle; + width: 24px; + height: 24px; + -webkit-mask: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E %3Cpath fill-opacity='.9' fill-rule='evenodd' d='M5 10.25a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5z'/%3E%3C/svg%3E") no-repeat 50% 50%; + mask: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E %3Cpath fill-opacity='.9' fill-rule='evenodd' d='M5 10.25a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5z'/%3E%3C/svg%3E") no-repeat 50% 50%; + -webkit-mask-size: cover; + mask-size: cover; + background-color: currentColor; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-icon-btn_goback { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + display: inline-block; + vertical-align: middle; + width: 12px; + height: 24px; + -webkit-mask: url("data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10%2019.438L8.955%2020.5l-7.666-7.79a1.02%201.02%200%20010-1.42L8.955%203.5%2010%204.563%202.682%2012%2010%2019.438z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E") no-repeat 50% 50%; + mask: url("data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10%2019.438L8.955%2020.5l-7.666-7.79a1.02%201.02%200%20010-1.42L8.955%203.5%2010%204.563%202.682%2012%2010%2019.438z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E") no-repeat 50% 50%; + -webkit-mask-size: cover; + mask-size: cover; + background-color: currentColor; +} + +.weui-icon-btn_close { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + display: inline-block; + vertical-align: middle; + width: 14px; + height: 24px; + -webkit-mask: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.25%2010.693L6.057%204.5%205%205.557l6.193%206.193L5%2017.943%206.057%2019l6.193-6.193L18.443%2019l1.057-1.057-6.193-6.193L19.5%205.557%2018.443%204.5z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E") no-repeat 50% 50%; + mask: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.25%2010.693L6.057%204.5%205%205.557l6.193%206.193L5%2017.943%206.057%2019l6.193-6.193L18.443%2019l1.057-1.057-6.193-6.193L19.5%205.557%2018.443%204.5z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E") no-repeat 50% 50%; + -webkit-mask-size: cover; + mask-size: cover; + background-color: currentColor; +} + +.weui-toast { + position: fixed; + z-index: 5000; + width: 136px; + height: 136px; + top: 40%; + left: 50%; + -webkit-transform: translate(-50%,-50%); + transform: translate(-50%,-50%); + text-align: center; + border-radius: 12px; + color: rgba(255,255,255,0.9); + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -webkit-flex-direction: column; + flex-direction: column; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; + -webkit-box-pack: center; + -webkit-justify-content: center; + justify-content: center; + background-color: #4c4c4c; + background-color: var(--weui-BG-4); + box-sizing: border-box; + line-height: 1.4; +} + +.weui-toast_text { + height: auto; + min-width: 152px; + max-width: 216px; + padding: 12px 0; +} + +.weui-toast_text .weui-toast__content { + font-size: 14px; +} + +.weui-icon_toast { + display: block; + width: 40px; + height: 40px; + margin-bottom: 16px; +} + +.weui-icon_toast.weui-icon-success-no-circle { + color: rgba(255,255,255,0.9); +} + +.weui-icon_toast.weui-icon-warn { + color: rgba(255,255,255,0.9); +} + +.weui-icon_toast.weui-loading { + width: 36px; + height: 36px; +} + +.weui-icon_toast.weui-primary-loading { + font-size: 40px; + color: #EDEDED; +} + +.weui-icon_toast.weui-primary-loading:before { + border-width: 4px 0 4px 4px; +} + +.weui-icon_toast.weui-primary-loading:after { + border-width: 4px 4px 4px 0; +} + +.weui-icon_toast.weui-primary-loading .weui-primary-loading__dot { + width: 4px; + height: 4px; + border-top-right-radius: 4px; + border-bottom-right-radius: 4px; +} + +.weui-toast__content { + font-size: 17px; + padding: 0 12px; + word-wrap: break-word; + -webkit-hyphens: auto; + hyphens: auto; +} + +.weui-toast_text-more .weui-icon_toast { + margin-bottom: 12px; +} + +.weui-toast_text-more .weui-toast__content { + font-size: 14px; + line-height: 1.6; +} + +.weui-mask { + position: fixed; + z-index: 1000; + top: 0; + right: 0; + left: 0; + bottom: 0; + background: rgba(0,0,0,0.6); +} + +.weui-mask_transparent { + position: fixed; + z-index: 1000; + top: 0; + right: 0; + left: 0; + bottom: 0; +} + +.weui-actionsheet { + position: fixed; + left: 0; + bottom: 0; + -webkit-transform: translate(0,100%); + transform: translate(0,100%); + -webkit-backface-visibility: hidden; + backface-visibility: hidden; + z-index: 5000; + width: 100%; + background-color: #f7f7f7; + background-color: var(--weui-BG-1); + -webkit-transition: -webkit-transform 0.3s; + transition: -webkit-transform 0.3s; + transition: transform 0.3s; + transition: transform 0.3s,-webkit-transform 0.3s; + border-top-left-radius: 12px; + border-top-right-radius: 12px; + overflow: hidden; +} + +.weui-actionsheet__title { + position: relative; + height: 56px; + padding: 0 24px; + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-pack: center; + -webkit-justify-content: center; + justify-content: center; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -webkit-flex-direction: column; + flex-direction: column; + text-align: center; + font-size: 12px; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + line-height: 1.4; + background: #fff; + background: var(--weui-BG-2); +} + +.weui-actionsheet__title:before { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-actionsheet__title .weui-actionsheet__title-text { + overflow: hidden; + text-overflow: ellipsis; + display: -webkit-box; + -webkit-box-orient: vertical; + -webkit-line-clamp: 2; +} + +.weui-actionsheet__menu { + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + background-color: #fff; + background-color: var(--weui-BG-2); +} + +.weui-actionsheet__action { + margin-top: 8px; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + background-color: #fff; + background-color: var(--weui-BG-2); + padding-bottom: constant(safe-area-inset-bottom); + padding-bottom: env(safe-area-inset-bottom); +} + +.weui-actionsheet__cell { + position: relative; + padding: 16px; + text-align: center; + font-size: 17px; + line-height: 1.41176471; +} + +.weui-actionsheet__cell:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-actionsheet__cell:active { + background-color: #ececec; + background-color: var(--weui-BG-COLOR-ACTIVE); +} + +.weui-actionsheet__cell:first-child:before { + display: none; +} + +.weui-actionsheet__cell_warn { + color: #fa5151; + color: var(--weui-RED); +} + +.weui-skin_android .weui-actionsheet { + position: fixed; + left: 50%; + top: 50%; + bottom: auto; + -webkit-transform: translate(-50%,-50%); + transform: translate(-50%,-50%); + width: 274px; + box-sizing: border-box; + -webkit-backface-visibility: hidden; + backface-visibility: hidden; + background: transparent; + -webkit-transition: -webkit-transform 0.3s; + transition: -webkit-transform 0.3s; + transition: transform 0.3s; + transition: transform 0.3s,-webkit-transform 0.3s; + border-top-left-radius: 0; + border-top-right-radius: 0; +} + +.weui-skin_android .weui-actionsheet__action { + display: none; +} + +.weui-skin_android .weui-actionsheet__menu { + border-radius: 2px; + box-shadow: 0 6px 30px 0 rgba(0,0,0,0.1); +} + +.weui-skin_android .weui-actionsheet__cell { + padding: 16px; + font-size: 17px; + line-height: 1.41176471; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + text-align: left; +} + +.weui-skin_android .weui-actionsheet__cell:first-child { + border-top-left-radius: 2px; + border-top-right-radius: 2px; +} + +.weui-skin_android .weui-actionsheet__cell:last-child { + border-bottom-left-radius: 2px; + border-bottom-right-radius: 2px; +} + +.weui-actionsheet_toggle { + -webkit-transform: translate(0,0); + transform: translate(0,0); +} + +.weui-loadmore { + width: 65%; + margin: 20px auto; + text-align: center; + font-size: 0; +} + +.weui-loadmore .weui-loading,.weui-loadmore .weui-primary-loading { + margin-right: 8px; +} + +.weui-loadmore__tips { + display: inline-block; + vertical-align: middle; + font-size: 14px; + line-height: 1.6; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-loadmore_line { + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + margin-top: 32px; +} + +.weui-loadmore_line .weui-loadmore__tips { + position: relative; + top: -0.9em; + padding: 0 0.55em; + background-color: #fff; + background-color: var(--weui-BG-2); + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); +} + +.weui-loadmore_dot .weui-loadmore__tips { + padding: 0 0.16em; +} + +.weui-loadmore_dot .weui-loadmore__tips:before { + content: " "; + width: 4px; + height: 4px; + border-radius: 50%; + background-color: rgba(0,0,0,0.1); + background-color: var(--weui-FG-3); + display: inline-block; + position: relative; + vertical-align: 0; + top: -0.16em; +} + +.weui-badge { + display: inline-block; + padding: 0.15em 0.4em; + min-width: 8px; + border-radius: 18px; + background-color: #fa5151; + background-color: var(--weui-RED); + color: #fff; + line-height: 1.2; + text-align: center; + font-size: 12px; + vertical-align: middle; +} + +.weui-badge_dot { + padding: 0.4em; + min-width: 0; +} + +.weui-toptips { + display: none; + position: fixed; + -webkit-transform: translateZ(0); + transform: translateZ(0); + top: 8px; + left: 8px; + right: 8px; + padding: 10px; + border-radius: 8px; + font-size: 14px; + text-align: center; + color: #fff; + z-index: 5000; + word-wrap: break-word; + word-break: break-all; +} + +.weui-toptips_warn { + background-color: #fa5151; + background-color: var(--weui-RED); +} + +.weui-list-tips { + list-style: none; + padding-top: 24px; + padding-bottom: 24px; + line-height: 1.4; + font-size: 14px; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + position: relative; +} + +.weui-list-tips:before { + content: ""; + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-list-tips:last-child { + padding-bottom: 0; +} + +.weui-list-tips__item { + position: relative; + padding-left: 15px; + margin: 16px 0; +} + +.weui-list-tips__item:before { + content: "\2022"; + position: absolute; + left: 0; + top: -0.1em; +} + +.weui-list-tips__item:first-child { + margin-top: 0; +} + +.weui-form-preview__list+.weui-list-tips>.weui-list-tips__item:first-child { + margin-top: 6px; +} + +.weui-search-bar { + position: relative; + padding: 8px; + display: -webkit-box; + display: -webkit-flex; + display: flex; + box-sizing: border-box; + background-color: #ededed; + background-color: var(--weui-BG-0); + -webkit-text-size-adjust: 100%; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; +} + +.weui-search-bar.weui-search-bar_focusing .weui-search-bar__cancel-btn { + display: block; +} + +.weui-search-bar.weui-search-bar_focusing .weui-search-bar__label { + display: none; +} + +.weui-search-bar .weui-icon-search { + width: 16px; + height: 16px; +} + +.weui-search-bar__form { + position: relative; + -webkit-box-flex: 1; + -webkit-flex: auto; + flex: auto; + background-color: #fff; + background-color: var(--weui-BG-2); + border-radius: 4px; +} + +.weui-search-bar__box { + position: relative; + padding-left: 28px; + padding-right: 32px; + height: 100%; + width: 100%; + box-sizing: border-box; + z-index: 1; +} + +.weui-search-bar__box .weui-search-bar__input { + padding: 8px 0; + width: 100%; + height: 1.14285714em; + border: 0; + font-size: 14px; + line-height: 1.14285714em; + box-sizing: content-box; + background: transparent; + caret-color: #07c160; + caret-color: var(--weui-BRAND); + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); +} + +.weui-search-bar__box .weui-search-bar__input:focus { + outline: none; +} + +.weui-search-bar__box .weui-icon-search { + position: absolute; + top: 50%; + left: 8px; + margin-top: -8px; +} + +.weui-search-bar__box .weui-icon-clear { + position: absolute; + top: 50%; + right: 0; + margin-top: -16px; + padding: 8px; + width: 16px; + height: 16px; + -webkit-mask-size: 16px; + mask-size: 16px; +} + +.weui-search-bar__label { + position: absolute; + top: 0; + right: 0; + bottom: 0; + left: 0; + z-index: 2; + font-size: 0; + border-radius: 4px; + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; + -webkit-box-pack: center; + -webkit-justify-content: center; + justify-content: center; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + background: #fff; + background: var(--weui-BG-2); +} + +.weui-search-bar__label span { + display: inline-block; + font-size: 14px; + vertical-align: middle; +} + +.weui-search-bar__label .weui-icon-search { + margin-right: 4px; +} + +.weui-search-bar__cancel-btn { + display: none; + margin-left: 8px; + line-height: 28px; + color: #576b95; + color: var(--weui-LINK); + white-space: nowrap; +} + +.weui-search-bar__input:not(:valid)+.weui-icon-clear { + display: none; +} + +input[type="search"]::-webkit-search-decoration,input[type="search"]::-webkit-search-cancel-button,input[type="search"]::-webkit-search-results-button,input[type="search"]::-webkit-search-results-decoration { + display: none; +} + +.weui-picker { + position: fixed; + width: 100%; + box-sizing: border-box; + left: 0; + bottom: 0; + z-index: 5000; + background-color: #fff; + background-color: var(--weui-BG-2); + padding-bottom: constant(safe-area-inset-bottom); + padding-bottom: env(safe-area-inset-bottom); + -webkit-backface-visibility: hidden; + backface-visibility: hidden; + -webkit-transform: translate(0,100%); + transform: translate(0,100%); + -webkit-transition: -webkit-transform 0.3s; + transition: -webkit-transform 0.3s; + transition: transform 0.3s; + transition: transform 0.3s,-webkit-transform 0.3s; +} + +.weui-picker__hd { + display: -webkit-box; + display: -webkit-flex; + display: flex; + padding: 16px; + padding: 16px calc(16px + constant(safe-area-inset-right)) 16px calc(16px + constant(safe-area-inset-left)); + padding: 16px calc(16px + env(safe-area-inset-right)) 16px calc(16px + env(safe-area-inset-left)); + position: relative; + text-align: center; + font-size: 17px; + line-height: 1.4; +} + +.weui-picker__hd:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-picker__bd { + display: -webkit-box; + display: -webkit-flex; + display: flex; + position: relative; + background-color: #fff; + background-color: var(--weui-BG-2); + height: 240px; + overflow: hidden; +} + +.weui-picker__group { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; + position: relative; + height: 100%; +} + +.weui-picker__group:first-child .weui-picker__item { + padding-left: constant(safe-area-inset-left); + padding-left: env(safe-area-inset-left); +} + +.weui-picker__group:last-child .weui-picker__item { + padding-right: constant(safe-area-inset-right); + padding-right: env(safe-area-inset-right); +} + +.weui-picker__mask { + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; + margin: 0 auto; + z-index: 3; + background-image: -webkit-linear-gradient(top,rgba(255,255,255,0.95),rgba(255,255,255,0.6)),-webkit-linear-gradient(bottom,rgba(255,255,255,0.95),rgba(255,255,255,0.6)); + background-image: linear-gradient(180deg,rgba(255,255,255,0.95),rgba(255,255,255,0.6)),linear-gradient(0deg,rgba(255,255,255,0.95),rgba(255,255,255,0.6)); + background-position: top,bottom; + background-size: 100% 92px; + background-repeat: no-repeat; + -webkit-transform: translateZ(0); + transform: translateZ(0); +} + +body[data-weui-theme='dark'] .weui-picker__mask { + background-image: -webkit-linear-gradient(top,rgba(25,25,25,0.95),rgba(25,25,25,0.6)),-webkit-linear-gradient(bottom,rgba(25,25,25,0.95),rgba(25,25,25,0.6)); + background-image: linear-gradient(180deg,rgba(25,25,25,0.95),rgba(25,25,25,0.6)),linear-gradient(0deg,rgba(25,25,25,0.95),rgba(25,25,25,0.6)); +} + +@media (prefers-color-scheme:dark) { + body:not([data-weui-theme='light']) .weui-picker__mask { + background-image: -webkit-linear-gradient(top,rgba(25,25,25,0.95),rgba(25,25,25,0.6)),-webkit-linear-gradient(bottom,rgba(25,25,25,0.95),rgba(25,25,25,0.6)); + background-image: linear-gradient(180deg,rgba(25,25,25,0.95),rgba(25,25,25,0.6)),linear-gradient(0deg,rgba(25,25,25,0.95),rgba(25,25,25,0.6)); + } +} + +.weui-picker__indicator { + width: 100%; + height: 56px; + position: absolute; + left: 0; + top: 92px; + z-index: 3; +} + +.weui-picker__indicator:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid rgba(0,0,0,0.1); + border-top: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 0; + transform-origin: 0 0; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-picker__indicator:after { + content: " "; + position: absolute; + left: 0; + bottom: 0; + right: 0; + height: 1px; + border-bottom: 1px solid rgba(0,0,0,0.1); + border-bottom: 1px solid var(--weui-FG-3); + color: rgba(0,0,0,0.1); + color: var(--weui-FG-3); + -webkit-transform-origin: 0 100%; + transform-origin: 0 100%; + -webkit-transform: scaleY(0.5); + transform: scaleY(0.5); +} + +.weui-picker__content { + position: absolute; + top: 0; + left: 0; + width: 100%; +} + +.weui-picker__item { + height: 48px; + line-height: 48px; + text-align: center; + color: rgba(0,0,0,0.9); + color: var(--weui-FG-0); + text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; +} + +.weui-picker__item_disabled { + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); +} + +@-webkit-keyframes slideUp { + from { + -webkit-transform: translate3d(0,100%,0); + transform: translate3d(0,100%,0); + } + + to { + -webkit-transform: translate3d(0,0,0); + transform: translate3d(0,0,0); + } +} + +@keyframes slideUp { + from { + -webkit-transform: translate3d(0,100%,0); + transform: translate3d(0,100%,0); + } + + to { + -webkit-transform: translate3d(0,0,0); + transform: translate3d(0,0,0); + } +} + +.weui-animate-slide-up { + -webkit-animation: slideUp ease 0.3s forwards; + animation: slideUp ease 0.3s forwards; +} + +@-webkit-keyframes slideDown { + from { + -webkit-transform: translate3d(0,0,0); + transform: translate3d(0,0,0); + } + + to { + -webkit-transform: translate3d(0,100%,0); + transform: translate3d(0,100%,0); + } +} + +@keyframes slideDown { + from { + -webkit-transform: translate3d(0,0,0); + transform: translate3d(0,0,0); + } + + to { + -webkit-transform: translate3d(0,100%,0); + transform: translate3d(0,100%,0); + } +} + +.weui-animate-slide-down { + -webkit-animation: slideDown ease 0.3s forwards; + animation: slideDown ease 0.3s forwards; +} + +@-webkit-keyframes fadeIn { + from { + opacity: 0; + } + + to { + opacity: 1; + } +} + +@keyframes fadeIn { + from { + opacity: 0; + } + + to { + opacity: 1; + } +} + +.weui-animate-fade-in { + -webkit-animation: fadeIn ease 0.3s forwards; + animation: fadeIn ease 0.3s forwards; +} + +@-webkit-keyframes fadeOut { + from { + opacity: 1; + } + + to { + opacity: 0; + } +} + +@keyframes fadeOut { + from { + opacity: 1; + } + + to { + opacity: 0; + } +} + +.weui-animate-fade-out { + -webkit-animation: fadeOut ease 0.3s forwards; + animation: fadeOut ease 0.3s forwards; +} + +.weui-agree { + display: block; + padding: 8px 15px 0; + font-size: 14px; + -webkit-tap-highlight-color: rgba(0,0,0,0); +} + +.weui-agree a,.weui-agree navigator { + color: #576b95; + color: var(--weui-LINK); +} + +.weui-agree navigator { + display: inline; +} + +.weui-agree__text { + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + margin-left: 2px; +} + +.weui-agree__checkbox { + -webkit-appearance: none; + appearance: none; + display: inline-block; + border: 0; + outline: 0; + vertical-align: middle; + background-color: currentColor; + -webkit-mask-position: 0 0; + mask-position: 0 0; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + -webkit-mask-size: 100%; + mask-size: 100%; + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E); + color: rgba(0,0,0,0.3); + color: var(--weui-FG-2); + width: 1em; + height: 1em; + font-size: 17px; + margin-top: -0.2em; +} + +.weui-agree__checkbox-check { + position: absolute; + left: -9999px; +} + +.weui-agree__checkbox:checked,.weui-agree__checkbox-check[aria-checked="true"]+.weui-agree__checkbox { + -webkit-mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E); + mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E); + color: #07c160; + color: var(--weui-BRAND); +} + +.weui-agree_animate { + -webkit-animation: weuiAgree 0.3s 1; + animation: weuiAgree 0.3s 1; +} + +@-webkit-keyframes weuiAgree { + 0% { + -webkit-transform: translateX(0); + transform: translateX(0); + } + + 16% { + -webkit-transform: translateX(-8px); + transform: translateX(-8px); + } + + 28% { + -webkit-transform: translateX(-16px); + transform: translateX(-16px); + } + + 44% { + -webkit-transform: translateX(0); + transform: translateX(0); + } + + 59% { + -webkit-transform: translateX(-16px); + transform: translateX(-16px); + } + + 73% { + -webkit-transform: translateX(0); + transform: translateX(0); + } + + 82% { + -webkit-transform: translateX(16px); + transform: translateX(16px); + } + + 94% { + -webkit-transform: translateX(8px); + transform: translateX(8px); + } + + 100% { + -webkit-transform: translateX(0); + transform: translateX(0); + } +} + +@keyframes weuiAgree { + 0% { + -webkit-transform: translateX(0); + transform: translateX(0); + } + + 16% { + -webkit-transform: translateX(-8px); + transform: translateX(-8px); + } + + 28% { + -webkit-transform: translateX(-16px); + transform: translateX(-16px); + } + + 44% { + -webkit-transform: translateX(0); + transform: translateX(0); + } + + 59% { + -webkit-transform: translateX(-16px); + transform: translateX(-16px); + } + + 73% { + -webkit-transform: translateX(0); + transform: translateX(0); + } + + 82% { + -webkit-transform: translateX(16px); + transform: translateX(16px); + } + + 94% { + -webkit-transform: translateX(8px); + transform: translateX(8px); + } + + 100% { + -webkit-transform: translateX(0); + transform: translateX(0); + } +} + +.weui-primary-loading { + font-size: 16px; + display: -webkit-inline-box; + display: -webkit-inline-flex; + display: inline-flex; + position: relative; + width: 1em; + height: 1em; + vertical-align: middle; + color: #606060; + -webkit-animation: circleLoading 1s steps(60,end) infinite; + animation: circleLoading 1s steps(60,end) infinite; +} + +.weui-primary-loading:before,.weui-primary-loading:after { + content: ""; + display: block; + width: 0.5em; + height: 1em; + box-sizing: border-box; + border: 0.125em solid; + border-color: currentColor; +} + +.weui-primary-loading:before { + border-right-width: 0; + border-top-left-radius: 1em; + border-bottom-left-radius: 1em; + -webkit-mask-image: -webkit-linear-gradient(top,#000000 8%,rgba(0,0,0,0.3) 95%); +} + +.weui-primary-loading:after { + border-left-width: 0; + border-top-right-radius: 1em; + border-bottom-right-radius: 1em; + -webkit-mask-image: -webkit-linear-gradient(top,rgba(0,0,0,0) 8%,rgba(0,0,0,0.3) 95%); +} + +.weui-primary-loading__dot { + position: absolute; + top: 0; + left: 50%; + margin-left: -0.0625em; + width: 0.125em; + height: 0.125em; + border-top-right-radius: 0.125em; + border-bottom-right-radius: 0.125em; + background: currentColor; +} + +@-webkit-keyframes circleLoading { + 0% { + -webkit-transform: rotate3d(0,0,1,0deg); + transform: rotate3d(0,0,1,0deg); + } + + 100% { + -webkit-transform: rotate3d(0,0,1,360deg); + transform: rotate3d(0,0,1,360deg); + } +} + +@keyframes circleLoading { + 0% { + -webkit-transform: rotate3d(0,0,1,0deg); + transform: rotate3d(0,0,1,0deg); + } + + 100% { + -webkit-transform: rotate3d(0,0,1,360deg); + transform: rotate3d(0,0,1,360deg); + } +} + +.weui-primary-loading_brand { + color: #07c160; + color: var(--weui-BRAND); +} + +.weui-primary-loading_transparent { + color: #EDEDED; +} + +.weui-loading { + width: 20px; + height: 20px; + display: inline-block; + vertical-align: middle; + -webkit-animation: weuiLoading 1s steps(12,end) infinite; + animation: weuiLoading 1s steps(12,end) infinite; + background: transparent url("data:image/svg+xml;charset=utf8, %3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120' viewBox='0 0 100 100'%3E%3Cpath fill='none' d='M0 0h100v100H0z'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23E9E9E9' rx='5' ry='5' transform='translate(0 -30)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23989697' rx='5' ry='5' transform='rotate(30 105.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%239B999A' rx='5' ry='5' transform='rotate(60 75.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23A3A1A2' rx='5' ry='5' transform='rotate(90 65 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23ABA9AA' rx='5' ry='5' transform='rotate(120 58.66 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23B2B2B2' rx='5' ry='5' transform='rotate(150 54.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23BAB8B9' rx='5' ry='5' transform='rotate(180 50 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23C2C0C1' rx='5' ry='5' transform='rotate(-150 45.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23CBCBCB' rx='5' ry='5' transform='rotate(-120 41.34 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23D2D2D2' rx='5' ry='5' transform='rotate(-90 35 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23DADADA' rx='5' ry='5' transform='rotate(-60 24.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23E2E2E2' rx='5' ry='5' transform='rotate(-30 -5.98 65)'/%3E%3C/svg%3E") no-repeat; + background-size: 100%; +} + +.weui-loading.weui-loading_transparent,.weui-btn_loading.weui-btn_primary .weui-loading { + background-image: url("data:image/svg+xml;charset=utf8, %3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120' viewBox='0 0 100 100'%3E%3Cpath fill='none' d='M0 0h100v100H0z'/%3E%3Crect xmlns='http://www.w3.org/2000/svg' width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.56)' rx='5' ry='5' transform='translate(0 -30)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.5)' rx='5' ry='5' transform='rotate(30 105.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.43)' rx='5' ry='5' transform='rotate(60 75.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.38)' rx='5' ry='5' transform='rotate(90 65 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.32)' rx='5' ry='5' transform='rotate(120 58.66 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.28)' rx='5' ry='5' transform='rotate(150 54.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.25)' rx='5' ry='5' transform='rotate(180 50 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.2)' rx='5' ry='5' transform='rotate(-150 45.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.17)' rx='5' ry='5' transform='rotate(-120 41.34 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.14)' rx='5' ry='5' transform='rotate(-90 35 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.1)' rx='5' ry='5' transform='rotate(-60 24.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.03)' rx='5' ry='5' transform='rotate(-30 -5.98 65)'/%3E%3C/svg%3E"); +} + +@-webkit-keyframes weuiLoading { + 0% { + -webkit-transform: rotate3d(0,0,1,0deg); + transform: rotate3d(0,0,1,0deg); + } + + 100% { + -webkit-transform: rotate3d(0,0,1,360deg); + transform: rotate3d(0,0,1,360deg); + } +} + +@keyframes weuiLoading { + 0% { + -webkit-transform: rotate3d(0,0,1,0deg); + transform: rotate3d(0,0,1,0deg); + } + + 100% { + -webkit-transform: rotate3d(0,0,1,360deg); + transform: rotate3d(0,0,1,360deg); + } +} + +.weui-slider { + padding: 15px 18px; + -webkit-user-select: none; + user-select: none; +} + +.weui-slider__inner { + position: relative; + height: 2px; + background-color: rgba(0,0,0,0.1); + background-color: var(--weui-FG-3); +} + +.weui-slider__track { + height: 2px; + background-color: #07c160; + background-color: var(--weui-BRAND); + width: 0; +} + +.weui-slider__handler { + position: absolute; + left: 0; + top: 50%; + width: 28px; + height: 28px; + margin-left: -14px; + margin-top: -14px; + border-radius: 50%; + background-color: #fff; + box-shadow: 0 0 4px rgba(0,0,0,0.1); + box-shadow: 0 0 4px var(--weui-FG-3); +} + +.weui-slider-box { + display: -webkit-box; + display: -webkit-flex; + display: flex; + -webkit-box-align: center; + -webkit-align-items: center; + align-items: center; +} + +.weui-slider-box .weui-slider { + -webkit-box-flex: 1; + -webkit-flex: 1; + flex: 1; +} + +.weui-slider-box__value { + margin-left: 0.5em; + min-width: 24px; + color: rgba(0,0,0,0.5); + color: var(--weui-FG-1); + text-align: center; + font-size: 14px; +} +/*# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["style/base/theme/fn.less","style/weui.css","style/base/reset.less","style/base/mixin/mobile.less","style/base/theme/index.less","style/base/theme/vars/light.less","style/base/theme/vars/dark.less","style/icon/weui-icon.less","style/widget/weui-text/weui-link.less","style/widget/weui-button/weui-btn_global.less","style/widget/weui-button/weui-btn_default.less","style/widget/weui-button/weui-btn_primary.less","style/widget/weui-button/weui-btn_warn.less","style/widget/weui-button/weui-btn_disabled.less","style/widget/weui-button/weui-btn_loading.less","style/widget/weui-button/weui-btn_cell.less","style/widget/weui-button/weui-button.less","style/widget/weui-cell/weui-cell_global.less","style/base/mixin/setOnepx.less","style/widget/weui-cell/weui-cell_swiped.less","style/widget/weui-cell/weui-access.less","style/widget/weui-cell/weui-check/weui-check_common.less","style/widget/weui-cell/weui-check/weui-radio.less","style/widget/weui-cell/weui-check/weui-checkbox.less","style/widget/weui-cell/weui-form/weui-form_common.less","style/base/mixin/text.less","style/widget/weui-cell/weui-form/weui-form-preview.less","style/widget/weui-cell/weui-form/weui-select.less","style/widget/weui-cell/weui-form/weui-vcode.less","style/widget/weui-cell/weui-gallery.less","style/widget/weui-cell/weui-switch.less","style/widget/weui-cell/weui-uploader.less","style/widget/weui-page/weui-msg.less","style/widget/weui-cell/weui-cells__group.less","style/widget/weui-page/weui-form.less","style/widget/weui-page/weui-article.less","style/widget/weui-tab/weui-tabbar.less","style/widget/weui-tab/weui-navbar.less","style/widget/weui-tab/weui-tab.less","style/widget/weui-progress/weui-progress.less","style/widget/weui-panel/weui-panel.less","style/widget/weui-media-box/weui-media-box.less","style/widget/weui-grid/weui-grid.less","style/widget/weui-footer/weui-footer.less","style/widget/weui-flex/weui-flex.less","style/widget/weui-tips/weui-dialog.less","style/widget/weui-tips/weui-half-screen-dialog.less","style/widget/weui-tips/weui-toast.less","style/widget/weui-tips/weui-mask.less","style/widget/weui-tips/weui-actionsheet.less","style/widget/weui-tips/weui-loadmore.less","style/widget/weui-tips/weui-badge.less","style/widget/weui-tips/weui-toptips.less","style/widget/weui-tips/weui-list-tips.less","style/widget/weui-searchbar/weui-searchbar.less","style/widget/weui-picker/weui-picker.less","style/widget/weui-animate/weui-animate.less","style/widget/weui-agree/weui-agree.less","style/widget/weui-loading/weui-primary-loading.less","style/base/mixin/setLoading.less","style/widget/weui-loading/weui-loading.less","style/widget/weui-slider/weui-slider.less"],"names":[],"mappings":"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","file":"style/weui.css","sourcesContent":["@import 'vars/light';\n@import 'vars/dark';\n\n.dark(@rule) {\n    body[data-weui-theme='dark'] & {\n        @rule();\n    }\n\n    @media (prefers-color-scheme: dark) {\n        body:not([data-weui-theme='light']) & {\n            @rule();\n        }\n    }\n}\n\n.setColor(@var, @color) {\n    .setColor(@var, @color, @color);\n}\n\n.setColor(@var, @light, @dark) {\n    ._setColor({\n            @{var}: @light;\n    }, {\n            @{var}: @dark;\n    });\n}\n._setColor(@lightRule, @darkRule) {\n    body {\n        @lightRule();\n    }\n    body[data-weui-theme='dark'] {\n        @darkRule();\n    }\n\n    @media (prefers-color-scheme: dark) {\n        body:not([data-weui-theme='light']) {\n            @darkRule();\n        }\n    }\n}","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n*\n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n*\n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n*       http://opensource.org/licenses/MIT\n*\n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nbody {\n  --weui-BTN-DISABLED-FONT-COLOR: rgba(0, 0, 0, 0.2);\n}\nbody[data-weui-theme='dark'] {\n  --weui-BTN-DISABLED-FONT-COLOR: rgba(255, 255, 255, 0.2);\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) {\n    --weui-BTN-DISABLED-FONT-COLOR: rgba(255, 255, 255, 0.2);\n  }\n}\nbody {\n  --weui-BTN-DEFAULT-BG: #f2f2f2;\n}\nbody[data-weui-theme='dark'] {\n  --weui-BTN-DEFAULT-BG: rgba(255, 255, 255, 0.08);\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) {\n    --weui-BTN-DEFAULT-BG: rgba(255, 255, 255, 0.08);\n  }\n}\nbody {\n  --weui-BTN-DEFAULT-COLOR: #06ae56;\n}\nbody[data-weui-theme='dark'] {\n  --weui-BTN-DEFAULT-COLOR: rgba(255, 255, 255, 0.8);\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) {\n    --weui-BTN-DEFAULT-COLOR: rgba(255, 255, 255, 0.8);\n  }\n}\nbody {\n  --weui-BTN-DEFAULT-ACTIVE-BG: #e6e6e6;\n}\nbody[data-weui-theme='dark'] {\n  --weui-BTN-DEFAULT-ACTIVE-BG: rgba(255, 255, 255, 0.126);\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) {\n    --weui-BTN-DEFAULT-ACTIVE-BG: rgba(255, 255, 255, 0.126);\n  }\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nbody {\n  --weui-DIALOG-LINE-COLOR: rgba(0, 0, 0, 0.1);\n}\nbody[data-weui-theme='dark'] {\n  --weui-DIALOG-LINE-COLOR: rgba(255, 255, 255, 0.1);\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) {\n    --weui-DIALOG-LINE-COLOR: rgba(255, 255, 255, 0.1);\n  }\n}\nhtml {\n  -ms-text-size-adjust: 100%;\n  -webkit-text-size-adjust: 100%;\n}\nbody {\n  line-height: 1.6;\n  font-family: -apple-system-font, \"Helvetica Neue\", sans-serif;\n}\n* {\n  margin: 0;\n  padding: 0;\n}\na img {\n  border: 0;\n}\na {\n  text-decoration: none;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\ninput,\ntextarea {\n  caret-color: var(--weui-BRAND);\n}\n::placeholder {\n  color: var(--weui-FG-2);\n}\nbody {\n  --weui-BG-0: #ededed;\n  --weui-BG-1: #f7f7f7;\n  --weui-BG-2: #fff;\n  --weui-BG-3: #f7f7f7;\n  --weui-BG-4: #4c4c4c;\n  --weui-BG-5: #fff;\n  --weui-FG-0: rgba(0, 0, 0, 0.9);\n  --weui-FG-HALF: rgba(0, 0, 0, 0.9);\n  --weui-FG-1: rgba(0, 0, 0, 0.5);\n  --weui-FG-2: rgba(0, 0, 0, 0.3);\n  --weui-FG-3: rgba(0, 0, 0, 0.1);\n  --weui-RED: #fa5151;\n  --weui-ORANGE: #fa9d3b;\n  --weui-YELLOW: #ffc300;\n  --weui-GREEN: #91d300;\n  --weui-LIGHTGREEN: #95ec69;\n  --weui-BRAND: #07c160;\n  --weui-BLUE: #10aeff;\n  --weui-INDIGO: #1485ee;\n  --weui-PURPLE: #6467f0;\n  --weui-WHITE: #fff;\n  --weui-LINK: #576b95;\n  --weui-LINK-ACTIVE: rgba(87, 107, 149, 0.5);\n  --weui-TEXTGREEN: #06ae56;\n  --weui-FG: black;\n  --weui-BG: white;\n  --weui-TAG-TEXT-ORANGE: #fa9d3b;\n  --weui-TAG-BACKGROUND-ORANGE: rgba(250, 157, 59, 0.1);\n  --weui-TAG-TEXT-GREEN: #06ae56;\n  --weui-TAG-BACKGROUND-GREEN: rgba(6, 174, 86, 0.1);\n  --weui-TAG-TEXT-BLUE: #10aeff;\n  --weui-TAG-BACKGROUND-BLUE: rgba(16, 174, 255, 0.1);\n  --weui-TAG-TEXT-BLACK: rgba(0, 0, 0, 0.5);\n  --weui-TAG-BACKGROUND-BLACK: rgba(0, 0, 0, 0.05);\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) {\n    --weui-BG-0: #111111;\n    --weui-BG-1: #1e1e1e;\n    --weui-BG-2: #191919;\n    --weui-BG-3: #202020;\n    --weui-BG-4: #404040;\n    --weui-BG-5: #2c2c2c;\n    --weui-FG-0: rgba(255, 255, 255, 0.8);\n    --weui-FG-HALF: rgba(255, 255, 255, 0.6);\n    --weui-FG-1: rgba(255, 255, 255, 0.5);\n    --weui-FG-2: rgba(255, 255, 255, 0.3);\n    --weui-FG-3: rgba(255, 255, 255, 0.05);\n    --weui-RED: #fa5151;\n    --weui-ORANGE: #c87d2f;\n    --weui-YELLOW: #cc9c00;\n    --weui-GREEN: #74a800;\n    --weui-LIGHTGREEN: #3eb575;\n    --weui-BRAND: #07c160;\n    --weui-BLUE: #10aeff;\n    --weui-INDIGO: #1196ff;\n    --weui-PURPLE: #8183ff;\n    --weui-WHITE: rgba(255, 255, 255, 0.8);\n    --weui-LINK: #7d90a9;\n    --weui-LINK-ACTIVE: rgba(125, 144, 169, 0.5);\n    --weui-TEXTGREEN: #259c5c;\n    --weui-FG: white;\n    --weui-BG: black;\n    --weui-TAG-TEXT-ORANGE: rgba(250, 157, 59, 0.6);\n    --weui-TAG-BACKGROUND-ORANGE: rgba(250, 157, 59, 0.1);\n    --weui-TAG-TEXT-GREEN: rgba(6, 174, 86, 0.6);\n    --weui-TAG-BACKGROUND-GREEN: rgba(6, 174, 86, 0.1);\n    --weui-TAG-TEXT-BLUE: rgba(16, 174, 255, 0.6);\n    --weui-TAG-BACKGROUND-BLUE: rgba(16, 174, 255, 0.1);\n    --weui-TAG-TEXT-BLACK: rgba(255, 255, 255, 0.5);\n    --weui-TAG-BACKGROUND-BLACK: rgba(255, 255, 255, 0.05);\n  }\n}\nbody[data-weui-theme='dark'] {\n  --weui-BG-0: #111111;\n  --weui-BG-1: #1e1e1e;\n  --weui-BG-2: #191919;\n  --weui-BG-3: #202020;\n  --weui-BG-4: #404040;\n  --weui-BG-5: #2c2c2c;\n  --weui-FG-0: rgba(255, 255, 255, 0.8);\n  --weui-FG-HALF: rgba(255, 255, 255, 0.6);\n  --weui-FG-1: rgba(255, 255, 255, 0.5);\n  --weui-FG-2: rgba(255, 255, 255, 0.3);\n  --weui-FG-3: rgba(255, 255, 255, 0.05);\n  --weui-RED: #fa5151;\n  --weui-ORANGE: #c87d2f;\n  --weui-YELLOW: #cc9c00;\n  --weui-GREEN: #74a800;\n  --weui-LIGHTGREEN: #3eb575;\n  --weui-BRAND: #07c160;\n  --weui-BLUE: #10aeff;\n  --weui-INDIGO: #1196ff;\n  --weui-PURPLE: #8183ff;\n  --weui-WHITE: rgba(255, 255, 255, 0.8);\n  --weui-LINK: #7d90a9;\n  --weui-LINK-ACTIVE: rgba(125, 144, 169, 0.5);\n  --weui-TEXTGREEN: #259c5c;\n  --weui-FG: white;\n  --weui-BG: black;\n  --weui-TAG-TEXT-ORANGE: rgba(250, 157, 59, 0.6);\n  --weui-TAG-BACKGROUND-ORANGE: rgba(250, 157, 59, 0.1);\n  --weui-TAG-TEXT-GREEN: rgba(6, 174, 86, 0.6);\n  --weui-TAG-BACKGROUND-GREEN: rgba(6, 174, 86, 0.1);\n  --weui-TAG-TEXT-BLUE: rgba(16, 174, 255, 0.6);\n  --weui-TAG-BACKGROUND-BLUE: rgba(16, 174, 255, 0.1);\n  --weui-TAG-TEXT-BLACK: rgba(255, 255, 255, 0.5);\n  --weui-TAG-BACKGROUND-BLACK: rgba(255, 255, 255, 0.05);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/* stylelint-disable no-duplicate-selectors */\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nbody {\n  --weui-BG-COLOR-ACTIVE: #ececec;\n}\nbody[data-weui-theme='dark'] {\n  --weui-BG-COLOR-ACTIVE: #373737;\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) {\n    --weui-BG-COLOR-ACTIVE: #373737;\n  }\n}\n[class^=\"weui-icon-\"],\n[class*=\" weui-icon-\"] {\n  display: inline-block;\n  vertical-align: middle;\n  width: 24px;\n  height: 24px;\n  mask-position: 50% 50%;\n  mask-repeat: no-repeat;\n  mask-size: 100%;\n  background-color: currentColor;\n}\n.weui-icon-circle {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-download {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M11.25%2012.04l-1.72-1.72-1.06%201.06%202.828%202.83a1%201%200%20001.414-.001l2.828-2.828-1.06-1.061-1.73%201.73V7h-1.5v5.04zm0-5.04V2h1.5v5h6.251c.55%200%20.999.446.999.996v13.008a.998.998%200%2001-.996.996H4.996A.998.998%200%20014%2021.004V7.996A1%201%200%20014.999%207h6.251z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-info {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-.75-12v7h1.5v-7h-1.5zM12%209a1%201%200%20100-2%201%201%200%20000%202z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-safe-success {\n  mask-image: url(data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%201000%201000%22%3E%3Cpath%20d%3D%22M500.9%204.6C315.5%2046.7%20180.4%2093.1%2057.6%20132c0%20129.3.2%20231.7.2%20339.7%200%20304.2%20248.3%20471.6%20443.1%20523.7C695.7%20943.3%20944%20775.9%20944%20471.7c0-108%20.2-210.4.2-339.7C821.4%2093.1%20686.3%2046.7%20500.9%204.6zm248.3%20349.1l-299.7%20295c-2.1%202-5.3%202-7.4-.1L304.4%20506.1c-2-2.1-2.3-5.7-.6-8l18.3-24.9c1.7-2.3%205-2.8%207.2-1l112.2%2086c2.3%201.8%206%201.7%208.1-.1l274.7-228.9c2.2-1.8%205.7-1.7%207.7.3l17%2016.8c2.2%202.1%202.2%205.3.2%207.4z%22%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20fill%3D%22%23070202%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-safe-warn {\n  mask-image: url(data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%201000%201000%22%3E%3Cpath%20d%3D%22M500.9%204.5c-185.4%2042-320.4%2088.4-443.2%20127.3%200%20129.3.2%20231.7.2%20339.6%200%20304.1%20248.2%20471.4%20443%20523.6%20194.7-52.2%20443-219.5%20443-523.6%200-107.9.2-210.3.2-339.6C821.3%2092.9%20686.2%2046.5%20500.9%204.5zm-26.1%20271.1h52.1c5.8%200%2010.3%204.7%2010.1%2010.4l-11.6%20313.8c-.1%202.8-2.5%205.2-5.4%205.2h-38.2c-2.9%200-5.3-2.3-5.4-5.2L464.8%20286c-.2-5.8%204.3-10.4%2010-10.4zm26.1%20448.3c-20.2%200-36.5-16.3-36.5-36.5s16.3-36.5%2036.5-36.5%2036.5%2016.3%2036.5%2036.5-16.4%2036.5-36.5%2036.5z%22%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20fill%3D%22%23020202%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success-circle {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6zm-1.172-6.242l5.809-5.808.848.849-5.95%205.95a1%201%200%2001-1.414%200L7%2012.426l.849-.849%202.98%202.98z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success-no-circle {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.657%2018.435L3%2012.778l1.414-1.414%204.95%204.95L20.678%205l1.414%201.414-12.02%2012.021a1%201%200%2001-1.415%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-waiting {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.75%2011.38V6h-1.5v6l4.243%204.243%201.06-1.06-3.803-3.804zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-waiting-circle {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.6%2011.503l3.891%203.891-.848.849L11.4%2012V6h1.2v5.503zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-warn {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-.763-15.864l.11%207.596h1.305l.11-7.596h-1.525zm.759%2010.967c.512%200%20.902-.383.902-.882%200-.5-.39-.882-.902-.882a.878.878%200%2000-.896.882c0%20.499.396.882.896.882z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-info-circle {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6zM11.4%2010h1.2v7h-1.2v-7zm.6-1a1%201%200%20110-2%201%201%200%20010%202z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-cancel {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cg%20fill-rule%3D%22evenodd%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6z%22%20fill-rule%3D%22nonzero%22%2F%3E%3Cpath%20d%3D%22M12.849%2012l3.11%203.111-.848.849L12%2012.849l-3.111%203.11-.849-.848L11.151%2012l-3.11-3.111.848-.849L12%2011.151l3.111-3.11.849.848L12.849%2012z%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E);\n}\n.weui-icon-search {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M16.31%2015.561l4.114%204.115-.848.848-4.123-4.123a7%207%200%2011.857-.84zM16.8%2011a5.8%205.8%200%2010-11.6%200%205.8%205.8%200%200011.6%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-clear {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M13.06%2012l3.006-3.005-1.06-1.06L12%2010.938%208.995%207.934l-1.06%201.06L10.938%2012l-3.005%203.005%201.06%201.06L12%2013.062l3.005%203.005%201.06-1.06L13.062%2012zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm1.999-6.563L10.68%2012%2014%208.562%2012.953%207.5%209.29%2011.277a1.045%201.045%200%20000%201.446l3.663%203.777L14%2015.437z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-delete {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M6.774%206.4l.812%2013.648a.8.8%200%2000.798.752h7.232a.8.8%200%2000.798-.752L17.226%206.4H6.774zm11.655%200l-.817%2013.719A2%202%200%200115.616%2022H8.384a2%202%200%2001-1.996-1.881L5.571%206.4H3.5v-.7a.5.5%200%2001.5-.5h16a.5.5%200%2001.5.5v.7h-2.071zM14%203a.5.5%200%2001.5.5v.7h-5v-.7A.5.5%200%200110%203h4zM9.5%209h1.2l.5%209H10l-.5-9zm3.8%200h1.2l-.5%209h-1.2l.5-9z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success-no-circle-thin {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.864%2016.617l-5.303-5.303-1.061%201.06%205.657%205.657a1%201%200%20001.414%200L21.238%206.364l-1.06-1.06L8.864%2016.616z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-arrow {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-arrow-bold {\n  mask-image: url(data:image/svg+xml,%3Csvg%20height%3D%2224%22%20width%3D%2212%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10.157%2012.711L4.5%2018.368l-1.414-1.414%204.95-4.95-4.95-4.95L4.5%205.64l5.657%205.657a1%201%200%20010%201.414z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back-arrow {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M3.343%2012l7.071%207.071L9%2020.485l-7.778-7.778a1%201%200%20010-1.414L9%203.515l1.414%201.414L3.344%2012z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back-arrow-thin {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10%2019.438L8.955%2020.5l-7.666-7.79a1.02%201.02%200%20010-1.42L8.955%203.5%2010%204.563%202.682%2012%2010%2019.438z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-close {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2010.586l5.657-5.657%201.414%201.414L13.414%2012l5.657%205.657-1.414%201.414L12%2013.414l-5.657%205.657-1.414-1.414L10.586%2012%204.929%206.343%206.343%204.93%2012%2010.586z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-close-thin {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.25%2010.693L6.057%204.5%205%205.557l6.193%206.193L5%2017.943%206.057%2019l6.193-6.193L18.443%2019l1.057-1.057-6.193-6.193L19.5%205.557%2018.443%204.5z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back-circle {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6zm1.999-5.363L12.953%2016.5%209.29%2012.723a1.045%201.045%200%20010-1.446L12.953%207.5%2014%208.563%2010.68%2012%2014%2015.438z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success {\n  color: var(--weui-BRAND);\n}\n.weui-icon-waiting {\n  color: var(--weui-BLUE);\n}\n.weui-icon-warn {\n  color: var(--weui-RED);\n}\n.weui-icon-info {\n  color: var(--weui-BLUE);\n}\n.weui-icon-success-circle {\n  color: var(--weui-BRAND);\n}\n.weui-icon-success-no-circle,\n.weui-icon-success-no-circle-thin {\n  color: var(--weui-BRAND);\n}\n.weui-icon-waiting-circle {\n  color: var(--weui-BLUE);\n}\n.weui-icon-circle {\n  color: var(--weui-FG-2);\n}\n.weui-icon-download {\n  color: var(--weui-BRAND);\n}\n.weui-icon-info-circle {\n  color: var(--weui-FG-2);\n}\n.weui-icon-safe-success {\n  color: var(--weui-BRAND);\n}\n.weui-icon-safe-warn {\n  color: var(--weui-YELLOW);\n}\n.weui-icon-cancel {\n  color: var(--weui-RED);\n}\n.weui-icon-search {\n  color: var(--weui-FG-1);\n}\n.weui-icon-clear {\n  color: var(--weui-FG-2);\n}\n.weui-icon-clear:active {\n  color: var(--weui-FG-1);\n}\n.weui-icon-delete.weui-icon_gallery-delete {\n  color: var(--weui-WHITE);\n}\n.weui-icon-arrow,\n.weui-icon-arrow-bold,\n.weui-icon-back-arrow,\n.weui-icon-back-arrow-thin {\n  width: 12px;\n}\n.weui-icon-arrow,\n.weui-icon-arrow-bold {\n  color: var(--weui-FG-2);\n}\n.weui-icon-back-arrow,\n.weui-icon-back-arrow-thin {\n  color: var(--weui-FG-0);\n}\n.weui-icon-back,\n.weui-icon-back-circle {\n  color: var(--weui-FG-0);\n}\n.weui-icon_msg {\n  width: 64px;\n  height: 64px;\n}\n.weui-icon_msg.weui-icon-warn {\n  color: var(--weui-RED);\n}\n.weui-icon_msg.weui-icon-info-circle {\n  color: var(--weui-BLUE);\n}\n.weui-icon_msg-primary {\n  width: 64px;\n  height: 64px;\n}\n.weui-icon_msg-primary.weui-icon-warn {\n  color: var(--weui-YELLOW);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-link {\n  color: var(--weui-LINK);\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.weui-link:visited {\n  color: var(--weui-LINK);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-btn {\n  position: relative;\n  display: block;\n  width: 184px;\n  margin-left: auto;\n  margin-right: auto;\n  padding: 8px 24px;\n  box-sizing: border-box;\n  font-weight: 700;\n  font-size: 17px;\n  text-align: center;\n  text-decoration: none;\n  color: #fff;\n  line-height: 1.41176471;\n  border-radius: 4px;\n  overflow: hidden;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.weui-btn_block {\n  width: auto;\n}\n.weui-btn_inline {\n  display: inline-block;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-btn_default {\n  color: var(--weui-BTN-DEFAULT-COLOR);\n  background-color: var(--weui-BTN-DEFAULT-BG);\n}\n.weui-btn_default:not(.weui-btn_disabled):visited {\n  color: var(--weui-BTN-DEFAULT-COLOR);\n}\n.weui-btn_default:not(.weui-btn_disabled):active {\n  background-color: var(--weui-BTN-DEFAULT-ACTIVE-BG);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-btn_primary {\n  background-color: var(--weui-BRAND);\n}\n.weui-btn_primary:not(.weui-btn_disabled):visited {\n  color: #fff;\n}\n.weui-btn_primary:not(.weui-btn_disabled):active {\n  background-color: var(--weui-TAG-TEXT-GREEN);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-btn_warn {\n  color: var(--weui-RED);\n  background-color: var(--weui-BTN-DEFAULT-BG);\n}\n.weui-btn_warn:not(.weui-btn_disabled):visited {\n  color: var(--weui-RED);\n}\n.weui-btn_warn:not(.weui-btn_disabled):active {\n  background-color: var(--weui-BTN-DEFAULT-ACTIVE-BG);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-btn_disabled {\n  color: var(--weui-BTN-DISABLED-FONT-COLOR);\n  background-color: var(--weui-BTN-DEFAULT-BG);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-btn_loading .weui-loading {\n  margin: -0.2em 0.34em 0 0;\n}\n.weui-btn_loading .weui-primary-loading {\n  margin: -0.2em 8px 0 0;\n  vertical-align: middle;\n}\n.weui-btn_loading.weui-btn_primary {\n  background-color: var(--weui-TAG-TEXT-GREEN);\n  color: var(--weui-WHITE);\n}\n.weui-btn_loading.weui-btn_default {\n  background-color: var(--weui-BTN-DEFAULT-ACTIVE-BG);\n}\n.weui-btn_loading.weui-btn_warn {\n  background-color: var(--weui-BTN-DEFAULT-ACTIVE-BG);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-btn_cell {\n  position: relative;\n  display: block;\n  margin-left: auto;\n  margin-right: auto;\n  box-sizing: border-box;\n  font-size: 17px;\n  text-align: center;\n  text-decoration: none;\n  color: #fff;\n  line-height: 1.41176471;\n  padding: 16px;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n  overflow: hidden;\n  background-color: var(--weui-BG-5);\n}\n.weui-btn_cell + .weui-btn_cell {\n  margin-top: 16px;\n}\n.weui-btn_cell:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-btn_cell__icon {\n  display: inline-block;\n  vertical-align: middle;\n  width: 24px;\n  height: 24px;\n  margin: -0.2em 0.34em 0 0;\n}\n.weui-btn_cell-default {\n  color: var(--weui-FG-0);\n}\n.weui-btn_cell-primary {\n  color: var(--weui-LINK);\n}\n.weui-btn_cell-warn {\n  color: var(--weui-RED);\n}\nbutton.weui-btn,\ninput.weui-btn {\n  border-width: 0;\n  outline: 0;\n  -webkit-appearance: none;\n}\nbutton.weui-btn:focus,\ninput.weui-btn:focus {\n  outline: 0;\n}\nbutton.weui-btn_inline,\ninput.weui-btn_inline,\nbutton.weui-btn_mini,\ninput.weui-btn_mini {\n  width: auto;\n}\n.weui-btn_mini {\n  display: inline-block;\n  width: auto;\n  padding: 0 0.75em;\n  line-height: 2;\n  font-size: 16px;\n}\n/* gap between btn */\n.weui-btn:not(.weui-btn_mini) + .weui-btn:not(.weui-btn_mini) {\n  margin-top: 16px;\n}\n.weui-btn.weui-btn_inline + .weui-btn.weui-btn_inline {\n  margin-top: auto;\n  margin-left: 16px;\n}\n.weui-btn-area {\n  margin: 48px 16px 8px;\n}\n.weui-btn-area_inline {\n  display: flex;\n}\n.weui-btn-area_inline .weui-btn {\n  margin-top: auto;\n  margin-right: 16px;\n  width: 100%;\n  flex: 1;\n}\n.weui-btn-area_inline .weui-btn:last-child {\n  margin-right: 0;\n}\n.weui-btn_reset {\n  background: transparent;\n  border: 0;\n  padding: 0;\n  outline: 0;\n}\n.weui-btn_icon {\n  font-size: 0;\n}\n.weui-btn_icon:active [class*=\"weui-icon-\"] {\n  color: var(--weui-FG-1);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\nz-index:\n0: .weui-swiped-btn\n1: .weui-cell_swiped .weui-cell__bd\n2: .weui-cells和.weui-cell的1px线\n*/\n.weui-cells {\n  margin-top: 8px;\n  background-color: var(--weui-BG-2);\n  line-height: 1.41176471;\n  font-size: 17px;\n  overflow: hidden;\n  position: relative;\n}\n.weui-cells:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n  z-index: 2;\n}\n.weui-cells:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n  z-index: 2;\n}\n.weui-cells__title {\n  margin-top: 16px;\n  margin-bottom: 3px;\n  padding-left: 16px;\n  padding-right: 16px;\n  color: var(--weui-FG-1);\n  font-size: 14px;\n  line-height: 1.4;\n}\n.weui-cells__title + .weui-cells {\n  margin-top: 0;\n}\n.weui-cells__tips {\n  margin-top: 8px;\n  color: var(--weui-FG-1);\n  padding-left: 16px;\n  padding-right: 16px;\n  font-size: 14px;\n  line-height: 1.4;\n}\n.weui-cells__tips a,\n.weui-cells__tips navigator {\n  color: var(--weui-LINK);\n}\n.weui-cells__tips navigator {\n  display: inline;\n}\n.weui-cell {\n  padding: 16px;\n  position: relative;\n  display: flex;\n  align-items: center;\n}\n.weui-cell:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n  left: 16px;\n  z-index: 2;\n}\n.weui-cell:first-child:before {\n  display: none;\n}\n.weui-cell_active:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-cell_primary {\n  align-items: flex-start;\n}\n.weui-cell__bd {\n  flex: 1;\n}\n.weui-cell__ft {\n  text-align: right;\n  color: var(--weui-FG-1);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cell_swiped {\n  display: block;\n  padding: 0;\n}\n.weui-cell_swiped > .weui-cell__bd {\n  position: relative;\n  z-index: 1;\n  background-color: var(--weui-BG-2);\n}\n.weui-cell_swiped > .weui-cell__ft {\n  position: absolute;\n  right: 0;\n  top: 0;\n  bottom: 0;\n  display: flex;\n  color: #fff;\n}\n.weui-swiped-btn {\n  display: block;\n  padding: 16px 1em;\n  line-height: 1.41176471;\n  color: inherit;\n}\n.weui-swiped-btn_default {\n  background-color: var(--weui-BG-0);\n}\n.weui-swiped-btn_warn {\n  background-color: var(--weui-RED);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cell_access {\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n  color: inherit;\n}\n.weui-cell_access:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-cell_access .weui-cell__ft {\n  padding-right: 22px;\n  position: relative;\n}\n.weui-cell_access .weui-cell__ft:after {\n  content: \" \";\n  width: 12px;\n  height: 24px;\n  mask-position: 0 0;\n  mask-repeat: no-repeat;\n  mask-size: 100%;\n  background-color: currentColor;\n  color: var(--weui-FG-2);\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n  position: absolute;\n  top: 50%;\n  right: 0;\n  margin-top: -12px;\n}\n.weui-cell_link {\n  color: var(--weui-LINK);\n  font-size: 17px;\n}\n.weui-cell_link:first-child:before {\n  display: block;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-check__label {\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.weui-check__label:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-check {\n  position: absolute;\n  left: -9999px;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cells_radio .weui-cell__ft {\n  padding-left: 16px;\n  font-size: 0;\n}\n.weui-cells_radio .weui-check + .weui-icon-checked {\n  min-width: 16px;\n  color: transparent;\n}\n.weui-cells_radio .weui-check:checked + .weui-icon-checked,\n.weui-cells_radio .weui-check[aria-checked=\"true\"] + .weui-icon-checked {\n  color: var(--weui-BRAND);\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.657%2018.435L3%2012.778l1.414-1.414%204.95%204.95L20.678%205l1.414%201.414-12.02%2012.021a1%201%200%2001-1.415%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cells_checkbox .weui-check__label:before {\n  left: 55px;\n}\n.weui-cells_checkbox .weui-cell__hd {\n  padding-right: 16px;\n  font-size: 0;\n}\n.weui-cells_checkbox .weui-icon-checked {\n  color: var(--weui-FG-2);\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-cells_checkbox .weui-check:checked + .weui-icon-checked,\n.weui-cells_checkbox .weui-check[aria-checked=\"true\"] + .weui-icon-checked {\n  color: var(--weui-BRAND);\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-label {\n  display: block;\n  width: 105px;\n  word-wrap: break-word;\n  word-break: break-all;\n}\n.weui-input {\n  width: 100%;\n  border: 0;\n  outline: 0;\n  -webkit-appearance: none;\n  background-color: transparent;\n  font-size: inherit;\n  color: inherit;\n  height: 1.41176471em;\n  line-height: 1.41176471;\n}\n.weui-input::-webkit-outer-spin-button,\n.weui-input::-webkit-inner-spin-button {\n  -webkit-appearance: none;\n  margin: 0;\n}\n.weui-input:focus:not(:placeholder-shown) + .weui-btn_input-clear {\n  display: inline;\n}\n.weui-textarea {\n  display: block;\n  border: 0;\n  resize: none;\n  background: transparent;\n  width: 100%;\n  color: inherit;\n  font-size: 1em;\n  line-height: inherit;\n  outline: 0;\n}\n.weui-textarea-counter {\n  color: var(--weui-FG-2);\n  text-align: right;\n  font-size: 14px;\n}\n.weui-cell_warn .weui-textarea-counter {\n  color: var(--weui-RED);\n}\n.weui-cells_form .weui-cell_switch:active,\n.weui-cells_form .weui-cell_vcode:active,\n.weui-cells_form .weui-cell_readonly:active,\n.weui-cells_form .weui-cell_disabled:active {\n  background-color: transparent;\n}\n.weui-cells_form .weui-cell__ft {\n  font-size: 0;\n}\n.weui-cells_form .weui-icon-warn {\n  display: none;\n}\n.weui-cells_form input,\n.weui-cells_form textarea,\n.weui-cells_form label[for] {\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.weui-cell_warn {\n  color: var(--weui-RED);\n}\n.weui-cell_warn .weui-icon-warn {\n  display: inline-block;\n}\n.weui-cell_readonly .weui-input:disabled,\n.weui-cell_disabled .weui-input:disabled,\n.weui-cell_readonly .weui-textarea:disabled,\n.weui-cell_disabled .weui-textarea:disabled {\n  opacity: 1;\n  -webkit-text-fill-color: var(--weui-FG-1);\n}\n.weui-cell_readonly .weui-input[disabled],\n.weui-cell_disabled .weui-input[disabled],\n.weui-cell_readonly .weui-textarea[disabled],\n.weui-cell_disabled .weui-textarea[disabled],\n.weui-cell_readonly .weui-input[readonly],\n.weui-cell_disabled .weui-input[readonly],\n.weui-cell_readonly .weui-textarea[readonly],\n.weui-cell_disabled .weui-textarea[readonly] {\n  color: var(--weui-FG-1);\n}\n.weui-btn_input-clear {\n  display: none;\n  padding-left: 8px;\n}\n.weui-btn_input-clear [class*=\"weui-icon-\"] {\n  width: 18px;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-form-preview {\n  position: relative;\n  background-color: var(--weui-BG-2);\n}\n.weui-form-preview:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-form-preview:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n}\n.weui-form-preview__hd {\n  position: relative;\n  padding: 16px;\n  text-align: right;\n  line-height: 2.5em;\n}\n.weui-form-preview__hd:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n  left: 16px;\n}\n.weui-form-preview__hd .weui-form-preview__value {\n  font-style: normal;\n  font-size: 1.6em;\n}\n.weui-form-preview__bd {\n  padding: 16px;\n  font-size: 0.9em;\n  text-align: right;\n  color: var(--weui-FG-1);\n  line-height: 2;\n}\n.weui-form-preview__ft {\n  position: relative;\n  line-height: 50px;\n  display: flex;\n}\n.weui-form-preview__ft:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-DIALOG-LINE-COLOR);\n  color: var(--weui-DIALOG-LINE-COLOR);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-form-preview__item {\n  overflow: hidden;\n}\n.weui-form-preview__label {\n  float: left;\n  margin-right: 1em;\n  min-width: 4em;\n  color: var(--weui-FG-1);\n  text-align: justify;\n  text-align-last: justify;\n}\n.weui-form-preview__value {\n  display: block;\n  overflow: hidden;\n  word-break: normal;\n  word-wrap: break-word;\n  color: var(--weui-FG-0);\n}\n.weui-form-preview__btn {\n  position: relative;\n  display: block;\n  flex: 1;\n  color: var(--weui-LINK);\n  text-align: center;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\nbutton.weui-form-preview__btn {\n  background-color: transparent;\n  border: 0;\n  outline: 0;\n  line-height: inherit;\n  font-size: inherit;\n}\n.weui-form-preview__btn:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-form-preview__btn:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-left: 1px solid var(--weui-DIALOG-LINE-COLOR);\n  color: var(--weui-DIALOG-LINE-COLOR);\n  transform-origin: 0 0;\n  transform: scaleX(0.5);\n}\n.weui-form-preview__btn:first-child:after {\n  display: none;\n}\n.weui-form-preview__btn_default {\n  color: var(--weui-FG-HALF);\n}\n.weui-form-preview__btn_primary {\n  color: var(--weui-LINK);\n}\n.weui-form-preview__list {\n  padding-top: 24px;\n  padding-bottom: 24px;\n  line-height: 1.4;\n  font-size: 14px;\n  position: relative;\n}\n.weui-form-preview__list:before {\n  content: \"\";\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-form-preview__list:last-child {\n  padding-bottom: 0;\n}\n.weui-form-preview__list .weui-form-preview__label {\n  text-align: left;\n  text-align-last: unset;\n  width: 6em;\n}\n.weui-form-preview__list .weui-form-preview__value {\n  hyphens: auto;\n}\n.weui-form-preview__list .weui-form-preview__item {\n  margin-top: 12px;\n}\n.weui-form-preview__list .weui-form-preview__item:first-child {\n  margin-top: 0;\n}\n.weui-form-preview__list > .weui-cells__title:first-child {\n  margin-top: 0;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cell_select {\n  padding: 0;\n}\n.weui-cell_select .weui-select {\n  padding-right: 30px;\n}\n.weui-cell_select .weui-cell__bd:after {\n  content: \" \";\n  width: 12px;\n  height: 24px;\n  mask-position: 0 0;\n  mask-repeat: no-repeat;\n  mask-size: 100%;\n  background-color: currentColor;\n  color: var(--weui-FG-2);\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n  position: absolute;\n  top: 50%;\n  right: 16px;\n  margin-top: -12px;\n}\n.weui-select {\n  -webkit-appearance: none;\n  border: 0;\n  outline: 0;\n  background-color: transparent;\n  width: 100%;\n  font-size: inherit;\n  height: 56px;\n  line-height: 56px;\n  position: relative;\n  z-index: 1;\n  padding-left: 16px;\n  color: var(--weui-FG-0);\n}\n.weui-cell_select-before {\n  padding-right: 16px;\n}\n.weui-cell_select-before .weui-select {\n  width: 105px;\n  box-sizing: border-box;\n}\n.weui-cell_select-before .weui-cell__hd {\n  position: relative;\n}\n.weui-cell_select-before .weui-cell__hd:after {\n  content: \" \";\n  position: absolute;\n  right: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-right: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 100% 0;\n  transform: scaleX(0.5);\n}\n.weui-cell_select-before .weui-cell__hd:before {\n  content: \" \";\n  width: 12px;\n  height: 24px;\n  mask-position: 0 0;\n  mask-repeat: no-repeat;\n  mask-size: 100%;\n  background-color: currentColor;\n  color: var(--weui-FG-2);\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n  position: absolute;\n  top: 50%;\n  right: 16px;\n  margin-top: -12px;\n}\n.weui-cell_select-before .weui-cell__bd {\n  padding-left: 16px;\n}\n.weui-cell_select-before .weui-cell__bd:after {\n  display: none;\n}\n.weui-cell_select-before.weui-cell_access .weui-cell__hd {\n  line-height: 56px;\n  padding-left: 32px;\n}\n.weui-cell_select-after {\n  padding-left: 16px;\n}\n.weui-cell_select-after .weui-select {\n  padding-left: 0;\n}\n.weui-cell_select-after.weui-cell_access .weui-cell__bd {\n  line-height: 56px;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n*\n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n*\n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n*       http://opensource.org/licenses/MIT\n*\n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cell_vcode {\n  padding-top: 0;\n  padding-right: 0;\n  padding-bottom: 0;\n}\n.weui-vcode-img {\n  margin-left: 5px;\n  height: 56px;\n  vertical-align: middle;\n}\n.weui-vcode-btn {\n  display: inline-block;\n  height: 56px;\n  margin-left: 5px;\n  padding: 0 0.6em 0 0.7em;\n  line-height: 56px;\n  vertical-align: middle;\n  font-size: 17px;\n  color: var(--weui-LINK);\n  position: relative;\n}\n.weui-vcode-btn:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-left: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleX(0.5);\n}\nbutton.weui-vcode-btn {\n  background-color: transparent;\n  border: 0;\n  outline: 0;\n}\n.weui-vcode-btn:active {\n  color: var(--weui-LINK-ACTIVE);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-gallery {\n  display: none;\n  position: fixed;\n  top: 0;\n  right: 0;\n  bottom: 0;\n  left: 0;\n  background-color: #000;\n  z-index: 1000;\n}\n.weui-gallery__img,\n.weui-gallery__opr {\n  position: absolute;\n  left: 0;\n  left: constant(safe-area-inset-left);\n  left: env(safe-area-inset-left);\n  right: 0;\n  right: constant(safe-area-inset-right);\n  right: env(safe-area-inset-right);\n}\n.weui-gallery__img {\n  top: 0;\n  top: constant(safe-area-inset-top);\n  top: env(safe-area-inset-top);\n  bottom: 60px;\n  bottom: calc(60px + constant(safe-area-inset-bottom));\n  bottom: calc(60px + env(safe-area-inset-bottom));\n  width: 100%;\n  background: center center no-repeat;\n  background-size: contain;\n}\n.weui-gallery__opr {\n  position: absolute;\n  bottom: 0;\n  padding-bottom: 0;\n  padding-bottom: constant(safe-area-inset-bottom);\n  padding-bottom: env(safe-area-inset-bottom);\n  background-color: #0d0d0d;\n  color: var(--weui-WHITE);\n  line-height: 60px;\n  text-align: center;\n}\n.weui-gallery__del {\n  display: block;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cell_switch {\n  padding-top: 12px;\n  padding-bottom: 12px;\n}\n.weui-switch {\n  appearance: none;\n}\n.weui-switch,\n.weui-switch-cp__box {\n  position: relative;\n  width: 52px;\n  height: 32px;\n  border: 2px solid var(--weui-FG-3);\n  outline: 0;\n  border-radius: 16px;\n  box-sizing: border-box;\n  transition: background-color 0.1s, border 0.1s;\n}\n.weui-switch:before,\n.weui-switch-cp__box:before {\n  content: \" \";\n  position: absolute;\n  top: 0;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  border-radius: 15px;\n  background-color: var(--weui-BG-3);\n  transition: transform 0.35s cubic-bezier(0.45, 1, 0.4, 1);\n}\n.weui-switch:after,\n.weui-switch-cp__box:after {\n  content: \" \";\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 28px;\n  height: 28px;\n  border-radius: 15px;\n  background-color: #fff;\n  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4);\n  transition: transform 0.35s cubic-bezier(0.4, 0.4, 0.25, 1.35);\n}\n.weui-switch:checked,\n.weui-switch-cp__input:checked + .weui-switch-cp__box,\n.weui-switch-cp__input[aria-checked=\"true\"] + .weui-switch-cp__box {\n  border-color: var(--weui-BRAND);\n  background-color: var(--weui-BRAND);\n}\n.weui-switch:checked:before,\n.weui-switch-cp__input:checked + .weui-switch-cp__box:before,\n.weui-switch-cp__input[aria-checked=\"true\"] + .weui-switch-cp__box:before {\n  transform: scale(0);\n}\n.weui-switch:checked:after,\n.weui-switch-cp__input:checked + .weui-switch-cp__box:after,\n.weui-switch-cp__input[aria-checked=\"true\"] + .weui-switch-cp__box:after {\n  transform: translateX(20px);\n}\n.weui-switch-cp__input {\n  position: absolute;\n  left: -9999px;\n}\n.weui-switch-cp__box {\n  display: block;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cell_uploader {\n  padding-bottom: 24px;\n}\n.weui-uploader {\n  flex: 1;\n}\n.weui-uploader__hd {\n  display: flex;\n  padding-bottom: 16px;\n  align-items: center;\n}\n.weui-uploader__title {\n  flex: 1;\n}\n.weui-uploader__info {\n  color: var(--weui-FG-2);\n}\n.weui-uploader__bd {\n  margin-bottom: -8px;\n  margin-right: -8px;\n  overflow: hidden;\n}\n.weui-uploader__files {\n  list-style: none;\n}\n.weui-uploader__file {\n  float: left;\n  margin-right: 8px;\n  margin-bottom: 8px;\n  width: 96px;\n  height: 96px;\n  background: no-repeat center center;\n  background-size: cover;\n}\n.weui-uploader__file_status {\n  position: relative;\n}\n.weui-uploader__file_status:before {\n  content: \" \";\n  position: absolute;\n  top: 0;\n  right: 0;\n  bottom: 0;\n  left: 0;\n  background-color: rgba(0, 0, 0, 0.5);\n}\n.weui-uploader__file_status .weui-uploader__file-content {\n  display: block;\n}\n.weui-uploader__file-content {\n  display: none;\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  color: var(--weui-WHITE);\n}\n.weui-uploader__file-content .weui-icon-warn {\n  display: inline-block;\n}\n.weui-uploader__input-box {\n  float: left;\n  position: relative;\n  margin-right: 8px;\n  margin-bottom: 8px;\n  width: 96px;\n  height: 96px;\n  box-sizing: border-box;\n  background-color: #ededed;\n}\nbody[data-weui-theme='dark'] .weui-uploader__input-box {\n  background-color: #2e2e2e;\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) .weui-uploader__input-box {\n    background-color: #2e2e2e;\n  }\n}\n.weui-uploader__input-box:before,\n.weui-uploader__input-box:after {\n  content: \" \";\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  background-color: #a3a3a3;\n}\nbody[data-weui-theme='dark'] .weui-uploader__input-box:before,\nbody[data-weui-theme='dark'] .weui-uploader__input-box:after {\n  background-color: #6d6d6d;\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) .weui-uploader__input-box:before,\n  body:not([data-weui-theme='light']) .weui-uploader__input-box:after {\n    background-color: #6d6d6d;\n  }\n}\n.weui-uploader__input-box:before {\n  width: 2px;\n  height: 32px;\n}\n.weui-uploader__input-box:after {\n  width: 32px;\n  height: 2px;\n}\n.weui-uploader__input-box:active:before,\n.weui-uploader__input-box:active:after {\n  opacity: 0.7;\n}\n.weui-uploader__input {\n  position: absolute;\n  z-index: 1;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  opacity: 0;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-msg__desc a,\n.weui-msg__desc-primary a,\n.weui-msg__tips a {\n  color: var(--weui-LINK);\n  display: inline-block;\n  vertical-align: baseline;\n}\n.weui-msg {\n  padding-top: 48px;\n  padding: calc(48px + constant(safe-area-inset-top)) constant(safe-area-inset-right) constant(safe-area-inset-bottom) constant(safe-area-inset-left);\n  padding: calc(48px + env(safe-area-inset-top)) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);\n  text-align: center;\n  line-height: 1.4;\n  min-height: 100%;\n  box-sizing: border-box;\n  display: flex;\n  flex-direction: column;\n  background-color: var(--weui-BG-2);\n}\n.weui-msg__icon-area {\n  margin-bottom: 32px;\n}\n.weui-msg__text-area {\n  margin-bottom: 32px;\n  padding: 0 32px;\n  flex: 1;\n  line-height: 1.6;\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n}\n.weui-msg__text-area:first-child {\n  padding-top: 96px;\n}\n.weui-msg__title {\n  margin-bottom: 16px;\n  font-weight: 400;\n  font-size: 22px;\n  color: #191919;\n  -webkit-text-stroke: 0.02em;\n}\nbody[data-weui-theme='dark'] .weui-msg__title {\n  color: #D1D1D1;\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) .weui-msg__title {\n    color: #D1D1D1;\n  }\n}\n@supports (-webkit-overflow-scrolling:touch) {\n  .weui-msg__title {\n    font-weight: 500;\n    -webkit-text-stroke: initial;\n  }\n}\n.weui-msg__desc {\n  font-size: 17px;\n  font-weight: 400;\n  color: var(--weui-FG-0);\n  margin-bottom: 16px;\n}\n.weui-msg__desc-primary {\n  font-size: 14px;\n  color: var(--weui-FG-1);\n  margin-bottom: 16px;\n}\n.weui-msg__custom-area {\n  text-align: left;\n  word-wrap: break-word;\n  hyphens: auto;\n  margin-bottom: 16px;\n}\n.weui-msg__title + .weui-msg__custom-area {\n  margin-top: 48px;\n}\n.weui-msg__desc + .weui-msg__custom-area,\n.weui-msg__desc-primary + .weui-msg__custom-area {\n  margin-top: 40px;\n}\n.weui-msg__custom-area .weui-cells__group_form .weui-cells:before,\n.weui-msg__custom-area .weui-cells__group_form .weui-cells:after {\n  left: 0;\n  right: 0;\n}\n.weui-msg__custom-area .weui-cells__group_form .weui-cell {\n  padding-left: 0;\n  padding-right: 0;\n}\n.weui-msg__custom-area .weui-cells__group_form .weui-cell:before {\n  left: 0;\n  right: 0;\n}\n.weui-msg__opr-area {\n  margin-bottom: 16px;\n}\n.weui-msg__opr-area .weui-btn-area {\n  margin: 0;\n}\n.weui-msg__opr-area .weui-btn + .weui-btn {\n  margin-bottom: 16px;\n}\n.weui-msg__opr-area:last-child {\n  margin-bottom: 96px;\n}\n.weui-msg__opr-area + .weui-msg__extra-area {\n  margin-top: 48px;\n}\n.weui-msg__tips-area {\n  margin-bottom: 16px;\n  padding: 0 40px;\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n}\n.weui-msg__opr-area + .weui-msg__tips-area {\n  margin-bottom: 48px;\n}\n.weui-msg__tips-area:last-child {\n  margin-bottom: 64px;\n}\n.weui-msg__tips {\n  font-size: 12px;\n  color: var(--weui-FG-1);\n}\n.weui-msg__extra-area {\n  margin-bottom: 24px;\n  font-size: 12px;\n  color: var(--weui-FG-1);\n}\n.weui-msg__extra-area a,\n.weui-msg__extra-area navigator {\n  color: var(--weui-LINK);\n}\n.weui-msg__extra-area navigator {\n  display: inline;\n}\n.weui-msg_align-top .weui-msg__text-area:first-child {\n  padding-top: 0;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-cells__group_form:first-child .weui-cells__title {\n  margin-top: 0;\n}\n.weui-cells__group_form .weui-cells__title {\n  margin-top: 24px;\n  margin-bottom: 8px;\n  padding: 0 32px;\n}\n.weui-cells__group_form .weui-cells:before,\n.weui-cells__group_form .weui-cell:before {\n  left: 32px;\n  right: 32px;\n}\n.weui-cells__group_form .weui-cells_checkbox .weui-check__label:before {\n  left: 72px;\n}\n.weui-cells__group_form .weui-cells:after {\n  left: 32px;\n  right: 32px;\n}\n.weui-cells__group_form .weui-cell {\n  padding: 16px 32px;\n}\n.weui-cells__group_form .weui-cell:not(.weui-cell_link) {\n  color: var(--weui-FG-0);\n}\n.weui-cells__group_form .weui-cell__hd {\n  padding-right: 16px;\n}\n.weui-cells__group_form .weui-cell__ft {\n  padding-left: 16px;\n}\n.weui-cells__group_form .weui-cell_warn input {\n  color: var(--weui-RED);\n}\n.weui-cells__group_form .weui-label {\n  max-width: 5em;\n  margin-right: 8px;\n}\n.weui-cells__group_form .weui-cells__tips {\n  margin-top: 8px;\n  padding: 0 32px;\n  color: var(--weui-FG-2);\n}\n.weui-cells__group_form .weui-cells__tips a {\n  font-weight: 700;\n}\n.weui-cells__group_form .weui-cells__tips_warn {\n  color: var(--weui-RED);\n}\n.weui-cells__group_form .weui-cell_vcode {\n  padding: 12px 32px;\n}\n.weui-cells__group_form .weui-vcode-btn {\n  font-size: 16px;\n  padding: 0 12px;\n  margin-left: 0;\n  height: auto;\n  width: auto;\n  line-height: 2em;\n  color: var(--weui-BTN-DEFAULT-COLOR);\n  background-color: var(--weui-BTN-DEFAULT-BG);\n}\n.weui-cells__group_form .weui-vcode-btn:before {\n  display: none;\n}\n.weui-cells__group_form .weui-cell_select {\n  padding: 0;\n}\n.weui-cells__group_form .weui-cell_select .weui-select {\n  padding: 0 32px;\n}\n.weui-cells__group_form .weui-cell_select .weui-cell__bd:after {\n  right: 32px;\n}\n.weui-cells__group_form .weui-cell_select-before .weui-label {\n  margin-right: 24px;\n}\n.weui-cells__group_form .weui-cell_select-before .weui-select {\n  padding-right: 24px;\n  box-sizing: initial;\n}\n.weui-cells__group_form .weui-cell_select-after {\n  padding-left: 32px;\n}\n.weui-cells__group_form .weui-cell_select-after .weui-select {\n  padding-left: 0;\n}\n.weui-cells__group_form .weui-cell_switch {\n  padding: 12px 32px;\n}\n.weui-form {\n  padding: 56px 0 0;\n  padding: calc(56px + constant(safe-area-inset-top)) constant(safe-area-inset-right) constant(safe-area-inset-bottom) constant(safe-area-inset-left);\n  padding: calc(56px + env(safe-area-inset-top)) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);\n  display: flex;\n  flex-direction: column;\n  line-height: 1.4;\n  min-height: 100%;\n  box-sizing: border-box;\n  background-color: var(--weui-BG-2);\n}\n.weui-form .weui-footer,\n.weui-form .weui-footer__link {\n  font-size: 14px;\n}\n.weui-form .weui-agree {\n  padding: 0;\n}\n.weui-form__text-area {\n  padding: 0 32px;\n  color: var(--weui-FG-0);\n  text-align: center;\n}\n.weui-form__control-area {\n  flex: 1;\n  margin: 48px 0;\n}\n.weui-form__tips-area {\n  overflow: hidden;\n}\n.weui-form__tips-area,\n.weui-form__extra-area {\n  margin-bottom: 24px;\n  text-align: center;\n}\n.weui-form__opr-area {\n  margin-bottom: 64px;\n}\n.weui-form__opr-area:last-child {\n  margin-bottom: 96px;\n}\n.weui-form__title {\n  font-size: 22px;\n  font-weight: 700;\n  line-height: 1.36;\n}\n.weui-form__desc {\n  font-size: 17px;\n  margin-top: 16px;\n}\n.weui-form__tips {\n  color: var(--weui-FG-1);\n  font-size: 14px;\n}\n.weui-form__tips a,\n.weui-form__tips navigator {\n  color: var(--weui-LINK);\n}\n.weui-form__tips navigator {\n  display: inline;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-article {\n  padding: 24px 16px;\n  padding: 24px calc(16px + constant(safe-area-inset-right)) calc(24px + constant(safe-area-inset-bottom)) calc(16px + constant(safe-area-inset-left));\n  padding: 24px calc(16px + env(safe-area-inset-right)) calc(24px + env(safe-area-inset-bottom)) calc(16px + env(safe-area-inset-left));\n  font-size: 17px;\n  color: var(--weui-FG-0);\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n}\n.weui-article section {\n  margin-bottom: 1.5em;\n}\n.weui-article h1 {\n  font-size: 22px;\n  font-weight: 700;\n  margin-bottom: 0.9em;\n  line-height: 1.4;\n}\n.weui-article h2 {\n  font-size: 17px;\n  font-weight: 700;\n  margin-bottom: 0.34em;\n  line-height: 1.4;\n}\n.weui-article h3 {\n  font-weight: 700;\n  font-size: 15px;\n  margin-bottom: 0.34em;\n  line-height: 1.4;\n}\n.weui-article * {\n  max-width: 100%;\n  box-sizing: border-box;\n  word-wrap: break-word;\n}\n.weui-article p {\n  margin: 0 0 0.8em;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-tabbar {\n  display: flex;\n  position: relative;\n  z-index: 500;\n  background-color: var(--weui-BG-1);\n}\n.weui-tabbar:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-tabbar__item {\n  display: block;\n  flex: 1;\n  padding: 8px 0;\n  padding-bottom: calc(8px + constant(safe-area-inset-bottom));\n  padding-bottom: calc(8px + env(safe-area-inset-bottom));\n  font-size: 0;\n  color: var(--weui-FG-1);\n  text-align: center;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.weui-tabbar__item:first-child {\n  padding-left: constant(safe-area-inset-left);\n  padding-left: env(safe-area-inset-left);\n}\n.weui-tabbar__item:last-child {\n  padding-right: constant(safe-area-inset-right);\n  padding-right: env(safe-area-inset-right);\n}\n.weui-tabbar__item.weui-bar__item_on .weui-tabbar__icon,\n.weui-tabbar__item.weui-bar__item_on .weui-tabbar__icon > i,\n.weui-tabbar__item.weui-bar__item_on .weui-tabbar__label {\n  color: var(--weui-BRAND);\n}\n.weui-tabbar__icon {\n  display: inline-block;\n  width: 28px;\n  height: 28px;\n  margin-bottom: 2px;\n}\ni.weui-tabbar__icon,\n.weui-tabbar__icon > i {\n  font-size: 24px;\n  color: var(--weui-FG-1);\n}\n.weui-tabbar__icon img {\n  width: 100%;\n  height: 100%;\n}\n.weui-tabbar__label {\n  color: var(--weui-FG-0);\n  font-size: 10px;\n  line-height: 1.4;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-navbar {\n  display: flex;\n  position: relative;\n  z-index: 500;\n  background-color: var(--weui-BG-2);\n  padding-top: constant(safe-area-inset-top);\n  padding-top: env(safe-area-inset-top);\n}\n.weui-navbar:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n}\n.weui-navbar + .weui-tab__panel {\n  padding-bottom: constant(safe-area-inset-bottom);\n  padding-bottom: env(safe-area-inset-bottom);\n}\n.weui-navbar__item {\n  position: relative;\n  display: block;\n  flex: 1;\n  padding: 16px 0;\n  padding-top: calc(16px + constant(safe-area-inset-top));\n  padding-top: calc(16px + env(safe-area-inset-top));\n  text-align: center;\n  font-size: 17px;\n  line-height: 1.41176471;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.weui-navbar__item:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-navbar__item.weui-bar__item_on {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-navbar__item:after {\n  content: \" \";\n  position: absolute;\n  right: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-right: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 100% 0;\n  transform: scaleX(0.5);\n}\n.weui-navbar__item:first-child {\n  padding-left: constant(safe-area-inset-left);\n  padding-left: env(safe-area-inset-left);\n}\n.weui-navbar__item:last-child {\n  padding-right: constant(safe-area-inset-right);\n  padding-right: env(safe-area-inset-right);\n}\n.weui-navbar__item:last-child:after {\n  display: none;\n}\n.weui-tab {\n  display: flex;\n  height: 100%;\n  box-sizing: border-box;\n  flex-direction: column;\n}\n.weui-tab__panel {\n  box-sizing: border-box;\n  flex: 1;\n  overflow: auto;\n  -webkit-overflow-scrolling: touch;\n}\n.weui-tab__content {\n  display: none;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-progress {\n  display: flex;\n  align-items: center;\n}\n.weui-progress__bar {\n  background-color: var(--weui-BG-0);\n  height: 3px;\n  flex: 1;\n}\n.weui-progress__inner-bar {\n  width: 0;\n  height: 100%;\n  background-color: var(--weui-BRAND);\n}\n.weui-progress__opr {\n  display: block;\n  margin-left: 15px;\n  font-size: 0;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-panel {\n  background-color: var(--weui-BG-2);\n  margin-top: 10px;\n  position: relative;\n  overflow: hidden;\n}\n.weui-panel:first-child {\n  margin-top: 0;\n}\n.weui-panel:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-panel:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n}\n.weui-panel__hd {\n  padding: 16px 16px 13px;\n  color: var(--weui-FG-0);\n  font-size: 15px;\n  font-weight: 700;\n  position: relative;\n}\n.weui-panel__hd:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n  left: 15px;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-media-box {\n  padding: 16px;\n  position: relative;\n}\n.weui-media-box:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n  left: 16px;\n}\n.weui-media-box:first-child:before {\n  display: none;\n}\na.weui-media-box {\n  color: #000;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\na.weui-media-box:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-media-box__title {\n  font-weight: 400;\n  font-size: 17px;\n  line-height: 1.4;\n  color: var(--weui-FG-0);\n  width: auto;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  word-wrap: normal;\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n}\n.weui-media-box__desc {\n  color: var(--weui-FG-2);\n  font-size: 14px;\n  line-height: 1.4;\n  padding-top: 4px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  display: -webkit-box;\n  -webkit-box-orient: vertical;\n  -webkit-line-clamp: 2;\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n}\n.weui-media-box__info {\n  margin-top: 16px;\n  padding-bottom: 4px;\n  font-size: 13px;\n  color: var(--weui-FG-2);\n  line-height: 1em;\n  list-style: none;\n  overflow: hidden;\n}\n.weui-media-box__info__meta {\n  float: left;\n  padding-right: 1em;\n}\n.weui-media-box__info__meta_extra {\n  padding-left: 1em;\n  border-left: 1px solid var(--weui-FG-2);\n}\n.weui-media-box_appmsg {\n  display: flex;\n  align-items: center;\n}\n.weui-media-box_appmsg .weui-media-box__hd {\n  margin-right: 16px;\n  width: 60px;\n  height: 60px;\n  line-height: 60px;\n  text-align: center;\n}\n.weui-media-box_appmsg .weui-media-box__thumb {\n  width: 100%;\n  max-height: 100%;\n  vertical-align: top;\n}\n.weui-media-box_appmsg .weui-media-box__bd {\n  flex: 1;\n  min-width: 0;\n}\n.weui-media-box_small-appmsg {\n  padding: 0;\n}\n.weui-media-box_small-appmsg .weui-cells {\n  margin-top: 0;\n}\n.weui-media-box_small-appmsg .weui-cells:before {\n  display: none;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-grids {\n  position: relative;\n  overflow: hidden;\n}\n.weui-grids:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-grids:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-left: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleX(0.5);\n}\n.weui-grid {\n  position: relative;\n  float: left;\n  padding: 20px 10px;\n  width: 33.33333333%;\n  box-sizing: border-box;\n}\n.weui-grid:before {\n  content: \" \";\n  position: absolute;\n  right: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-right: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 100% 0;\n  transform: scaleX(0.5);\n}\n.weui-grid:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n}\n.weui-grid:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-grid__icon {\n  width: 28px;\n  height: 28px;\n  margin: 0 auto;\n}\n.weui-grid__icon img {\n  display: block;\n  width: 100%;\n  height: 100%;\n}\n.weui-grid__icon + .weui-grid__label {\n  margin-top: 4px;\n}\n.weui-grid__label {\n  display: block;\n  text-align: center;\n  color: var(--weui-FG-0);\n  font-size: 14px;\n  white-space: nowrap;\n  text-overflow: ellipsis;\n  overflow: hidden;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-footer {\n  color: var(--weui-FG-2);\n  font-size: 14px;\n  line-height: 1.4;\n  text-align: center;\n}\n.weui-footer a,\n.weui-footer navigator {\n  color: var(--weui-LINK);\n}\n.weui-footer navigator {\n  display: inline;\n}\n.weui-footer_fixed-bottom {\n  position: fixed;\n  bottom: 0;\n  left: 0;\n  right: 0;\n  padding-top: 16px;\n  padding-bottom: 16px;\n  padding-bottom: calc(16px + constant(safe-area-inset-bottom));\n  padding-bottom: calc(16px + env(safe-area-inset-bottom));\n  left: constant(safe-area-inset-left);\n  left: env(safe-area-inset-left);\n  right: constant(safe-area-inset-right);\n  right: env(safe-area-inset-right);\n}\n.weui-footer__links {\n  font-size: 0;\n}\n.weui-footer__link {\n  display: inline-block;\n  vertical-align: top;\n  margin: 0 8px;\n  position: relative;\n  font-size: 14px;\n}\n.weui-footer__link:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-left: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleX(0.5);\n  left: -8px;\n  top: 0.36em;\n  bottom: 0.36em;\n}\n.weui-footer__link:first-child:before {\n  display: none;\n}\n.weui-footer__text {\n  padding: 0 16px;\n  font-size: 12px;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-flex {\n  display: flex;\n}\n.weui-flex__item {\n  flex: 1;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-dialog {\n  position: fixed;\n  z-index: 5000;\n  top: 50%;\n  left: 16px;\n  right: 16px;\n  transform: translate(0, -50%);\n  background-color: var(--weui-BG-2);\n  text-align: center;\n  border-radius: 12px;\n  overflow: hidden;\n  display: -webkit-box;\n  display: -webkit-flex;\n  display: flex;\n  -webkit-flex-direction: column;\n  flex-direction: column;\n  max-height: 90%;\n}\n.weui-dialog__hd {\n  padding: 32px 24px 16px;\n}\n.weui-dialog__title {\n  font-weight: 700;\n  font-size: 17px;\n  line-height: 1.4;\n}\n.weui-dialog__bd {\n  overflow-y: auto;\n  -webkit-overflow-scrolling: touch;\n  padding: 0 24px;\n  margin-bottom: 32px;\n  font-size: 17px;\n  line-height: 1.4;\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n  color: var(--weui-FG-1);\n}\n.weui-dialog__bd:first-child {\n  min-height: 40px;\n  padding: 32px 24px 0;\n  font-weight: 700;\n  color: var(--weui-FG-0);\n  display: -webkit-box;\n  display: -webkit-flex;\n  display: flex;\n  -webkit-flex-direction: column;\n  flex-direction: column;\n  -webkit-box-pack: center;\n  -webkit-justify-content: center;\n  justify-content: center;\n}\n.weui-dialog__ft {\n  position: relative;\n  line-height: 56px;\n  min-height: 56px;\n  font-size: 17px;\n  display: flex;\n}\n.weui-dialog__ft:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-DIALOG-LINE-COLOR);\n  color: var(--weui-DIALOG-LINE-COLOR);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-dialog__btn {\n  display: block;\n  flex: 1;\n  color: var(--weui-LINK);\n  font-weight: 700;\n  text-decoration: none;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n  position: relative;\n}\n.weui-dialog__btn:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-dialog__btn:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  width: 1px;\n  bottom: 0;\n  border-left: 1px solid var(--weui-DIALOG-LINE-COLOR);\n  color: var(--weui-DIALOG-LINE-COLOR);\n  transform-origin: 0 0;\n  transform: scaleX(0.5);\n}\n.weui-dialog__btn:first-child:after {\n  display: none;\n}\n.weui-dialog__btn_default {\n  color: var(--weui-FG-HALF);\n}\n.weui-skin_android .weui-dialog {\n  text-align: left;\n  box-shadow: 0 6px 30px 0 rgba(0, 0, 0, 0.1);\n}\n.weui-skin_android .weui-dialog__title {\n  font-size: 22px;\n  line-height: 1.4;\n}\n.weui-skin_android .weui-dialog__hd {\n  text-align: left;\n}\n.weui-skin_android .weui-dialog__bd {\n  color: var(--weui-FG-1);\n  text-align: left;\n}\n.weui-skin_android .weui-dialog__bd:first-child {\n  color: var(--weui-FG-0);\n}\n.weui-skin_android .weui-dialog__ft {\n  display: block;\n  text-align: right;\n  line-height: 40px;\n  min-height: 40px;\n  padding: 0 24px 16px;\n}\n.weui-skin_android .weui-dialog__ft:after {\n  display: none;\n}\n.weui-skin_android .weui-dialog__btn {\n  display: inline-block;\n  vertical-align: top;\n  padding: 0 0.8em;\n}\n.weui-skin_android .weui-dialog__btn:after {\n  display: none;\n}\n.weui-skin_android .weui-dialog__btn:last-child {\n  margin-right: -0.8em;\n}\n.weui-skin_android .weui-dialog__btn_default {\n  color: var(--weui-FG-HALF);\n}\n@media screen and (min-width: 352px) {\n  .weui-dialog {\n    width: 320px;\n    margin: 0 auto;\n  }\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-half-screen-dialog {\n  position: fixed;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  max-height: 75%;\n  z-index: 5000;\n  line-height: 1.4;\n  background-color: var(--weui-BG-2);\n  border-top-left-radius: 12px;\n  border-top-right-radius: 12px;\n  overflow: hidden;\n  padding: 0 24px;\n  padding: 0 calc(24px + constant(safe-area-inset-right)) constant(safe-area-inset-bottom) calc(24px + constant(safe-area-inset-left));\n  padding: 0 calc(24px + env(safe-area-inset-right)) env(safe-area-inset-bottom) calc(24px + env(safe-area-inset-left));\n}\n@media only screen and (max-height: 558px) {\n  .weui-half-screen-dialog {\n    max-height: none;\n  }\n}\n.weui-half-screen-dialog__hd {\n  font-size: 8px;\n  height: 8em;\n  display: flex;\n  align-items: center;\n}\n.weui-half-screen-dialog__hd .weui-icon-btn {\n  position: absolute;\n  top: 50%;\n  -webkit-transform: translateY(-50%);\n  transform: translateY(-50%);\n}\n.weui-half-screen-dialog__hd .weui-icon-btn:active {\n  opacity: 0.5;\n}\n.weui-half-screen-dialog__hd__side {\n  position: relative;\n  left: -8px;\n}\n.weui-half-screen-dialog__hd__main {\n  flex: 1;\n}\n.weui-half-screen-dialog__hd__side + .weui-half-screen-dialog__hd__main {\n  text-align: center;\n  padding: 0 40px;\n}\n.weui-half-screen-dialog__hd__main + .weui-half-screen-dialog__hd__side {\n  right: -8px;\n  left: auto;\n}\n.weui-half-screen-dialog__hd__main + .weui-half-screen-dialog__hd__side .weui-icon-btn {\n  right: 0;\n}\n.weui-half-screen-dialog__title {\n  display: block;\n  color: var(--weui-FG-0);\n  font-weight: 700;\n  font-size: 15px;\n}\n.weui-half-screen-dialog__subtitle {\n  display: block;\n  color: var(--weui-FG-1);\n  font-size: 10px;\n}\n.weui-half-screen-dialog__bd {\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n  overflow-y: auto;\n  padding-top: 4px;\n  padding-bottom: 56px;\n  font-size: 14px;\n  color: var(--weui-FG-0);\n}\n.weui-half-screen-dialog__desc {\n  font-size: 17px;\n  font-weight: 700;\n  color: var(--weui-FG-0);\n  line-height: 1.4;\n}\n.weui-half-screen-dialog__tips {\n  padding-top: 16px;\n  font-size: 14px;\n  color: var(--weui-FG-2);\n  line-height: 1.4;\n}\n.weui-half-screen-dialog__ft {\n  padding: 0 0 64px;\n  text-align: center;\n}\n.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2),\n.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2) + .weui-btn {\n  display: inline-block;\n  vertical-align: top;\n  margin: 0 8px;\n  width: 120px;\n}\n.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2):first-child,\n.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2) + .weui-btn:first-child {\n  margin-left: 0;\n}\n.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2):last-child,\n.weui-half-screen-dialog__ft .weui-btn:nth-last-child(n+2) + .weui-btn:last-child {\n  margin-right: 0;\n}\n.weui-half-screen-dialog__btn-area + .weui-half-screen-dialog__attachment-area {\n  margin-top: 24px;\n  margin-bottom: -44px;\n}\n.weui-icon-btn {\n  outline: 0;\n  -webkit-appearance: none;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n  border-width: 0;\n  background-color: transparent;\n  color: var(--weui-FG-0);\n  font-size: 0;\n}\n.weui-icon-more {\n  display: inline-block;\n  vertical-align: middle;\n  width: 24px;\n  height: 24px;\n  mask: url(\"data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E  %3Cpath fill-opacity='.9' fill-rule='evenodd' d='M5 10.25a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5z'/%3E%3C/svg%3E\") no-repeat 50% 50%;\n  -webkit-mask-size: cover;\n  mask-size: cover;\n  background-color: currentColor;\n  color: var(--weui-FG-0);\n}\n.weui-icon-btn_goback {\n  color: var(--weui-FG-0);\n  display: inline-block;\n  vertical-align: middle;\n  width: 12px;\n  height: 24px;\n  mask: url(\"data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10%2019.438L8.955%2020.5l-7.666-7.79a1.02%201.02%200%20010-1.42L8.955%203.5%2010%204.563%202.682%2012%2010%2019.438z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E\") no-repeat 50% 50%;\n  -webkit-mask-size: cover;\n  mask-size: cover;\n  background-color: currentColor;\n}\n.weui-icon-btn_close {\n  color: var(--weui-FG-0);\n  display: inline-block;\n  vertical-align: middle;\n  width: 14px;\n  height: 24px;\n  mask: url(\"data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.25%2010.693L6.057%204.5%205%205.557l6.193%206.193L5%2017.943%206.057%2019l6.193-6.193L18.443%2019l1.057-1.057-6.193-6.193L19.5%205.557%2018.443%204.5z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E\") no-repeat 50% 50%;\n  -webkit-mask-size: cover;\n  mask-size: cover;\n  background-color: currentColor;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-toast {\n  position: fixed;\n  z-index: 5000;\n  width: 136px;\n  height: 136px;\n  top: 40%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  text-align: center;\n  border-radius: 12px;\n  color: rgba(255, 255, 255, 0.9);\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: center;\n  background-color: var(--weui-BG-4);\n  box-sizing: border-box;\n  line-height: 1.4;\n}\n.weui-toast_text {\n  height: auto;\n  min-width: 152px;\n  max-width: 216px;\n  padding: 12px 0;\n}\n.weui-toast_text .weui-toast__content {\n  font-size: 14px;\n}\n.weui-icon_toast {\n  display: block;\n  width: 40px;\n  height: 40px;\n  margin-bottom: 16px;\n}\n.weui-icon_toast.weui-icon-success-no-circle {\n  color: rgba(255, 255, 255, 0.9);\n}\n.weui-icon_toast.weui-icon-warn {\n  color: rgba(255, 255, 255, 0.9);\n}\n.weui-icon_toast.weui-loading {\n  width: 36px;\n  height: 36px;\n}\n.weui-icon_toast.weui-primary-loading {\n  font-size: 40px;\n  color: #EDEDED;\n}\n.weui-icon_toast.weui-primary-loading:before {\n  border-width: 4px 0 4px 4px;\n}\n.weui-icon_toast.weui-primary-loading:after {\n  border-width: 4px 4px 4px 0;\n}\n.weui-icon_toast.weui-primary-loading .weui-primary-loading__dot {\n  width: 4px;\n  height: 4px;\n  border-top-right-radius: 4px;\n  border-bottom-right-radius: 4px;\n}\n.weui-toast__content {\n  font-size: 17px;\n  padding: 0 12px;\n  word-wrap: break-word;\n  -webkit-hyphens: auto;\n  hyphens: auto;\n}\n.weui-toast_text-more .weui-icon_toast {\n  margin-bottom: 12px;\n}\n.weui-toast_text-more .weui-toast__content {\n  font-size: 14px;\n  line-height: 1.6;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-mask {\n  position: fixed;\n  z-index: 1000;\n  top: 0;\n  right: 0;\n  left: 0;\n  bottom: 0;\n  background: rgba(0, 0, 0, 0.6);\n}\n.weui-mask_transparent {\n  position: fixed;\n  z-index: 1000;\n  top: 0;\n  right: 0;\n  left: 0;\n  bottom: 0;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-actionsheet {\n  position: fixed;\n  left: 0;\n  bottom: 0;\n  transform: translate(0, 100%);\n  backface-visibility: hidden;\n  z-index: 5000;\n  width: 100%;\n  background-color: var(--weui-BG-1);\n  transition: transform 0.3s;\n  border-top-left-radius: 12px;\n  border-top-right-radius: 12px;\n  overflow: hidden;\n}\n.weui-actionsheet__title {\n  position: relative;\n  height: 56px;\n  padding: 0 24px;\n  display: flex;\n  justify-content: center;\n  flex-direction: column;\n  text-align: center;\n  font-size: 12px;\n  color: var(--weui-FG-1);\n  line-height: 1.4;\n  background: var(--weui-BG-2);\n}\n.weui-actionsheet__title:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n}\n.weui-actionsheet__title .weui-actionsheet__title-text {\n  overflow: hidden;\n  text-overflow: ellipsis;\n  display: -webkit-box;\n  -webkit-box-orient: vertical;\n  -webkit-line-clamp: 2;\n}\n.weui-actionsheet__menu {\n  color: var(--weui-FG-0);\n  background-color: var(--weui-BG-2);\n}\n.weui-actionsheet__action {\n  margin-top: 8px;\n  color: var(--weui-FG-0);\n  background-color: var(--weui-BG-2);\n  padding-bottom: constant(safe-area-inset-bottom);\n  padding-bottom: env(safe-area-inset-bottom);\n}\n.weui-actionsheet__cell {\n  position: relative;\n  padding: 16px;\n  text-align: center;\n  font-size: 17px;\n  line-height: 1.41176471;\n}\n.weui-actionsheet__cell:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-actionsheet__cell:active {\n  background-color: var(--weui-BG-COLOR-ACTIVE);\n}\n.weui-actionsheet__cell:first-child:before {\n  display: none;\n}\n.weui-actionsheet__cell_warn {\n  color: var(--weui-RED);\n}\n.weui-skin_android .weui-actionsheet {\n  position: fixed;\n  left: 50%;\n  top: 50%;\n  bottom: auto;\n  transform: translate(-50%, -50%);\n  width: 274px;\n  box-sizing: border-box;\n  backface-visibility: hidden;\n  background: transparent;\n  transition: transform 0.3s;\n  border-top-left-radius: 0;\n  border-top-right-radius: 0;\n}\n.weui-skin_android .weui-actionsheet__action {\n  display: none;\n}\n.weui-skin_android .weui-actionsheet__menu {\n  border-radius: 2px;\n  box-shadow: 0 6px 30px 0 rgba(0, 0, 0, 0.1);\n}\n.weui-skin_android .weui-actionsheet__cell {\n  padding: 16px;\n  font-size: 17px;\n  line-height: 1.41176471;\n  color: var(--weui-FG-0);\n  text-align: left;\n}\n.weui-skin_android .weui-actionsheet__cell:first-child {\n  border-top-left-radius: 2px;\n  border-top-right-radius: 2px;\n}\n.weui-skin_android .weui-actionsheet__cell:last-child {\n  border-bottom-left-radius: 2px;\n  border-bottom-right-radius: 2px;\n}\n.weui-actionsheet_toggle {\n  transform: translate(0, 0);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-loadmore {\n  width: 65%;\n  margin: 20px auto;\n  text-align: center;\n  font-size: 0;\n}\n.weui-loadmore .weui-loading,\n.weui-loadmore .weui-primary-loading {\n  margin-right: 8px;\n}\n.weui-loadmore__tips {\n  display: inline-block;\n  vertical-align: middle;\n  font-size: 14px;\n  line-height: 1.6;\n  color: var(--weui-FG-0);\n}\n.weui-loadmore_line {\n  border-top: 1px solid var(--weui-FG-3);\n  margin-top: 32px;\n}\n.weui-loadmore_line .weui-loadmore__tips {\n  position: relative;\n  top: -0.9em;\n  padding: 0 0.55em;\n  background-color: var(--weui-BG-2);\n  color: var(--weui-FG-1);\n}\n.weui-loadmore_dot .weui-loadmore__tips {\n  padding: 0 0.16em;\n}\n.weui-loadmore_dot .weui-loadmore__tips:before {\n  content: \" \";\n  width: 4px;\n  height: 4px;\n  border-radius: 50%;\n  background-color: var(--weui-FG-3);\n  display: inline-block;\n  position: relative;\n  vertical-align: 0;\n  top: -0.16em;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-badge {\n  display: inline-block;\n  padding: 0.15em 0.4em;\n  min-width: 8px;\n  border-radius: 18px;\n  background-color: var(--weui-RED);\n  color: #fff;\n  line-height: 1.2;\n  text-align: center;\n  font-size: 12px;\n  vertical-align: middle;\n}\n.weui-badge_dot {\n  padding: 0.4em;\n  min-width: 0;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-toptips {\n  display: none;\n  position: fixed;\n  transform: translateZ(0);\n  top: 8px;\n  left: 8px;\n  right: 8px;\n  padding: 10px;\n  border-radius: 8px;\n  font-size: 14px;\n  text-align: center;\n  color: #fff;\n  z-index: 5000;\n  word-wrap: break-word;\n  word-break: break-all;\n}\n.weui-toptips_warn {\n  background-color: var(--weui-RED);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-list-tips {\n  list-style: none;\n  padding-top: 24px;\n  padding-bottom: 24px;\n  line-height: 1.4;\n  font-size: 14px;\n  color: var(--weui-FG-1);\n  position: relative;\n}\n.weui-list-tips:before {\n  content: \"\";\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-list-tips:last-child {\n  padding-bottom: 0;\n}\n.weui-list-tips__item {\n  position: relative;\n  padding-left: 15px;\n  margin: 16px 0;\n}\n.weui-list-tips__item:before {\n  content: \"\\2022\";\n  position: absolute;\n  left: 0;\n  top: -0.1em;\n}\n.weui-list-tips__item:first-child {\n  margin-top: 0;\n}\n.weui-form-preview__list + .weui-list-tips > .weui-list-tips__item:first-child {\n  margin-top: 6px;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-search-bar {\n  position: relative;\n  padding: 8px;\n  display: flex;\n  box-sizing: border-box;\n  background-color: var(--weui-BG-0);\n  -webkit-text-size-adjust: 100%;\n  align-items: center;\n}\n.weui-search-bar.weui-search-bar_focusing .weui-search-bar__cancel-btn {\n  display: block;\n}\n.weui-search-bar.weui-search-bar_focusing .weui-search-bar__label {\n  display: none;\n}\n.weui-search-bar .weui-icon-search {\n  width: 16px;\n  height: 16px;\n}\n.weui-search-bar__form {\n  position: relative;\n  flex: auto;\n  background-color: var(--weui-BG-2);\n  border-radius: 4px;\n}\n.weui-search-bar__box {\n  position: relative;\n  padding-left: 28px;\n  padding-right: 32px;\n  height: 100%;\n  width: 100%;\n  box-sizing: border-box;\n  z-index: 1;\n}\n.weui-search-bar__box .weui-search-bar__input {\n  padding: 8px 0;\n  width: 100%;\n  height: 1.14285714em;\n  border: 0;\n  font-size: 14px;\n  line-height: 1.14285714em;\n  box-sizing: content-box;\n  background: transparent;\n  caret-color: var(--weui-BRAND);\n  color: var(--weui-FG-0);\n}\n.weui-search-bar__box .weui-search-bar__input:focus {\n  outline: none;\n}\n.weui-search-bar__box .weui-icon-search {\n  position: absolute;\n  top: 50%;\n  left: 8px;\n  margin-top: -8px;\n}\n.weui-search-bar__box .weui-icon-clear {\n  position: absolute;\n  top: 50%;\n  right: 0;\n  margin-top: -16px;\n  padding: 8px;\n  width: 16px;\n  height: 16px;\n  mask-size: 16px;\n}\n.weui-search-bar__label {\n  position: absolute;\n  top: 0;\n  right: 0;\n  bottom: 0;\n  left: 0;\n  z-index: 2;\n  font-size: 0;\n  border-radius: 4px;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  color: var(--weui-FG-1);\n  background: var(--weui-BG-2);\n}\n.weui-search-bar__label span {\n  display: inline-block;\n  font-size: 14px;\n  vertical-align: middle;\n}\n.weui-search-bar__label .weui-icon-search {\n  margin-right: 4px;\n}\n.weui-search-bar__cancel-btn {\n  display: none;\n  margin-left: 8px;\n  line-height: 28px;\n  color: var(--weui-LINK);\n  white-space: nowrap;\n}\n.weui-search-bar__input:not(:valid) + .weui-icon-clear {\n  display: none;\n}\ninput[type=\"search\"]::-webkit-search-decoration,\ninput[type=\"search\"]::-webkit-search-cancel-button,\ninput[type=\"search\"]::-webkit-search-results-button,\ninput[type=\"search\"]::-webkit-search-results-decoration {\n  display: none;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-picker {\n  position: fixed;\n  width: 100%;\n  box-sizing: border-box;\n  left: 0;\n  bottom: 0;\n  z-index: 5000;\n  background-color: var(--weui-BG-2);\n  padding-bottom: constant(safe-area-inset-bottom);\n  padding-bottom: env(safe-area-inset-bottom);\n  backface-visibility: hidden;\n  transform: translate(0, 100%);\n  transition: transform 0.3s;\n}\n.weui-picker__hd {\n  display: flex;\n  padding: 16px;\n  padding: 16px calc(16px + constant(safe-area-inset-right)) 16px calc(16px + constant(safe-area-inset-left));\n  padding: 16px calc(16px + env(safe-area-inset-right)) 16px calc(16px + env(safe-area-inset-left));\n  position: relative;\n  text-align: center;\n  font-size: 17px;\n  line-height: 1.4;\n}\n.weui-picker__hd:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n}\n.weui-picker__bd {\n  display: flex;\n  position: relative;\n  background-color: var(--weui-BG-2);\n  height: 240px;\n  overflow: hidden;\n}\n.weui-picker__group {\n  flex: 1;\n  position: relative;\n  height: 100%;\n}\n.weui-picker__group:first-child .weui-picker__item {\n  padding-left: constant(safe-area-inset-left);\n  padding-left: env(safe-area-inset-left);\n}\n.weui-picker__group:last-child .weui-picker__item {\n  padding-right: constant(safe-area-inset-right);\n  padding-right: env(safe-area-inset-right);\n}\n.weui-picker__mask {\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  margin: 0 auto;\n  z-index: 3;\n  background-image: linear-gradient(180deg, rgba(255, 255, 255, 0.95), rgba(255, 255, 255, 0.6)), linear-gradient(0deg, rgba(255, 255, 255, 0.95), rgba(255, 255, 255, 0.6));\n  background-position: top, bottom;\n  background-size: 100% 92px;\n  background-repeat: no-repeat;\n  transform: translateZ(0);\n}\nbody[data-weui-theme='dark'] .weui-picker__mask {\n  background-image: linear-gradient(180deg, rgba(25, 25, 25, 0.95), rgba(25, 25, 25, 0.6)), linear-gradient(0deg, rgba(25, 25, 25, 0.95), rgba(25, 25, 25, 0.6));\n}\n@media (prefers-color-scheme: dark) {\n  body:not([data-weui-theme='light']) .weui-picker__mask {\n    background-image: linear-gradient(180deg, rgba(25, 25, 25, 0.95), rgba(25, 25, 25, 0.6)), linear-gradient(0deg, rgba(25, 25, 25, 0.95), rgba(25, 25, 25, 0.6));\n  }\n}\n.weui-picker__indicator {\n  width: 100%;\n  height: 56px;\n  position: absolute;\n  left: 0;\n  top: 92px;\n  z-index: 3;\n}\n.weui-picker__indicator:before {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  top: 0;\n  right: 0;\n  height: 1px;\n  border-top: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 0;\n  transform: scaleY(0.5);\n}\n.weui-picker__indicator:after {\n  content: \" \";\n  position: absolute;\n  left: 0;\n  bottom: 0;\n  right: 0;\n  height: 1px;\n  border-bottom: 1px solid var(--weui-FG-3);\n  color: var(--weui-FG-3);\n  transform-origin: 0 100%;\n  transform: scaleY(0.5);\n}\n.weui-picker__content {\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n}\n.weui-picker__item {\n  height: 48px;\n  line-height: 48px;\n  text-align: center;\n  color: var(--weui-FG-0);\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n}\n.weui-picker__item_disabled {\n  color: var(--weui-FG-1);\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n@keyframes slideUp {\n  from {\n    transform: translate3d(0, 100%, 0);\n  }\n  to {\n    transform: translate3d(0, 0, 0);\n  }\n}\n.weui-animate-slide-up {\n  animation: slideUp ease 0.3s forwards;\n}\n@keyframes slideDown {\n  from {\n    transform: translate3d(0, 0, 0);\n  }\n  to {\n    transform: translate3d(0, 100%, 0);\n  }\n}\n.weui-animate-slide-down {\n  animation: slideDown ease 0.3s forwards;\n}\n@keyframes fadeIn {\n  from {\n    opacity: 0;\n  }\n  to {\n    opacity: 1;\n  }\n}\n.weui-animate-fade-in {\n  animation: fadeIn ease 0.3s forwards;\n}\n@keyframes fadeOut {\n  from {\n    opacity: 1;\n  }\n  to {\n    opacity: 0;\n  }\n}\n.weui-animate-fade-out {\n  animation: fadeOut ease 0.3s forwards;\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-agree {\n  display: block;\n  padding: 8px 15px 0;\n  font-size: 14px;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.weui-agree a,\n.weui-agree navigator {\n  color: var(--weui-LINK);\n}\n.weui-agree navigator {\n  display: inline;\n}\n.weui-agree__text {\n  color: var(--weui-FG-1);\n  margin-left: 2px;\n}\n.weui-agree__checkbox {\n  appearance: none;\n  display: inline-block;\n  border: 0;\n  outline: 0;\n  vertical-align: middle;\n  background-color: currentColor;\n  mask-position: 0 0;\n  mask-repeat: no-repeat;\n  mask-size: 100%;\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E);\n  color: var(--weui-FG-2);\n  width: 1em;\n  height: 1em;\n  font-size: 17px;\n  margin-top: -0.2em;\n}\n.weui-agree__checkbox-check {\n  position: absolute;\n  left: -9999px;\n}\n.weui-agree__checkbox:checked,\n.weui-agree__checkbox-check[aria-checked=\"true\"] + .weui-agree__checkbox {\n  mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E);\n  color: var(--weui-BRAND);\n}\n.weui-agree_animate {\n  animation: weuiAgree 0.3s 1;\n}\n@keyframes weuiAgree {\n  0% {\n    transform: translateX(0);\n  }\n  16% {\n    transform: translateX(-8px);\n  }\n  28% {\n    transform: translateX(-16px);\n  }\n  44% {\n    transform: translateX(0);\n  }\n  59% {\n    transform: translateX(-16px);\n  }\n  73% {\n    transform: translateX(0);\n  }\n  82% {\n    transform: translateX(16px);\n  }\n  94% {\n    transform: translateX(8px);\n  }\n  100% {\n    transform: translateX(0);\n  }\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-primary-loading {\n  font-size: 16px;\n  display: inline-flex;\n  position: relative;\n  width: 1em;\n  height: 1em;\n  vertical-align: middle;\n  color: #606060;\n  animation: circleLoading 1s steps(60, end) infinite;\n}\n.weui-primary-loading:before,\n.weui-primary-loading:after {\n  content: \"\";\n  display: block;\n  width: 0.5em;\n  height: 1em;\n  box-sizing: border-box;\n  border: 0.125em solid;\n  border-color: currentColor;\n}\n.weui-primary-loading:before {\n  border-right-width: 0;\n  border-top-left-radius: 1em;\n  border-bottom-left-radius: 1em;\n  -webkit-mask-image: linear-gradient(180deg, #000000 8%, rgba(0, 0, 0, 0.3) 95%);\n}\n.weui-primary-loading:after {\n  border-left-width: 0;\n  border-top-right-radius: 1em;\n  border-bottom-right-radius: 1em;\n  -webkit-mask-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 8%, rgba(0, 0, 0, 0.3) 95%);\n}\n.weui-primary-loading__dot {\n  position: absolute;\n  top: 0;\n  left: 50%;\n  margin-left: -0.0625em;\n  width: 0.125em;\n  height: 0.125em;\n  border-top-right-radius: 0.125em;\n  border-bottom-right-radius: 0.125em;\n  background: currentColor;\n}\n@keyframes circleLoading {\n  0% {\n    transform: rotate3d(0, 0, 1, 0deg);\n  }\n  100% {\n    transform: rotate3d(0, 0, 1, 360deg);\n  }\n}\n.weui-primary-loading_brand {\n  color: var(--weui-BRAND);\n}\n.weui-primary-loading_transparent {\n  color: #EDEDED;\n}\n.weui-loading {\n  width: 20px;\n  height: 20px;\n  display: inline-block;\n  vertical-align: middle;\n  animation: weuiLoading 1s steps(12, end) infinite;\n  background: transparent url(\"data:image/svg+xml;charset=utf8, %3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120' viewBox='0 0 100 100'%3E%3Cpath fill='none' d='M0 0h100v100H0z'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23E9E9E9' rx='5' ry='5' transform='translate(0 -30)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23989697' rx='5' ry='5' transform='rotate(30 105.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%239B999A' rx='5' ry='5' transform='rotate(60 75.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23A3A1A2' rx='5' ry='5' transform='rotate(90 65 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23ABA9AA' rx='5' ry='5' transform='rotate(120 58.66 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23B2B2B2' rx='5' ry='5' transform='rotate(150 54.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23BAB8B9' rx='5' ry='5' transform='rotate(180 50 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23C2C0C1' rx='5' ry='5' transform='rotate(-150 45.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23CBCBCB' rx='5' ry='5' transform='rotate(-120 41.34 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23D2D2D2' rx='5' ry='5' transform='rotate(-90 35 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23DADADA' rx='5' ry='5' transform='rotate(-60 24.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23E2E2E2' rx='5' ry='5' transform='rotate(-30 -5.98 65)'/%3E%3C/svg%3E\") no-repeat;\n  background-size: 100%;\n}\n.weui-loading.weui-loading_transparent,\n.weui-btn_loading.weui-btn_primary .weui-loading {\n  background-image: url(\"data:image/svg+xml;charset=utf8, %3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120' viewBox='0 0 100 100'%3E%3Cpath fill='none' d='M0 0h100v100H0z'/%3E%3Crect xmlns='http://www.w3.org/2000/svg' width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.56)' rx='5' ry='5' transform='translate(0 -30)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.5)' rx='5' ry='5' transform='rotate(30 105.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.43)' rx='5' ry='5' transform='rotate(60 75.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.38)' rx='5' ry='5' transform='rotate(90 65 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.32)' rx='5' ry='5' transform='rotate(120 58.66 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.28)' rx='5' ry='5' transform='rotate(150 54.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.25)' rx='5' ry='5' transform='rotate(180 50 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.2)' rx='5' ry='5' transform='rotate(-150 45.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.17)' rx='5' ry='5' transform='rotate(-120 41.34 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.14)' rx='5' ry='5' transform='rotate(-90 35 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.1)' rx='5' ry='5' transform='rotate(-60 24.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.03)' rx='5' ry='5' transform='rotate(-30 -5.98 65)'/%3E%3C/svg%3E\");\n}\n@-webkit-keyframes weuiLoading {\n  0% {\n    transform: rotate3d(0, 0, 1, 0deg);\n  }\n  100% {\n    transform: rotate3d(0, 0, 1, 360deg);\n  }\n}\n@keyframes weuiLoading {\n  0% {\n    transform: rotate3d(0, 0, 1, 0deg);\n  }\n  100% {\n    transform: rotate3d(0, 0, 1, 360deg);\n  }\n}\n/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n.weui-slider {\n  padding: 15px 18px;\n  user-select: none;\n}\n.weui-slider__inner {\n  position: relative;\n  height: 2px;\n  background-color: var(--weui-FG-3);\n}\n.weui-slider__track {\n  height: 2px;\n  background-color: var(--weui-BRAND);\n  width: 0;\n}\n.weui-slider__handler {\n  position: absolute;\n  left: 0;\n  top: 50%;\n  width: 28px;\n  height: 28px;\n  margin-left: -14px;\n  margin-top: -14px;\n  border-radius: 50%;\n  background-color: #fff;\n  box-shadow: 0 0 4px var(--weui-FG-3);\n}\n.weui-slider-box {\n  display: flex;\n  align-items: center;\n}\n.weui-slider-box .weui-slider {\n  flex: 1;\n}\n.weui-slider-box__value {\n  margin-left: 0.5em;\n  min-width: 24px;\n  color: var(--weui-FG-1);\n  text-align: center;\n  font-size: 14px;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"fn\";\n\nhtml {\n    -ms-text-size-adjust: 100%;\n    -webkit-text-size-adjust: 100%;\n}\n\nbody {\n    line-height: 1.6;\n    font-family: @weuiFontDefault;\n}\n\n* {\n    margin: 0;\n    padding: 0;\n}\n\na img {\n    border: 0;\n}\n\na {\n    text-decoration: none;\n    .setTapColor();\n}\ninput,\ntextarea {\n    caret-color: @weuiColorPrimary;\n}\n::placeholder, {\n    color: var(--weui-FG-2);\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n.setTapColor(@c:rgba(0,0,0,0)) {\n    -webkit-tap-highlight-color: @c;\n}\n\n\n\n\n","@import 'fn';\n\nbody {\n    .varsLight();\n}\n\n@media (prefers-color-scheme: dark) {\n    body:not([data-weui-theme='light']) {\n        .varsDark();\n    }\n}\n\nbody[data-weui-theme='dark'] {\n    .varsDark();\n}\n",".varsLight() {\n    --weui-BG-0: #ededed;\n    --weui-BG-1: #f7f7f7;\n    --weui-BG-2: #fff;\n    --weui-BG-3: #f7f7f7;\n    --weui-BG-4: #4c4c4c;\n    --weui-BG-5: #fff;\n    --weui-FG-0: rgba(0, 0, 0, 0.9);\n    --weui-FG-HALF: rgba(0, 0, 0, 0.9);\n    --weui-FG-1: rgba(0, 0, 0, 0.5);\n    --weui-FG-2: rgba(0, 0, 0, 0.3);\n    --weui-FG-3: rgba(0, 0, 0, 0.1);\n    --weui-RED: #fa5151;\n    --weui-ORANGE: #fa9d3b;\n    --weui-YELLOW: #ffc300;\n    --weui-GREEN: #91d300;\n    --weui-LIGHTGREEN: #95ec69;\n    --weui-BRAND: #07c160;\n    --weui-BLUE: #10aeff;\n    --weui-INDIGO: #1485ee;\n    --weui-PURPLE: #6467f0;\n    --weui-WHITE: #fff;\n    --weui-LINK: #576b95;\n    --weui-LINK-ACTIVE: fade(#576b95, 50%);\n    --weui-TEXTGREEN: #06ae56;\n    --weui-FG: black;\n    --weui-BG: white;\n    --weui-TAG-TEXT-ORANGE: #fa9d3b;\n    --weui-TAG-BACKGROUND-ORANGE: rgba(250, 157, 59, 0.1);\n    --weui-TAG-TEXT-GREEN: #06ae56;\n    --weui-TAG-BACKGROUND-GREEN: rgba(6, 174, 86, 0.1);\n    --weui-TAG-TEXT-BLUE: #10aeff;\n    --weui-TAG-BACKGROUND-BLUE: rgba(16, 174, 255, 0.1);\n    --weui-TAG-TEXT-BLACK: rgba(0, 0, 0, 0.5);\n    --weui-TAG-BACKGROUND-BLACK: rgba(0, 0, 0, 0.05);\n}\n",".varsDark() {\n    --weui-BG-0: #111111;\n    --weui-BG-1: #1e1e1e;\n    --weui-BG-2: #191919;\n    --weui-BG-3: #202020;\n    --weui-BG-4: #404040;\n    --weui-BG-5: #2c2c2c;\n    --weui-FG-0: rgba(255, 255, 255, 0.8);\n    --weui-FG-HALF: rgba(255, 255, 255, 0.6);\n    --weui-FG-1: rgba(255, 255, 255, 0.5);\n    --weui-FG-2: rgba(255, 255, 255, 0.3);\n    --weui-FG-3: rgba(255, 255, 255, 0.05);\n    --weui-RED: #fa5151;\n    --weui-ORANGE: #c87d2f;\n    --weui-YELLOW: #cc9c00;\n    --weui-GREEN: #74a800;\n    --weui-LIGHTGREEN: #3eb575;\n    --weui-BRAND: #07c160;\n    --weui-BLUE: #10aeff;\n    --weui-INDIGO: #1196ff;\n    --weui-PURPLE: #8183ff;\n    --weui-WHITE: rgba(255, 255, 255, 0.8);\n    --weui-LINK: #7d90a9;\n    --weui-LINK-ACTIVE: fade(#7d90a9, 50%);\n    --weui-TEXTGREEN: #259c5c;\n    --weui-FG: white;\n    --weui-BG: black;\n    --weui-TAG-TEXT-ORANGE: rgba(250, 157, 59, 0.6);\n    --weui-TAG-BACKGROUND-ORANGE: rgba(250, 157, 59, 0.1);\n    --weui-TAG-TEXT-GREEN: rgba(6, 174, 86, 0.6);\n    --weui-TAG-BACKGROUND-GREEN: rgba(6, 174, 86, 0.1);\n    --weui-TAG-TEXT-BLUE: rgba(16, 174, 255, 0.6);\n    --weui-TAG-BACKGROUND-BLUE: rgba(16, 174, 255, 0.1);\n    --weui-TAG-TEXT-BLACK: rgba(255, 255, 255, 0.5);\n    --weui-TAG-BACKGROUND-BLACK: rgba(255, 255, 255, 0.05);\n};\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/* stylelint-disable no-duplicate-selectors */\n\n@import \"../base/variable/color\";\n\n[class^=\"weui-icon-\"],\n[class*=\" weui-icon-\"] {\n    display: inline-block;\n    vertical-align: middle;\n    width: 24px;\n    height: 24px;\n    mask-position: 50% 50%;\n    mask-repeat: no-repeat;\n    mask-size: 100%;\n    background-color: currentColor;\n\n    // 平滑升级\n    //&:not([class^=\"weui-icon_\"]):not([class*=\" weui-icon_\"]){\n    //    font-size:14px;\n    //    margin-left: .2em;\n    //    margin-right: .2em;\n    //}\n}\n\n\n// icon map\n.weui-icon-circle {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-download {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M11.25%2012.04l-1.72-1.72-1.06%201.06%202.828%202.83a1%201%200%20001.414-.001l2.828-2.828-1.06-1.061-1.73%201.73V7h-1.5v5.04zm0-5.04V2h1.5v5h6.251c.55%200%20.999.446.999.996v13.008a.998.998%200%2001-.996.996H4.996A.998.998%200%20014%2021.004V7.996A1%201%200%20014.999%207h6.251z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-info {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-.75-12v7h1.5v-7h-1.5zM12%209a1%201%200%20100-2%201%201%200%20000%202z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-safe-success {\n    mask-image: url(data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%201000%201000%22%3E%3Cpath%20d%3D%22M500.9%204.6C315.5%2046.7%20180.4%2093.1%2057.6%20132c0%20129.3.2%20231.7.2%20339.7%200%20304.2%20248.3%20471.6%20443.1%20523.7C695.7%20943.3%20944%20775.9%20944%20471.7c0-108%20.2-210.4.2-339.7C821.4%2093.1%20686.3%2046.7%20500.9%204.6zm248.3%20349.1l-299.7%20295c-2.1%202-5.3%202-7.4-.1L304.4%20506.1c-2-2.1-2.3-5.7-.6-8l18.3-24.9c1.7-2.3%205-2.8%207.2-1l112.2%2086c2.3%201.8%206%201.7%208.1-.1l274.7-228.9c2.2-1.8%205.7-1.7%207.7.3l17%2016.8c2.2%202.1%202.2%205.3.2%207.4z%22%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20fill%3D%22%23070202%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-safe-warn {\n    mask-image: url(data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%201000%201000%22%3E%3Cpath%20d%3D%22M500.9%204.5c-185.4%2042-320.4%2088.4-443.2%20127.3%200%20129.3.2%20231.7.2%20339.6%200%20304.1%20248.2%20471.4%20443%20523.6%20194.7-52.2%20443-219.5%20443-523.6%200-107.9.2-210.3.2-339.6C821.3%2092.9%20686.2%2046.5%20500.9%204.5zm-26.1%20271.1h52.1c5.8%200%2010.3%204.7%2010.1%2010.4l-11.6%20313.8c-.1%202.8-2.5%205.2-5.4%205.2h-38.2c-2.9%200-5.3-2.3-5.4-5.2L464.8%20286c-.2-5.8%204.3-10.4%2010-10.4zm26.1%20448.3c-20.2%200-36.5-16.3-36.5-36.5s16.3-36.5%2036.5-36.5%2036.5%2016.3%2036.5%2036.5-16.4%2036.5-36.5%2036.5z%22%20fill-rule%3D%22evenodd%22%20clip-rule%3D%22evenodd%22%20fill%3D%22%23020202%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success-circle {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6zm-1.172-6.242l5.809-5.808.848.849-5.95%205.95a1%201%200%2001-1.414%200L7%2012.426l.849-.849%202.98%202.98z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success-no-circle {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.657%2018.435L3%2012.778l1.414-1.414%204.95%204.95L20.678%205l1.414%201.414-12.02%2012.021a1%201%200%2001-1.415%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-waiting {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.75%2011.38V6h-1.5v6l4.243%204.243%201.06-1.06-3.803-3.804zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-waiting-circle {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.6%2011.503l3.891%203.891-.848.849L11.4%2012V6h1.2v5.503zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-warn {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-.763-15.864l.11%207.596h1.305l.11-7.596h-1.525zm.759%2010.967c.512%200%20.902-.383.902-.882%200-.5-.39-.882-.902-.882a.878.878%200%2000-.896.882c0%20.499.396.882.896.882z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-info-circle {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6zM11.4%2010h1.2v7h-1.2v-7zm.6-1a1%201%200%20110-2%201%201%200%20010%202z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-cancel {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cg%20fill-rule%3D%22evenodd%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6z%22%20fill-rule%3D%22nonzero%22%2F%3E%3Cpath%20d%3D%22M12.849%2012l3.11%203.111-.848.849L12%2012.849l-3.111%203.11-.849-.848L11.151%2012l-3.11-3.111.848-.849L12%2011.151l3.111-3.11.849.848L12.849%2012z%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E);\n}\n.weui-icon-search {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M16.31%2015.561l4.114%204.115-.848.848-4.123-4.123a7%207%200%2011.857-.84zM16.8%2011a5.8%205.8%200%2010-11.6%200%205.8%205.8%200%200011.6%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-clear {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M13.06%2012l3.006-3.005-1.06-1.06L12%2010.938%208.995%207.934l-1.06%201.06L10.938%2012l-3.005%203.005%201.06%201.06L12%2013.062l3.005%203.005%201.06-1.06L13.062%2012zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm1.999-6.563L10.68%2012%2014%208.562%2012.953%207.5%209.29%2011.277a1.045%201.045%200%20000%201.446l3.663%203.777L14%2015.437z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-delete {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M6.774%206.4l.812%2013.648a.8.8%200%2000.798.752h7.232a.8.8%200%2000.798-.752L17.226%206.4H6.774zm11.655%200l-.817%2013.719A2%202%200%200115.616%2022H8.384a2%202%200%2001-1.996-1.881L5.571%206.4H3.5v-.7a.5.5%200%2001.5-.5h16a.5.5%200%2001.5.5v.7h-2.071zM14%203a.5.5%200%2001.5.5v.7h-5v-.7A.5.5%200%200110%203h4zM9.5%209h1.2l.5%209H10l-.5-9zm3.8%200h1.2l-.5%209h-1.2l.5-9z%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-success-no-circle-thin {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.864%2016.617l-5.303-5.303-1.061%201.06%205.657%205.657a1%201%200%20001.414%200L21.238%206.364l-1.06-1.06L8.864%2016.616z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-arrow {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-arrow-bold {\n    mask-image: url(data:image/svg+xml,%3Csvg%20height%3D%2224%22%20width%3D%2212%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10.157%2012.711L4.5%2018.368l-1.414-1.414%204.95-4.95-4.95-4.95L4.5%205.64l5.657%205.657a1%201%200%20010%201.414z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back-arrow {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M3.343%2012l7.071%207.071L9%2020.485l-7.778-7.778a1%201%200%20010-1.414L9%203.515l1.414%201.414L3.344%2012z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back-arrow-thin {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10%2019.438L8.955%2020.5l-7.666-7.79a1.02%201.02%200%20010-1.42L8.955%203.5%2010%204.563%202.682%2012%2010%2019.438z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-close {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2010.586l5.657-5.657%201.414%201.414L13.414%2012l5.657%205.657-1.414%201.414L12%2013.414l-5.657%205.657-1.414-1.414L10.586%2012%204.929%206.343%206.343%204.93%2012%2010.586z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-close-thin {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.25%2010.693L6.057%204.5%205%205.557l6.193%206.193L5%2017.943%206.057%2019l6.193-6.193L18.443%2019l1.057-1.057-6.193-6.193L19.5%205.557%2018.443%204.5z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n}\n.weui-icon-back-circle {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6zm1.999-5.363L12.953%2016.5%209.29%2012.723a1.045%201.045%200%20010-1.446L12.953%207.5%2014%208.563%2010.68%2012%2014%2015.438z%22%2F%3E%3C%2Fsvg%3E);\n}\n\n// icon setting\n.weui-icon-success {\n    color: @weuiColorPrimary;\n}\n.weui-icon-waiting {\n    color: var(--weui-BLUE);\n}\n.weui-icon-warn {\n    color: @weuiColorWarn;\n}\n.weui-icon-info {\n    color: var(--weui-BLUE);\n}\n\n.weui-icon-success-circle {\n    color: @weuiColorPrimary;\n}\n.weui-icon-success-no-circle,\n.weui-icon-success-no-circle-thin {\n    color: @weuiColorPrimary;\n}\n.weui-icon-waiting-circle {\n    color: var(--weui-BLUE);\n}\n.weui-icon-circle {\n    color: @weuiTextColorTips;\n}\n.weui-icon-download {\n    color: @weuiColorPrimary;\n}\n\n.weui-icon-info-circle {\n    color: @weuiTextColorTips;\n}\n\n.weui-icon-safe-success {\n    color: @weuiColorPrimary;\n}\n.weui-icon-safe-warn {\n    color: var(--weui-YELLOW);\n}\n\n.weui-icon-cancel {\n    color: @weuiColorWarn;\n}\n\n.weui-icon-search {\n    color: @weuiTextColorDesc;\n}\n\n.weui-icon-clear {\n    color: @weuiTextColorTips;\n    &:active {\n        color: @weuiTextColorDesc;\n    }\n}\n\n.weui-icon-delete {\n    &.weui-icon_gallery-delete {\n        color: var(--weui-WHITE);\n    }\n}\n.weui-icon-arrow,\n.weui-icon-arrow-bold,\n.weui-icon-back-arrow,\n.weui-icon-back-arrow-thin {\n    width: 12px;\n}\n.weui-icon-arrow,\n.weui-icon-arrow-bold {\n    color: @weuiTextColorTips;\n}\n.weui-icon-back-arrow,\n.weui-icon-back-arrow-thin {\n    color: @weuiTextColorTitle;\n}\n.weui-icon-back,\n.weui-icon-back-circle {\n    color: @weuiTextColorTitle;\n}\n\n.weui-icon_msg {\n    width: 64px;\n    height: 64px;\n    &.weui-icon-warn {\n        color: @weuiColorWarn;\n    }\n    &.weui-icon-info-circle {\n      color: var(--weui-BLUE);\n    }\n}\n.weui-icon_msg-primary {\n    width: 64px;\n    height: 64px;\n    &.weui-icon-warn {\n        color: var(--weui-YELLOW);\n    }\n}\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-link {\n    color: @weuiLinkColorDefault;\n    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n    &:visited {\n        color: @weuiLinkColorDefault;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-btn {\n    position: relative;\n    display: block;\n    width: @weuiBtnWidth;\n    margin-left: auto;\n    margin-right: auto;\n    padding: 8px 24px;\n    box-sizing: border-box;\n    font-weight: 700;\n    font-size: @weuiBtnFontSize;\n    text-align: center;\n    text-decoration: none;\n    color: @weuiBtnFontColor;\n    line-height: unit((@weuiBtnHeight - 16) / @weuiBtnFontSize);\n    border-radius: @weuiBtnBorderRadius;\n    overflow: hidden;\n    \n    .setTapColor();\n}\n.weui-btn_block {\n    width: auto;\n}\n.weui-btn_inline {\n    display: inline-block;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-btn_default {\n    color: @weuiBtnDefaultFontColor;\n    background-color: @weuiBtnDefaultBg;\n    &:not(.weui-btn_disabled):visited {\n        color: @weuiBtnDefaultFontColor;\n    }\n    &:not(.weui-btn_disabled):active {\n        background-color: @weuiBtnDefaultActiveBg;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-btn_primary {\n    background-color: @weuiBtnPrimaryBg;\n    &:not(.weui-btn_disabled):visited {\n        color: @weuiBtnPrimaryFontColor;\n    }\n    &:not(.weui-btn_disabled):active {\n        background-color: @weuiBtnPrimaryActiveBg;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-btn_warn {\n    color: @weuiBtnWarnFontColor;\n    background-color: @weuiBtnWarnBg;\n    &:not(.weui-btn_disabled):visited {\n        color: @weuiBtnWarnFontColor;\n    }\n    &:not(.weui-btn_disabled):active {\n        background-color: @weuiBtnWarnActiveBg;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-btn_disabled {\n    color: @weuiBtnDisabledFontColor;\n    background-color: @weuiBtnDisabledBg;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-btn_loading {\n    .weui-loading {\n        margin: -0.2em 0.34em 0 0;\n    }\n    .weui-primary-loading {\n        margin: -.2em 8px 0 0;\n        vertical-align:middle;\n    }\n    &.weui-btn_primary {\n        background-color: @weuiBtnPrimaryActiveBg;\n        color: var(--weui-WHITE);\n    }\n    &.weui-btn_default {\n        background-color: @weuiBtnDefaultActiveBg;\n    }\n    &.weui-btn_warn {\n        background-color: @weuiBtnWarnActiveBg;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-btn_cell {\n    position: relative;\n    display: block;\n    margin-left: auto;\n    margin-right: auto;\n    box-sizing: border-box;\n    font-size: @weuiBtnFontSize;\n    text-align: center;\n    text-decoration: none;\n    color: @weuiBtnFontColor;\n    line-height: @weuiBtnCellLineHeight;\n    padding: @weuiBtnCellGap;\n    .setTapColor();\n\n    overflow: hidden;\n    background-color: var(--weui-BG-5);\n    & + & {\n        margin-top: @weuiBtnDefaultGap;\n    }\n    &:active {\n        background-color: @weuiBgColorActive;\n    }\n}\n.weui-btn_cell__icon {\n    display: inline-block;\n    vertical-align: middle;\n    width: 24px;\n    height: 24px;\n    margin: -0.2em 0.34em 0 0;\n}\n.weui-btn_cell-default {\n    color: var(--weui-FG-0);\n}\n.weui-btn_cell-primary {\n    color: @weuiLinkColorDefault;\n}\n.weui-btn_cell-warn {\n    color: @weuiColorWarn;\n}\n\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n@import \"weui-btn_global\";\n@import \"weui-btn_default\";\n@import \"weui-btn_primary\";\n@import \"weui-btn_warn\";\n@import \"weui-btn_disabled\";\n@import \"weui-btn_loading\";\n@import \"weui-btn_cell\";\n\nbutton,\ninput {\n    &.weui-btn {\n        border-width: 0;\n        outline: 0;\n        -webkit-appearance: none;\n        &:focus {\n            outline: 0;\n        }\n    }\n    &.weui-btn_inline,\n    &.weui-btn_mini {\n        width: auto;\n    }\n}\n\n.weui-btn_mini {\n    display: inline-block;\n    width: auto;\n    padding: 0 unit(12px/@weuiBtnMiniFontSize, em);\n    line-height: unit(@weuiBtnMiniHeight/@weuiBtnMiniFontSize);\n    font-size: @weuiBtnMiniFontSize;\n}\n\n\n/* gap between btn */\n.weui-btn:not(.weui-btn_mini) + .weui-btn:not(.weui-btn_mini) {\n    margin-top: @weuiBtnDefaultGap;\n}\n\n.weui-btn.weui-btn_inline + .weui-btn.weui-btn_inline {\n    margin-top: auto;\n    margin-left: @weuiBtnDefaultGap;\n}\n\n.weui-btn-area {\n    margin: 48px @weuiBtnDefaultGap 8px;\n}\n.weui-btn-area_inline {\n    display: flex;\n    .weui-btn {\n        margin-top: auto;\n        margin-right: @weuiBtnDefaultGap;\n        width: 100%;\n        flex: 1;\n        &:last-child {\n            margin-right: 0;\n        }\n    }\n}\n\n.weui-btn_reset {\n    background: transparent;\n    border: 0;\n    padding: 0;\n    outline: 0;\n}\n.weui-btn_icon {\n    font-size: 0;\n    &:active {\n        [class*=\"weui-icon-\"] {\n            color: var(--weui-FG-1);\n        }\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n/*\nz-index:\n0: .weui-swiped-btn\n1: .weui-cell_swiped .weui-cell__bd\n2: .weui-cells和.weui-cell的1px线\n*/\n\n.weui-cells {\n    margin-top: @weuiCellsMarginTop;\n    background-color: @weuiCellBg;\n    line-height: @weuiCellLineHeight;\n    font-size: @weuiCellFontSize; //cell中间有效高度23px，跟客户端默认图标尺寸一致\n    overflow: hidden; //因为每个cell的border使用before元素left搞的，ie下伪元素的containing block估计跟标准不同，在cell上用oh不生效\n\n    // onepx\n    position: relative;\n    &:before {\n        .setTopLine(@weuiCellBorderColor);\n\n        z-index: 2;\n    }\n    &:after {\n        .setBottomLine(@weuiCellBorderColor);\n\n        z-index: 2;\n    }\n}\n\n.weui-cells__title {\n    margin-top: 16px;\n    margin-bottom: 3px;\n    padding-left: @weuiCellGapH;\n    padding-right: @weuiCellGapH;\n    color: @weuiTextColorDesc;\n    font-size: @weuiCellTipsFontSize;\n    line-height: 1.4;\n\n    & + .weui-cells {\n        margin-top: 0;\n    }\n}\n\n.weui-cells__tips {\n    margin-top: 8px;\n    color: @weuiTextColorDesc;\n    padding-left: @weuiCellGapH;\n    padding-right: @weuiCellGapH;\n    font-size: @weuiCellTipsFontSize;\n    line-height: 1.4;\n    a,\n    navigator {\n        color: @weuiLinkColorDefault;\n    }\n    navigator {\n        display: inline;\n    }\n}\n\n.weui-cell {\n    padding: @weuiCellGapV;\n    position: relative; //这个是为了兼容cells容器onepx方案被before挡住而做的\n    display: flex;\n    align-items: center;\n    &:before {\n        .setTopLine(@weuiCellBorderColor);\n\n        left: @weuiCellGapH;\n        z-index: 2;\n    }\n    &:first-child {\n        &:before {\n            display: none;\n        }\n    }\n}\n.weui-cell_active {\n    &:active {\n        background-color: @weuiBgColorActive;\n    }\n}\n.weui-cell_primary {\n    align-items: flex-start;\n}\n.weui-cell__bd {\n    flex: 1;\n}\n.weui-cell__ft {\n    text-align: right;\n    color: @weuiTextColorDesc;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../variable/color\";\n\n.setTopLine(@c: @weuiLineColorLight) {\n    content: \" \";\n    position: absolute;\n    left: 0;\n    top: 0;\n    right: 0;\n    height: 1px;\n    border-top: 1px solid @c;\n    color: @c;\n    transform-origin: 0 0;\n    transform: scaleY(0.5);\n}\n\n.setBottomLine(@c: @weuiLineColorLight) {\n    content: \" \";\n    position: absolute;\n    left: 0;\n    bottom: 0;\n    right: 0;\n    height: 1px;\n    border-bottom: 1px solid @c;\n    color: @c;\n    transform-origin: 0 100%;\n    transform: scaleY(0.5);\n}\n\n.setLeftLine(@c: @weuiLineColorLight) {\n    content: \" \";\n    position: absolute;\n    left: 0;\n    top: 0;\n    width: 1px;\n    bottom: 0;\n    border-left: 1px solid @c;\n    color: @c;\n    transform-origin: 0 0;\n    transform: scaleX(0.5);\n}\n\n.setRightLine(@c: @weuiLineColorLight) {\n    content: \" \";\n    position: absolute;\n    right: 0;\n    top: 0;\n    width: 1px;\n    bottom: 0;\n    border-right: 1px solid @c;\n    color: @c;\n    transform-origin: 100% 0;\n    transform: scaleX(0.5);\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-cell_swiped {\n    display: block;\n    padding: 0;\n    > .weui-cell__bd {\n        position: relative;\n        z-index: 1;\n        background-color: @weuiCellBg;\n    }\n    > .weui-cell__ft {\n        position: absolute;\n        right: 0;\n        top: 0;\n        bottom: 0;\n        display: flex;\n        color: #fff; // 固定色值\n    }\n}\n.weui-swiped-btn {\n    display: block;\n    padding: @weuiCellGapV 1em;\n    line-height: @weuiCellLineHeight;\n    color: inherit;\n}\n.weui-swiped-btn_default {\n    background-color: @weuiBgColorDefault;\n}\n.weui-swiped-btn_warn {\n    background-color: @weuiColorWarn;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-cell_access {\n    .setTapColor();\n\n    color: inherit;\n    &:active {\n        background-color: @weuiBgColorActive;\n    }\n    .weui-cell__ft {\n        padding-right: 22px;\n        position: relative;\n        &:after {\n            content: \" \";\n            width: 12px;\n            height: 24px;\n            mask-position: 0 0;\n            mask-repeat: no-repeat;\n            mask-size: 100%;\n            background-color: currentColor;\n            color: @weuiTextColorTips;\n            mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n            position: absolute;\n            top: 50%;\n            right: 0;\n            margin-top: -12px;\n        }\n    }\n}\n.weui-cell_link {\n    color: @weuiLinkColorDefault;\n    font-size: 17px;\n\n    // 由于weui-cell:first-child的:before为隐藏，所以这里要重新显示出来\n    &:first-child {\n        &:before {\n            display: block;\n        }\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../../base/fn\";\n\n.weui-check__label {\n    .setTapColor();\n    &:active {\n        background-color: @weuiBgColorActive;\n    }\n}\n\n.weui-check {\n    position: absolute;\n    left: -9999px;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../../base/fn\";\n\n// method2 accessbility\n.weui-cells_radio {\n    .weui-cell__ft {\n        padding-left: @weuiCellInnerGapH;\n        font-size: 0;\n    }\n}\n.weui-check {\n    // radio\n    .weui-cells_radio & {\n        & + .weui-icon-checked {\n            min-width: 16px;\n            color: transparent;\n        }\n        &:checked,\n        &[aria-checked=\"true\"] {\n            & + .weui-icon-checked {\n                color: @weuiColorPrimary;\n                mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.657%2018.435L3%2012.778l1.414-1.414%204.95%204.95L20.678%205l1.414%201.414-12.02%2012.021a1%201%200%2001-1.415%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n            }\n        }\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../../base/fn\";\n\n.weui-cells_checkbox {\n    .weui-check__label {\n        &:before { left: 55px; }\n    }\n    .weui-cell__hd {\n        padding-right: @weuiCellInnerGapH;\n        font-size: 0;\n    }\n    .weui-icon-checked {\n        color: @weuiTextColorTips;\n        mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E);\n    }\n}\n\n// method2 accessbility\n.weui-check {\n    // checkbox\n    .weui-cells_checkbox & {\n        &:checked,\n        &[aria-checked=\"true\"] {\n            & + .weui-icon-checked {\n                color: @weuiColorPrimary;\n                mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E);\n            }\n        }\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../../base/fn\";\n\n.weui-label {\n    display: block;\n    width: @weuiCellLabelWidth;\n    .text_wrap();\n}\n.weui-input {\n    width: 100%;\n    border: 0;\n    outline: 0;\n    -webkit-appearance: none;\n    background-color: transparent;\n    font-size: inherit;\n    color: inherit;\n    height: unit(@weuiCellLineHeight, em);\n    line-height: @weuiCellLineHeight;\n\n    // hides the spin-button\n    &::-webkit-outer-spin-button,\n    &::-webkit-inner-spin-button {\n        -webkit-appearance: none;\n        margin: 0;\n    }\n    &:focus {\n        &:not(:placeholder-shown) {\n            & + .weui-btn_input-clear {\n                display: inline;\n            }\n        }\n    }\n}\n\n.weui-textarea {\n    display: block;\n    border: 0;\n    resize: none;\n    background: transparent;\n    width: 100%;\n    color: inherit;\n    font-size: 1em;\n    line-height: inherit;\n    outline: 0;\n}\n\n.weui-textarea-counter {\n    color: @weuiTextColorTips;\n    text-align: right;\n    font-size: 14px;\n    .weui-cell_warn & {\n        color: @weuiTextColorWarn;\n    }\n}\n\n.weui-cells_form {\n    .weui-cell_switch,\n    .weui-cell_vcode,\n    .weui-cell_readonly,\n    .weui-cell_disabled {\n        &:active {\n            background-color: transparent;\n        }\n    }\n    .weui-cell__ft {\n        font-size: 0;\n    }\n    .weui-icon-warn {\n        display: none;\n    }\n    input,\n    textarea,\n    label[for] {\n        .setTapColor();\n    }\n}\n.weui-cell_warn {\n    color: @weuiTextColorWarn;\n    .weui-icon-warn { display: inline-block; }\n}\n.weui-cell_readonly,\n.weui-cell_disabled {\n    .weui-input,\n    .weui-textarea {\n        &:disabled {\n            opacity: 1;\n            -webkit-text-fill-color: @weuiTextColorDesc;\n        }\n        &[disabled],\n        &[readonly] {\n            color: @weuiTextColorDesc;\n        }\n    }\n}\n.weui-btn_input-clear {\n    display: none;\n    padding-left: 8px;\n    [class*=\"weui-icon-\"] {\n        width: 18px;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n.ellipsis(@w:auto) {\n    width: @w;\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n    word-wrap: normal;\n}\n\n.ellipsisLn(@line) {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    display: -webkit-box;\n    -webkit-box-orient: vertical;\n    -webkit-line-clamp: @line;\n}\n.text_wrap() {\n    word-wrap: break-word;\n    word-break: break-all;\n}\n.hyphens() {\n    word-wrap: break-word;\n    -webkit-hyphens: auto;\n    hyphens: auto;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../../base/fn\";\n\n.weui-form-preview {\n    position: relative;\n    background-color: var(--weui-BG-2);\n    &:before {\n        .setTopLine(@weuiCellBorderColor);\n    }\n    &:after {\n        .setBottomLine(@weuiCellBorderColor);\n    }\n}\n.weui-form-preview__hd {\n    position: relative;\n    padding: @weuiCellGapV;\n    text-align: right;\n    line-height: 2.5em;\n    &:after {\n        .setBottomLine(@weuiCellBorderColor);\n\n        left: @weuiCellGapH;\n    }\n    .weui-form-preview__value {\n        font-style: normal;\n        font-size: 1.6em;\n    }\n}\n.weui-form-preview__bd {\n    padding: @weuiCellGapV;\n    font-size: 0.9em;\n    text-align: right;\n    color: @weuiTextColorDesc;\n    line-height: 2;\n}\n.weui-form-preview__ft {\n    position: relative;\n    line-height: 50px;\n    display: flex;\n    &:before {\n        .setTopLine(@weuiDialogLineColor);\n    }\n}\n.weui-form-preview__item {\n    overflow: hidden;\n}\n.weui-form-preview__label {\n    float: left;\n    margin-right: 1em;\n    min-width: 4em;\n    color: @weuiTextColorDesc;\n    text-align: justify;\n    text-align-last: justify;\n}\n.weui-form-preview__value {\n    display: block;\n    overflow: hidden;\n    word-break: normal;\n    word-wrap: break-word;\n    color: var(--weui-FG-0);\n}\n.weui-form-preview__btn {\n    position: relative;\n    display: block;\n    flex: 1;\n    color: @weuiDialogLinkColor;\n    text-align: center;\n    .setTapColor();\n    button& {\n        background-color: transparent;\n        border: 0;\n        outline: 0;\n        line-height: inherit;\n        font-size: inherit;\n    }\n    &:active {\n        background-color: @weuiDialogLinkActiveBc;\n    }\n    &:after {\n        .setLeftLine(@weuiDialogLineColor);\n    }\n    &:first-child {\n        &:after {\n            display: none;\n        }\n    }\n}\n.weui-form-preview__btn_default {\n    color: var(--weui-FG-HALF);\n}\n.weui-form-preview__btn_primary {\n    color: @weuiLinkColorDefault;\n}\n\n// 列表块，一般放msg组件的自定义区域\n.weui-form-preview__list{\n  padding-top:24px;\n  padding-bottom:24px;\n  line-height:1.4;\n  font-size:14px;\n  position:relative;\n  &:before{\n    content:\"\";\n    .setTopLine(var(--weui-FG-3));\n  }\n  &:last-child{\n    padding-bottom:0;\n  }\n  .weui-form-preview__label{\n    text-align:left;\n    text-align-last:unset;\n    width:6em;\n  }\n  .weui-form-preview__value{hyphens:auto;}\n  .weui-form-preview__item{\n    margin-top:12px;\n    &:first-child{margin-top:0;}\n  }\n  &>.weui-cells__title{\n    &:first-child{\n      margin-top:0;\n    }\n  }\n}\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../../base/fn\";\n\n.weui-cell_select {\n    padding: 0;\n    .weui-select {\n        padding-right: 30px;\n    }\n    .weui-cell__bd {\n        &:after {\n            content: \" \";\n            width: 12px;\n            height: 24px;\n            mask-position: 0 0;\n            mask-repeat: no-repeat;\n            mask-size: 100%;\n            background-color: currentColor;\n            color: @weuiTextColorTips;\n            mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n            position: absolute;\n            top: 50%;\n            right: @weuiCellGapH;\n            margin-top: -12px;\n        }\n    }\n}\n\n.weui-select {\n    -webkit-appearance: none;\n    border: 0;\n    outline: 0;\n    background-color: transparent;\n    width: 100%;\n    font-size: inherit;\n    height: @weuiCellHeight;\n    line-height: @weuiCellHeight;\n    position: relative;\n    z-index: 1;\n    padding-left: @weuiCellGapH;\n    color: var(--weui-FG-0);\n}\n\n.weui-cell_select-before {\n    padding-right: @weuiCellGapH;\n    .weui-select {\n        width: @weuiCellLabelWidth;\n        box-sizing: border-box;\n    }\n    .weui-cell__hd {\n        position: relative;\n        &:after {\n            .setRightLine(@weuiCellBorderColor);\n        }\n        &:before {\n            content: \" \";\n            width: 12px;\n            height: 24px;\n            mask-position: 0 0;\n            mask-repeat: no-repeat;\n            mask-size: 100%;\n            background-color: currentColor;\n            color: @weuiTextColorTips;\n            mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M2.454%206.58l1.06-1.06%205.78%205.779a.996.996%200%20010%201.413l-5.78%205.779-1.06-1.061%205.425-5.425-5.425-5.424z%22%20fill%3D%22%23B2B2B2%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E);\n            position: absolute;\n            top: 50%;\n            right: @weuiCellGapH;\n            margin-top: -12px;\n        }\n    }\n    .weui-cell__bd {\n        padding-left: @weuiCellGapH;\n        &:after {\n            display: none;\n        }\n    }\n    &.weui-cell_access {\n        .weui-cell__hd {\n            line-height: 56px;\n            padding-left: 32px;\n        }\n    }\n}\n\n.weui-cell_select-after {\n    padding-left: @weuiCellGapH;\n    .weui-select {\n        padding-left: 0;\n    }\n    &.weui-cell_access {\n        .weui-cell__bd {\n            line-height: 56px;\n        }\n    }\n}\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n*\n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n*\n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n*\n*       http://opensource.org/licenses/MIT\n*\n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../../base/fn\";\n\n.weui-cell_vcode {\n    padding-top: 0;\n    padding-right: 0;\n    padding-bottom: 0;\n}\n.weui-vcode-img {\n    margin-left: 5px;\n    height: @weuiCellHeight;\n    vertical-align: middle;\n}\n\n.weui-vcode-btn {\n    display: inline-block;\n    height: @weuiCellHeight;\n    margin-left: 5px;\n    padding: 0 0.6em 0 0.7em;\n    line-height: @weuiCellHeight;\n    vertical-align: middle;\n    font-size: @weuiCellFontSize;\n    color: @weuiDialogLinkColor;\n    position: relative;\n    &:before {\n        .setLeftLine(@weuiLineColorLight);\n    }\n    button& {\n        background-color: transparent;\n        border: 0;\n        outline: 0;\n    }\n    &:active {\n        color: var(--weui-LINK-ACTIVE);\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n@weuiGalleryOprHeight: 60px;\n.weui-gallery {\n    display: none;\n    position: fixed;\n    top: 0;\n    right: 0;\n    bottom: 0;\n    left: 0;\n    background-color: #000; // 固定色值\n    z-index: 1000;\n}\n.weui-gallery__img,\n.weui-gallery__opr {\n    position: absolute;\n    left: 0;\n    left: constant(safe-area-inset-left);\n    left: env(safe-area-inset-left);\n    right: 0;\n    right: constant(safe-area-inset-right);\n    right: env(safe-area-inset-right);\n}\n.weui-gallery__img {\n    top: 0;\n    top: constant(safe-area-inset-top);\n    top: env(safe-area-inset-top);\n    bottom: @weuiGalleryOprHeight;\n    bottom: calc(@weuiGalleryOprHeight ~\"+ constant(safe-area-inset-bottom)\");\n    bottom: calc(@weuiGalleryOprHeight ~\"+ env(safe-area-inset-bottom)\");\n    width: 100%;\n    background: center center no-repeat;\n    background-size: contain;\n}\n.weui-gallery__opr {\n    position: absolute;\n    bottom: 0;\n    padding-bottom: 0;\n    padding-bottom: constant(safe-area-inset-bottom);\n    padding-bottom: env(safe-area-inset-bottom);\n    background-color: #0d0d0d;  // 固定色值\n    color: var(--weui-WHITE);\n    line-height: @weuiGalleryOprHeight;\n    text-align: center;\n}\n.weui-gallery__del {\n    display: block;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-cell_switch {\n    padding-top: (@weuiCellHeight - @weuiSwitchHeight) / 2;\n    padding-bottom: (@weuiCellHeight - @weuiSwitchHeight) / 2;\n}\n.weui-switch {\n    appearance: none;\n}\n.weui-switch,\n.weui-switch-cp__box {\n    position: relative;\n    width: 52px;\n    height: @weuiSwitchHeight;\n    border: 2px solid @weuiLineColorLight;\n    outline: 0;\n    border-radius: 16px;\n    box-sizing: border-box;\n    transition: background-color 0.1s, border 0.1s;\n\n    &:before {\n        content: \" \";\n        position: absolute;\n        top: 0;\n        left: 0;\n        bottom: 0;\n        right: 0;\n        border-radius: 15px;\n        background-color: var(--weui-BG-3);\n        transition: transform 0.35s cubic-bezier(0.45, 1, 0.4, 1);\n    }\n    &:after {\n        content: \" \";\n        position: absolute;\n        top: 0;\n        left: 0;\n        width: @weuiSwitchHeight - 4;\n        height: @weuiSwitchHeight - 4;\n        border-radius: 15px;\n        background-color: #fff; // 固定色值\n        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4);\n        transition: transform 0.35s cubic-bezier(0.4, 0.4, 0.25, 1.35);\n    }\n}\n.weui-switch:checked,\n.weui-switch-cp__input:checked + .weui-switch-cp__box,\n.weui-switch-cp__input[aria-checked=\"true\"] + .weui-switch-cp__box {\n    border-color: @weuiColorPrimary;\n    background-color: @weuiColorPrimary;\n    &:before {\n        transform: scale(0);\n    }\n    &:after {\n        transform: translateX(20px);\n    }\n}\n\n// 兼容小程序/IE Edge的版本\n.weui-switch-cp__input {\n    position: absolute;\n    left: -9999px;\n}\n.weui-switch-cp__box {\n    display: block;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-cell_uploader {\n  padding-bottom:24px;\n}\n.weui-uploader {\n    flex: 1;\n}\n.weui-uploader__hd {\n    display: flex;\n    padding-bottom: @weuiCellGapV;\n    align-items: center;\n}\n.weui-uploader__title {\n    flex: 1;\n}\n.weui-uploader__info {\n    color: @weuiTextColorTips;\n}\n\n.weui-uploader__bd {\n    margin-bottom: @weuiCellGapH - (@weuiCellGapV + @weuiUploaderFileSpacing);\n    margin-right: -@weuiUploaderFileSpacing;\n    overflow: hidden;\n}\n.weui-uploader__files {\n    list-style: none;\n}\n.weui-uploader__file {\n    float: left;\n    margin-right: @weuiUploaderFileSpacing;\n    margin-bottom: @weuiUploaderFileSpacing;\n    width: @weuiUploaderSize;\n    height: @weuiUploaderSize;\n    background: no-repeat center center;\n    background-size: cover;\n}\n.weui-uploader__file_status {\n    position: relative;\n    &:before {\n        content: \" \";\n        position: absolute;\n        top: 0;\n        right: 0;\n        bottom: 0;\n        left: 0;\n        background-color: rgba(0, 0, 0, 0.5); // 固定色值\n    }\n    .weui-uploader__file-content {\n        display: block;\n    }\n}\n.weui-uploader__file-content {\n    display: none;\n    position: absolute;\n    top: 50%;\n    left: 50%;\n    transform: translate(-50%, -50%);\n    color: var(--weui-WHITE);\n    .weui-icon-warn {\n        display: inline-block;\n    }\n}\n.weui-uploader__input-box {\n    float: left;\n    position: relative;\n    margin-right: @weuiUploaderFileSpacing;\n    margin-bottom: @weuiUploaderFileSpacing;\n    width: @weuiUploaderSize;\n    height: @weuiUploaderSize;\n    box-sizing: border-box;\n    background-color: #ededed;\n    .dark({\n        background-color: #2e2e2e;\n    });\n    &:before,\n    &:after {\n        content: \" \";\n        position: absolute;\n        top: 50%;\n        left: 50%;\n        transform: translate(-50%, -50%);\n        background-color: #a3a3a3;\n        .dark({\n            background-color: #6d6d6d;\n        });\n    }\n    &:before {\n        width: @weuiUploaderBorderWidth + 1;\n        height: @weuiUploaderSize / 3;\n    }\n    &:after {\n        width: @weuiUploaderSize / 3;\n        height: @weuiUploaderBorderWidth + 1;\n    }\n    &:active {\n        &:before,\n        &:after {\n            opacity: 0.7;\n        }\n    }\n}\n.weui-uploader__input {\n    position: absolute;\n    z-index: 1;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    opacity: 0;\n    .setTapColor();\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n@import \"../weui-button/weui-button\";\n\na{\n  .weui-msg__desc &,\n  .weui-msg__desc-primary &,\n  .weui-msg__tips &{\n    color: @weuiLinkColorDefault;\n    display: inline-block;\n    vertical-align: baseline;\n  }\n}\n.weui-msg {\n    padding-top: @weuiMsgPaddingTop;\n    padding: calc(@weuiMsgPaddingTop ~\"+ constant(safe-area-inset-top)\") constant(safe-area-inset-right) constant(safe-area-inset-bottom) constant(safe-area-inset-left);\n    padding: calc(@weuiMsgPaddingTop ~\"+ env(safe-area-inset-top)\") env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);\n    text-align: center;\n    line-height: 1.4;\n    min-height: 100%;\n    box-sizing: border-box;\n    display: flex;\n    flex-direction: column;\n    background-color: var(--weui-BG-2);\n}\n.weui-msg__icon-area {\n    margin-bottom: 32px;\n}\n.weui-msg__text-area {\n    margin-bottom: 32px;\n    padding: 0 32px;\n    flex: 1;\n    line-height: 1.6;\n    .hyphens;\n    &:first-child { padding-top: 96px; }\n}\n.weui-msg__title {\n    margin-bottom: @weuiMsgTitleGap;\n    font-weight: 400;\n    font-size: 22px;\n    color: #191919;\n    .dark({\n      color: #D1D1D1;\n    });\n    -webkit-text-stroke: .02em;\n}\n@supports (-webkit-overflow-scrolling:touch){\n  .weui-msg__title {\n    font-weight: 500;\n    -webkit-text-stroke: initial;\n  }\n}\n.weui-msg__desc {\n    font-size: 17px;\n    font-weight:400;\n    color: @weuiTextColorTitle;\n    margin-bottom: 16px;\n}\n.weui-msg__desc-primary {\n    font-size: 14px;\n    color: @weuiTextColorDesc;\n    margin-bottom: 16px;\n}\n.weui-msg__custom-area{\n  text-align:left;\n  word-wrap: break-word;\n  hyphens:auto;\n  margin-bottom:16px;\n  .weui-msg__title + &{\n    margin-top:48px;\n  }\n  .weui-msg__desc + &,\n  .weui-msg__desc-primary + &{\n    margin-top:40px;\n  }\n  .weui-cells__group_form{\n    .weui-cells{\n      &:before,&:after{\n        left:0;\n        right:0;\n      }\n    }\n    .weui-cell{\n      padding-left:0;\n      padding-right:0;\n      &:before{\n        left:0;\n        right:0;\n      }\n    }\n  }\n}\n.weui-msg__opr-area {\n    margin-bottom: 16px;\n    .weui-btn-area { margin: 0; }\n    .weui-btn + .weui-btn { margin-bottom: 16px; }\n    &:last-child { margin-bottom: 96px; }\n    & + .weui-msg__extra-area {\n        margin-top: 48px;\n    }\n}\n.weui-msg__tips-area {\n    margin-bottom: 16px;\n    padding: 0 40px;\n    .hyphens;\n    .weui-msg__opr-area + & {\n        margin-bottom: 48px;\n    }\n    &:last-child {\n        margin-bottom: 64px;\n    }\n}\n.weui-msg__tips {\n    font-size: 12px;\n    color: @weuiTextColorDesc;\n}\n.weui-msg__extra-area {\n    margin-bottom: 24px;\n    font-size: 12px;\n    color: @weuiTextColorDesc;\n    a,\n    navigator {\n        color: @weuiLinkColorDefault;\n    }\n    navigator {\n        display: inline;\n    }\n}\n\n// 部分场景需要去掉头部间距\n.weui-msg_align-top{\n  .weui-msg__text-area{\n    &:first-child{padding-top:0;}\n  }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-cells__group{}\n.weui-cells__group_form {\n\n    &:first-child {\n        .weui-cells__title {\n            margin-top: 0;\n        }\n    }\n\n    .weui-cells__title {\n        margin-top: 24px;\n        margin-bottom: 8px;\n        padding: 0 32px;\n    }\n  \n\n    .weui-cells,\n    .weui-cell {\n        &:before {\n            left: 32px;\n            right: 32px;\n        }\n    }\n    .weui-cells_checkbox {\n        .weui-check__label {\n            &:before { left: 72px; }\n        }\n    }\n    .weui-cells {\n        &:after {\n            left: 32px;\n            right: 32px;\n        }\n    }\n    .weui-cell {\n        padding: 16px 32px;\n        &:not(.weui-cell_link) {\n            color: @weuiTextColorTitle;\n        }\n    }\n    .weui-cell__hd {\n        padding-right: 16px;\n    }\n    .weui-cell__ft {\n        padding-left: 16px;\n    }\n    .weui-cell_warn {\n        input {\n            color: @weuiColorWarn;\n        }\n    }\n\n\n    .weui-label {\n        max-width: 5em;\n        margin-right: 8px;\n    }\n\n\n    .weui-cells__tips {\n        margin-top: 8px;\n        padding: 0 32px;\n        color: var(--weui-FG-2);\n        a {\n            font-weight: 700;\n        }\n    }\n    .weui-cells__tips_warn{\n        color: var(--weui-RED);\n    }\n\n\n    .weui-cell_vcode {\n        padding: 12px 32px;\n    }\n    .weui-vcode-btn {\n        font-size: 16px;\n        padding: 0 12px;\n        margin-left: 0;\n        height: auto;\n        width: auto;\n        line-height: 2em;\n        color: @weuiBtnDefaultFontColor;\n        background-color: @weuiBtnDefaultBg;\n        &:before {\n            display: none;\n        }\n    }\n\n\n    .weui-cell_select {\n        padding: 0;\n        .weui-select {\n            padding: 0 32px;\n        }\n        .weui-cell__bd:after {\n            right: 32px;\n        }\n    }\n    .weui-cell_select-before {\n        .weui-label {\n            margin-right: 24px;\n        }\n        .weui-select {\n            padding-right: 24px;\n            box-sizing: initial;\n        }\n    }\n    .weui-cell_select-after {\n        padding-left: 32px;\n        .weui-select {\n            padding-left: 0;\n        }\n    }\n\n\n    .weui-cell_switch {\n        padding: 12px 32px;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n@import \"../weui-cell/weui-cells__group\";\n\n.weui-form {\n    padding: 56px 0 0;\n    padding: calc(56px ~\"+ constant(safe-area-inset-top)\") constant(safe-area-inset-right) constant(safe-area-inset-bottom) constant(safe-area-inset-left);\n    padding: calc(56px ~\"+ env(safe-area-inset-top)\") env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);\n    display: flex;\n    flex-direction: column;\n    line-height: 1.4;\n    min-height: 100%;\n    box-sizing: border-box;\n    background-color: var(--weui-BG-2);\n\n    .weui-footer,\n    .weui-footer__link {\n        font-size: 14px;\n    }\n    .weui-agree {\n        padding: 0;\n    }\n}\n.weui-form__text-area {\n    padding: 0 32px;\n    color: var(--weui-FG-0);\n    text-align: center;\n}\n.weui-form__control-area {\n    flex: 1;\n    margin: 48px 0;\n}\n.weui-form__tips-area {\n    overflow: hidden;\n}\n.weui-form__tips-area,\n.weui-form__extra-area {\n    margin-bottom: 24px;\n    text-align: center;\n}\n.weui-form__opr-area {\n    margin-bottom: 64px;\n    &:last-child {\n        margin-bottom: 96px;\n    }\n}\n.weui-form__title {\n    font-size: 22px;\n    font-weight: 700;\n    line-height: 1.36;\n}\n.weui-form__desc {\n    font-size: 17px;\n    margin-top: 16px;\n}\n.weui-form__tips {\n    color: @weuiTextColorDesc;\n    font-size: 14px;\n    a,\n    navigator {\n        color: @weuiLinkColorDefault;\n    }\n    navigator {\n        display: inline;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-article {\n    padding: 24px 16px;\n    padding: 24px calc(16px ~\"+ constant(safe-area-inset-right)\") calc(24px ~\"+ constant(safe-area-inset-bottom)\") calc(16px ~\"+ constant(safe-area-inset-left)\");\n    padding: 24px calc(16px ~\"+ env(safe-area-inset-right)\") calc(24px ~\"+ env(safe-area-inset-bottom)\") calc(16px ~\"+ env(safe-area-inset-left)\");\n    font-size: 17px;\n    color: var(--weui-FG-0);\n    .hyphens;\n    section {\n        margin-bottom: 1.5em;\n    }\n    h1 {\n        font-size: 22px;\n        font-weight: 700;\n        margin-bottom: 0.9em;\n        line-height: 1.4;\n    }\n    h2 {\n        font-size: 17px;\n        font-weight: 700;\n        margin-bottom: 0.34em;\n        line-height: 1.4;\n    }\n    h3 {\n        font-weight: 700;\n        font-size: 15px;\n        margin-bottom: 0.34em;\n        line-height: 1.4;\n    }\n    * {\n        max-width: 100%;\n        box-sizing: border-box;\n        word-wrap: break-word;\n    }\n    p {\n        margin: 0 0 0.8em;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-tabbar {\n    display: flex;\n    position: relative;\n    z-index: 500;\n    background-color: @weuiBgColorPrimary;\n\n    &:before {\n        .setTopLine(@weuiLineColorLight);\n    }\n}\n\n.weui-tabbar__item {\n    display: block;\n    flex: 1;\n    padding: 8px 0;\n    padding-bottom: calc(8px ~\"+ constant(safe-area-inset-bottom)\");\n    padding-bottom: calc(8px ~\"+ env(safe-area-inset-bottom)\");\n    font-size: 0;\n    color: @weuiTextColorDesc;\n    text-align: center;\n    .setTapColor();\n\n    &:first-child {\n        padding-left: constant(safe-area-inset-left);\n        padding-left: env(safe-area-inset-left);\n    }\n    &:last-child {\n        padding-right: constant(safe-area-inset-right);\n        padding-right: env(safe-area-inset-right);\n    }\n\n    &.weui-bar__item_on {\n        .weui-tabbar__icon,\n        .weui-tabbar__icon > i,\n        .weui-tabbar__label {\n            color: @weuiColorPrimary;\n        }\n    }\n}\n\n.weui-tabbar__icon {\n    display: inline-block;\n    width: @weuiTabBarHeight - 8*2 - 10*1.4 - 2;\n    height: @weuiTabBarHeight - 8*2 - 10*1.4 - 2;\n    margin-bottom: 2px;\n\n\n    i&,\n    > i {\n        font-size: 24px;\n        color: @weuiTextColorDesc;\n    }\n\n    img {\n        width: 100%;\n        height: 100%;\n    }\n}\n\n.weui-tabbar__label {\n    color: @weuiTextColorTitle;\n    font-size: 10px;\n    line-height: 1.4;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-navbar {\n    display: flex;\n    position: relative;\n    z-index: 500;\n    background-color: var(--weui-BG-2);\n    padding-top: constant(safe-area-inset-top);\n    padding-top: env(safe-area-inset-top);\n\n    &:after {\n        .setBottomLine(@weuiLineColorLight);\n    }\n\n    & + .weui-tab__panel {\n        padding-bottom: constant(safe-area-inset-bottom);\n        padding-bottom: env(safe-area-inset-bottom);\n    }\n}\n\n.weui-navbar__item {\n    position: relative;\n    display: block;\n    flex: 1;\n    padding: 16px 0;\n    padding-top: calc(16px ~\"+ constant(safe-area-inset-top)\");\n    padding-top: calc(16px ~\"+ env(safe-area-inset-top)\");\n    text-align: center;\n    font-size: 17px;\n    line-height: unit((@weuiNavBarHeight - 32) / 17);\n    .setTapColor();\n\n    &:active {\n        background-color: @weuiBgColorActive;\n    }\n\n    &.weui-bar__item_on {\n        background-color: @weuiBgColorActive;\n    }\n\n    &:after {\n        .setRightLine(@weuiLineColorLight);\n    }\n\n    &:first-child {\n        padding-left: constant(safe-area-inset-left);\n        padding-left: env(safe-area-inset-left);\n    }\n    &:last-child {\n        padding-right: constant(safe-area-inset-right);\n        padding-right: env(safe-area-inset-right);\n        &:after {\n            display: none;\n        }\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n@import \"weui-tabbar\";\n@import \"weui-navbar\";\n\n.weui-tab {\n    display: flex;\n    height: 100%;\n    box-sizing: border-box;\n    flex-direction: column;\n}\n\n.weui-tab__panel {\n    box-sizing: border-box;\n    flex: 1;\n    overflow: auto;\n    -webkit-overflow-scrolling: touch;\n}\n.weui-tab__content {\n    display: none;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-progress {\n    display: flex;\n    align-items: center;\n}\n\n.weui-progress__bar {\n    background-color: @weuiProgressBg;\n    height: @weuiProgressHeight;\n    flex: 1;\n}\n\n.weui-progress__inner-bar {\n    width: 0;\n    height: 100%;\n    background-color: @weuiProgressColor;\n}\n\n.weui-progress__opr {\n    display: block;\n    margin-left: 15px;\n    font-size: 0;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n\n.weui-panel {\n    background-color: var(--weui-BG-2);\n    margin-top: 10px;\n    &:first-child {\n        margin-top: 0;\n    }\n\n    position: relative;\n    overflow: hidden;\n    &:before {\n        .setTopLine(@weuiLineColorLight);\n    }\n    &:after {\n        .setBottomLine(@weuiLineColorLight);\n    }\n}\n\n.weui-panel__hd {\n    padding: 16px 16px 13px;\n    color: @weuiTextColorTitle;\n    font-size: 15px;\n    font-weight: 700;\n    position: relative;\n    &:after {\n        .setBottomLine(@weuiLineColorLight);\n\n        left: 15px;\n    }\n}\n\n\n\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-media-box {\n    padding: 16px;\n    position: relative;\n    &:before {\n        .setTopLine(@weuiLineColorLight);\n\n        left: 16px;\n    }\n    &:first-child {\n        &:before {\n            display: none;\n        }\n    }\n\n    a& {\n        color: #000;\n        .setTapColor();\n        &:active {\n            background-color: @weuiBgColorActive;\n        }\n    }\n}\n.weui-media-box__title {\n    font-weight: 400;\n    font-size: 17px;\n    line-height: 1.4;\n    color: @weuiTextColorTitle;\n    .ellipsis();\n    .hyphens;\n}\n.weui-media-box__desc {\n    color: @weuiTextColorTips;\n    font-size: 14px;\n    line-height: 1.4;\n    padding-top: 4px;\n    .ellipsisLn(2);\n    .hyphens;\n}\n.weui-media-box__info {\n    margin-top: 16px;\n    padding-bottom: 4px;\n    font-size: 13px;\n    color: @weuiTextColorTips;\n    line-height: 1em;\n    list-style: none;\n    overflow: hidden;\n}\n.weui-media-box__info__meta {\n    float: left;\n    padding-right: 1em;\n}\n.weui-media-box__info__meta_extra {\n    padding-left: 1em;\n    border-left: 1px solid @weuiTextColorTips;\n}\n.weui-media-box_appmsg {\n    display: flex;\n    align-items: center;\n    .weui-media-box__hd {\n        margin-right: 16px;\n        width: 60px;\n        height: 60px;\n        line-height: 60px;\n        text-align: center;\n    }\n    .weui-media-box__thumb {\n        width: 100%;\n        max-height: 100%;\n        vertical-align: top;\n    }\n    .weui-media-box__bd {\n        flex: 1;\n        min-width: 0;\n    }\n}\n.weui-media-box_small-appmsg {\n    padding: 0;\n    .weui-cells {\n        margin-top: 0;\n        &:before {\n            display: none;\n        }\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-grids {\n    position: relative;\n    overflow: hidden;\n\n    &:before {\n        .setTopLine(@weuiGridBorderColor);\n    }\n    &:after {\n        .setLeftLine(@weuiGridBorderColor);\n    }\n}\n\n.weui-grid {\n    position: relative;\n    float: left;\n    padding: 20px 10px;\n    width: 100% / @weuiGridColumnCount;\n    box-sizing: border-box;\n\n    &:before {\n        .setRightLine(@weuiGridBorderColor);\n    }\n    &:after {\n        .setBottomLine(@weuiGridBorderColor);\n    }\n\n    &:active {\n        background-color: @weuiBgColorActive;\n    }\n}\n\n.weui-grid__icon {\n    width: @weuiGridIconSize;\n    height: @weuiGridIconSize;\n    margin: 0 auto;\n\n    img {\n        display: block;\n        width: 100%;\n        height: 100%;\n    }\n\n    & + .weui-grid__label {\n        margin-top: 4px;\n    }\n}\n\n.weui-grid__label {\n    display: block;\n    text-align: center;\n    color: @weuiTextColorTitle;\n    font-size: @weuiGridFontSize;\n    white-space: nowrap;\n    text-overflow: ellipsis;\n    overflow: hidden;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-footer {\n    color: @weuiTextColorTips;\n    font-size: 14px;\n    line-height: 1.4;\n    text-align: center;\n    a,\n    navigator {\n        color: @weuiLinkColorDefault;\n    }\n    navigator {\n        display: inline;\n    }\n}\n.weui-footer_fixed-bottom {\n    position: fixed;\n    bottom: 0;\n    left: 0;\n    right: 0;\n    padding-top: 16px;\n    padding-bottom: 16px;\n    padding-bottom: calc(16px ~\"+ constant(safe-area-inset-bottom)\");\n    padding-bottom: calc(16px ~\"+ env(safe-area-inset-bottom)\");\n    left: constant(safe-area-inset-left);\n    left: env(safe-area-inset-left);\n    right: constant(safe-area-inset-right);\n    right: env(safe-area-inset-right);\n}\n.weui-footer__links {\n    font-size: 0;\n}\n.weui-footer__link {\n    display: inline-block;\n    vertical-align: top;\n    margin: 0 8px;\n    position: relative;\n    font-size: 14px;\n    &:before {\n        .setLeftLine();\n\n        left: -8px;\n        top: 0.36em;\n        bottom: 0.36em;\n    }\n    &:first-child {\n        &:before {\n            display: none;\n        }\n    }\n}\n.weui-footer__text {\n    padding: 0 16px;\n    font-size: 12px;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-flex {\n    display: flex;\n}\n.weui-flex__item {\n    flex: 1;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-dialog {\n    position: fixed;\n    z-index: 5000;\n    top: 50%;\n    left: 16px;\n    right: 16px;\n    transform: translate(0, -50%);\n    background-color: @weuiDialogBackgroundColor;\n    text-align: center;\n    border-radius: 12px;\n    overflow: hidden;\n    display: -webkit-box;\n    display: -webkit-flex;\n    display: flex;\n    -webkit-flex-direction: column;\n    flex-direction: column;\n    max-height: 90%;\n}\n.weui-dialog__hd {\n    padding: 32px @weuiDialogGapWidth 16px;\n}\n.weui-dialog__title {\n    font-weight: 700;\n    font-size: 17px;\n    line-height: 1.4;\n}\n.weui-dialog__bd {\n    overflow-y: auto;\n    -webkit-overflow-scrolling: touch;\n    padding: 0 @weuiDialogGapWidth;\n    margin-bottom: 32px;\n    font-size: 17px;\n    line-height: 1.4;\n    .hyphens;\n\n    color: @weuiTextColorDesc;\n    &:first-child {\n        min-height: 40px;\n        padding: 32px @weuiDialogGapWidth 0;\n        font-weight: 700;\n        color: @weuiTextColorTitle;\n        display: -webkit-box;\n        display: -webkit-flex;\n        display: flex;\n        -webkit-flex-direction: column;\n        flex-direction: column;\n        -webkit-box-pack: center;\n        -webkit-justify-content: center;\n        justify-content: center;\n    }\n}\n.weui-dialog__ft {\n    position: relative;\n    line-height: 56px;\n    min-height: 56px;\n    font-size: 17px;\n    display: flex;\n    &:after {\n        content: \" \";\n        .setTopLine(@weuiDialogLineColor);\n    }\n}\n.weui-dialog__btn {\n    display: block;\n    flex: 1;\n    color: @weuiDialogLinkColor;\n    font-weight: 700;\n    text-decoration: none;\n    .setTapColor();\n    &:active {\n        background-color: @weuiDialogLinkActiveBc;\n    }\n\n    position: relative;\n    &:after {\n        content: \" \";\n        .setLeftLine(@weuiDialogLineColor);\n    }\n    &:first-child {\n        &:after {\n            display: none;\n        }\n    }\n}\n.weui-dialog__btn_default {\n    color: var(--weui-FG-HALF);\n}\n\n.weui-skin_android {\n    .weui-dialog {\n        text-align: left;\n        box-shadow: 0 6px 30px 0 rgba(0, 0, 0, 0.1);\n    }\n    .weui-dialog__title {\n        font-size: 22px;\n        line-height: 1.4;\n    }\n    .weui-dialog__hd {\n        text-align: left;\n    }\n    .weui-dialog__bd {\n        color: @weuiTextColorDesc;\n        text-align: left;\n        &:first-child {\n            color: @weuiTextColorTitle;\n        }\n    }\n    .weui-dialog__ft {\n        display: block;\n        text-align: right;\n        line-height: 40px;\n        min-height: 40px;\n        padding: 0 @weuiDialogGapWidth 16px;\n        &:after {\n            display: none;\n        }\n    }\n    .weui-dialog__btn {\n        display: inline-block;\n        vertical-align: top;\n        padding: 0 0.8em;\n        &:after {\n            display: none;\n        }\n        &:last-child {\n            margin-right: -0.8em;\n        }\n    }\n    .weui-dialog__btn_default {\n        color: var(--weui-FG-HALF);\n    }\n}\n\n@media screen and (min-width: 352px) {\n    .weui-dialog {\n        width: 320px;\n        margin: 0 auto;\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-half-screen-dialog {\n    position: fixed;\n    left: 0;\n    right: 0;\n    bottom: 0;\n    max-height: 75%;\n    z-index: 5000;\n    line-height: 1.4;\n    background-color: var(--weui-BG-2);\n    border-top-left-radius: 12px;\n    border-top-right-radius: 12px;\n    overflow: hidden;\n    padding: 0 24px;\n    padding: 0 calc(24px ~\"+ constant(safe-area-inset-right)\") constant(safe-area-inset-bottom) calc(24px ~\"+ constant(safe-area-inset-left)\");\n    padding: 0 calc(24px ~\"+ env(safe-area-inset-right)\") env(safe-area-inset-bottom) calc(24px ~\"+ env(safe-area-inset-left)\");\n\n    @media only screen and (max-height: 558px) {\n        max-height: none;\n    }\n}\n.weui-half-screen-dialog__hd {\n    font-size: 8px;\n    height: 8em;\n    display: flex;\n    align-items: center;\n\n    .weui-icon-btn {\n        position: absolute;\n        top: 50%;\n        -webkit-transform: translateY(-50%);\n        transform: translateY(-50%);\n        &:active { opacity: 0.5; }\n    }\n}\n.weui-half-screen-dialog__hd__side {\n    position: relative;\n    left: -8px;\n}\n.weui-half-screen-dialog__hd__main {\n    flex: 1;\n    .weui-half-screen-dialog__hd__side + & {\n        text-align: center;\n        padding: 0 40px;\n    }\n    & + .weui-half-screen-dialog__hd__side {\n        right: -8px;\n        left: auto;\n        .weui-icon-btn {\n            right: 0;\n        }\n    }\n}\n.weui-half-screen-dialog__title {\n    display: block;\n    color: var(--weui-FG-0);\n    font-weight: 700;\n    font-size: 15px;\n}\n.weui-half-screen-dialog__subtitle {\n    display: block;\n    color: var(--weui-FG-1);\n    font-size: 10px;\n}\n\n.weui-half-screen-dialog__bd {\n    .hyphens();\n\n    overflow-y: auto;\n    padding-top: 4px;\n    padding-bottom: 56px;\n    font-size: 14px;\n    color: var(--weui-FG-0);\n}\n.weui-half-screen-dialog__desc {\n    font-size: 17px;\n    font-weight: 700;\n    color: var(--weui-FG-0);\n    line-height: 1.4;\n}\n.weui-half-screen-dialog__tips {\n    padding-top: 16px;\n    font-size: 14px;\n    color: var(--weui-FG-2);\n    line-height: 1.4;\n}\n.weui-half-screen-dialog__ft {\n    padding: 0 0 64px;\n    text-align: center;\n    .weui-btn:nth-last-child(n+2),\n    .weui-btn:nth-last-child(n+2) + .weui-btn {\n        display: inline-block;\n        vertical-align: top;\n        margin: 0 8px;\n        width: 120px;\n        &:first-child{\n          margin-left:0;\n        }\n        &:last-child{\n          margin-right:0;\n        }\n    }\n}\n.weui-half-screen-dialog__btn-area{\n  &+.weui-half-screen-dialog__attachment-area{\n    margin-top:24px;\n    margin-bottom:-44px;\n  }\n}\n.weui-icon-btn {\n    outline: 0;\n    -webkit-appearance: none;\n    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n    border-width: 0;\n    background-color: transparent;\n    color: var(--weui-FG-0);\n    font-size: 0;\n}\n.weui-icon-more {\n    display: inline-block;\n    vertical-align: middle;\n    width: 24px;\n    height: 24px;\n    mask: url(\"data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E  %3Cpath fill-opacity='.9' fill-rule='evenodd' d='M5 10.25a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zm7 0a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5z'/%3E%3C/svg%3E\") no-repeat 50% 50%;\n    -webkit-mask-size: cover;\n    mask-size: cover;\n    background-color: currentColor;\n    color: @weuiTextColorTitle;\n}\n.weui-icon-btn_goback {\n    color: @weuiTextColorTitle;\n    display: inline-block;\n    vertical-align: middle;\n    width: 12px;\n    height: 24px;\n    mask: url(\"data:image/svg+xml,%3Csvg%20width%3D%2212%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M10%2019.438L8.955%2020.5l-7.666-7.79a1.02%201.02%200%20010-1.42L8.955%203.5%2010%204.563%202.682%2012%2010%2019.438z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E\") no-repeat 50% 50%;\n    -webkit-mask-size: cover;\n    mask-size: cover;\n    background-color: currentColor;\n}\n.weui-icon-btn_close {\n    color: @weuiTextColorTitle;\n    display: inline-block;\n    vertical-align: middle;\n    width: 14px;\n    height: 24px;\n    mask: url(\"data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.25%2010.693L6.057%204.5%205%205.557l6.193%206.193L5%2017.943%206.057%2019l6.193-6.193L18.443%2019l1.057-1.057-6.193-6.193L19.5%205.557%2018.443%204.5z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E\") no-repeat 50% 50%;\n    -webkit-mask-size: cover;\n    mask-size: cover;\n    background-color: currentColor;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-toast {\n    position: fixed;\n    z-index: 5000;\n    width: 136px;\n    height: 136px;\n    top: 40%;\n    left: 50%;\n    transform: translate(-50%, -50%);\n    text-align: center;\n    border-radius: 12px;\n    color: rgba(255, 255, 255, 0.9);\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n    justify-content: center;\n    background-color: var(--weui-BG-4);\n    box-sizing:border-box;\n    line-height:1.4;\n}\n.weui-toast_text {\n  height:auto;\n  min-width:152px;\n  max-width:216px;\n  padding:12px 0;\n  .weui-toast__content {\n    font-size:14px;\n  }\n}\n.weui-icon_toast {\n    display: block;\n    width: 40px;\n    height: 40px;\n    margin-bottom:16px;\n    &.weui-icon-success-no-circle {\n        color: rgba(255, 255, 255, 0.9);\n    }\n    &.weui-icon-warn {\n        color: rgba(255, 255, 255, 0.9);\n    }\n    &.weui-loading {\n      width:36px;\n      height:36px;\n    }\n    &.weui-primary-loading {\n      font-size:40px;\n      color:#EDEDED;\n      &:before{\n        border-width:4px 0 4px 4px;\n      }\n      &:after{\n        border-width:4px 4px 4px 0;\n      }\n      .weui-primary-loading__dot{\n        width:4px;\n        height:4px;\n        border-top-right-radius:4px;\n        border-bottom-right-radius:4px;\n      }\n    }\n}\n\n.weui-toast__content {\n    font-size: 17px;\n    padding:0 12px;\n    .hyphens;\n}\n\n// 多行文本场景\n.weui-toast_text-more{\n  .weui-icon_toast{\n    margin-bottom:12px;\n  }\n  .weui-toast__content{\n    font-size:14px;\n    line-height:1.6;\n  }\n}\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-mask {\n    position: fixed;\n    z-index: 1000;\n    top: 0;\n    right: 0;\n    left: 0;\n    bottom: 0;\n    background: rgba(0, 0, 0, 0.6);\n}\n\n.weui-mask_transparent {\n    position: fixed;\n    z-index: 1000;\n    top: 0;\n    right: 0;\n    left: 0;\n    bottom: 0;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n@weuiActionSheetAndroidBorderRadius: 2px;\n\n.weui-actionsheet {\n    position: fixed;\n    left: 0;\n    bottom: 0;\n    transform: translate(0, 100%);\n    backface-visibility: hidden;\n    z-index: 5000;\n    width: 100%;\n    background-color: @weuiBgColorPrimary;\n    //slide up animation\n    transition: transform 0.3s;\n    border-top-left-radius: 12px;\n    border-top-right-radius: 12px;\n    overflow: hidden;\n}\n.weui-actionsheet__title {\n    position: relative;\n    height: 56px;\n    padding: 0 24px;\n    display: flex;\n    justify-content: center;\n    flex-direction: column;\n    text-align: center;\n    font-size: 12px;\n    color: @weuiTextColorDesc;\n    line-height: 1.4;\n    background: var(--weui-BG-2);\n    &:before {\n        .setBottomLine(@weuiCellBorderColor);\n    }\n    .weui-actionsheet__title-text {\n        .ellipsisLn(2);\n    }\n}\n.weui-actionsheet__menu {\n    color: @weuiTextColorTitle;\n    background-color: var(--weui-BG-2);\n}\n.weui-actionsheet__action {\n    margin-top: 8px;\n    color: @weuiTextColorTitle;\n    background-color: var(--weui-BG-2);\n    padding-bottom: constant(safe-area-inset-bottom);\n    padding-bottom: env(safe-area-inset-bottom);\n}\n.weui-actionsheet__cell {\n    position: relative;\n    padding: @weuiCellGapV;\n    text-align: center;\n    font-size: 17px;\n    line-height: @weuiCellLineHeight;\n    &:before {\n        .setTopLine(@weuiCellBorderColor);\n    }\n    &:active {\n        background-color: @weuiBgColorActive;\n    }\n    &:first-child {\n        &:before {\n            display: none;\n        }\n    }\n}\n.weui-actionsheet__cell_warn {\n    color: @weuiColorWarn;\n}\n\n\n//android actionSheet\n.weui-skin_android {\n    .weui-actionsheet {\n        position: fixed;\n        left: 50%;\n        top: 50%;\n        bottom: auto;\n        transform: translate(-50%, -50%);\n        //padding: 0 40px;\n        width: 274px;\n        box-sizing: border-box;\n        backface-visibility: hidden;\n        background: transparent;\n        //slide up animation\n        transition: transform 0.3s;\n        border-top-left-radius: 0;\n        border-top-right-radius: 0;\n    }\n    .weui-actionsheet__action {\n        display: none;\n    }\n    .weui-actionsheet__menu {\n        border-radius: @weuiActionSheetAndroidBorderRadius;\n        box-shadow: 0 6px 30px 0 rgba(0, 0, 0, 0.1);\n    }\n    .weui-actionsheet__cell {\n        padding: @weuiCellGapV;\n        font-size: 17px;\n        line-height: @weuiCellLineHeight;\n        color: @weuiTextColorTitle;\n        text-align: left;\n        &:first-child {\n            border-top-left-radius: @weuiActionSheetAndroidBorderRadius;\n            border-top-right-radius: @weuiActionSheetAndroidBorderRadius;\n        }\n        &:last-child {\n            border-bottom-left-radius: @weuiActionSheetAndroidBorderRadius;\n            border-bottom-right-radius: @weuiActionSheetAndroidBorderRadius;\n        }\n    }\n}\n\n//actionSheet aniamtion\n.weui-actionsheet_toggle {\n    transform: translate(0, 0);\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-loadmore {\n    width: 65%;\n    margin: 20px auto;\n    text-align: center;\n    font-size:0;\n\n    .weui-loading,\n    .weui-primary-loading{\n      margin-right:8px;\n    }\n}\n.weui-loadmore__tips {\n    display: inline-block;\n    vertical-align: middle;\n    font-size: 14px;\n    line-height: 1.6;\n    color: @weuiTextColorTitle;\n}\n\n.weui-loadmore_line {\n    border-top: 1px solid @weuiLineColorLight;\n    margin-top: 32px;\n    .weui-loadmore__tips {\n        position: relative;\n        top: -0.9em;\n        padding: 0 0.55em;\n        background-color: var(--weui-BG-2);\n        color: @weuiTextColorDesc;\n    }\n}\n.weui-loadmore_dot {\n    .weui-loadmore__tips {\n        padding: 0 0.16em;\n        &:before {\n            content: \" \";\n            width: 4px;\n            height: 4px;\n            border-radius: 50%;\n            background-color: @weuiLineColorLight;\n            display: inline-block;\n            position: relative;\n            vertical-align: 0;\n            top: -0.16em;\n        }\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-badge {\n    display: inline-block;\n    padding: 0.15em 0.4em;\n    min-width: 8px;\n    border-radius: 18px;\n    background-color: @weuiColorWarn;\n    color: #fff; // 固定色值\n    line-height: 1.2;\n    text-align: center;\n    font-size: 12px;\n    vertical-align: middle;\n}\n.weui-badge_dot {\n    padding: 0.4em;\n    min-width: 0;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-toptips {\n    display: none;\n    position: fixed;\n    transform: translateZ(0);\n    top: 8px;\n    left: 8px;\n    right: 8px;\n    padding: 10px;\n    border-radius: 8px;\n    font-size: 14px;\n    text-align: center;\n    color: #fff; // 固定色值\n    z-index: 5000;\n    .text_wrap();\n}\n.weui-toptips_warn {\n    background-color: @weuiColorWarn;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-list-tips{\n  list-style:none;\n  padding-top:24px;\n  padding-bottom:24px;\n  line-height:1.4;\n  font-size:14px;\n  color:var(--weui-FG-1);\n\n  position:relative;\n  &:before{\n    content:\"\";\n    .setTopLine(var(--weui-FG-3));\n  }\n  &:last-child{\n    padding-bottom:0;\n  }\n}\n.weui-list-tips__item{\n  position:relative;\n  padding-left:15px;\n  margin:16px 0;\n  &:before{\n    content:\"\\2022\";\n    position:absolute;\n    left:0;\n    top:-.1em;\n  }\n  &:first-child{\n    margin-top:0;\n  }\n  .weui-form-preview__list + .weui-list-tips > &{\n    &:first-child{\n      margin-top:6px;\n    }\n  }\n}\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@weuiSearchInputHeight:32px;\n\n@import \"../../base/fn\";\n.weui-search-bar {\n    position: relative;\n    padding: 8px;\n    display: flex;\n    box-sizing: border-box;\n    background-color: @weuiBgColorDefault;\n    -webkit-text-size-adjust: 100%;\n    align-items: center;\n    &.weui-search-bar_focusing {\n        .weui-search-bar__cancel-btn {\n            display: block;\n        }\n        .weui-search-bar__label {\n            display: none;\n        }\n    }\n\n    .weui-icon-search {\n        width: 16px;\n        height: 16px;\n    }\n}\n.weui-search-bar__form {\n    position: relative;\n    flex: auto;\n    background-color: var(--weui-BG-2);\n    border-radius: 4px;\n}\n.weui-search-bar__box {\n    position: relative;\n    padding-left: 28px;\n    padding-right: 32px;\n    height: 100%;\n    width: 100%;\n    box-sizing: border-box;\n    z-index: 1;\n    .weui-search-bar__input {\n        padding: 8px 0;\n        width: 100%;\n        height: unit(@weuiSearchInputHeight - 16px)/14em;\n        border: 0;\n        font-size: 14px;\n        line-height: unit(@weuiSearchInputHeight - 16px)/14em;\n        box-sizing: content-box;\n        background: transparent;\n        caret-color: @weuiColorPrimary;\n        color: @weuiTextColorTitle;\n        &:focus {\n            outline: none;\n        }\n    }\n    .weui-icon-search {\n        position: absolute;\n        top: 50%;\n        left: 8px;\n        margin-top: -8px;\n    }\n    .weui-icon-clear {\n        position: absolute;\n        top: 50%;\n        right: 0;\n        margin-top: -16px;\n        padding: 8px;\n        width: 16px;\n        height: 16px;\n        mask-size: 16px;\n    }\n}\n.weui-search-bar__label {\n    position: absolute;\n    top: 0;\n    right: 0;\n    bottom: 0;\n    left: 0;\n    z-index: 2;\n    font-size: 0;\n    border-radius: 4px;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    color: @weuiTextColorDesc;\n    background: var(--weui-BG-2);\n    span {\n        display: inline-block;\n        font-size: 14px;\n        vertical-align: middle;\n    }\n    .weui-icon-search {\n        margin-right: 4px;\n    }\n}\n.weui-search-bar__cancel-btn {\n    display: none;\n    margin-left: 8px;\n    line-height: 28px;\n    color: @weuiLinkColorDefault;\n    white-space: nowrap;\n}\n.weui-search-bar__input:not(:valid) + .weui-icon-clear {\n    display: none;\n}\n\n//干掉input[search]默认的clear button\ninput[type=\"search\"]::-webkit-search-decoration,\ninput[type=\"search\"]::-webkit-search-cancel-button,\ninput[type=\"search\"]::-webkit-search-results-button,\ninput[type=\"search\"]::-webkit-search-results-decoration {\n    display: none;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n@pickerItemHeight: 48px;\n.weui-picker {\n    position: fixed;\n    width: 100%;\n    box-sizing: border-box;\n    left: 0;\n    bottom: 0;\n    z-index: 5000;\n    background-color: var(--weui-BG-2);\n    padding-bottom: constant(safe-area-inset-bottom);\n    padding-bottom: env(safe-area-inset-bottom);\n    backface-visibility: hidden;\n    transform: translate(0, 100%);\n    //slide up animation\n    transition: transform 0.3s;\n}\n\n.weui-picker__hd {\n    display: flex;\n    padding: 16px;\n    padding: 16px calc(16px ~\"+ constant(safe-area-inset-right)\") 16px calc(16px ~\"+ constant(safe-area-inset-left)\");\n    padding: 16px calc(16px ~\"+ env(safe-area-inset-right)\") 16px calc(16px ~\"+ env(safe-area-inset-left)\");\n    position: relative;\n    text-align: center;\n    font-size: 17px;\n    line-height: 1.4;\n    &:after {\n        .setBottomLine(@weuiLineColorLight);\n    }\n}\n\n.weui-picker__bd {\n    display: flex;\n    position: relative;\n    background-color: var(--weui-BG-2);\n    height: 240px;\n    overflow: hidden;\n}\n\n.weui-picker__group {\n    flex: 1;\n    position: relative;\n    height: 100%;\n    &:first-child {\n        .weui-picker__item {\n            padding-left: constant(safe-area-inset-left);\n            padding-left: env(safe-area-inset-left);\n        }\n    }\n    &:last-child {\n        .weui-picker__item {\n            padding-right: constant(safe-area-inset-right);\n            padding-right: env(safe-area-inset-right);\n        }\n    }\n}\n\n.weui-picker__mask {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    margin: 0 auto;\n    z-index: 3;\n    background-image: linear-gradient(180deg, rgba(255, 255, 255, 0.95), rgba(255, 255, 255, 0.6)), linear-gradient(0deg, rgba(255, 255, 255, 0.95), rgba(255, 255, 255, 0.6));\n    .dark({\n        background-image: linear-gradient(180deg, rgba(25, 25, 25, 0.95), rgba(25, 25, 25, 0.6)), linear-gradient(0deg, rgba(25, 25, 25, 0.95), rgba(25, 25, 25, 0.6));\n    });\n    \n    background-position: top, bottom;\n    background-size: 100% 92px;\n    background-repeat: no-repeat;\n    transform: translateZ(0);\n}\n\n.weui-picker__indicator {\n    width: 100%;\n    height: 56px;\n    position: absolute;\n    left: 0;\n    top: 92px;\n    z-index: 3;\n    &:before {\n        .setTopLine(@weuiLineColorLight);\n    }\n    &:after {\n        .setBottomLine(@weuiLineColorLight);\n    }\n}\n\n.weui-picker__content {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 100%;\n}\n\n.weui-picker__item {\n    height: @pickerItemHeight;\n    line-height: @pickerItemHeight;\n    text-align: center;\n    color: @weuiTextColorTitle;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n    overflow: hidden;\n}\n\n.weui-picker__item_disabled {\n    color: @weuiTextColorDesc;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n@keyframes slideUp {\n    from {\n        transform: translate3d(0, 100%, 0);\n    }\n\n    to {\n        transform: translate3d(0, 0, 0);\n    }\n}\n\n.weui-animate-slide-up {\n    animation: slideUp ease 0.3s forwards;\n}\n\n@keyframes slideDown {\n    from {\n        transform: translate3d(0, 0, 0);\n    }\n\n    to {\n        transform: translate3d(0, 100%, 0);\n    }\n}\n\n.weui-animate-slide-down {\n    animation: slideDown ease 0.3s forwards;\n}\n\n@keyframes fadeIn {\n    from {\n        opacity: 0;\n    }\n    to {\n        opacity: 1;\n    }\n}\n\n.weui-animate-fade-in {\n    animation: fadeIn ease 0.3s forwards;\n}\n\n@keyframes fadeOut {\n    from {\n        opacity: 1;\n    }\n    to {\n        opacity: 0;\n    }\n}\n\n.weui-animate-fade-out {\n    animation: fadeOut ease 0.3s forwards;\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-agree {\n    display: block;\n    padding: 8px 15px 0;\n    font-size: 14px;\n    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n\n    a,\n    navigator {\n        color: @weuiLinkColorDefault;\n    }\n    navigator {\n        display: inline;\n    }\n}\n.weui-agree__text {\n    color: @weuiTextColorDesc;\n    margin-left: 2px;\n}\n.weui-agree__checkbox {\n    appearance: none;\n    display: inline-block;\n    border: 0;\n    outline: 0;\n    vertical-align: middle;\n    background-color: currentColor;\n    mask-position: 0 0;\n    mask-repeat: no-repeat;\n    mask-size: 100%;\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E);\n    color: @weuiLineColorDark;\n    width: 1em;\n    height: 1em;\n    font-size: 17px;\n    margin-top: -0.2em;\n}\n.weui-agree__checkbox-check { // 兼容小程序\n    position: absolute;\n    left: -9999px;\n}\n.weui-agree__checkbox:checked,\n.weui-agree__checkbox-check[aria-checked=\"true\"] + .weui-agree__checkbox {\n    mask-image: url(data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E);\n    color: @weuiColorPrimary;\n}\n.weui-agree_animate {\n    animation: weuiAgree 0.3s 1;\n}\n\n@keyframes weuiAgree {\n    0% {\n        transform: translateX(0);\n    }\n\n    16% {\n        transform: translateX(-8px);\n    }\n\n    28% {\n        transform: translateX(-16px);\n    }\n\n    44% {\n        transform: translateX(0);\n    }\n\n    59% {\n        transform: translateX(-16px);\n    }\n\n    73% {\n        transform: translateX(0);\n    }\n\n    82% {\n        transform: translateX(16px);\n    }\n\n    94% {\n        transform: translateX(8px);\n    }\n\n    100% {\n        transform: translateX(0);\n    }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n// 默认色\n.weui-primary-loading{\n  font-size:16px;\n  .setCircleLoading(#606060,1em,0.125em);\n}\n\n// 跟随系统切换的品牌色\n.weui-primary-loading_brand{\n  color:var(--weui-BRAND);\n}\n\n// 固定白色半透明\n.weui-primary-loading_transparent{\n  color:#EDEDED;\n}\n\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n.setCircleLoading(@color:currentColor,@size:80px,@wide:7px){\n  display:inline-flex;\n  position:relative;\n  width:@size;\n  height:@size;\n  vertical-align:middle;\n  color:@color;\n  animation: circleLoading 1s steps(60,end) infinite;\n\n  &:before,&:after{\n    content:\"\";\n    display:block;\n    width:@size/2;\n    height:@size;\n    box-sizing:border-box;\n    border:@wide solid;\n    border-color:currentColor;\n  }\n\n  &:before{\n    border-right-width:0;\n    border-top-left-radius:@size;\n    border-bottom-left-radius:@size;\n    -webkit-mask-image:linear-gradient(180deg, rgba(0,0,0,1) 8%, rgba(0,0,0,.3) 95%);\n  }\n  &:after{\n    border-left-width:0;\n    border-top-right-radius:@size;\n    border-bottom-right-radius:@size;\n    -webkit-mask-image:linear-gradient(180deg, rgba(0,0,0,0) 8% , rgba(0,0,0,.3) 95%);\n  }\n  &__dot{\n    position:absolute;\n    top:0;\n    left:50%;\n    margin-left:-@wide/2;\n    width:@wide;\n    height:@wide;\n    border-top-right-radius:@wide;\n    border-bottom-right-radius:@wide;\n    background:currentColor;\n  }\n\n  @keyframes circleLoading {\n    0% {\n      transform: rotate3d(0, 0, 1, 0deg);\n    }\n\n    100% {\n      transform: rotate3d(0, 0, 1, 360deg);\n    }\n  }\n}\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n@import \"./weui-primary-loading\";\n\n.weui-loading {\n    width: 20px;\n    height: 20px;\n    display: inline-block;\n    vertical-align: middle;\n    animation: weuiLoading 1s steps(12, end) infinite;\n    background: transparent url(\"data:image/svg+xml;charset=utf8, %3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120' viewBox='0 0 100 100'%3E%3Cpath fill='none' d='M0 0h100v100H0z'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23E9E9E9' rx='5' ry='5' transform='translate(0 -30)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23989697' rx='5' ry='5' transform='rotate(30 105.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%239B999A' rx='5' ry='5' transform='rotate(60 75.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23A3A1A2' rx='5' ry='5' transform='rotate(90 65 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23ABA9AA' rx='5' ry='5' transform='rotate(120 58.66 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23B2B2B2' rx='5' ry='5' transform='rotate(150 54.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23BAB8B9' rx='5' ry='5' transform='rotate(180 50 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23C2C0C1' rx='5' ry='5' transform='rotate(-150 45.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23CBCBCB' rx='5' ry='5' transform='rotate(-120 41.34 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23D2D2D2' rx='5' ry='5' transform='rotate(-90 35 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23DADADA' rx='5' ry='5' transform='rotate(-60 24.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='%23E2E2E2' rx='5' ry='5' transform='rotate(-30 -5.98 65)'/%3E%3C/svg%3E\") no-repeat;\n    background-size: 100%;\n\n    &.weui-loading_transparent,\n    .weui-btn_loading.weui-btn_primary & {\n        background-image: url(\"data:image/svg+xml;charset=utf8, %3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120' viewBox='0 0 100 100'%3E%3Cpath fill='none' d='M0 0h100v100H0z'/%3E%3Crect xmlns='http://www.w3.org/2000/svg' width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.56)' rx='5' ry='5' transform='translate(0 -30)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.5)' rx='5' ry='5' transform='rotate(30 105.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.43)' rx='5' ry='5' transform='rotate(60 75.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.38)' rx='5' ry='5' transform='rotate(90 65 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.32)' rx='5' ry='5' transform='rotate(120 58.66 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.28)' rx='5' ry='5' transform='rotate(150 54.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.25)' rx='5' ry='5' transform='rotate(180 50 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.2)' rx='5' ry='5' transform='rotate(-150 45.98 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.17)' rx='5' ry='5' transform='rotate(-120 41.34 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.14)' rx='5' ry='5' transform='rotate(-90 35 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.1)' rx='5' ry='5' transform='rotate(-60 24.02 65)'/%3E%3Crect width='7' height='20' x='46.5' y='40' fill='rgba(255,255,255,.03)' rx='5' ry='5' transform='rotate(-30 -5.98 65)'/%3E%3C/svg%3E\");\n    }\n}\n\n@-webkit-keyframes weuiLoading {\n    0% {\n        transform: rotate3d(0, 0, 1, 0deg);\n    }\n\n    100% {\n        transform: rotate3d(0, 0, 1, 360deg);\n    }\n}\n\n@keyframes weuiLoading {\n    0% {\n        transform: rotate3d(0, 0, 1, 0deg);\n    }\n\n    100% {\n        transform: rotate3d(0, 0, 1, 360deg);\n    }\n}\n\n","/*\n* Tencent is pleased to support the open source community by making WeUI available.\n* \n* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.\n* \n* Licensed under the MIT License (the \"License\"); you may not use this file except in compliance\n* with the License. You may obtain a copy of the License at\n* \n*       http://opensource.org/licenses/MIT\n* \n* Unless required by applicable law or agreed to in writing, software distributed under the License is\n* distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\n* either express or implied. See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n@import \"../../base/fn\";\n\n.weui-slider {\n    padding: 15px 18px;\n    user-select: none;\n}\n\n.weui-slider__inner {\n    position: relative;\n    height: 2px;\n    background-color: @weuiLineColorLight;\n}\n\n.weui-slider__track {\n    height: 2px;\n    background-color: @weuiColorPrimary;\n    width: 0;\n}\n\n.weui-slider__handler {\n    position: absolute;\n    left: 0;\n    top: 50%;\n    width: 28px;\n    height: 28px;\n    margin-left: -14px;\n    margin-top: -14px;\n    border-radius: 50%;\n    background-color: #fff; // 固定色值\n    box-shadow: 0 0 4px var(--weui-FG-3);\n}\n\n\n.weui-slider-box {\n    display: flex;\n    align-items: center;\n    .weui-slider {\n        flex: 1;\n    }\n}\n.weui-slider-box__value {\n    margin-left: 0.5em;\n    min-width: 24px;\n    color: @weuiTextColorDesc;\n    text-align: center;\n    font-size: 14px;\n}\n"]} */ diff --git a/opencv_dev/lesson2.html b/opencv_dev/lesson2.html new file mode 100644 index 0000000..8b0d5e6 --- /dev/null +++ b/opencv_dev/lesson2.html @@ -0,0 +1,121 @@ + + + + + + OpenCV WebAssembly + + + + + + +
+
+
+
图像处理
+
+ + +
+ 灰度化 + 边缘检测 + 特征点检测 +
+
+
+
+
+ + + + + + + + \ No newline at end of file diff --git a/opencv_dev/opencv3.4.16.wasm b/opencv_dev/opencv3.4.16.wasm new file mode 100644 index 0000000..bc353e2 Binary files /dev/null and b/opencv_dev/opencv3.4.16.wasm differ