From 38b475eb663af4d9931aad0ae56b4ce68aaea7c1 Mon Sep 17 00:00:00 2001 From: aihe <961836564@qq.com> Date: Sat, 11 May 2024 18:46:26 +0800 Subject: [PATCH] uu --- common/api/common.js | 2 +- common/api/order.js | 2 +- common/libs/qs.js | 1739 ++++++++++++++++++++++++++++++++++++++++ common/manageServer.js | 28 +- common/request.js | 40 +- common/untool.js | 55 +- 6 files changed, 1784 insertions(+), 82 deletions(-) create mode 100644 common/libs/qs.js diff --git a/common/api/common.js b/common/api/common.js index 475f4bd..84b0ce8 100644 --- a/common/api/common.js +++ b/common/api/common.js @@ -56,7 +56,7 @@ export const getLatestNotices = (data = {})=> { // 接口返回-文件流 export const getStaffQRCodePng = (data = {})=> { - return coreRequest(url.getStaffQRCodePng, data, {}, "GET", { _isFile: true }) + return coreRequest(url.getStaffQRCodePng, data, {}, "GET") } diff --git a/common/api/order.js b/common/api/order.js index 90bca8f..1ddf3a1 100644 --- a/common/api/order.js +++ b/common/api/order.js @@ -93,5 +93,5 @@ export const getNextStationList = (data = {})=> { // 获取运单详细信息-图片 接口返回-文件流 export const getRealGetWaybillPrintData = (data = {})=> { - return coreRequest(url.getRealGetWaybillPrintData, data, {}, "GET", { _isFile: true }) + return coreRequest(url.getRealGetWaybillPrintData, data, {}, "GET") } diff --git a/common/libs/qs.js b/common/libs/qs.js new file mode 100644 index 0000000..473138d --- /dev/null +++ b/common/libs/qs.js @@ -0,0 +1,1739 @@ +function f() { + var define, module, exports; + return (function() { + function r(e, n, t) { + function o(i, f) { + if (!n[i]) { + if (!e[i]) { + var c = "function" == typeof require && require; + if (!f && c) return c(i, !0); + if (u) return u(i, !0); + var a = new Error("Cannot find module '" + i + "'"); + throw a.code = "MODULE_NOT_FOUND", a + } + var p = n[i] = { + exports: {} + }; + e[i][0].call(p.exports, function(r) { + var n = e[i][1][r]; + return o(n || r) + }, p, p.exports, r, e, n, t) + } + return n[i].exports + } + for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]); + return o + } + return r + })()({ + 1: [function(require, module, exports) { + "use strict"; + var replace = String.prototype.replace, + percentTwenties = /%20/g, + Format = { + RFC1738: "RFC1738", + RFC3986: "RFC3986" + }; + module.exports = { + default: Format.RFC3986, + formatters: { + RFC1738: function(e) { + return replace.call(e, percentTwenties, "+") + }, + RFC3986: function(e) { + return String(e) + } + }, + RFC1738: Format.RFC1738, + RFC3986: Format.RFC3986 + }; + + }, {}], + 2: [function(require, module, exports) { + "use strict"; + var stringify = require(4), + parse = require(3), + formats = require(1); + module.exports = { + formats: formats, + parse: parse, + stringify: stringify + }; + + }, { + "1": 1, + "3": 3, + "4": 4 + }], + 3: [function(require, module, exports) { + "use strict"; + var utils = require(5), + has = Object.prototype.hasOwnProperty, + isArray = Array.isArray, + defaults = { + allowDots: !1, + allowEmptyArrays: !1, + allowPrototypes: !1, + allowSparse: !1, + arrayLimit: 20, + charset: "utf-8", + charsetSentinel: !1, + comma: !1, + decodeDotInKeys: !1, + decoder: utils.decode, + delimiter: "&", + depth: 5, + duplicates: "combine", + ignoreQueryPrefix: !1, + interpretNumericEntities: !1, + parameterLimit: 1e3, + parseArrays: !0, + plainObjects: !1, + strictNullHandling: !1 + }, + interpretNumericEntities = function(e) { + return e.replace(/&#(\d+);/g, (function(e, t) { + return String.fromCharCode(parseInt(t, 10)) + })) + }, + parseArrayValue = function(e, t) { + return e && "string" == typeof e && t.comma && e.indexOf(",") > -1 ? e.split( + ",") : e + }, + isoSentinel = "utf8=%26%2310003%3B", + charsetSentinel = "utf8=%E2%9C%93", + parseValues = function parseQueryStringValues(e, t) { + var r, a = { + __proto__: null + }, + o = t.ignoreQueryPrefix ? e.replace(/^\?/, "") : e, + i = t.parameterLimit === 1 / 0 ? void 0 : t.parameterLimit, + l = o.split(t.delimiter, i), + s = -1, + n = t.charset; + if (t.charsetSentinel) + for (r = 0; r < l.length; ++r) 0 === l[r].indexOf("utf8=") && (l[r] === + charsetSentinel ? n = "utf-8" : l[r] === isoSentinel && (n = + "iso-8859-1"), s = r, r = l.length); + for (r = 0; r < l.length; ++r) + if (r !== s) { + var p, c, d = l[r], + u = d.indexOf("]="), + y = -1 === u ? d.indexOf("=") : u + 1; - 1 === y ? (p = t.decoder(d, + defaults.decoder, n, "key"), c = t.strictNullHandling ? + null : "") : (p = t.decoder(d.slice(0, y), defaults.decoder, n, + "key"), c = utils.maybeMap(parseArrayValue(d.slice(y + 1), + t), (function(e) { + return t.decoder(e, defaults.decoder, n, "value") + }))), c && t.interpretNumericEntities && "iso-8859-1" === n && (c = + interpretNumericEntities(c)), d.indexOf("[]=") > -1 && (c = + isArray(c) ? [c] : c); + var f = has.call(a, p); + f && "combine" === t.duplicates ? a[p] = utils.combine(a[p], c) : f && + "last" !== t.duplicates || (a[p] = c) + } return a + }, + parseObject = function(e, t, r, a) { + for (var o = a ? t : parseArrayValue(t, r), i = e.length - 1; i >= 0; --i) { + var l, s = e[i]; + if ("[]" === s && r.parseArrays) l = r.allowEmptyArrays && "" === o ? [] : + [].concat(o); + else { + l = r.plainObjects ? Object.create(null) : {}; + var n = "[" === s.charAt(0) && "]" === s.charAt(s.length - 1) ? s.slice( + 1, -1) : s, + p = r.decodeDotInKeys ? n.replace(/%2E/g, ".") : n, + c = parseInt(p, 10); + r.parseArrays || "" !== p ? !isNaN(c) && s !== p && String(c) === p && + c >= 0 && r.parseArrays && c <= r.arrayLimit ? (l = [])[c] = o : + "__proto__" !== p && (l[p] = o) : l = { + 0: o + } + } + o = l + } + return o + }, + parseKeys = function parseQueryStringKeys(e, t, r, a) { + if (e) { + var o = r.allowDots ? e.replace(/\.([^.[]+)/g, "[$1]") : e, + i = /(\[[^[\]]*])/g, + l = r.depth > 0 && /(\[[^[\]]*])/.exec(o), + s = l ? o.slice(0, l.index) : o, + n = []; + if (s) { + if (!r.plainObjects && has.call(Object.prototype, s) && !r + .allowPrototypes) return; + n.push(s) + } + for (var p = 0; r.depth > 0 && null !== (l = i.exec(o)) && p < r.depth;) { + if (p += 1, !r.plainObjects && has.call(Object.prototype, l[1].slice(1, + -1)) && !r.allowPrototypes) return; + n.push(l[1]) + } + return l && n.push("[" + o.slice(l.index) + "]"), parseObject(n, t, r, a) + } + }, + normalizeParseOptions = function normalizeParseOptions(e) { + if (!e) return defaults; + if (void 0 !== e.allowEmptyArrays && "boolean" != typeof e.allowEmptyArrays) + throw new TypeError( + "`allowEmptyArrays` option can only be `true` or `false`, when provided" + ); + if (void 0 !== e.decodeDotInKeys && "boolean" != typeof e.decodeDotInKeys) + throw new TypeError( + "`decodeDotInKeys` option can only be `true` or `false`, when provided" + ); + if (null !== e.decoder && void 0 !== e.decoder && "function" != typeof e + .decoder) throw new TypeError("Decoder has to be a function."); + if (void 0 !== e.charset && "utf-8" !== e.charset && "iso-8859-1" !== e.charset) + throw new TypeError( + "The charset option must be either utf-8, iso-8859-1, or undefined"); + var t = void 0 === e.charset ? defaults.charset : e.charset, + r = void 0 === e.duplicates ? defaults.duplicates : e.duplicates; + if ("combine" !== r && "first" !== r && "last" !== r) throw new TypeError( + "The duplicates option must be either combine, first, or last"); + return { + allowDots: void 0 === e.allowDots ? !0 === e.decodeDotInKeys || defaults + .allowDots : !!e.allowDots, + allowEmptyArrays: "boolean" == typeof e.allowEmptyArrays ? !!e + .allowEmptyArrays : defaults.allowEmptyArrays, + allowPrototypes: "boolean" == typeof e.allowPrototypes ? e.allowPrototypes : + defaults.allowPrototypes, + allowSparse: "boolean" == typeof e.allowSparse ? e.allowSparse : defaults + .allowSparse, + arrayLimit: "number" == typeof e.arrayLimit ? e.arrayLimit : defaults + .arrayLimit, + charset: t, + charsetSentinel: "boolean" == typeof e.charsetSentinel ? e.charsetSentinel : + defaults.charsetSentinel, + comma: "boolean" == typeof e.comma ? e.comma : defaults.comma, + decodeDotInKeys: "boolean" == typeof e.decodeDotInKeys ? e.decodeDotInKeys : + defaults.decodeDotInKeys, + decoder: "function" == typeof e.decoder ? e.decoder : defaults.decoder, + delimiter: "string" == typeof e.delimiter || utils.isRegExp(e.delimiter) ? e + .delimiter : defaults.delimiter, + depth: "number" == typeof e.depth || !1 === e.depth ? +e.depth : defaults + .depth, + duplicates: r, + ignoreQueryPrefix: !0 === e.ignoreQueryPrefix, + interpretNumericEntities: "boolean" == typeof e.interpretNumericEntities ? e + .interpretNumericEntities : defaults.interpretNumericEntities, + parameterLimit: "number" == typeof e.parameterLimit ? e.parameterLimit : + defaults.parameterLimit, + parseArrays: !1 !== e.parseArrays, + plainObjects: "boolean" == typeof e.plainObjects ? e.plainObjects : defaults + .plainObjects, + strictNullHandling: "boolean" == typeof e.strictNullHandling ? e + .strictNullHandling : defaults.strictNullHandling + } + }; + module.exports = function(e, t) { + var r = normalizeParseOptions(t); + if ("" === e || null == e) return r.plainObjects ? Object.create(null) : {}; + for (var a = "string" == typeof e ? parseValues(e, r) : e, o = r.plainObjects ? + Object.create(null) : {}, i = Object.keys(a), l = 0; l < i.length; ++ + l) { + var s = i[l], + n = parseKeys(s, a[s], r, "string" == typeof e); + o = utils.merge(o, n, r) + } + return !0 === r.allowSparse ? o : utils.compact(o) + }; + + }, { + "5": 5 + }], + 4: [function(require, module, exports) { + "use strict"; + var getSideChannel = require(29), + utils = require(5), + formats = require(1), + has = Object.prototype.hasOwnProperty, + arrayPrefixGenerators = { + brackets: function brackets(e) { + return e + "[]" + }, + comma: "comma", + indices: function indices(e, r) { + return e + "[" + r + "]" + }, + repeat: function repeat(e) { + return e + } + }, + isArray = Array.isArray, + push = Array.prototype.push, + pushToArray = function(e, r) { + push.apply(e, isArray(r) ? r : [r]) + }, + toISO = Date.prototype.toISOString, + defaultFormat = formats.default, + defaults = { + addQueryPrefix: !1, + allowDots: !1, + allowEmptyArrays: !1, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: !1, + delimiter: "&", + encode: !0, + encodeDotInKeys: !1, + encoder: utils.encode, + encodeValuesOnly: !1, + format: defaultFormat, + formatter: formats.formatters[defaultFormat], + indices: !1, + serializeDate: function serializeDate(e) { + return toISO.call(e) + }, + skipNulls: !1, + strictNullHandling: !1 + }, + isNonNullishPrimitive = function isNonNullishPrimitive(e) { + return "string" == typeof e || "number" == typeof e || "boolean" == typeof e || + "symbol" == typeof e || "bigint" == typeof e + }, + sentinel = {}, + stringify = function stringify(e, r, t, o, a, n, i, l, s, f, u, d, y, c, p, m, h, + v) { + for (var w = e, b = v, g = 0, A = !1; void 0 !== (b = b.get(sentinel)) && !A;) { + var D = b.get(e); + if (g += 1, void 0 !== D) { + if (D === g) throw new RangeError("Cyclic object value"); + A = !0 + } + void 0 === b.get(sentinel) && (g = 0) + } + if ("function" == typeof f ? w = f(r, w) : w instanceof Date ? w = y(w) : + "comma" === t && isArray(w) && (w = utils.maybeMap(w, (function(e) { + return e instanceof Date ? y(e) : e + }))), null === w) { + if (n) return s && !m ? s(r, defaults.encoder, h, "key", c) : r; + w = "" + } + if (isNonNullishPrimitive(w) || utils.isBuffer(w)) return s ? [p(m ? r : s(r, + defaults.encoder, h, "key", c)) + "=" + p(s(w, defaults.encoder, + h, "value", c))] : [p(r) + "=" + p(String(w))]; + var E, N = []; + if (void 0 === w) return N; + if ("comma" === t && isArray(w)) m && s && (w = utils.maybeMap(w, s)), E = [{ + value: w.length > 0 ? w.join(",") || null : void 0 + }]; + else if (isArray(f)) E = f; + else { + var S = Object.keys(w); + E = u ? S.sort(u) : S + } + var O = l ? r.replace(/\./g, "%2E") : r, + T = o && isArray(w) && 1 === w.length ? O + "[]" : O; + if (a && isArray(w) && 0 === w.length) return T + "[]"; + for (var k = 0; k < E.length; ++k) { + var I = E[k], + P = "object" == typeof I && void 0 !== I.value ? I.value : w[I]; + if (!i || null !== P) { + var x = d && l ? I.replace(/\./g, "%2E") : I, + z = isArray(w) ? "function" == typeof t ? t(T, x) : T : T + (d ? + "." + x : "[" + x + "]"); + v.set(e, g); + var K = getSideChannel(); + K.set(sentinel, v), pushToArray(N, stringify(P, z, t, o, a, n, i, l, + "comma" === t && m && isArray(w) ? null : s, f, u, d, y, c, + p, m, h, K)) + } + } + return N + }, + normalizeStringifyOptions = function normalizeStringifyOptions(e) { + if (!e) return defaults; + if (void 0 !== e.allowEmptyArrays && "boolean" != typeof e.allowEmptyArrays) + throw new TypeError( + "`allowEmptyArrays` option can only be `true` or `false`, when provided" + ); + if (void 0 !== e.encodeDotInKeys && "boolean" != typeof e.encodeDotInKeys) + throw new TypeError( + "`encodeDotInKeys` option can only be `true` or `false`, when provided" + ); + if (null !== e.encoder && void 0 !== e.encoder && "function" != typeof e + .encoder) throw new TypeError("Encoder has to be a function."); + var r = e.charset || defaults.charset; + if (void 0 !== e.charset && "utf-8" !== e.charset && "iso-8859-1" !== e.charset) + throw new TypeError( + "The charset option must be either utf-8, iso-8859-1, or undefined"); + var t = formats.default; + if (void 0 !== e.format) { + if (!has.call(formats.formatters, e.format)) throw new TypeError( + "Unknown format option provided."); + t = e.format + } + var o, a = formats.formatters[t], + n = defaults.filter; + if (("function" == typeof e.filter || isArray(e.filter)) && (n = e.filter), o = + e.arrayFormat in arrayPrefixGenerators ? e.arrayFormat : "indices" in e ? e + .indices ? "indices" : "repeat" : defaults.arrayFormat, "commaRoundTrip" in + e && "boolean" != typeof e.commaRoundTrip) throw new TypeError( + "`commaRoundTrip` must be a boolean, or absent"); + var i = void 0 === e.allowDots ? !0 === e.encodeDotInKeys || defaults + .allowDots : !!e.allowDots; + return { + addQueryPrefix: "boolean" == typeof e.addQueryPrefix ? e.addQueryPrefix : + defaults.addQueryPrefix, + allowDots: i, + allowEmptyArrays: "boolean" == typeof e.allowEmptyArrays ? !!e + .allowEmptyArrays : defaults.allowEmptyArrays, + arrayFormat: o, + charset: r, + charsetSentinel: "boolean" == typeof e.charsetSentinel ? e.charsetSentinel : + defaults.charsetSentinel, + commaRoundTrip: e.commaRoundTrip, + delimiter: void 0 === e.delimiter ? defaults.delimiter : e.delimiter, + encode: "boolean" == typeof e.encode ? e.encode : defaults.encode, + encodeDotInKeys: "boolean" == typeof e.encodeDotInKeys ? e.encodeDotInKeys : + defaults.encodeDotInKeys, + encoder: "function" == typeof e.encoder ? e.encoder : defaults.encoder, + encodeValuesOnly: "boolean" == typeof e.encodeValuesOnly ? e + .encodeValuesOnly : defaults.encodeValuesOnly, + filter: n, + format: t, + formatter: a, + serializeDate: "function" == typeof e.serializeDate ? e.serializeDate : + defaults.serializeDate, + skipNulls: "boolean" == typeof e.skipNulls ? e.skipNulls : defaults + .skipNulls, + sort: "function" == typeof e.sort ? e.sort : null, + strictNullHandling: "boolean" == typeof e.strictNullHandling ? e + .strictNullHandling : defaults.strictNullHandling + } + }; + module.exports = function(e, r) { + var t, o = e, + a = normalizeStringifyOptions(r); + "function" == typeof a.filter ? o = (0, a.filter)("", o) : isArray(a.filter) && + (t = a.filter); + var n = []; + if ("object" != typeof o || null === o) return ""; + var i = arrayPrefixGenerators[a.arrayFormat], + l = "comma" === i && a.commaRoundTrip; + t || (t = Object.keys(o)), a.sort && t.sort(a.sort); + for (var s = getSideChannel(), f = 0; f < t.length; ++f) { + var u = t[f]; + a.skipNulls && null === o[u] || pushToArray(n, stringify(o[u], u, i, l, a + .allowEmptyArrays, a.strictNullHandling, a.skipNulls, a + .encodeDotInKeys, a.encode ? a.encoder : null, a.filter, a.sort, + a.allowDots, a.serializeDate, a.format, a.formatter, a + .encodeValuesOnly, a.charset, s)) + } + var d = n.join(a.delimiter), + y = !0 === a.addQueryPrefix ? "?" : ""; + return a.charsetSentinel && ("iso-8859-1" === a.charset ? y += + "utf8=%26%2310003%3B&" : y += "utf8=%E2%9C%93&"), d.length > 0 ? y + d : + "" + }; + + }, { + "1": 1, + "29": 29, + "5": 5 + }], + 5: [function(require, module, exports) { + "use strict"; + var formats = require(1), + has = Object.prototype.hasOwnProperty, + isArray = Array.isArray, + hexTable = function() { + for (var e = [], r = 0; r < 256; ++r) e.push("%" + ((r < 16 ? "0" : "") + r + .toString(16)).toUpperCase()); + return e + }(), + compactQueue = function compactQueue(e) { + for (; e.length > 1;) { + var r = e.pop(), + t = r.obj[r.prop]; + if (isArray(t)) { + for (var o = [], n = 0; n < t.length; ++n) void 0 !== t[n] && o.push(t[ + n]); + r.obj[r.prop] = o + } + } + }, + arrayToObject = function arrayToObject(e, r) { + for (var t = r && r.plainObjects ? Object.create(null) : {}, o = 0; o < e + .length; ++o) void 0 !== e[o] && (t[o] = e[o]); + return t + }, + merge = function merge(e, r, t) { + if (!r) return e; + if ("object" != typeof r) { + if (isArray(e)) e.push(r); + else { + if (!e || "object" != typeof e) return [e, r]; + (t && (t.plainObjects || t.allowPrototypes) || !has.call(Object + .prototype, r)) && (e[r] = !0) + } + return e + } + if (!e || "object" != typeof e) return [e].concat(r); + var o = e; + return isArray(e) && !isArray(r) && (o = arrayToObject(e, t)), isArray(e) && + isArray(r) ? (r.forEach((function(r, o) { + if (has.call(e, o)) { + var n = e[o]; + n && "object" == typeof n && r && "object" == typeof r ? + e[o] = merge(n, r, t) : e.push(r) + } else e[o] = r + })), e) : Object.keys(r).reduce((function(e, o) { + var n = r[o]; + return has.call(e, o) ? e[o] = merge(e[o], n, t) : e[o] = n, e + }), o) + }, + assign = function assignSingleSource(e, r) { + return Object.keys(r).reduce((function(e, t) { + return e[t] = r[t], e + }), e) + }, + decode = function(e, r, t) { + var o = e.replace(/\+/g, " "); + if ("iso-8859-1" === t) return o.replace(/%[0-9a-f]{2}/gi, unescape); + try { + return decodeURIComponent(o) + } catch (e) { + return o + } + }, + limit = 1024, + encode = function encode(e, r, t, o, n) { + if (0 === e.length) return e; + var a = e; + if ("symbol" == typeof e ? a = Symbol.prototype.toString.call(e) : "string" != + typeof e && (a = String(e)), "iso-8859-1" === t) return escape(a).replace( + /%u[0-9a-f]{4}/gi, (function(e) { + return "%26%23" + parseInt(e.slice(2), 16) + "%3B" + })); + for (var c = "", i = 0; i < a.length; i += limit) { + for (var u = a.length >= limit ? a.slice(i, i + limit) : a, p = [], s = + 0; s < u.length; ++s) { + var f = u.charCodeAt(s); + 45 === f || 46 === f || 95 === f || 126 === f || f >= 48 && f <= 57 || + f >= 65 && f <= 90 || f >= 97 && f <= 122 || n === formats + .RFC1738 && (40 === f || 41 === f) ? p[p.length] = u.charAt(s) : f < + 128 ? p[p.length] = hexTable[f] : f < 2048 ? p[p.length] = hexTable[ + 192 | f >> 6] + hexTable[128 | 63 & f] : f < 55296 || f >= + 57344 ? p[p.length] = hexTable[224 | f >> 12] + hexTable[128 | f >> + 6 & 63] + hexTable[128 | 63 & f] : (s += 1, f = 65536 + ((1023 & + f) << 10 | 1023 & u.charCodeAt(s)), p[p.length] = hexTable[ + 240 | f >> 18] + hexTable[128 | f >> 12 & 63] + hexTable[ + 128 | f >> 6 & 63] + hexTable[128 | 63 & f]) + } + c += p.join("") + } + return c + }, + compact = function compact(e) { + for (var r = [{ + obj: { + o: e + }, + prop: "o" + }], t = [], o = 0; o < r.length; ++o) + for (var n = r[o], a = n.obj[n.prop], c = Object.keys(a), i = 0; i < c + .length; ++i) { + var u = c[i], + p = a[u]; + "object" == typeof p && null !== p && -1 === t.indexOf(p) && (r.push({ + obj: a, + prop: u + }), t.push(p)) + } + return compactQueue(r), e + }, + isRegExp = function isRegExp(e) { + return "[object RegExp]" === Object.prototype.toString.call(e) + }, + isBuffer = function isBuffer(e) { + return !(!e || "object" != typeof e || !(e.constructor && e.constructor + .isBuffer && e.constructor.isBuffer(e))) + }, + combine = function combine(e, r) { + return [].concat(e, r) + }, + maybeMap = function maybeMap(e, r) { + if (isArray(e)) { + for (var t = [], o = 0; o < e.length; o += 1) t.push(r(e[o])); + return t + } + return r(e) + }; + module.exports = { + /* common-shake removed: arrayToObject:arrayToObject */ /* common-shake removed: assign:assign */ + combine: combine, + compact: compact, + decode: decode, + encode: encode, + isBuffer: isBuffer, + isRegExp: isRegExp, + maybeMap: maybeMap, + merge: merge + }; + + }, { + "1": 1 + }], + 29: [function(require, module, exports) { + "use strict"; + var GetIntrinsic = require(20), + callBound = require(7), + inspect = require(27), + $TypeError = require(16), + $WeakMap = GetIntrinsic("%WeakMap%", !0), + $Map = GetIntrinsic("%Map%", !0), + $weakMapGet = callBound("WeakMap.prototype.get", !0), + $weakMapSet = callBound("WeakMap.prototype.set", !0), + $weakMapHas = callBound("WeakMap.prototype.has", !0), + $mapGet = callBound("Map.prototype.get", !0), + $mapSet = callBound("Map.prototype.set", !0), + $mapHas = callBound("Map.prototype.has", !0), + listGetNode = function(e, t) { + for (var n, a = e; null !== (n = a.next); a = n) + if (n.key === t) return a.next = n.next, n.next = e.next, e.next = n, n + }, + listGet = function(e, t) { + var n = listGetNode(e, t); + return n && n.value + }, + listSet = function(e, t, n) { + var a = listGetNode(e, t); + a ? a.value = n : e.next = { + key: t, + next: e.next, + value: n + } + }, + listHas = function(e, t) { + return !!listGetNode(e, t) + }; + module.exports = function getSideChannel() { + var e, t, n, a = { + assert: function(e) { + if (!a.has(e)) throw new $TypeError( + "Side channel does not contain " + inspect(e)) + }, + get: function(a) { + if ($WeakMap && a && ("object" == typeof a || "function" == + typeof a)) { + if (e) return $weakMapGet(e, a) + } else if ($Map) { + if (t) return $mapGet(t, a) + } else if (n) return listGet(n, a) + }, + has: function(a) { + if ($WeakMap && a && ("object" == typeof a || "function" == + typeof a)) { + if (e) return $weakMapHas(e, a) + } else if ($Map) { + if (t) return $mapHas(t, a) + } else if (n) return listHas(n, a); + return !1 + }, + set: function(a, r) { + $WeakMap && a && ("object" == typeof a || "function" == + typeof a) ? (e || (e = new $WeakMap), $weakMapSet(e, a, + r)) : $Map ? (t || (t = new $Map), $mapSet(t, a, r)) : ( + n || (n = { + key: {}, + next: null + }), listSet(n, a, r)) + } + }; + return a + }; + + }, { + "16": 16, + "20": 20, + "27": 27, + "7": 7 + }], + 6: [function(require, module, exports) { + + }, {}], + 7: [function(require, module, exports) { + "use strict"; + var GetIntrinsic = require(20), + callBind = require(8), + $indexOf = callBind(GetIntrinsic("String.prototype.indexOf")); + module.exports = function callBoundIntrinsic(i, n) { + var t = GetIntrinsic(i, !!n); + return "function" == typeof t && $indexOf(i, ".prototype.") > -1 ? callBind(t) : + t + }; + + }, { + "20": 20, + "8": 8 + }], + 20: [function(require, module, exports) { + "use strict"; + var undefined, $Error = require(12), + $EvalError = require(11), + $RangeError = require(13), + $ReferenceError = require(14), + $SyntaxError = require(15), + $TypeError = require(16), + $URIError = require(17), + $Function = Function, + getEvalledConstructor = function(r) { + try { + return $Function('"use strict"; return (' + r + ").constructor;")() + } catch (r) {} + }, + $gOPD = Object.getOwnPropertyDescriptor; + if ($gOPD) try { + $gOPD({}, "") + } catch (r) { + $gOPD = null + } + var throwTypeError = function() { + throw new $TypeError + }, + ThrowTypeError = $gOPD ? function() { + try { + return throwTypeError + } catch (r) { + try { + return $gOPD(arguments, "callee").get + } catch (r) { + return throwTypeError + } + } + }() : throwTypeError, + hasSymbols = require(24)(), + hasProto = require(23)(), + getProto = Object.getPrototypeOf || (hasProto ? function(r) { + return r.__proto__ + } : null), + needsEval = {}, + TypedArray = "undefined" != typeof Uint8Array && getProto ? getProto(Uint8Array) : + undefined, + INTRINSICS = { + __proto__: null, + "%AggregateError%": "undefined" == typeof AggregateError ? undefined : + AggregateError, + "%Array%": Array, + "%ArrayBuffer%": "undefined" == typeof ArrayBuffer ? undefined : ArrayBuffer, + "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol + .iterator]()) : undefined, + "%AsyncFromSyncIteratorPrototype%": undefined, + "%AsyncFunction%": needsEval, + "%AsyncGenerator%": needsEval, + "%AsyncGeneratorFunction%": needsEval, + "%AsyncIteratorPrototype%": needsEval, + "%Atomics%": "undefined" == typeof Atomics ? undefined : Atomics, + "%BigInt%": "undefined" == typeof BigInt ? undefined : BigInt, + "%BigInt64Array%": "undefined" == typeof BigInt64Array ? undefined : + BigInt64Array, + "%BigUint64Array%": "undefined" == typeof BigUint64Array ? undefined : + BigUint64Array, + "%Boolean%": Boolean, + "%DataView%": "undefined" == typeof DataView ? undefined : DataView, + "%Date%": Date, + "%decodeURI%": decodeURI, + "%decodeURIComponent%": decodeURIComponent, + "%encodeURI%": encodeURI, + "%encodeURIComponent%": encodeURIComponent, + "%Error%": $Error, + "%eval%": eval, + "%EvalError%": $EvalError, + "%Float32Array%": "undefined" == typeof Float32Array ? undefined : Float32Array, + "%Float64Array%": "undefined" == typeof Float64Array ? undefined : Float64Array, + "%FinalizationRegistry%": "undefined" == typeof FinalizationRegistry ? + undefined : FinalizationRegistry, + "%Function%": $Function, + "%GeneratorFunction%": needsEval, + "%Int8Array%": "undefined" == typeof Int8Array ? undefined : Int8Array, + "%Int16Array%": "undefined" == typeof Int16Array ? undefined : Int16Array, + "%Int32Array%": "undefined" == typeof Int32Array ? undefined : Int32Array, + "%isFinite%": isFinite, + "%isNaN%": isNaN, + "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol + .iterator + ]())) : undefined, + "%JSON%": "object" == typeof JSON ? JSON : undefined, + "%Map%": "undefined" == typeof Map ? undefined : Map, + "%MapIteratorPrototype%": "undefined" != typeof Map && hasSymbols && getProto ? + getProto((new Map)[Symbol.iterator]()) : undefined, + "%Math%": Math, + "%Number%": Number, + "%Object%": Object, + "%parseFloat%": parseFloat, + "%parseInt%": parseInt, + "%Promise%": "undefined" == typeof Promise ? undefined : Promise, + "%Proxy%": "undefined" == typeof Proxy ? undefined : Proxy, + "%RangeError%": $RangeError, + "%ReferenceError%": $ReferenceError, + "%Reflect%": "undefined" == typeof Reflect ? undefined : Reflect, + "%RegExp%": RegExp, + "%Set%": "undefined" == typeof Set ? undefined : Set, + "%SetIteratorPrototype%": "undefined" != typeof Set && hasSymbols && getProto ? + getProto((new Set)[Symbol.iterator]()) : undefined, + "%SharedArrayBuffer%": "undefined" == typeof SharedArrayBuffer ? undefined : + SharedArrayBuffer, + "%String%": String, + "%StringIteratorPrototype%": hasSymbols && getProto ? getProto("" [Symbol + .iterator + ]()) : undefined, + "%Symbol%": hasSymbols ? Symbol : undefined, + "%SyntaxError%": $SyntaxError, + "%ThrowTypeError%": ThrowTypeError, + "%TypedArray%": TypedArray, + "%TypeError%": $TypeError, + "%Uint8Array%": "undefined" == typeof Uint8Array ? undefined : Uint8Array, + "%Uint8ClampedArray%": "undefined" == typeof Uint8ClampedArray ? undefined : + Uint8ClampedArray, + "%Uint16Array%": "undefined" == typeof Uint16Array ? undefined : Uint16Array, + "%Uint32Array%": "undefined" == typeof Uint32Array ? undefined : Uint32Array, + "%URIError%": $URIError, + "%WeakMap%": "undefined" == typeof WeakMap ? undefined : WeakMap, + "%WeakRef%": "undefined" == typeof WeakRef ? undefined : WeakRef, + "%WeakSet%": "undefined" == typeof WeakSet ? undefined : WeakSet + }; + if (getProto) try { + null.error + } catch (r) { + var errorProto = getProto(getProto(r)); + INTRINSICS["%Error.prototype%"] = errorProto + } + var doEval = function doEval(r) { + var e; + if ("%AsyncFunction%" === r) e = getEvalledConstructor("async function () {}"); + else if ("%GeneratorFunction%" === r) e = getEvalledConstructor( + "function* () {}"); + else if ("%AsyncGeneratorFunction%" === r) e = getEvalledConstructor( + "async function* () {}"); + else if ("%AsyncGenerator%" === r) { + var t = doEval("%AsyncGeneratorFunction%"); + t && (e = t.prototype) + } else if ("%AsyncIteratorPrototype%" === r) { + var o = doEval("%AsyncGenerator%"); + o && getProto && (e = getProto(o.prototype)) + } + return INTRINSICS[r] = e, e + }, + LEGACY_ALIASES = { + __proto__: null, + "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], + "%ArrayPrototype%": ["Array", "prototype"], + "%ArrayProto_entries%": ["Array", "prototype", "entries"], + "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], + "%ArrayProto_keys%": ["Array", "prototype", "keys"], + "%ArrayProto_values%": ["Array", "prototype", "values"], + "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], + "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], + "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", + "prototype"], + "%BooleanPrototype%": ["Boolean", "prototype"], + "%DataViewPrototype%": ["DataView", "prototype"], + "%DatePrototype%": ["Date", "prototype"], + "%ErrorPrototype%": ["Error", "prototype"], + "%EvalErrorPrototype%": ["EvalError", "prototype"], + "%Float32ArrayPrototype%": ["Float32Array", "prototype"], + "%Float64ArrayPrototype%": ["Float64Array", "prototype"], + "%FunctionPrototype%": ["Function", "prototype"], + "%Generator%": ["GeneratorFunction", "prototype"], + "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], + "%Int8ArrayPrototype%": ["Int8Array", "prototype"], + "%Int16ArrayPrototype%": ["Int16Array", "prototype"], + "%Int32ArrayPrototype%": ["Int32Array", "prototype"], + "%JSONParse%": ["JSON", "parse"], + "%JSONStringify%": ["JSON", "stringify"], + "%MapPrototype%": ["Map", "prototype"], + "%NumberPrototype%": ["Number", "prototype"], + "%ObjectPrototype%": ["Object", "prototype"], + "%ObjProto_toString%": ["Object", "prototype", "toString"], + "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], + "%PromisePrototype%": ["Promise", "prototype"], + "%PromiseProto_then%": ["Promise", "prototype", "then"], + "%Promise_all%": ["Promise", "all"], + "%Promise_reject%": ["Promise", "reject"], + "%Promise_resolve%": ["Promise", "resolve"], + "%RangeErrorPrototype%": ["RangeError", "prototype"], + "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], + "%RegExpPrototype%": ["RegExp", "prototype"], + "%SetPrototype%": ["Set", "prototype"], + "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], + "%StringPrototype%": ["String", "prototype"], + "%SymbolPrototype%": ["Symbol", "prototype"], + "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], + "%TypedArrayPrototype%": ["TypedArray", "prototype"], + "%TypeErrorPrototype%": ["TypeError", "prototype"], + "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], + "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], + "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], + "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], + "%URIErrorPrototype%": ["URIError", "prototype"], + "%WeakMapPrototype%": ["WeakMap", "prototype"], + "%WeakSetPrototype%": ["WeakSet", "prototype"] + }, + bind = require(19), + hasOwn = require(26), + $concat = bind.call(Function.call, Array.prototype.concat), + $spliceApply = bind.call(Function.apply, Array.prototype.splice), + $replace = bind.call(Function.call, String.prototype.replace), + $strSlice = bind.call(Function.call, String.prototype.slice), + $exec = bind.call(Function.call, RegExp.prototype.exec), + rePropName = + /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g, + reEscapeChar = /\\(\\)?/g, + stringToPath = function stringToPath(r) { + var e = $strSlice(r, 0, 1), + t = $strSlice(r, -1); + if ("%" === e && "%" !== t) throw new $SyntaxError( + "invalid intrinsic syntax, expected closing `%`"); + if ("%" === t && "%" !== e) throw new $SyntaxError( + "invalid intrinsic syntax, expected opening `%`"); + var o = []; + return $replace(r, rePropName, (function(r, e, t, n) { + o[o.length] = t ? $replace(n, reEscapeChar, "$1") : e || r + })), o + }, + getBaseIntrinsic = function getBaseIntrinsic(r, e) { + var t, o = r; + if (hasOwn(LEGACY_ALIASES, o) && (o = "%" + (t = LEGACY_ALIASES[o])[0] + "%"), + hasOwn(INTRINSICS, o)) { + var n = INTRINSICS[o]; + if (n === needsEval && (n = doEval(o)), void 0 === n && !e) + throw new $TypeError("intrinsic " + r + + " exists, but is not available. Please file an issue!"); + return { + alias: t, + name: o, + value: n + } + } + throw new $SyntaxError("intrinsic " + r + " does not exist!") + }; + module.exports = function GetIntrinsic(r, e) { + if ("string" != typeof r || 0 === r.length) throw new $TypeError( + "intrinsic name must be a non-empty string"); + if (arguments.length > 1 && "boolean" != typeof e) throw new $TypeError( + '"allowMissing" argument must be a boolean'); + if (null === $exec(/^%?[^%]*%?$/, r)) throw new $SyntaxError( + "`%` may not be present anywhere but at the beginning and end of the intrinsic name" + ); + var t = stringToPath(r), + o = t.length > 0 ? t[0] : "", + n = getBaseIntrinsic("%" + o + "%", e), + a = n.name, + y = n.value, + i = !1, + p = n.alias; + p && (o = p[0], $spliceApply(t, $concat([0, 1], p))); + for (var d = 1, s = !0; d < t.length; d += 1) { + var f = t[d], + u = $strSlice(f, 0, 1), + l = $strSlice(f, -1); + if (('"' === u || "'" === u || "`" === u || '"' === l || "'" === l || + "`" === l) && u !== l) throw new $SyntaxError( + "property names with quotes must have matching quotes"); + if ("constructor" !== f && s || (i = !0), hasOwn(INTRINSICS, a = "%" + (o += + "." + f) + "%")) y = INTRINSICS[a]; + else if (null != y) { + if (!(f in y)) { + if (!e) throw new $TypeError("base intrinsic for " + r + + " exists, but the property is not available."); + return + } + if ($gOPD && d + 1 >= t.length) { + var c = $gOPD(y, f); + y = (s = !!c) && "get" in c && !("originalValue" in c.get) ? c.get : + y[f] + } else s = hasOwn(y, f), y = y[f]; + s && !i && (INTRINSICS[a] = y) + } + } + return y + }; + + }, { + "11": 11, + "12": 12, + "13": 13, + "14": 14, + "15": 15, + "16": 16, + "17": 17, + "19": 19, + "23": 23, + "24": 24, + "26": 26 + }], + 8: [function(require, module, exports) { + "use strict"; + var bind = require(19), + GetIntrinsic = require(20), + setFunctionLength = require(28), + $TypeError = require(16), + $apply = GetIntrinsic("%Function.prototype.apply%"), + $call = GetIntrinsic("%Function.prototype.call%"), + $reflectApply = GetIntrinsic("%Reflect.apply%", !0) || bind.call($call, $apply), + $defineProperty = require(10), + $max = GetIntrinsic("%Math.max%"); + module.exports = function callBind(e) { + if ("function" != typeof e) throw new $TypeError("a function is required"); + var n = $reflectApply(bind, $call, arguments); + return setFunctionLength(n, 1 + $max(0, e.length - (arguments.length - 1)), !0) + }; + var applyBind = function applyBind() { + return $reflectApply(bind, $apply, arguments) + }; + $defineProperty ? $defineProperty(module.exports, "apply", { + value: applyBind + }) : module.exports.apply = applyBind; + + }, { + "10": 10, + "16": 16, + "19": 19, + "20": 20, + "28": 28 + }], + 16: [function(require, module, exports) { + "use strict"; + module.exports = TypeError; + + }, {}], + 19: [function(require, module, exports) { + "use strict"; + var implementation = require(18); + module.exports = Function.prototype.bind || implementation; + + }, { + "18": 18 + }], + 10: [function(require, module, exports) { + "use strict"; + var GetIntrinsic = require(20), + $defineProperty = GetIntrinsic("%Object.defineProperty%", !0) || !1; + if ($defineProperty) try { + $defineProperty({}, "a", { + value: 1 + }) + } catch (e) { + $defineProperty = !1 + } + module.exports = $defineProperty; + + }, { + "20": 20 + }], + 28: [function(require, module, exports) { + "use strict"; + var GetIntrinsic = require(20), + define = require(9), + hasDescriptors = require(22)(), + gOPD = require(21), + $TypeError = require(16), + $floor = GetIntrinsic("%Math.floor%"); + module.exports = function setFunctionLength(e, r) { + if ("function" != typeof e) throw new $TypeError("`fn` is not a function"); + if ("number" != typeof r || r < 0 || r > 4294967295 || $floor(r) !== r) + throw new $TypeError("`length` must be a positive 32-bit integer"); + var t = arguments.length > 2 && !!arguments[2], + i = !0, + n = !0; + if ("length" in e && gOPD) { + var o = gOPD(e, "length"); + o && !o.configurable && (i = !1), o && !o.writable && (n = !1) + } + return (i || n || !t) && (hasDescriptors ? define(e, "length", r, !0, !0) : + define(e, "length", r)), e + }; + + }, { + "16": 16, + "20": 20, + "21": 21, + "22": 22, + "9": 9 + }], + 9: [function(require, module, exports) { + "use strict"; + var $defineProperty = require(10), + $SyntaxError = require(15), + $TypeError = require(16), + gopd = require(21); + module.exports = function defineDataProperty(e, r, o) { + if (!e || "object" != typeof e && "function" != typeof e) throw new $TypeError( + "`obj` must be an object or a function`"); + if ("string" != typeof r && "symbol" != typeof r) throw new $TypeError( + "`property` must be a string or a symbol`"); + if (arguments.length > 3 && "boolean" != typeof arguments[3] && null !== + arguments[3]) throw new $TypeError( + "`nonEnumerable`, if provided, must be a boolean or null"); + if (arguments.length > 4 && "boolean" != typeof arguments[4] && null !== + arguments[4]) throw new $TypeError( + "`nonWritable`, if provided, must be a boolean or null"); + if (arguments.length > 5 && "boolean" != typeof arguments[5] && null !== + arguments[5]) throw new $TypeError( + "`nonConfigurable`, if provided, must be a boolean or null"); + if (arguments.length > 6 && "boolean" != typeof arguments[6]) + throw new $TypeError("`loose`, if provided, must be a boolean"); + var n = arguments.length > 3 ? arguments[3] : null, + l = arguments.length > 4 ? arguments[4] : null, + t = arguments.length > 5 ? arguments[5] : null, + i = arguments.length > 6 && arguments[6], + a = !!gopd && gopd(e, r); + if ($defineProperty) $defineProperty(e, r, { + configurable: null === t && a ? a.configurable : !t, + enumerable: null === n && a ? a.enumerable : !n, + value: o, + writable: null === l && a ? a.writable : !l + }); + else { + if (!i && (n || l || t)) throw new $SyntaxError( + "This environment does not support defining a property as non-configurable, non-writable, or non-enumerable." + ); + e[r] = o + } + }; + + }, { + "10": 10, + "15": 15, + "16": 16, + "21": 21 + }], + 15: [function(require, module, exports) { + "use strict"; + module.exports = SyntaxError; + + }, {}], + 21: [function(require, module, exports) { + "use strict"; + var GetIntrinsic = require(20), + $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", !0); + if ($gOPD) try { + $gOPD([], "length") + } catch (t) { + $gOPD = null + } + module.exports = $gOPD; + + }, { + "20": 20 + }], + 11: [function(require, module, exports) { + "use strict"; + module.exports = EvalError; + + }, {}], + 12: [function(require, module, exports) { + "use strict"; + module.exports = Error; + + }, {}], + 13: [function(require, module, exports) { + "use strict"; + module.exports = RangeError; + + }, {}], + 14: [function(require, module, exports) { + "use strict"; + module.exports = ReferenceError; + + }, {}], + 17: [function(require, module, exports) { + "use strict"; + module.exports = URIError; + + }, {}], + 18: [function(require, module, exports) { + "use strict"; + var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ", + toStr = Object.prototype.toString, + max = Math.max, + funcType = "[object Function]", + concatty = function concatty(t, n) { + for (var r = [], o = 0; o < t.length; o += 1) r[o] = t[o]; + for (var e = 0; e < n.length; e += 1) r[e + t.length] = n[e]; + return r + }, + slicy = function slicy(t, n) { + for (var r = [], o = n || 0, e = 0; o < t.length; o += 1, e += 1) r[e] = t[o]; + return r + }, + joiny = function(t, n) { + for (var r = "", o = 0; o < t.length; o += 1) r += t[o], o + 1 < t.length && ( + r += n); + return r + }; + module.exports = function bind(t) { + var n = this; + if ("function" != typeof n || toStr.apply(n) !== funcType) throw new TypeError( + ERROR_MESSAGE + n); + for (var r, o = slicy(arguments, 1), e = max(0, n.length - o.length), i = [], + c = 0; c < e; c++) i[c] = "$" + c; + if (r = Function("binder", "return function (" + joiny(i, ",") + + "){ return binder.apply(this,arguments); }")((function() { + if (this instanceof r) { + var e = n.apply(this, concatty(o, arguments)); + return Object(e) === e ? e : this + } + return n.apply(t, concatty(o, arguments)) + })), n.prototype) { + var p = function Empty() {}; + p.prototype = n.prototype, r.prototype = new p, p.prototype = null + } + return r + }; + + }, {}], + 23: [function(require, module, exports) { + "use strict"; + var test = { + __proto__: null, + foo: {} + }, + $Object = Object; + module.exports = function hasProto() { + return { + __proto__: test + }.foo === test.foo && !(test instanceof $Object) + }; + + }, {}], + 26: [function(require, module, exports) { + "use strict"; + var call = Function.prototype.call, + $hasOwn = Object.prototype.hasOwnProperty, + bind = require(19); + module.exports = bind.call(call, $hasOwn); + + }, { + "19": 19 + }], + 24: [function(require, module, exports) { + "use strict"; + var origSymbol = "undefined" != typeof Symbol && Symbol, + hasSymbolSham = require(25); + module.exports = function hasNativeSymbols() { + return "function" == typeof origSymbol && "function" == typeof Symbol && + "symbol" == typeof origSymbol("foo") && "symbol" == typeof Symbol("bar") && + hasSymbolSham() + }; + + }, { + "25": 25 + }], + 22: [function(require, module, exports) { + "use strict"; + var $defineProperty = require(10), + hasPropertyDescriptors = function hasPropertyDescriptors() { + return !!$defineProperty + }; + hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() { + if (!$defineProperty) return null; + try { + return 1 !== $defineProperty([], "length", { + value: 1 + }).length + } catch (r) { + return !0 + } + }, module.exports = hasPropertyDescriptors; + + }, { + "10": 10 + }], + 25: [function(require, module, exports) { + "use strict"; + module.exports = function hasSymbols() { + if ("function" != typeof Symbol || "function" != typeof Object + .getOwnPropertySymbols) return !1; + if ("symbol" == typeof Symbol.iterator) return !0; + var t = {}, + e = Symbol("test"), + r = Object(e); + if ("string" == typeof e) return !1; + if ("[object Symbol]" !== Object.prototype.toString.call(e)) return !1; + if ("[object Symbol]" !== Object.prototype.toString.call(r)) return !1; + for (e in t[e] = 42, t) return !1; + if ("function" == typeof Object.keys && 0 !== Object.keys(t).length) return !1; + if ("function" == typeof Object.getOwnPropertyNames && 0 !== Object + .getOwnPropertyNames(t).length) return !1; + var o = Object.getOwnPropertySymbols(t); + if (1 !== o.length || o[0] !== e) return !1; + if (!Object.prototype.propertyIsEnumerable.call(t, e)) return !1; + if ("function" == typeof Object.getOwnPropertyDescriptor) { + var n = Object.getOwnPropertyDescriptor(t, e); + if (42 !== n.value || !0 !== n.enumerable) return !1 + } + return !0 + }; + + }, {}], + 27: [function(require, module, exports) { + (function(global) { + (function() { + var hasMap = "function" == typeof Map && Map.prototype, + mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? + Object.getOwnPropertyDescriptor(Map.prototype, "size") : null, + mapSize = hasMap && mapSizeDescriptor && "function" == + typeof mapSizeDescriptor.get ? mapSizeDescriptor.get : null, + mapForEach = hasMap && Map.prototype.forEach, + hasSet = "function" == typeof Set && Set.prototype, + setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? + Object.getOwnPropertyDescriptor(Set.prototype, "size") : null, + setSize = hasSet && setSizeDescriptor && "function" == + typeof setSizeDescriptor.get ? setSizeDescriptor.get : null, + setForEach = hasSet && Set.prototype.forEach, + hasWeakMap = "function" == typeof WeakMap && WeakMap.prototype, + weakMapHas = hasWeakMap ? WeakMap.prototype.has : null, + hasWeakSet = "function" == typeof WeakSet && WeakSet.prototype, + weakSetHas = hasWeakSet ? WeakSet.prototype.has : null, + hasWeakRef = "function" == typeof WeakRef && WeakRef.prototype, + weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null, + booleanValueOf = Boolean.prototype.valueOf, + objectToString = Object.prototype.toString, + functionToString = Function.prototype.toString, + $match = String.prototype.match, + $slice = String.prototype.slice, + $replace = String.prototype.replace, + $toUpperCase = String.prototype.toUpperCase, + $toLowerCase = String.prototype.toLowerCase, + $test = RegExp.prototype.test, + $concat = Array.prototype.concat, + $join = Array.prototype.join, + $arrSlice = Array.prototype.slice, + $floor = Math.floor, + bigIntValueOf = "function" == typeof BigInt ? BigInt.prototype + .valueOf : null, + gOPS = Object.getOwnPropertySymbols, + symToString = "function" == typeof Symbol && "symbol" == + typeof Symbol.iterator ? Symbol.prototype.toString : null, + hasShammedSymbols = "function" == typeof Symbol && "object" == + typeof Symbol.iterator, + toStringTag = "function" == typeof Symbol && Symbol.toStringTag && ( + Symbol.toStringTag, 1) ? Symbol.toStringTag : null, + isEnumerable = Object.prototype.propertyIsEnumerable, + gPO = ("function" == typeof Reflect ? Reflect.getPrototypeOf : + Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? + function(t) { + return t.__proto__ + } : null); + + function addNumericSeparator(t, e) { + if (t === 1 / 0 || t === -1 / 0 || t != t || t && t > -1e3 && t < + 1e3 || $test.call(/e/, e)) return e; + var r = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g; + if ("number" == typeof t) { + var n = t < 0 ? -$floor(-t) : $floor(t); + if (n !== t) { + var o = String(n), + i = $slice.call(e, o.length + 1); + return $replace.call(o, r, "$&_") + "." + $replace.call( + $replace.call(i, /([0-9]{3})/g, "$&_"), /_$/, "") + } + } + return $replace.call(e, r, "$&_") + } + var utilInspect = require(6), + inspectCustom = utilInspect.custom, + inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null; + + function wrapQuotes(t, e, r) { + var n = "double" === (r.quoteStyle || e) ? '"' : "'"; + return n + t + n + } + + function quote(t) { + return $replace.call(String(t), /"/g, """) + } + + function isArray(t) { + return !("[object Array]" !== toStr(t) || toStringTag && "object" == + typeof t && toStringTag in t) + } + + function isDate(t) { + return !("[object Date]" !== toStr(t) || toStringTag && "object" == + typeof t && toStringTag in t) + } + + function isRegExp(t) { + return !("[object RegExp]" !== toStr(t) || toStringTag && + "object" == typeof t && toStringTag in t) + } + + function isError(t) { + return !("[object Error]" !== toStr(t) || toStringTag && "object" == + typeof t && toStringTag in t) + } + + function isString(t) { + return !("[object String]" !== toStr(t) || toStringTag && + "object" == typeof t && toStringTag in t) + } + + function isNumber(t) { + return !("[object Number]" !== toStr(t) || toStringTag && + "object" == typeof t && toStringTag in t) + } + + function isBoolean(t) { + return !("[object Boolean]" !== toStr(t) || toStringTag && + "object" == typeof t && toStringTag in t) + } + + function isSymbol(t) { + if (hasShammedSymbols) return t && "object" == typeof t && + t instanceof Symbol; + if ("symbol" == typeof t) return !0; + if (!t || "object" != typeof t || !symToString) return !1; + try { + return symToString.call(t), !0 + } catch (t) {} + return !1 + } + + function isBigInt(t) { + if (!t || "object" != typeof t || !bigIntValueOf) return !1; + try { + return bigIntValueOf.call(t), !0 + } catch (t) {} + return !1 + } + module.exports = function inspect_(t, e, r, n) { + var o = e || {}; + if (has(o, "quoteStyle") && "single" !== o.quoteStyle && + "double" !== o.quoteStyle) throw new TypeError( + 'option "quoteStyle" must be "single" or "double"'); + if (has(o, "maxStringLength") && ("number" == typeof o + .maxStringLength ? o.maxStringLength < 0 && o + .maxStringLength !== 1 / 0 : null !== o.maxStringLength + )) throw new TypeError( + 'option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`' + ); + var i = !has(o, "customInspect") || o.customInspect; + if ("boolean" != typeof i && "symbol" !== i) + throw new TypeError( + "option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`" + ); + if (has(o, "indent") && null !== o.indent && "\t" !== o + .indent && !(parseInt(o.indent, 10) === o.indent && o + .indent > 0)) throw new TypeError( + 'option "indent" must be "\\t", an integer > 0, or `null`' + ); + if (has(o, "numericSeparator") && "boolean" != typeof o + .numericSeparator) throw new TypeError( + 'option "numericSeparator", if provided, must be `true` or `false`' + ); + var a = o.numericSeparator; + if (void 0 === t) return "undefined"; + if (null === t) return "null"; + if ("boolean" == typeof t) return t ? "true" : "false"; + if ("string" == typeof t) return inspectString(t, o); + if ("number" == typeof t) { + if (0 === t) return 1 / 0 / t > 0 ? "0" : "-0"; + var c = String(t); + return a ? addNumericSeparator(t, c) : c + } + if ("bigint" == typeof t) { + var l = String(t) + "n"; + return a ? addNumericSeparator(t, l) : l + } + var p = void 0 === o.depth ? 5 : o.depth; + if (void 0 === r && (r = 0), r >= p && p > 0 && "object" == + typeof t) return isArray(t) ? "[Array]" : "[Object]"; + var u = getIndent(o, r); + if (void 0 === n) n = []; + else if (indexOf(n, t) >= 0) return "[Circular]"; + + function inspect(t, e, i) { + if (e && (n = $arrSlice.call(n)).push(e), i) { + var a = { + depth: o.depth + }; + return has(o, "quoteStyle") && (a.quoteStyle = o + .quoteStyle), inspect_(t, a, r + 1, n) + } + return inspect_(t, o, r + 1, n) + } + if ("function" == typeof t && !isRegExp(t)) { + var s = nameOf(t), + f = arrObjKeys(t, inspect); + return "[Function" + (s ? ": " + s : " (anonymous)") + "]" + + (f.length > 0 ? " { " + $join.call(f, ", ") + " }" : "") + } + if (isSymbol(t)) { + var y = hasShammedSymbols ? $replace.call(String(t), + /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call( + t); + return "object" != typeof t || hasShammedSymbols ? y : + markBoxed(y) + } + if (isElement(t)) { + for (var S = "<" + $toLowerCase.call(String(t.nodeName)), + g = t.attributes || [], m = 0; m < g.length; m++) + S += " " + g[m].name + "=" + wrapQuotes(quote(g[m] + .value), "double", o); + return S += ">", t.childNodes && t.childNodes.length && ( + S += "..."), S + "" + } + if (isArray(t)) { + if (0 === t.length) return "[]"; + var b = arrObjKeys(t, inspect); + return u && !singleLineValues(b) ? "[" + indentedJoin(b, + u) + "]" : "[ " + $join.call(b, ", ") + " ]" + } + if (isError(t)) { + var h = arrObjKeys(t, inspect); + return "cause" in Error.prototype || !("cause" in t) || + isEnumerable.call(t, "cause") ? 0 === h.length ? "[" + + String(t) + "]" : "{ [" + String(t) + "] " + $join.call( + h, ", ") + " }" : "{ [" + String(t) + "] " + $join + .call($concat.call("[cause]: " + inspect(t.cause), h), + ", ") + " }" + } + if ("object" == typeof t && i) { + if (inspectSymbol && "function" == typeof t[ + inspectSymbol] && utilInspect) return utilInspect(t, { + depth: p - r + }); + if ("symbol" !== i && "function" == typeof t.inspect) + return t.inspect() + } + if (isMap(t)) { + var d = []; + return mapForEach && mapForEach.call(t, (function(e, r) { + d.push(inspect(r, t, !0) + " => " + inspect( + e, t)) + })), collectionOf("Map", mapSize.call(t), d, u) + } + if (isSet(t)) { + var j = []; + return setForEach && setForEach.call(t, (function(e) { + j.push(inspect(e, t)) + })), collectionOf("Set", setSize.call(t), j, u) + } + if (isWeakMap(t)) return weakCollectionOf("WeakMap"); + if (isWeakSet(t)) return weakCollectionOf("WeakSet"); + if (isWeakRef(t)) return weakCollectionOf("WeakRef"); + if (isNumber(t)) return markBoxed(inspect(Number(t))); + if (isBigInt(t)) return markBoxed(inspect(bigIntValueOf.call( + t))); + if (isBoolean(t)) return markBoxed(booleanValueOf.call(t)); + if (isString(t)) return markBoxed(inspect(String(t))); + if ("undefined" != typeof window && t === window) + return "{ [object Window] }"; + if (t === global) return "{ [object globalThis] }"; + if (!isDate(t) && !isRegExp(t)) { + var O = arrObjKeys(t, inspect), + w = gPO ? gPO(t) === Object.prototype : + t instanceof Object || t.constructor === Object, + $ = t instanceof Object ? "" : "null prototype", + k = !w && toStringTag && Object(t) === t && + toStringTag in t ? $slice.call(toStr(t), 8, -1) : $ ? + "Object" : "", + v = (w || "function" != typeof t.constructor ? "" : t + .constructor.name ? t.constructor.name + " " : "") + + (k || $ ? "[" + $join.call($concat.call([], k || [], + $ || []), ": ") + "] " : ""); + return 0 === O.length ? v + "{}" : u ? v + "{" + + indentedJoin(O, u) + "}" : v + "{ " + $join.call(O, + ", ") + " }" + } + return String(t) + }; + var hasOwn = Object.prototype.hasOwnProperty || function(t) { + return t in this + }; + + function has(t, e) { + return hasOwn.call(t, e) + } + + function toStr(t) { + return objectToString.call(t) + } + + function nameOf(t) { + if (t.name) return t.name; + var e = $match.call(functionToString.call(t), + /^function\s*([\w$]+)/); + return e ? e[1] : null + } + + function indexOf(t, e) { + if (t.indexOf) return t.indexOf(e); + for (var r = 0, n = t.length; r < n; r++) + if (t[r] === e) return r; + return -1 + } + + function isMap(t) { + if (!mapSize || !t || "object" != typeof t) return !1; + try { + mapSize.call(t); + try { + setSize.call(t) + } catch (t) { + return !0 + } + return t instanceof Map + } catch (t) {} + return !1 + } + + function isWeakMap(t) { + if (!weakMapHas || !t || "object" != typeof t) return !1; + try { + weakMapHas.call(t, weakMapHas); + try { + weakSetHas.call(t, weakSetHas) + } catch (t) { + return !0 + } + return t instanceof WeakMap + } catch (t) {} + return !1 + } + + function isWeakRef(t) { + if (!weakRefDeref || !t || "object" != typeof t) return !1; + try { + return weakRefDeref.call(t), !0 + } catch (t) {} + return !1 + } + + function isSet(t) { + if (!setSize || !t || "object" != typeof t) return !1; + try { + setSize.call(t); + try { + mapSize.call(t) + } catch (t) { + return !0 + } + return t instanceof Set + } catch (t) {} + return !1 + } + + function isWeakSet(t) { + if (!weakSetHas || !t || "object" != typeof t) return !1; + try { + weakSetHas.call(t, weakSetHas); + try { + weakMapHas.call(t, weakMapHas) + } catch (t) { + return !0 + } + return t instanceof WeakSet + } catch (t) {} + return !1 + } + + function isElement(t) { + return !(!t || "object" != typeof t) && ("undefined" != + typeof HTMLElement && t instanceof HTMLElement || + "string" == typeof t.nodeName && "function" == typeof t + .getAttribute) + } + + function inspectString(t, e) { + if (t.length > e.maxStringLength) { + var r = t.length - e.maxStringLength, + n = "... " + r + " more character" + (r > 1 ? "s" : ""); + return inspectString($slice.call(t, 0, e.maxStringLength), e) + + n + } + return wrapQuotes($replace.call($replace.call(t, /(['\\])/g, + "\\$1"), /[\x00-\x1f]/g, lowbyte), "single", e) + } + + function lowbyte(t) { + var e = t.charCodeAt(0), + r = { + 8: "b", + 9: "t", + 10: "n", + 12: "f", + 13: "r" + } [e]; + return r ? "\\" + r : "\\x" + (e < 16 ? "0" : "") + $toUpperCase + .call(e.toString(16)) + } + + function markBoxed(t) { + return "Object(" + t + ")" + } + + function weakCollectionOf(t) { + return t + " { ? }" + } + + function collectionOf(t, e, r, n) { + return t + " (" + e + ") {" + (n ? indentedJoin(r, n) : $join.call( + r, ", ")) + "}" + } + + function singleLineValues(t) { + for (var e = 0; e < t.length; e++) + if (indexOf(t[e], "\n") >= 0) return !1; + return !0 + } + + function getIndent(t, e) { + var r; + if ("\t" === t.indent) r = "\t"; + else { + if (!("number" == typeof t.indent && t.indent > 0)) return null; + r = $join.call(Array(t.indent + 1), " ") + } + return { + base: r, + prev: $join.call(Array(e + 1), r) + } + } + + function indentedJoin(t, e) { + if (0 === t.length) return ""; + var r = "\n" + e.prev + e.base; + return r + $join.call(t, "," + r) + "\n" + e.prev + } + + function arrObjKeys(t, e) { + var r = isArray(t), + n = []; + if (r) { + n.length = t.length; + for (var o = 0; o < t.length; o++) n[o] = has(t, o) ? e(t[o], + t) : "" + } + var i, a = "function" == typeof gOPS ? gOPS(t) : []; + if (hasShammedSymbols) { + i = {}; + for (var c = 0; c < a.length; c++) i["$" + a[c]] = a[c] + } + for (var l in t) has(t, l) && (r && String(Number(l)) === l && l < t + .length || hasShammedSymbols && i["$" + + l] instanceof Symbol || ($test.call(/[^\w$]/, l) ? n.push(e( + l, t) + ": " + e(t[l], t)) : n.push(l + ": " + e(t[ + l], t)))); + if ("function" == typeof gOPS) + for (var p = 0; p < a.length; p++) isEnumerable.call(t, a[p]) && + n.push("[" + e(a[p]) + "]: " + e(t[a[p]], t)); + return n + } + + }).call(this) + }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? + self : typeof window !== "undefined" ? window : {}) + }, { + "6": 6 + }] + }, {}, [2])(2) +} +export default f() \ No newline at end of file diff --git a/common/manageServer.js b/common/manageServer.js index aa23bdd..12656a9 100644 --- a/common/manageServer.js +++ b/common/manageServer.js @@ -13,7 +13,7 @@ const getCommonReqData = ()=> { } // 请求接口 -function dealRequest(def, url, param, coreParams) { +function dealRequest({ def, url, param, coreParams, reqHeader }) { if(param && param._loading) { showLoading() } @@ -33,14 +33,15 @@ function dealRequest(def, url, param, coreParams) { }) } handleResponse({ - response, - data, + url, + param, + coreParams, + reqHeader, resolve, reject, - url, + response, + data, header, - param, - coreParams }); }, function(response) { console.log('request url==========1', url) @@ -65,19 +66,12 @@ function dealRequest(def, url, param, coreParams) { } // 处理响应 -async function handleResponse({ - data, - header, - resolve, - reject, - url, - param, - coreParams -}) { +async function handleResponse(options) { + let { data, header, resolve, reject, url, param, coreParams } = options // 图片类型数据特殊处理 if((header['content-type'] || header['Content-Type'])?.indexOf?.("image/") > -1) { - const base64 = "data:image/png;base64," + uni.arrayBufferToBase64(data) - let fileUrl = await getImageTempFilePath(base64) + // 重新获取下载后的临时路径 + let fileUrl = await getImageTempFilePath(options) resolve({ data: { fileUrl } }) return } diff --git a/common/request.js b/common/request.js index 2553997..7ba3476 100644 --- a/common/request.js +++ b/common/request.js @@ -4,20 +4,11 @@ import { host } from "./api" import { getSessionXToken } from "@/session" const coreRequestBase = (url, reqParams, options = {}, methodType = "POST", coreParams = {}) => { - - let comReqData = getCommonReqData() - if(coreParams._isFile) { - coreParams.responseType = "arraybuffer" - } - return new Promise((resolve, reject) => { uni.request({ - url: `${host}${url}`, + url, data: reqParams, - header: { - ...comReqData.header, - ...options - }, + header: options, method: methodType, ...coreParams, success: (res) => { @@ -30,21 +21,30 @@ const coreRequestBase = (url, reqParams, options = {}, methodType = "POST", core }) } -const BaseParam = {} +const baseParam = {} + // 请求处理 -let coreRequest = function(url, params = {}, options = {}, methodType, coreParams) { +let coreRequest = function(url, params = {}, options = {}, methodType, coreParams = {}) { + let comReqData = getCommonReqData() // 统一把emo转unicode // emoUnicode(params) const reqParams = { - ...BaseParam, + ...baseParam, ...params, } - return dealRequest( - coreRequestBase(url, reqParams, options, methodType, coreParams), - url, - reqParams, - coreParams - ).then(res => { + url = `${host}${url}` + options = { + ...options, + ...comReqData.header, + } + + return dealRequest({ + def: coreRequestBase(url, reqParams, options, methodType, coreParams), + url, + param: reqParams, + coreParams, + reqHeader: options + }).then(res => { // 解析unicode // emoUnicode(res, 2) return res diff --git a/common/untool.js b/common/untool.js index 6ad601d..019046b 100644 --- a/common/untool.js +++ b/common/untool.js @@ -1,3 +1,5 @@ +import qs from "@/common/libs/qs" + const tabBarUrls = [ '/pages/tabBar/deal/deal', '/pages/tabBar/home/home', @@ -85,10 +87,11 @@ const makePhoneCall = (phoneNumber)=> { }); } -const downloadFile = (url)=> { +const downloadFile = (url, ext = {})=> { return new Promise((resolve, reject)=> { uni.downloadFile({ url: url, + ...ext, success: (res) => { console.log("downloadFile:success:res======", res) if (res.statusCode === 200 || res.statusCode === 400) { @@ -158,49 +161,15 @@ const getImageInfo = (src)=> { }) } -// 微信小程序 有该api -const writeFile = (params = {}, fileEndFix = '.png')=> { - return new Promise((resolve, reject)=> { - //声明文件系统 - const fs = wx.getFileSystemManager(); - var times = new Date().getTime(); - var filePath = wx.env.USER_DATA_PATH + '/' + times + fileEndFix; - //将base64图片写入 - var that = this; - fs.writeFile({ - filePath: filePath, - ...params, - success: (res) => { - resolve({ filePath }) - }, - fail: (err)=> { - console.log("writeFile:错误==", err) - reject(err) - } - }); - }) -} - -const getImageTempFilePath = (base64File) => { +const getImageTempFilePath = (options) => { return new Promise(async (resolve, reject) => { - let tempFile = base64File - - // // #ifdef MP-WEIXIN - // let wxRes = await writeFile({ data: base64File, encoding: 'base64' }) - // tempFile = wxRes.filePath - // // #endif - - // // #ifdef H5 - // let webRes = await downloadFile(base64File) - // tempFile = webRes.tempFilePath - // // #endif - - // // #ifdef APP-PLUS - // let appRes = await downloadFile(tempFile) - // console.log("===appRes===", appRes) - // // #endif - - resolve(tempFile) + let { url, reqHeader, param } = options + if(param) { + let qsStr =qs.stringify(param) + url += `${url.indexOf("?")>-1?'&':'?'}${qsStr}` + } + let res = await downloadFile(url, { header: reqHeader }) + resolve(res.tempFilePath) }) }